(FILECREATED "29-Aug-86 12:23:57" {QV}<NOTECARDS>1.3K>NEXT>RHTPATCH098.;2 14839  

      changes to:  (VARS RHTPATCH098COMS)
		   (FNS NC.SaveDirtyCards NC.OpenDatabaseFile)

      previous date: "29-Aug-86 12:13:11" {QV}<NOTECARDS>1.3K>NEXT>RHTPATCH098.;1)


(* Copyright (c) 1986 by Xerox Corporation. All rights reserved.)

(PRETTYCOMPRINT RHTPATCH098COMS)

(RPAQQ RHTPATCH098COMS ((* * Changes to NCDATABASE)
			  (FNS NC.OpenDatabaseFile NC.SaveDirtyCards)))
(* * Changes to NCDATABASE)

(DEFINEQ

(NC.OpenDatabaseFile
  (LAMBDA (NoteFileOrFileName Access Don'tCacheTypesAndTitlesFlg QuietFlg Don'tCreateFlg 
			      Convertw/oConfirmFlg Don'tCreateArrayFlg Don'tTruncateFlg 
			      Don'tCreateInterfaceFlg Don'tGetSpecialCardsFlg InterestedWindow 
			      Don'tCheckOperationInProgressFlg MenuPosition)
                                                             (* rht: "29-Aug-86 12:12")

          (* * Open an already existing NoteFile and return a NoteFile object)



          (* * rht 8/7/84: For nonexistent files, asks user whether to create unless Don'tCreateFlg is non-nil.)



          (* * rht 1/9/85: Checks NC.UncachingNotCompleted global var. If non-nil, then previous notefile died unnaturally, 
	  so we first clear junk off the IDs.)



          (* * rht 8/6/85: Added Don'tTruncateFlg, which, if on, prevents the check for truncation.)



          (* * fgh 10/16/85 Updated to use new cacheing scheme.)



          (* * kirk 10/29/85: Now does cacheing of types and titles as background process.)



          (* * fkr 11/8/85: Converted from Streams to NoteFile object.)



          (* * kirk 30Nov85 Added a check for correct version number.)



          (* * rht 12/6/85: Moved Kirk's above patch to NC.CheckForNeededConversion and modified somewhat.
	  Added check for plausible header.)



          (* * rht 1/8/86: Now reuses old notefile object if there is one for this filename.)



          (* * fgh 1/13/86: Fixed bug with returning File Name with embedded call to CreateDatabaseFile.
	  Now just calls OpenDatabaseFile recursively using result of CreateDatabaseFile.)



          (* * fgh 1/16/86 Folded the cacheing of the special cards into BuildHashArray instead of making it a separate 
	  function after the hash array is already read in.)



          (* * kirk 20Jan86 Added NC.AskYesOrNo and InterestedWindow for prompt)



          (* * fgh 5/2/86 Implemented before and after opening hooks using NC.OpenNoteFileFns global variable.)



          (* * fgh 6/8/86 Added code to insure that two files with SameUIDP would never be open at once.)



          (* * fgh 6/25/86 Added contention locks -- NC.ProtectedNoteFileOperation, Don'tCheckOperationInProgressFlg etc.)



          (* * fgh 6/27/86 Added MenuPsotion arg to pass to SetUpNoteFileInterface)



          (* * rht 7/6/86: Added InterestedWindow arg to call to NC.CheckForNeededTruncation.)



          (* * kirk 15Jul86 Added call to NC.SetUpNoteFileInterface if already open)



          (* * rht 8/29/86: Now resets Name after conversion from version 2 to version3.)


    (PROG (NoteFile FileName Name Stream NewStream Card CardTotal)
	    (OR Access (SETQ Access (QUOTE BOTH)))
	    (SETQ FileName (COND
		((type? NoteFile NoteFileOrFileName)
		  (SETQ NoteFile NoteFileOrFileName)
		  (fetch (NoteFile FullFileName) of NoteFileOrFileName))
		(T NoteFileOrFileName)))
	    (if (NOT (OR FileName (SETQ FileName (NC.DatabaseFileName 
								      "Name of NoteFile to open:"
										" -- " T NIL NIL 
										InterestedWindow))))
		then (RETURN NIL))                       (* Use existing notefile object if there is one for 
							     this file name.)
	    (OR (type? NoteFile NoteFile)
		  (SETQ NoteFile (OR (NC.NoteFileFromFileName FileName)
					 (create NoteFile))))

          (* * If there is no interested window, see if the menu window can be used.)


	    (if (AND (NULL InterestedWindow)
			 (fetch (NoteFile Menu) of NoteFile))
		then (SETQ InterestedWindow (WFROMMENU (fetch (NoteFile Menu) of NoteFile)))
		  )

          (* * If this is an open NoteFIle, just bring up its menu.)


	    (if (NC.NoteFileOpenP NoteFile)
		then (OR Don'tCreateInterfaceFlg (NC.SetUpNoteFileInterface NoteFile 
										  MenuPosition))
                                                             (* bring up or create notefile icon if needed)
		       (RETURN NIL))

          (* * Check to make sure the file is not busy.)


	    (if (OPENP FileName)
		then (NC.PrintMsg InterestedWindow T FileName 
				      " is unavailable because something else has it open."
				      (CHARACTER 13))
		       (RETURN NIL))

          (* * Check to see if this NoteFile is busy doing something else)


	    (if (AND (NULL Don'tCheckOperationInProgressFlg)
			 (PROCESSP (NC.NoteFileProp NoteFile (QUOTE ProcessInProgress))))
		then (NC.PrintOperationInProgressMsg InterestedWindow (QUOTE Open% NoteFile)
							 (NC.NoteFileProp NoteFile (QUOTE 
									      OperationInProgress)))
		       (RETURN NIL))

          (* * Run rest of function with contention lock.)


	    (RETURN (NC.ProtectedNoteFileOperation
			NoteFile Open% NoteFile
			(PROG NIL
			        (if (NOT (SETQ Name (INFILEP FileName)))
				    then (COND
					     (Don'tCreateFlg (NC.PrintMsg InterestedWindow T 
									"Couldn't find NoteFile "
									    FileName "."
									    (CHARACTER 13))
							     (RETURN NIL))
					     ((NC.AskYesOrNo (CONCAT "Unable to find NoteFile " 
									 FileName "." (CHARACTER
									   13)
									 
						   "Want to create a new NoteFile by that name? ")
							       " -- " "Yes" T InterestedWindow)
					       (SETQ NoteFile (NC.CreateDatabaseFile FileName NIL 
									       "Opening NoteFile"
											 T))
					       (if (NOT (type? NoteFile NoteFile))
						   then (NC.PrintMsg InterestedWindow T 
								     "Unable to create Notefile "
									 FileName "." (CHARACTER
									   13))
							  (RETURN NIL)
						 else (RETURN (NC.OpenDatabaseFile NoteFile 
											 Access 
								      Don'tCacheTypesAndTitlesFlg 
											 QuietFlg 
										   Don'tCreateFlg 
									     Convertw/oConfirmFlg 
									      Don'tCreateArrayFlg 
										 Don'tTruncateFlg 
									  Don'tCreateInterfaceFlg 
									  Don'tGetSpecialCardsFlg 
										 InterestedWindow T)))
					       )
					     (T (RETURN NIL))))

          (* * Run through OpenNoteFileFns with param of BEFORE. Exit if any returns DON'T)


			        (if (for Function in NC.OpenNoteFileFns
					 thereis (OR (EQ Function (QUOTE DON'T))
							 (EQ (QUOTE DON'T)
							       (APPLY* Function Name NoteFile
									 (QUOTE BEFORE)))))
				    then (RETURN NIL))

          (* * Open the file)


			        (OR QuietFlg (NC.PrintMsg InterestedWindow T "Opening NoteFile " 
							      Name " . . ." (CHARACTER 13)))
			        (if (NULL (SETQ Stream
						(CAR (ERSETQ (OPENSTREAM Name Access
									       (QUOTE OLD)
									       (QUOTE
										 ((TYPE BINARY))))))))
				    then (NC.PrintMsg InterestedWindow T "Couldn't open " 
							  FileName "." (CHARACTER 13))
					   (RETURN NIL))
			        (replace (NoteFile Stream) of NoteFile with Stream)
			        (replace (NoteFile FullFileName) of NoteFile with (FULLNAME
											  Stream))
			        (NC.SetMonitor NoteFile (CREATE.MONITORLOCK (MKATOM
										  (CONCAT Name 
											  ":LOCK"))))
			        (NC.GetNoteFileHeader NoteFile)

          (* * Make sure there is no other open NF with this UID.)


			        (LET (NF)
				     (if (AND (SETQ NF (GETHASH (fetch (NoteFile UID)
									   of NoteFile)
									NC.NoteFilesHashArray))
						  (NEQ (fetch (NoteFile FullFileName)
							    of NoteFile)
							 (fetch (NoteFile FullFileName)
							    of NF))
						  (NC.NoteFileOpenP NF))
					 then (FLASHW PROMPTWINDOW)
						(NC.PrintMsg InterestedWindow T "Couldn't open " 
							       FileName (CHARACTER 13)
							       "because "
							       (fetch (NoteFile FullFileName)
								  of NF)
							       " is already open "
							       (CHARACTER 13)
							       "and has the same UID.")
						(if (STREAMP (fetch (NoteFile Stream)
								    of NoteFile))
						    then (CLOSEF? (fetch (NoteFile Stream)
									 of NoteFile)))
						(replace (NoteFile Stream) of NoteFile
						   with NIL)
						(RETURN NIL)))

          (* * See if notefile is out of date. If so, convert to current version.)


			        (if (NOT (NC.CheckForNeededConversion NoteFile 
									    Convertw/oConfirmFlg 
									    InterestedWindow))
				    then (CLOSEF (fetch (NoteFile Stream) of NoteFile))
					   (NC.PrintMsg InterestedWindow T "Open cancelled.")
					   (RETURN NIL)
				  else                     (* Reset Name, because conversion may have changed 
							     version num.)
					 (SETQ Name (fetch (NoteFile FullFileName) of NoteFile))
				      )                      (* See if notefile header seems reasonable.
							     If not, bail out.)
			        (if (NOT (NC.PlausibleNoteFileHeaderP NoteFile))
				    then (NC.PrintMsg InterestedWindow NIL 
				       "Notefile has bad header.  Please see a NoteCards wizard."
							  (CHARACTER 13)
							  "Open cancelled.")
					   (RETURN NIL))
			        (COND
				  ((NULL Don'tTruncateFlg)
                                                             (* Can either bail out entirely or run inspector and 
							     then bail out.)
				    (SELECTQ (SETQ NewStream (NC.CheckForNeededTruncation
						   NoteFile Access InterestedWindow))
					       (ABORT (CLOSEF Stream)
						      (NC.PrintMsg InterestedWindow T 
								     "Open cancelled.")
						      (DISMISS 1500)
						      (NC.ClearMsg InterestedWindow T)
						      (RETURN NIL))
					       (ABORTANDINSPECT (CLOSEF Stream)
								(NC.ScavengerPhase1 Name)
								(RETURN NIL))
					       NIL)
				    (AND (STREAMP NewStream)
					   (replace (NoteFile Stream) of NoteFile with 
											NewStream))))

          (* * Stash the notefile in the global notefiles hash array.)


			        (NC.StoreNoteFile NoteFile)

          (* * Build the hash array and cache the special cards if necessary)


			        (OR Don'tCreateArrayFlg (NC.BuildHashArray NoteFile QuietFlg 
									  Don'tGetSpecialCardsFlg 
									       InterestedWindow
									       (CONCAT
										 "Opening NoteFile " 
										 Name (CHARACTER
										   13))))
			        (OR Don'tGetSpecialCardsFlg (NC.GetSpecialCards
					NoteFile QuietFlg InterestedWindow (CONCAT 
									      "Opening NoteFile "
										     Name
										     (CHARACTER
										       13))))

          (* * Make sure the NF can't be closed by CLOSEALL)


			        (WHENCLOSE (fetch (NoteFile Stream) of NoteFile)
					     (QUOTE CLOSEALL)
					     (QUOTE NO))
			        (COND
				  ((NULL Don'tCacheTypesAndTitlesFlg)
                                                             (* Cache all of the titles in this database)
				    (replace (NoteFile CachingProcess) of NoteFile
				       with (ADD.PROCESS (LIST (FUNCTION 
								       NC.CacheTypesAndTitles)
								     NoteFile)))))
			        (COND
				  ((NULL Don'tCreateInterfaceFlg)
                                                             (* Make an interface menu for this notefile.)
				    (NC.SetUpNoteFileInterface NoteFile MenuPosition)))
			        (AND (NULL QuietFlg)
				       (NC.PrintMsg InterestedWindow T "Opened " (FULLNAME Stream)
						      (CHARACTER 13))
				       (NC.ClearMsg InterestedWindow T))
			        (SETQ NC.LastNoteFileOpened NoteFile)

          (* * Run through OpenNoteFIleFns with param of AFTER. Stop if any returns DON'T)


			        (for Function in NC.OpenNoteFileFns
				   thereis (EQ (QUOTE DON'T)
						   (APPLY* Function Name NoteFile (QUOTE AFTER))))

          (* * return the opened NF)


			        (RETURN NoteFile)))))))

(NC.SaveDirtyCards
  (LAMBDA (NoteFile TerminateOperationsInProgressFlg InterestedWindow OperationMsg QuietFlg)
                                                             (* rht: "29-Aug-86 12:23")

          (* * Save every card that is both active and dirty to the notefile.)



          (* * rht 9/21/85: Now records cards that were shrunken and reshrinks after checkpoint is completed.)



          (* * fgh 10/15/85 Put in stuff to make using cache array efficient)



          (* * rht 10/20/85: Now uses NC.GetShrunkenWin to find if card's win is shrunken, rather than looking at all open 
	  windows on the screen.)



          (* * rht 11/13/85: Updated to handle new NoteFile and Card formats.)



          (* * fgh 6/13/86 Added TerminateOperationsInProgressFlg OperationMsg & InterestedWindow arg and associated action.)



          (* * rht 8/29/86: Added QuietFlg argument.)


    (LET (ShrunkenCardWins ActiveCards)
         (NC.MapCards NoteFile (FUNCTION (LAMBDA (Card)
			  (if (NC.ActiveCardP Card)
			      then (push ActiveCards Card))
			  (if (NC.GetShrunkenWin Card)
			      then (push ShrunkenCardWins (NC.FetchWindow Card))))))
         (RESETLST (RESETSAVE NC.ForceSourcesFlg NIL)
		     (RESETSAVE NC.ForceTitlesFlg NIL)
		     (for Card in ActiveCards eachtime (BLOCK)
			do (AND TerminateOperationsInProgressFlg (
				      NC.TerminateCardOperationInProgress Card))
			     (NC.CardSaveFn Card QuietFlg T InterestedWindow OperationMsg)))
         (for Win in ShrunkenCardWins eachtime (BLOCK) do (SHRINKW Win)))))
)
(PUTPROPS RHTPATCH098 COPYRIGHT ("Xerox Corporation" 1986))
(DECLARE: DONTCOPY
  (FILEMAP (NIL (508 14757 (NC.OpenDatabaseFile 518 . 13048) (NC.SaveDirtyCards 13050 . 14755)))))
STOP