PSCommandInitImpl.mesa
Copyright (C) Xerox Corporation 1983, 1984, 1985, 1986. All rights reserved.
Last edited by Jacks: 20-May-86 15:27:46
Ruseli Binsol: October 15, 1986 3:14:16 pm PDT
Tim Diebert: December 15, 1986 2:59:37 pm PST
<<Print Service Initialization and Expunge routines.>>
DIRECTORY
BasicTime USING [GetGMT, GMT, nullNetworkAddress, Now],
BootSwitch USING [promptForInitializationParameters, Set],
ControlMessages USING [Key],
DecomposerControl USING [Expunge, Init, ModifyTraceLevel, NoticeNewFonts, NotifyProc, SetBannerMode],
FaxStatus USING [TransmissionRetryReason],
FontDirectory USING [Init],
ForwardingControl USING [Init, ModifyTraceLevel, SetTargetPrintService],
Heap USING [Create, systemZone],
MarkerControl USING [ClientProcsHandle],
MarkerInit USING [Init, MarkerInitParams],
MergeControl USING [Init, ModifyTraceLevel, NotifyProc],
MiscUtilities USING [CalcPagesForBandBuffers, CalcRMPagesForMarker, pagesPerBandBuffer],
NSAssignedTypes USING [FileType],
NSFile USING [Attribute, Close, Create, Delete, DeleteByName, Error, fullAccess, GetReference, Handle, OpenByName, nullHandle, nullID, nullTime, Reference, Session],
NSName USING [maxDomainLength, maxLocalLength, maxOrgLength, Name, NameRecord, nullNameRecord],
NSSegment USING [Map, Origin],
NSString USING [AppendString, MakeString, nullString, String, StringFromMesaString],
PaperTypes USING [nullDimensions, PaperMMDimension, PaperSize],
PrincOps USING [PageCount],
PrintingTypes USING [Option, RavenBuild],
PrintQueue USING [FaxLocalPrintStatus, FaxMitStatus, Initialize, Next, nilQueueObjectHandle, ObjectStatus, QueueObjectHandle, QueueStage, ReleaseAsTestPattern, Requeue, ReserveForTestPattern],
Process USING [Detach, priorityBackground, priorityNormal],
PS80State USING [PaperSize, RavenBuild, State, StateHandle],
PS90State USING [PaperSize, RavenBuild, State, StateHandle],
PSAssignedTypes USING [tBackup, tPSCommandStableData, tSpooled, tTestPatterns],
PSCommand USING [GetPrintServiceStatus, ResetStatistics],
PSCommandInternal USING [BansheeStatusWatcher, D1StatusWatcher, DocumentCompleted, FaxStatusWatcher, FinishedMarking, FX3500StatusWatcher, MarkingEngineFailure, ProblemDuringDecomposition, ProblemDuringMerge, PutAsyncMsgFromKey, RavenStatusWatcher, ReadyToMark, RepairModeWatcher, RotateFonts90, WritableStateHandle],
PSInit USING [calculateDefaultBBAllocation, calculateDefaultRMAllocation, Error, ErrorType, OptionalParms, RequiredParms, unlimitedPrintingCutOffMemSize],
PSKMessages USING [GetHandle],
PSState USING [maxStopReasonLength, maxUserNameLength, ServiceState, State, TraceLevel],
PSVolume USING [GetDefaultSession, OpenDirectory],
PSVolumeExtras USING [DeleteAll],
QueueControl USING [CompletionProc, Init],
QueueFile USING [Delete],
Space USING [ForceOut, Interval, nullInterval, PagesFromWords, Unmap],
SpecialSpace USING [realMemorySize],
SpoolControl USING [Init, ModifyTraceLevel],
StableData USING [DataProcessor, Enumerate, NotFound],
TargetPS USING [Error, GetPrinterProperties, GetPrinterStatus],
TargetPSStatus USING [Current, Properties],
TestPattern USING [Init],
VM USING [Interval, nullInterval],
XMessage USING [Handle, MsgKey];
PSCommandInitImpl: CEDAR PROGRAM
IMPORTS BasicTime, BootSwitch, DecomposerControl, FontDirectory, ForwardingControl, MarkerInit, MergeControl, MiscUtilities, NSFile, NSSegment, NSString, PrintQueue, Process, PSCommand, PSCommandInternal, PSInit, PSKMessages, PSVolume, PSVolumeExtras, QueueControl, QueueFile, Space, SpecialSpace, SpoolControl, StableData, TargetPS, TestPattern
EXPORTS PSInit, PSCommandInternal = BEGIN
TYPEs
blank: BYTE = LOOPHOLE[' ];
PUBLIC variables exported by PSCommandInternal:
state: PUBLIC PSCommandInternal.WritableStateHandle ← NIL;
currentCondition: PUBLIC PSState.ServiceState ← notInitialized;
markerProcs: PUBLIC MarkerControl.ClientProcsHandle ← NIL; --Record containing all procs returned by marker at init.
This flag is set to TRUE if test patterns have not been cataloged or may have been installed or
deleted, so that when StartPrinting is called the current test patterns will be enumerated:
testPatternsNoticed: PUBLIC BOOLEAN ← TRUE;
This flag is set to FALSE when fonts are installed or deleted, because the decomposer closes all the font files at that time. When StartPrinting is called the current fonts will be cataloged by the decomposer and rotated if necessary for banshee:
fontsNoticed: PUBLIC BOOLEAN ← TRUE;
PUBLIC ERRORs and SIGNALs exported by PSInit:
Error: PUBLIC ERROR [problem: PSInit.ErrorType] = CODE;
Private variables:
developmentMode: BOOLEAN ← TRUE;
Message domain handle:
controlMsgs: XMessage.Handle ← PSKMessages.GetHandle[control];
=============================================================================
PRINT SERVICE INITIALIZATION AND EXPUNGE PROCS (exported by PSInit):
============================================================================
InitializeState: PUBLIC PROCEDURE =
<<Initializes the state record, finding old backing file on disk or
creating a new one with default values.
NOTE: REMEMBER IN THE RELEASE AFTER 9.0, THE CODE MUST RECOGNIZE AND
INITIALIZE FROM 8.0 OR 9.0 BACKING FILES! (Many customers will not
be getting 9.0 software.)>>
BEGIN OPEN S: NSString;
nsBackingStore: ROPE = "PrinterState17.BackingStore";
backupDir: NSFile.Handle ← PSVolume.OpenDirectory[PSAssignedTypes.tBackup];
backupDir: ROPE ← "///BackUp/";
stateBackingFile: FS.OpenFile ← FS.nullOpenFile;
newBackingFile: BOOLEAN ← FALSE;
=====================================
CreateBackingFile: SAFE PROCEDURE = BEGIN
attrList: ARRAY [0..3) OF NSFile.Attribute ← [[dataSize[2*SIZE[PSState.State]]], [name[nsBackingStore]], [type[PSAssignedTypes.tBackup]]];
stateBackingFile ← FS.Create[name: nsBackingStore, setPages: TRUE, pages: (SIZE[PSState.State]/PrincOps.wordsPerPage)+1, wDir: backupDir]
END; -- CreateBackingFile
=====================================
InitializeSpace: SAFE PROCEDURE = BEGIN
currentTime: BasicTime.GMT ← Time.Now[];
state ← NEW[PSState.State ← [
Current Status--
mode: [notStarted, notStarted],
clientControl: [spooler: enabled, formatterEnabled: TRUE, markerEnabled: TRUE],
internalControl: [spooler: disabled, formatterEnabled: FALSE, markerEnabled: FALSE],
Systems Statistics--
networkAddress: XNS.unknownAddress,
statisticsReset: currentTime,
lastInstallation: currentTime,
lastBoot: currentTime,
lastActivity: currentTime,
nBoots: 0,
docsPrinted: [total:0, grandTotal:0],
docsAborted: [total:0, grandTotal:0],
testPatternsPrinted: [total:0, grandTotal:0],
docsRetried: [total:0, grandTotal:0],
docsPurged: [total:0, grandTotal:0],
commErrors: [total:0, grandTotal:0],
stopPrintingReasonBody: ALL[blank],
stopPrintingUserBody: ALL[blank],
startPrintingUserBody: ALL[blank],
stopQueuingReasonBody: ALL[blank],
stopQueuingUserBody: ALL[blank],
startQueuingUserBody: ALL[blank],
Systems Parameters--
decomposeWhileMarking: TRUE,
spoolWhileMarking: TRUE,
formatterPriority: Process.priorityNormal,
markerPriority: Process.priorityNormal,
spoolerTrace: none,
formatterTrace: none,
markerTrace: none,
decomposerRMPagesForMarker: 256, **Will be calculated below.
decomposerVMPages: 6000,
markerRMPagesForBands: 48,
Option Independent Paper Handling--
printOrder: lastPageOutFirst,
stapling: FALSE,
twoSidedCopy: FALSE,
Reserved for emergency future use:
unused1: 0,
unused2: 0,
unused3: 0,
unused4: 0,
Option Specific Information--
Option information is initialized durint PromptForStartupOptions.
printingOptionSpecific: unknown[]
]];
state.decomposerRMPagesForMarker � -- Not really used
state.lastStopPrintingReason ← NEW[TEXT[PSState.maxStopReasonLength]],
state.lastUserToStopPrinting ← NEW[TEXT[PSState.maxUserNameLength]],
state.lastUserToStartPrinting ← NEW[TEXT[PSState.maxUserNameLength]],
state.lastStopQueuingReason ← NEW[TEXT[PSState.maxStopReasonLength]],
state.lastUserToStopQueuing ← NEW[TEXT[PSState.maxUserNameLength]],
state.lastUserToStartQueuing ← NEW[TEXT[PSState.maxUserNameLength]],
END; -- InitializeSpace
=====================================
UpdateState: SAFE PROCEDURE = BEGIN OPEN state;
mode ← [notStarted, notStarted];
lastBoot ← Time.Now[];
nBoots ← nBoots + 1;
docsPrinted.grandTotal ← docsPrinted.grandTotal + docsPrinted.total;
docsPrinted.total ← 0;
docsAborted.grandTotal ← docsAborted.grandTotal + docsAborted.total;
docsAborted.total ← 0;
testPatternsPrinted.grandTotal ← testPatternsPrinted.grandTotal + testPatternsPrinted.total;
testPatternsPrinted.total ← 0;
docsRetried.grandTotal ← docsRetried.grandTotal + docsRetried.total;
docsRetried.total ← 0;
docsPurged.grandTotal ← docsPurged.grandTotal + docsPurged.total;
docsPurged.total ← 0;
commErrors.grandTotal ← commErrors.grandTotal + commErrors.total;
commErrors.total ← 0;
lastStopPrintingReason.bytes ← LOOPHOLE[@state.stopPrintingReasonBody];
lastUserToStopPrinting.bytes ← LOOPHOLE[@state.stopPrintingUserBody];
lastUserToStartPrinting.bytes ← LOOPHOLE[@state.startPrintingUserBody];
lastStopQueuingReason.bytes ← LOOPHOLE[@state.stopQueuingReasonBody];
lastUserToStopQueuing.bytes ← LOOPHOLE[@state.stopQueuingUserBody];
lastUserToStartQueuing.bytes ← LOOPHOLE[@state.startQueuingUserBody];
WITH s: state SELECT FROM
fax495 => BEGIN
s.docsTransmitted.grandTotal ← s.docsTransmitted.grandTotal + s.docsTransmitted.total;
s.docsTransmitted.total ← 0;
END;
feps9700 => BEGIN
s.targetPSName.record.org.bytes ← LOOPHOLE[@s.targetPSName.org];
s.targetPSName.record.domain.bytes ← LOOPHOLE[@s.targetPSName.domain];
s.targetPSName.record.local.bytes ← LOOPHOLE[@s.targetPSName.local];
END;
ENDCASE;
END; -- UpdateState
=======================================
BEGIN
stateBackingFile ← FS.Open[name: backupDir, wDir: nsBackingStore
! FS.Error => GOTO fileNotFound];
EXITS fileNotFound => {CreateBackingFile[]; newBackingFile ← TRUE};
END;
BEGIN -- Create space for state record and map it to backing store.
origin: NSSegment.Origin ← [file: stateBackingFile, base: 0,
count: Space.PagesFromWords [SIZE[PSState.State]]];
stateSpace ← NSSegment.Map[origin: origin, access: NSFile.fullAccess, session: session];
state ← stateSpace.pointer;
END;
IF newBackingFile
THEN BEGIN
END
ELSE UpdateState[]; --update old 10.0 backing file
Space.ForceOut[stateSpace];
END; --InitializeState
InitializePrintService: PUBLIC PROCEDURE [normal: BOOLEAN, serviceName: CHName.Name,
required: PSInit.RequiredParms,
optional: PSInit.OptionalParms ← [printingOptionParms: unknown[]]] = BEGIN --Exported by PSInit
spoolDir, backupDir, fontDir: NSFile.Handle ← NSFile.nullHandle;
defaultServiceName: NSString.String ← NSString.MakeString[z: commandHeap, bytes: 0];
--null string used when RegisterService doesn't return service name
IF currentCondition # notInitialized THEN ERROR PSInit.Error[alreadyInitialized];
SELECT required.printingOption FROM
bansheeDl, d1, fax295, fax495, feps9700, fx3500, raven => NULL;
ENDCASE => ERROR PSInit.Error[printingOptionNotSupported];
IF state = NIL THEN InitializeState[];
****** Initialize/update state record and print queue *******
backupDir ← PSVolume.OpenDirectory[PSAssignedTypes.tBackup];
spoolDir ← PSVolume.OpenDirectory[PSAssignedTypes.tSpooled];
[] ← PSVolume.OpenDirectory[PSAssignedTypes.tTestPatterns];
FinalizeState[required, optional]; --Apply user specified parameters to state record.
fontDir ← FontDirectory.Init[state.option, session, optional.deleteIncompatibleFontsandTPs];
TestPattern.Init[printingOption: state.option, deleteIncompatibleTPs: optional.deleteIncompatibleFontsandTPs];
[] ← PrintQueue.Initialize[backupDir, 40, state.option];
DeleteObsoleteEngineLogs[backupDir]; --NOTE: Remove this in a later release.
state.formatterPriority ← IF state.decomposeWhileMarking
THEN Process.priorityBackground ELSE Process.priorityNormal;
ClearQueues[]; --Clear the intermediate queues
******* Marker Initialization ******
IF state.option # feps9700 THEN BEGIN
Marker must be initialized before spooler and decomposer because markerProcs is passed to both.
engineSpecMarkerInitParms: MarkerInit.MarkerInitParams ← [
bufferSize: state.markerRMPagesForBands,
engineFailure: PSCommandInternal.MarkingEngineFailure,
finishedMarking: PSCommandInternal.FinishedMarking,
readyToMark: PSCommandInternal.ReadyToMark,
device: unknown[] --Compiler won't accept select stmt (below) here. **AJ 12/20/83
];
<<Waiting between marking documents is specified below for the US printer products. It is done when spooling while marking is disabled and decomposing while marking is enabled. That combination may keep the marker constantly busy and the spooler preempted. Thus, there is a few second wait between jobs to allow spooling. The wait time is longest for the fax, because the fax engine is so slow. Last I knew Star/Viewpoint's print retry interval was 30 sec. AJ 9/85>>
WITH s: state SELECT FROM
bansheeDl => BEGIN
IF (NOT s.spoolWhileMarking) AND s.decomposeWhileMarking THEN BEGIN
engineSpecMarkerInitParms.waitBetweenJobs ← TRUE;
engineSpecMarkerInitParms.betweenJobWaitTime ← 15; --seconds
END;
engineSpecMarkerInitParms.device ← bansheeDl[enableUnlimitedPrinting:
IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize
THEN s.enableUnlimitedPrinting
ELSE FALSE];
END;
d1 => engineSpecMarkerInitParms.device ← d1[
reenteringRepairMode: s.mode.current = repair];
fax295 => BEGIN
IF (NOT s.spoolWhileMarking) AND s.decomposeWhileMarking THEN BEGIN
engineSpecMarkerInitParms.waitBetweenJobs ← TRUE;
engineSpecMarkerInitParms.betweenJobWaitTime ← 35; --seconds
END;
engineSpecMarkerInitParms.device ← fax295[];
END;
fax495 => BEGIN
IF (NOT s.spoolWhileMarking) AND s.decomposeWhileMarking THEN BEGIN
engineSpecMarkerInitParms.waitBetweenJobs ← TRUE;
engineSpecMarkerInitParms.betweenJobWaitTime ← 35; --seconds
END;
engineSpecMarkerInitParms.device ← fax495[];
END;
fx3500 => engineSpecMarkerInitParms.device ← fx3500[
reenteringRepairMode: s.mode.current = repair];
raven => BEGIN
IF (NOT s.spoolWhileMarking) AND s.decomposeWhileMarking THEN BEGIN
engineSpecMarkerInitParms.waitBetweenJobs ← TRUE;
engineSpecMarkerInitParms.betweenJobWaitTime ← 15; --seconds
END;
engineSpecMarkerInitParms.device ← raven[
enableUnlimitedPrinting:
IF SpecialSpace.realMemorySize > PSInit.unlimitedPrintingCutOffMemSize
THEN s.enableUnlimitedPrinting
ELSE FALSE];
END;
ENDCASE => ERROR;
markerProcs ← MarkerInit.Init[
priority: state.markerPriority,
putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey,
z: Heap.systemZone,
deviceParams: engineSpecMarkerInitParms];
Set engine independent marker parameters...
markerProcs.modifyTraceLevel[LOOPHOLE[state.markerTrace]];
markerProcs.setPrintOrder[state.printOrder];
END;
Set engine specific marker parameters and
merger/forwarder parameters for feps9700...
WITH s: state SELECT FROM
bansheeDl =>
WITH m: markerProcs SELECT FROM
bansheeDl => BEGIN
m.setBanner[s.banner];
Process.Detach[FORK PSCommandInternal.BansheeStatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
d1 =>
WITH m: markerProcs SELECT FROM
d1 => BEGIN
m.setBanner[s.banner];
m.setRegistration[s.registration];
Process.Detach[FORK PSCommandInternal.D1StatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
fax295 =>
WITH m: markerProcs SELECT FROM
fax295 => BEGIN
m.setBanner[s.banner];
m.setPaper[s.paperWidth];
Process.Detach[FORK PSCommandInternal.FaxStatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
fax495 =>
WITH m: markerProcs SELECT FROM
fax495 => BEGIN
m.setBanner[s.banner];
m.setPaper[s.paperWidth];
m.setTransmissionResolution[s.fineResolutionSupported];
m.setMultipleCopies[
s.multLocalCopiesAllowed, s.multRemoteCopiesAllowed];
FOR r: FaxStatus.TransmissionRetryReason IN [noConnection..transmitError] DO
m.setTransmissionRetries[r, s.retries[r].count, s.retries[r].delayInSecs];
ENDLOOP;
Process.Detach[FORK PSCommandInternal.FaxStatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
feps9700 => BEGIN
MergeControl.Init[
currentOption: feps9700, priority: Process.priorityNormal,
notifyProc: PSCommandInternal.ProblemDuringMerge,
putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey];
MergeControl.ModifyTraceLevel[LOOPHOLE[state.markerTrace]];
ForwardingControl.Init[
currentOption: feps9700, priority: Process.priorityNormal,
putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey];
IF s.targetPSAddress # Space.nullNetworkAddress THEN
ForwardingControl.SetTargetPrintService[s.targetPSAddress];
ForwardingControl.ModifyTraceLevel[LOOPHOLE[state.markerTrace]];
END;
fx3500 =>
WITH m: markerProcs SELECT FROM
fx3500 => BEGIN
m.setFeeding[s.paperFeed];
m.setBanner[s.banner];
m.setRegistration[s.registration];
Process.Detach[FORK PSCommandInternal.FX3500StatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
raven =>
WITH m: markerProcs SELECT FROM
raven => BEGIN
m.setEngineBuild[s.engineBuild];
m.setFeeding[s.paperFeed];
m.setPaper[s.paperSupply];
m.setBanner[s.banner];
m.setRegistration[s.registration];
m.setStacking[s.paperStacking];
Process.Detach[FORK PSCommandInternal.RavenStatusWatcher[]];
END;
ENDCASE => ERROR; --Procs returned by marker reflect different printing option than state record.
ENDCASE => ERROR; --unknown printing option?
****** Spooler initialization ******
state.networkAddress ← SpoolControl.Init[
maxConnections: 1, markerProcs: markerProcs, putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey];
SpoolControl.ModifyTraceLevel[LOOPHOLE[state.spoolerTrace]];
****** Decomposer initialization ******
DecomposerControl.Init[
currentOption: state.option,
priority: state.formatterPriority,
fontDirectory: fontDir,
maxVMPages: state.decomposerVMPages,
maxRMPagesForMarker: state.decomposerRMPagesForMarker,
maxDecomposeHandles: -- no decomposing while merging for feps9700
IF state.decomposeWhileMarking AND state.option # feps9700 THEN 3 ELSE 1,
psName: IF serviceName # NIL THEN serviceName.local ELSE defaultServiceName,
notifyProc: PSCommandInternal.ProblemDuringDecomposition,
putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey];
WITH s: state SELECT FROM
bansheeDl => DecomposerControl.SetBannerMode[s.banner # suppressed];
d1 => DecomposerControl.SetBannerMode[s.banner # suppressed];
fax295 => DecomposerControl.SetBannerMode[s.banner # suppressed];
fax495 =>
DecomposerControl.SetBannerMode[
s.banner.local # suppressed OR s.banner.remote # suppressed];
feps9700 => DecomposerControl.SetBannerMode[enableBanner: FALSE];
fx3500 => DecomposerControl.SetBannerMode[s.banner # suppressed];
raven => DecomposerControl.SetBannerMode[s.banner # suppressed];
ENDCASE => ERROR;
DecomposerControl.ModifyTraceLevel[LOOPHOLE[state.formatterTrace]];
****** QueueControl initialization ******
QueueControl.Init[
printingOption: state.option,
documentCompleted: PSCommandInternal.DocumentCompleted,
putAsyncMsgFromKey: PSCommandInternal.PutAsyncMsgFromKey,
trace: LOOPHOLE[state.markerTrace]];
ReserveTestPattern[];
MakeInternalStateConsistent[];
IF state.option = raven OR state.option = fx3500 OR
state.option = bansheeDl OR state.option = d1 THEN
Process.Detach[FORK PSCommandInternal.RepairModeWatcher[]]; --will put us back into Repair mode if appropriate
currentCondition ← stopped;
IF required.catalogFontsAtInit THEN BEGIN
IF state.option = bansheeDl THEN
This proc will check to make sure all the
fonts have been rotated for banshee...
PSCommandInternal.RotateFonts90[];
DecomposerControl.NoticeNewFonts[];
END
ELSE fontsNoticed ← FALSE; --setting this flag will force fonts to be cataloged/rotated when StartPrinting is called
[] ← PSCommand.GetPrintServiceStatus[]; --Calls markerProcs to get paperSupply for fx3500 if necessary.
Space.ForceOut[stateSpace];
END; --InitializePrintService
ExpungePrintService: PUBLIC PROCEDURE [deleteFonts: BOOLEAN] = BEGIN
IF state = NIL AND currentCondition = notInitialized THEN BEGIN
DecomposerControl.Expunge[];
IF deleteFonts THEN
PSVolumeExtras.DeleteAll[includingFonts: TRUE]
ELSE PSVolumeExtras.DeleteAll[includingFonts: FALSE];
END
ELSE ERROR PSInit.Error[alreadyInitialized];
END; --ExpungePrintService
=================================
STATE RECORD INITIALIZATION:
=================================
FinalizeState: PROCEDURE [required: PSInit.RequiredParms, optional: PSInit.OptionalParms] = BEGIN
BansheeInit: PROCEDURE [enableUnlimited: BOOLEAN] = BEGIN
state.printingOptionSpecific ← bansheeDl[
invertingTrayAttached: FALSE,
banner: oncePerJob,
paper: [knownSize: letter, otherSize: PaperTypes.nullDimensions],
enableUnlimitedPrinting: enableUnlimited];
WITH s: state SELECT FROM
bansheeDl =>
s.printOrder ← IF s.invertingTrayAttached THEN
firstPageOutFirst ELSE lastPageOutFirst;
ENDCASE => ERROR;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --BansheeInit
D1Init: PROCEDURE [] = BEGIN
state.printingOptionSpecific ← d1[
banner: oncePerJob,
paperSize: a4,
trayEmpty: FALSE,
registration: [15, 15]
];
NOTE: Check these assumptions:
state.printOrder ← lastPageOutFirst;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --D1Init
Fax295Init: PROCEDURE [paperWidth: CARDINAL] = BEGIN
state.printingOptionSpecific ← fax295[
banner: oncePerJob,
paperWidth: paperWidth
];
state.printOrder ← firstPageOutFirst;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --Fax295Init
Fax495Init: PROCEDURE [
paperWidth: CARDINAL, supportFineResolution: BOOLEAN] = BEGIN
state.printingOptionSpecific ← fax495[
docsTransmitted: [total: 0, grandTotal: 0],
banner: [local: oncePerJob, remote: suppressed],
paperWidth: paperWidth,
fineResolutionSupported: supportFineResolution,
multLocalCopiesAllowed: TRUE,
multRemoteCopiesAllowed: FALSE,
retries: [count: 6, delayInSecs: 300], --in case of no connection
[count: 3, delayInSecs: 180]; --in case of transmit error
state.printOrder ← firstPageOutFirst;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --Fax495Init
FEPS9700Init: PROCEDURE = BEGIN
state.printingOptionSpecific ← feps9700[
paperSupply: [letter, letter],
targetPSAddress: BasicTime.nullNetworkAddress,
targetPSName: [record: NSName.nullNameRecord, org: ALL[blank], domain: ALL[blank], local: ALL[blank]]
];
WITH s: state SELECT FROM
feps9700 => BEGIN
Initialize target name record:
s.targetPSName.record.org ← [
bytes: LOOPHOLE[@s.targetPSName.org],
length: 0, maxlength: NSName.maxOrgLength];
s.targetPSName.record.domain ← [
bytes: LOOPHOLE[@s.targetPSName.domain],
length: 0, maxlength: NSName.maxDomainLength];
s.targetPSName.record.local ← [
bytes: LOOPHOLE[@s.targetPSName.local],
length: 0, maxlength: NSName.maxLocalLength];
END;
ENDCASE => ERROR;
state.printOrder ← firstPageOutFirst;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE; --not really applicable to feps9700
state.markerRMPagesForBands ← MiscUtilities.pagesPerBandBuffer; --feps9700 always uses only one band buffer
state.decomposerVMPages ← 6000;
END; --FEPS9700Init
FX3500Init: PROCEDURE [] = BEGIN
state.printingOptionSpecific ← fx3500[
banner: oncePerJob,
paperSupply: [a4, a4],
topPaperTrayEmpty: FALSE,
bottomPaperTrayEmpty: FALSE,
paperFeed: fromBottomOrTop,
registration: [long: 15, short: 15]
];
state.printOrder ← lastPageOutFirst;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --FX3500Init
RavenInit: PROCEDURE [
version: PrintingTypes.RavenBuild, enableUnlimited: BOOLEAN] = BEGIN
state.printingOptionSpecific ← raven[
engineBuild: version,
banner: oncePerJob,
paperSupply: [letter, letter],
paperFeed: fromBottomOrTop,
paperStacking: aligned,
registration: [long: 23, short: 8],
enableUnlimitedPrinting: enableUnlimited];
WITH s: state SELECT FROM
raven => SELECT version FROM
b1 => {s.printOrder ← lastPageOutFirst; s.paperStacking ← aligned};
ENDCASE => {s.printOrder ← firstPageOutFirst; s.paperStacking ← jobOffset};
ENDCASE => ERROR;
state.decomposeWhileMarking ← state.spoolWhileMarking ← TRUE;
state.decomposerVMPages ← 6000;
END; --RavenInit
SetBansheeRequiredParms: PROCEDURE [enableUnlimited: BOOLEAN] =
BEGIN --Assume previous printing option was bansheeDl
WITH s: state SELECT FROM
bansheeDl => s.enableUnlimitedPrinting ← enableUnlimited;
ENDCASE;
END; -- of SetBansheeRequiredParms
SetFax295RequiredParms: PROCEDURE [paperWidth: CARDINAL] =
BEGIN --Assume previous printing option was fax295
WITH s: state SELECT FROM
fax295 => s.paperWidth ← paperWidth;
ENDCASE => ERROR;
END; --SetFax295RequiredParms
SetFax495RequiredParms: PROCEDURE [
paperWidth: CARDINAL, supportFineResolution: BOOLEAN] =
BEGIN --Assume previous printing option was fax495
WITH s: state SELECT FROM
fax495 => BEGIN
s.paperWidth ← paperWidth;
s.fineResolutionSupported ← supportFineResolution;
END;
ENDCASE => ERROR;
END; --SetFax495RequiredParms
SetRavenRequiredParms: PROCEDURE [
version: PrintingTypes.RavenBuild, enableUnlimited: BOOLEAN] =
BEGIN --Assume previous printing option was raven.
WITH s: state SELECT FROM
raven => BEGIN
s.engineBuild ← version;
s.enableUnlimitedPrinting ← enableUnlimited;
SELECT version FROM
b1 => {s.printOrder ← lastPageOutFirst; s.paperStacking ← aligned};
ENDCASE => {s.printOrder ← firstPageOutFirst; s.paperStacking ← jobOffset};
END;
ENDCASE => ERROR;
END; --SetRavenRequiredParms
SetVariantOptionalParms: PROCEDURE [
spoolWhileMarking, decomposeWhileMarking: BOOLEAN] = BEGIN
state.spoolWhileMarking ← spoolWhileMarking;
state.decomposeWhileMarking ← decomposeWhileMarking;
END; --SetVariantOptionalParms
==============================================
IF state.option = required.printingOption THEN BEGIN --same printing option as before
IF required.newParametersSpecified THEN
WITH r: required SELECT FROM
bansheeDl => SetBansheeRequiredParms[r.enableUnlimitedPrinting];
d1 => NULL;
fax295 => SetFax295RequiredParms[r.paperWidth];
fax495 => SetFax495RequiredParms[
r.paperWidth, r.supportFineResolution];
feps9700 => NULL;
fx3500 => NULL;
raven => SetRavenRequiredParms[r.version, r.enableUnlimitedPrinting];
ENDCASE => ERROR;
END
ELSE BEGIN --initialize a new printing option
WITH r: required SELECT FROM
bansheeDl => BansheeInit[r.enableUnlimitedPrinting];
d1 => D1Init[];
fax295 => Fax295Init[r.paperWidth];
fax495 => Fax495Init[r.paperWidth, r.supportFineResolution];
feps9700 => FEPS9700Init[];
fx3500 => FX3500Init[];
raven => RavenInit[r.version, r.enableUnlimitedPrinting];
ENDCASE => ERROR;
PSCommand.ResetStatistics[]; --reset counts of docs printed, docs transmitted, etc.
END;
If printingOption = unknown then optional parameters aren't specified.
IF optional.printingOption # unknown THEN BEGIN
Set optional parameters from variant part of parm record...
WITH o: optional SELECT FROM
bansheeDl => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
d1 => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
fax295 => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
fax495 => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
feps9700 => NULL; --no feps9700 optional parms
fx3500 => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
raven => SetVariantOptionalParms[o.spoolWhileMarking, o.decomposeWhileMarking];
ENDCASE => ERROR;
Set optional parameters from shared part of parm record...
state.decomposerVMPages ← optional.vmPagesForDecomposer;
WITH s: state SELECT FROM
bansheeDl => s.markerRMPagesForBands ← --banshee may have unlimited printing enabled
IF optional.bandBufferPages = PSInit.calculateDefaultBBAllocation THEN
MiscUtilities.CalcPagesForBandBuffers[bansheeDl, s.enableUnlimitedPrinting]
ELSE optional.bandBufferPages;
raven => s.markerRMPagesForBands ← --raven may have unlimited printing enabled
IF optional.bandBufferPages = PSInit.calculateDefaultBBAllocation THEN
MiscUtilities.CalcPagesForBandBuffers[raven, s.enableUnlimitedPrinting]
ELSE optional.bandBufferPages;
ENDCASE => s.markerRMPagesForBands ←
IF optional.bandBufferPages = PSInit.calculateDefaultBBAllocation THEN
MiscUtilities.CalcPagesForBandBuffers[s.option]
ELSE optional.bandBufferPages;
<<RM limit must be calculated after band buffer pages are calculated during above procedure calls, since the number of band buffer pages is a parameter to the RM limit calculation.>>
state.decomposerRMPagesForMarker ←
IF optional.decomposerRMPageLimit = PSInit.calculateDefaultRMAllocation THEN
MiscUtilities.CalcRMPagesForMarker[state.markerRMPagesForBands]
ELSE optional.decomposerRMPageLimit;
END
ELSE BEGIN
<<Unless they are specified with the optional parameters, always calculate the band buffer pages and the rm limit for the decomposer. Banshee and Raven may have unlimited printing enabled and this has to be taken into account when calculating the band buffer pages.>>
WITH s: state SELECT FROM
bansheeDl => s.markerRMPagesForBands ←
MiscUtilities.CalcPagesForBandBuffers[bansheeDl, s.enableUnlimitedPrinting];
raven => s.markerRMPagesForBands ←
MiscUtilities.CalcPagesForBandBuffers[raven, s.enableUnlimitedPrinting];
ENDCASE => s.markerRMPagesForBands ←
MiscUtilities.CalcPagesForBandBuffers[s.option];
state.decomposerRMPagesForMarker ← MiscUtilities.CalcRMPagesForMarker[state.markerRMPagesForBands];
END;
For feps9700 make remote procedure call to target (if known) to get paper size and properties...
WITH s: state SELECT FROM
feps9700 => IF s.targetPSAddress # BasicTime.nullNetworkAddress THEN BEGIN
remoteStatus: TargetPSStatus.Current ←
TargetPS.GetPrinterStatus[s.targetPSAddress
! TargetPS.Error => GOTO CantReachTarget];
remoteProperties: TargetPSStatus.Properties ←
TargetPS.GetPrinterProperties[s.targetPSAddress
! TargetPS.Error => GOTO CantReachTarget];
s.paperSupply ← remoteStatus.paperSupply;
s.stapling ← remoteProperties.staple;
s.twoSidedCopy ← remoteProperties.twoSided;
EXITS CantReachTarget =>
display warning message that target can't be reached
PSCommandInternal.PutAsyncMsgFromKey[
[domain: controlMsgs, key: XKey[mSetTargetWarning]]];
END;
ENDCASE;
Space.ForceOut[stateSpace];
END; --FinalizeState
===============================================
SUPPORT ROUTINES:
===============================================
ClearQueues: PROCEDURE = BEGIN
Clear the intermediate queues
Dispose[fromQueue: spooling, disposeQ: aborted,
statusOtherwise: sysRestartInSpooler];
Dispose[fromQueue: decomposing, retryQ: spooledNormal, disposeQ: aborted,
statusIfRetried: restart, statusOtherwise: sysRestartInDecomposer];
Dispose[fromQueue: decomposed, retryQ: spooledNormal, disposeQ: aborted,
statusIfRetried: restart, statusOtherwise: sysRestartInQueue];
Dispose[fromQueue: merging, retryQ: spooledNormal, disposeQ: aborted,
statusIfRetried: restart, statusOtherwise: sysRestartInMerger];
Dispose[fromQueue: marking, retryQ: spooledNormal, disposeQ: aborted,
statusIfRetried: restart, statusOtherwise: sysRestartInMarker];
Dispose[fromQueue: forwarding, retryQ: merged, disposeQ: aborted,
statusIfRetried: merged, statusOtherwise: sysRestartInForwarder];
Dispose[fromQueue: retransmit, retryQ: spooledNormal, disposeQ: aborted,
statusIfRetried: restart, statusOtherwise: sysRestartInQueue];
Dispose[fromQueue: temp, retryQ: spooledNormal, disposeQ: marked,
statusIfRetried: restart, statusOtherwise: sysRestartInQueue];
Dispose[fromQueue: tpSpooled, disposeQ: aborted,
statusOtherwise: sysRestartInQueue];
Dispose[fromQueue: tpDecomposed, disposeQ: aborted,
statusOtherwise: sysRestartInQueue];
Dispose[fromQueue: tpMerged, disposeQ: aborted,
statusOtherwise: sysRestartInQueue];
END; --ClearQueues
DeleteObsoleteEngineLogs: PROCEDURE [dir: NSFile.Handle] = BEGIN
<<Delete Raven.log and Banshee.log which were engine log files used in releases previous to 10.0. NOTE: Take out this proc in some subsequent release.>>
ravenLog: NSString.String = Str["Raven.log"L];
bansheeLog: NSString.String = Str["Banshee.log"L];
NSFile.DeleteByName[dir, ravenLog, session ! NSFile.Error => CONTINUE];
NSFile.DeleteByName[dir, bansheeLog, session ! NSFile.Error => CONTINUE];
END; -- of DeleteObsoleteEngineLogs
Dispose: PROCEDURE [
fromQueue: PrintQueue.QueueStage,
retryQ, disposeQ: PrintQueue.QueueStage ← inactive,
statusIfRetried: PrintQueue.ObjectStatus ← null,
statusOtherwise: PrintQueue.ObjectStatus] = BEGIN
statusIfRetried=PrintQueue.ObjectStatus[null] means: Just move job to disposeQ.
qOH: PrintQueue.QueueObjectHandle ← PrintQueue.Next[qOH: PrintQueue.nilQueueObjectHandle, fromQueue: fromQueue];
UNTIL qOH = PrintQueue.nilQueueObjectHandle DO
qOH.printObjectHandle ← NIL; -- Bands List and Font Load were temp files
IF qOH.priorStatus = null
AND statusIfRetried # PrintQueue.ObjectStatus[null]
AND qOH.deleteInactiveFile = TRUE --not a test pattern-- THEN BEGIN
qOH.priorStatus ← statusOtherwise;
qOH.currentStatus ← statusIfRetried;
WITH q: qOH SELECT FROM
fax495 => SELECT fromQueue FROM
marking, retransmit, temp => UpdateFaxStatuses[qOH: qOH,
localStatus: queued, remoteStatus: queued, willRetry: TRUE];
ENDCASE;
feps9700 => IF fromQueue = merging THEN
There's a timing consideration that we must check for.
If a document is found on the merging queue it is possible
that the merged file has already been made permanent
(i.e. we crashed just before moving the doc to merged queue).
QueueFile.Delete will not raise any error if
the file isn't found...
IF q.ivFileID # NSFile.nullID THEN
q.ivFileID ← QueueFile.Delete[q.ivFileID]; --returns nullID
ENDCASE;
qOH ← PrintQueue.Requeue[ --returns next qOH from fromQueue
qOH: qOH, fromQueue: fromQueue, toQueue: retryQ, position: front];
state.docsRetried.total ← state.docsRetried.total + 1;
END
ELSE BEGIN
qOH.currentStatus ← statusOtherwise;
WITH q: qOH SELECT FROM
fax495 => SELECT fromQueue FROM
marking, retransmit, temp => UpdateFaxStatuses[qOH: qOH,
localStatus: purgedAtSysRestart, remoteStatus: purgedAtSysRestart, willRetry: FALSE];
ENDCASE;
ENDCASE;
qOH ← PrintQueue.Requeue[ --returns next qOH from fromQueue
qOH: qOH, fromQueue: fromQueue, toQueue: disposeQ];
state.docsPurged.total ← state.docsPurged.total + 1;
END;
ENDLOOP;
END; -- Dispose
MakeInternalStateConsistent: PROCEDURE = BEGIN -- Sort out the control state...
The state.clientControl stays as is. Spooler, formatter and marker are disabled initially.
They get enabled by the start proc: StartPrintService (PSCommandAImpl).
SELECT state.mode.current FROM
repair => NULL; --should return to repair mode.
ENDCASE => BEGIN
state.internalControl.spooler ← disabled;
state.internalControl.formatterEnabled ← FALSE;
state.internalControl.markerEnabled ← FALSE;
IF state.mode.current # normal AND state.mode.current # notStarted THEN --diagnostic, fileWrite, fileDelete, and shutDown modes don't survive across boots
state.mode.current ← state.mode.returnTo ← normal;
END;
END; --MakeInternalStateConsistent
ReserveTestPattern: PROCEDURE = BEGIN
qOH: PrintQueue.QueueObjectHandle ← PrintQueue.Next[qOH:, fromQueue: tpInactive];
IF qOH = PrintQueue.nilQueueObjectHandle THEN BEGIN -- none installed
qOH ← PrintQueue.ReserveForTestPattern[qOH:, fromQueue: inactive, toQueue: tpInactive];
IF qOH=PrintQueue.nilQueueObjectHandle THEN ????
END
ELSE BEGIN -- ensure there's only one installed
tpQOH: PrintQueue.QueueObjectHandle ← PrintQueue.Next[qOH: qOH, fromQueue: tpInactive]; UNTIL tpQOH = PrintQueue.nilQueueObjectHandle DO
PrintQueue.ReleaseAsTestPattern[qOH: tpQOH, fromQueue: tpInactive,
toQueue: inactive];
tpQOH ← PrintQueue.Next[qOH: qOH, fromQueue: tpInactive];
ENDLOOP;
END;
END; -- ReserveTestPattern
UpdateFaxStatuses: PROCEDURE [qOH: PrintQueue.QueueObjectHandle,
localStatus: PrintQueue.FaxLocalPrintStatus,
remoteStatus: PrintQueue.FaxMitStatus, willRetry: BOOLEAN] = BEGIN
Straighten out local print and phone number statuses.
WITH q: qOH SELECT FROM
fax495 => BEGIN
IF q.localPrintStatus # printed AND q.localPrintStatus # null THEN BEGIN
q.localPrintStatus ← localStatus;
q.localPrintCompletionDate ← IF willRetry THEN NSFile.nullTime
ELSE BasicTime.GetGreenwichMeanTime[];
END;
FOR i: CARDINAL IN [0..q.phoneNoCount) DO
q.transmitData[i].completionDate ← IF willRetry THEN NSFile.nullTime
ELSE BasicTime.GetGreenwichMeanTime[];
q.transmitData[i].queuedForRetry ← FALSE;
SELECT q.transmitData[i].status FROM
IN [busy..transmitError], localFaxFailure =>
IF willRetry THEN q.transmitData[i].queuedForRetry ← TRUE;
transmitted => NULL;
ENDCASE => q.transmitData[i].status ← remoteStatus;
ENDLOOP;
END;
ENDCASE => ERROR;
END; --UpdateFaxStatuses
XKey: PROCEDURE [key: ControlMessages.Key] RETURNS [xKey: XMessage.MsgKey] =
{RETURN[ORD[key]]};
Str: PROCEDURE [s: LONG STRING] RETURNS [ns: NSString.String] = INLINE
{RETURN[NSString.StringFromMesaString[s]]};
END. -- of PSCommandInitImpl
LOG when/who/what
****EARLIER LOG ENTRIES DELETED. See archived version from 8.0.
12-Jul-84 14:42:09 - Jacks - Reset stacking to aligned with Raven B1 initialized.
17-Aug-84 13:42:31 - Jacks - Removed all reference to aps phototypesetter option.
****SPLIT OFF FROM PSCommandCImpl
20-Sep-84 13:31:14 - Jacks - Updated to 9.0 PS interfaces: PrintQueue, MarkerControl, MarkerInit, DecomposerControl, PSState, PSCommand.
2-Oct-84 15:01:25 - Jacks - Moved all operator interface prompts to PSExecInitImpl; redefined the Initialize proc as in PSInit interface; moved engine status watcher procs to PSCommandCImpl.
19-Oct-84 13:35:57 - Jacks - Moved CalcRMPagesForMarker into new MiscUtilitiesImpl module; added code for feps9700; added code to CopyOldStateData.
29-Oct-84 17:40:10 - Jacks - Put code in InitializeState to initialize ps80State strings before copying them.
16-Nov-84 13:42:07 - Jacks - Updated to second round 9.0 interface changes; moved noResources error msg from DecomposerControlImpl.Exception to ProblemDuringDecomposition; consolidated all QueueControl Init procs into DocumentCompleted; added RegisterAccountProc for new PrintServiceAccounting interface.
20-Nov-84 10:39:32 - Jacks - Added call to ForwardingControl.SetTargetPrintService to init.
27-Nov-84 13:57:11 - Jacks - Moved callback procs used as init parms and RegisterAccountProc to PSCommandCImpl (now import them from PSCommandInternal).
6-Dec-84 16:00:52 - Jacks - Replaced fontsNoticed with fontsInstalled and fontsDeleted; changed around DeleteOldFonts.
13-Dec-84 14:01:19 - Jacks - Changed call to TargetPS.GetPrinterStatus in FinalizeState.
16-Jan-85 15:49:11 - Jacks - Added "ps" prefix to all new msg keys for 9.0.
18-Jan-85 15:55:07 - Jacks - Updated product factoring for feps9700.
24-Jan-85 14:14:35 - Jacks - Commented back in deletion of pre 9.0 state information after 9.0 initialization.
6-Feb-85 17:19:03 - Jacks - Converted to new version of PSInit; added call to calculate RM for decomposer in default init case; call TestPattern.Init during initialization.
28-Feb-85 10:15:44 - Jacks - Now fork RepairModeWatcher for banshee; fontsInstalled and fontsDeleted were replaced by fontsNoticed.
18-Jun-85 14:55:27 - Jacks - Added copyright notice; updated to PS Euclid interfaces.
27-Jun-85 15:58:34 - Jacks - Added code for d1 engine.
1-Jul-85 16:45:10 - Jacks - Updated UpdateFaxStatuses.
24-Jul-85 11:14:51 - Jacks - Updated to Services Euclid interfaces, including XMessage; took out product factoring, leaving it up to PSExecInitImpl.
7-Aug-85 12:24:09 - Jacks - Rewrote DeleteOldFonts; now open all font directories; added MoveBansheeFontsIfNecessary; removed reenteringRepairMode from MarkerInit for raven; updated to new CalcRMPagesForMarker and CalcPagesForBandBuffers; added MoveD1Fonts; changed Adjust90State to Copy90State.
29-Aug-85 14:30:17 - Jacks - Added Expunge; unmap 8.0 and 9.0 state spaces; changed initialize size of commandHeap to 3 pages.
6-Sep-85 15:56:35 - Jacks - Created InitializeFontDirectory proc; improved DeleteIncompatibleFontDirs (used to be DeleteOldFonts), DeleteObsoleteEngineLogs and MoveBansheeFontsIfNecessary; always one band buffer for feps.
9-Sep-85 14:08:45 - Jacks - Changed fax retry defaults in Fax495Init; increased commandHeap to 5 pages.
11-Sep-85 11:30:07 - Jacks - Font directories reworked: moved the functionality to a new module FontDirectoryImpl, deleted InitializeFontDirectory, DeleteIncompatibleFontDirs, MoveD1Fonts and oveBansheeFontsIfNecessary.
25-Sep-85 12:30:56 - Jacks - Updated to new PSState, PSInit and MarkerInit with enableUnlimitedPrinting and betweenJobWaitTime options.
27-Sep-85 12:42:21 - Jacks - Don't enable unlimited printing unless mem size is big enough.
8-Oct-85 13:47:39 - Jacks - Updated to new CalcPagesForBandBuffers and changes to PSInit; fork RepairModeWatcher for d1; set spoolWhileMarking to TRUE for US printers.
15-Oct-85 9:38:02 - Jacks - New state backing store again.
6-Nov-85 10:43:33 - Jacks - Added call to DecomposerControl to Expunge; get msg handle from PSKMessages; added signal FontsNotCataloged.
7-Nov-85 11:23:22 - Jacks - Removed FontsNotCataloged; clear tpSpooled queue in ClearQueues.
13-Nov-85 10:30:04 - Jacks - Default spoolWhileMarking and decomposeWhileMarking to TRUE for FX printers.
27-Nov-85 17:07:05 - Jacks - Set decomposer vm pages to 6000 in various Init procs in FinalizeState.
26-Feb-86 17:25:46 - Jacks - Limit decompose handles to 1 for feps9700.
14-May-86 16:12:38 - Jacks - Moved InitializeState from mainline code to public proc; ExpungePrintService no longer needs to close backup directory.
20-May-86 15:27:32 - Jacks - Only catalog fonts if init parm indicates.