DIRECTORY
BasicTime USING [GMT, nullGMT, ToNSTime],
CHNameP2V0 USING [],
CrRPC USING [BulkDataXferProc, CreateClientHandle, DestroyClientHandle, Error, Handle],
Finalize,
FS USING [Error, FileInfo, StreamOpen],
IO USING [Close, EndOf, GetBlock, PutBlock, STREAM],
Process USING [Detach, Seconds, SecondsToTicks, SetTimeout],
RedBlackTree USING [Compare, Create, DuplicateKey, EachNode, EnumerateDecreasing, GetKey, Insert, Lookup, Table, UserData],
RefText USING [ObtainScratch, ReleaseScratch],
Rope USING [Compare, Equal, Match, ROPE, Size],
SystemNames USING [UserName],
UserProfile USING [Boolean, Line, Number, Token],
XNS USING [Address, Socket, unknownAddress, unknownSocket],
XNSCH USING [LookupAddressFromRope],
XNSCHName USING [Name, RopeFromName],
PrintingP4V3,
PrintingP4V3Aux,
XNSPrint,
XNSPrintExtras;

XNSPrintImpl: CEDAR MONITOR
IMPORTS BasicTime, CrRPC, Finalize, FS, IO, PrintingP4V3, PrintingP4V3Aux, Process, RedBlackTree, RefText, Rope, SystemNames, UserProfile, XNSCH, XNSCHName
EXPORTS XNSPrint, XNSPrintExtras ~ {
OPEN Printing: PrintingP4V3, PrintingAux: PrintingP4V3Aux, XNSPrint;
ROPE: TYPE ~ Rope.ROPE;


BANNER: ROPE ~	"Hardcopy.Banner";
COPYCOUNT: ROPE ~	"Hardcopy.CopyCount";
FAX: ROPE ~	"Hardcopy.FaxPhoneNumber";
IPPRINTER: ROPE ~	"Hardcopy.InterpressPrinter";
KEY: ROPE ~	"Hardcopy.Key";
MEDIUM: ROPE ~	"Hardcopy.Medium";
PIGEONHOLE: ROPE ~	"Hardcopy.PigeonHole";
PAGEFIRST: ROPE ~	"Hardcopy.PageFirst";
PAGELAST: ROPE ~	"Hardcopy.PageLast";
PRIORITY: ROPE ~	"Hardcopy.Priority";
STAPLED: ROPE ~	"Hardcopy.Stapled";
TWOSIDED: ROPE ~	"Hardcopy.TwoSided";
pendingPrintRequests: PrintRequestList Ź NIL;
QUANTUS: Process.Seconds Ź 30;
HACK: BOOL Ź TRUE;
extensions: LIST OF ContextExtension = LIST[NIL]; -- list head

ContextExtension: TYPE = REF ContextExtensionRep;
ContextExtensionRep: TYPE = RECORD [
contextHandle: Finalize.Handle,
useStapling: BOOL Ź TRUE,
usePlex: BOOL Ź TRUE
];

fq: Finalize.FinalizationQueue = Finalize.NewFQ[];

WithExtension: ENTRY PROC [context: Context, inner: PROC [ContextExtension]] = {
e: ContextExtension Ź NIL;
UNTIL Finalize.FQEmpty[fq] DO
h: Finalize.Handle = Finalize.FQNext[fq];
FOR tail: LIST OF ContextExtension Ź extensions, tail.rest UNTIL tail.rest = NIL DO
IF tail.rest.first.contextHandle = h THEN {tail.rest Ź tail.rest.rest; EXIT};
ENDLOOP;
ENDLOOP;
FOR tail: LIST OF ContextExtension Ź extensions.rest, tail.rest UNTIL tail = NIL DO
IF Finalize.HandleToObject[tail.first.contextHandle] = context THEN {
e Ź tail.first;
EXIT;
};
ENDLOOP;
IF e = NIL THEN {
e Ź NEW[ContextExtensionRep Ź [contextHandle: Finalize.EnableFinalization[context, fq]]];
extensions.rest Ź CONS[e, extensions.rest];
};
inner[e];
};

GetStapling: PUBLIC PROC [context: Context] RETURNS [result: XNSPrintExtras.Stapling Ź default] = {
Inner: PROC [x: ContextExtension] = {
result Ź IF x.useStapling THEN (IF context.stapled THEN $stapled ELSE $unstapled) ELSE $default
};
WithExtension[context, Inner];
};

SetStapling: PUBLIC PROC [context: Context, stapling: XNSPrintExtras.Stapling] = {
Inner: PROC [x: ContextExtension] = {
x.useStapling Ź stapling # $default;
context.stapled Ź stapling = $stapled;
};
WithExtension[context, Inner];
};

GetPlex: PUBLIC PROC [context: Context] RETURNS [result: XNSPrintExtras.Plex Ź default] = {
Inner: PROC [x: ContextExtension] = {
result Ź IF x.usePlex THEN (IF context.twoSided THEN $duplex ELSE $simplex) ELSE $default
};
WithExtension[context, Inner];
};

SetPlex: PUBLIC PROC [context: Context, plex: XNSPrintExtras.Plex] = {
Inner: PROC [x: ContextExtension] = {
x.usePlex Ź plex # $default;
context.twoSided Ź plex = $duplex;
};
WithExtension[context, Inner];
};

WatcherListChanged: PUBLIC CONDITION;
RequestListChanged: PUBLIC CONDITION;

RegisterPrintRequest: PUBLIC ENTRY PROC [request: PrintRequest, update: StatusChangedProc Ź NIL, clientData: REF Ź NIL] ~ {
ENABLE { UNWIND => NULL };
IF (clientData # NIL) THEN request.clientData Ź clientData;
request.update Ź update;
pendingPrintRequests Ź CONS[request, pendingPrintRequests];
BROADCAST RequestListChanged;
};

UnRegisterPrintRequest: PUBLIC ENTRY PROC [request: PrintRequest] ~ {
ENABLE { UNWIND => NULL };
SELECT TRUE FROM
( pendingPrintRequests = NIL ) => {
RETURN
};
( pendingPrintRequests.first = request ) => {
pendingPrintRequests Ź pendingPrintRequests.rest;
};
ENDCASE => {
FOR tail: PrintRequestList Ź pendingPrintRequests, tail.rest WHILE ( tail.rest # NIL ) DO
IF ( tail.rest.first = request ) THEN { tail.rest Ź tail.rest.rest; EXIT };
ENDLOOP;
};
BROADCAST RequestListChanged;
};

GetPrintRequestList: PUBLIC ENTRY PROC RETURNS [list: PrintRequestList] ~ {
ENABLE { UNWIND => NULL };
list Ź pendingPrintRequests;
};

WaitTilRequestListChanged: ENTRY PROC ~ {
ENABLE { UNWIND => NULL };
WAIT RequestListChanged;
};

WatchRequestList: PROC ~ {
msg: ROPE;
oldStatus: InterpressMasterStatus; -- defined here to avoid the extra {}
DO  -- Forever
WaitTilRequestListChanged[];
IF ( pendingPrintRequests = NIL ) THEN LOOP;
FOR tail: PrintRequestList Ź pendingPrintRequests, tail.rest WHILE ( tail # NIL ) DO {
ENABLE {
UNWIND => NULL;
Error => {msg Ź explanation; GOTO CleanUp};
};
oldStatus Ź tail.first.lastStatus.status;
SELECT TRUE FROM
( tail.first.update = NIL ) => {
UnRegisterPrintRequest[tail.first];
}
ENDCASE => {
tail.first.lastStatus Ź GetPrintRequestStatus[tail.first];
IF ( oldStatus # tail.first.lastStatus.status ) THEN {
tail.first.update[tail.first, tail.first.clientData];
};
};
EXITS
CleanUp => {
tail.first.lastStatus Ź [unknown, msg];
tail.first.update[tail.first, tail.first.clientData];
UnRegisterPrintRequest[tail.first];
};
} ENDLOOP;
ENDLOOP;  -- Forever
};
Error: PUBLIC ERROR [problem: Problem, explanation: ROPE] ~ CODE;
FIREWALL: PUBLIC ERROR ~ CODE; -- nobody should see and/or catch this one!
GetPrinterProperties: PUBLIC PROC [printer: ROPE]
RETURNS [service: ROPE, answer: Properties] ~ {
ENABLE {
Printing.ServiceUnavailable => {
ERROR Error[service, "Service Unavailable"];
};
Printing.SystemError => {
ERROR Error[service, "System Error"];
};
Printing.Undefined => {
ERROR Error[service, "Undefined"];
};
CrRPC.Error => {
SELECT errorReason FROM
courierVersionMismatch, rejectedNoSuchProgram, rejectedNoSuchVersion, cantConnectToRemote, communicationFailure => {
ERROR Error[connection, text];
};
rejectedNoSuchProcedure, rejectedInvalidArgument, argsError, resultsError, bulkDataError, protocolError, notImplemented, unknownOperation => {
ERROR Error[protocol, text];
};
rejectedUnspecified, remoteError, remoteClose => {
ERROR Error[connection, text]; };
ENDCASE  => {
ERROR Error[unknown, text];
};
};
};
distingName: XNSCHName.Name; h: CrRPC.Handle Ź NIL;
realAnswer: Printing.PrinterProperties;
[h, distingName] Ź CrHandleFromRope[printer, HACK];
realAnswer Ź Printing.GetPrinterProperties[h];
CrRPC.DestroyClientHandle[h];
answer Ź MungeProperties[realAnswer];
service Ź XNSCHName.RopeFromName[distingName];
};

GetPrinterStatus: PUBLIC PROC [printer: ROPE]
RETURNS [service: ROPE, answer: PrinterStatus] ~ {
ENABLE {
Printing.ServiceUnavailable => {
ERROR Error[service, "Service Unavailable"];
};
Printing.SystemError => {
ERROR Error[service, "System Error"];
};
Printing.Undefined => {
ERROR Error[service, "Undefined"];
};
CrRPC.Error => {
SELECT errorReason FROM
courierVersionMismatch, rejectedNoSuchProgram, rejectedNoSuchVersion, cantConnectToRemote, communicationFailure => {
ERROR Error[connection, text];
};
rejectedNoSuchProcedure, rejectedInvalidArgument, argsError, resultsError, bulkDataError, protocolError, notImplemented, unknownOperation => {
ERROR Error[protocol, text];
};
rejectedUnspecified, remoteError, remoteClose => {
ERROR Error[connection, text]; };
ENDCASE  => {
ERROR Error[unknown, text];
};
};
};
distingName: XNSCHName.Name; h: CrRPC.Handle Ź NIL;
realAnswer: Printing.PrinterStatus;
[h, distingName] Ź CrHandleFromRope[printer, HACK];
realAnswer Ź Printing.GetPrinterStatus[h];
CrRPC.DestroyClientHandle[h];
answer Ź MungePrinterStatus[realAnswer];
service Ź XNSCHName.RopeFromName[distingName];
};

GetPrintRequestStatus: PUBLIC PROC [request: PrintRequest]
RETURNS [status: RequestStatus] ~ {
ENABLE {
Printing.ServiceUnavailable => {
ERROR Error[service, "Service Unavailable"];
};
Printing.SystemError => {
ERROR Error[service, "System Error"];
};
Printing.Undefined => {
ERROR Error[service, "Undefined"];
};
CrRPC.Error => {
SELECT errorReason FROM
courierVersionMismatch, rejectedNoSuchProgram, rejectedNoSuchVersion, cantConnectToRemote, communicationFailure => {
ERROR Error[connection, text];
};
rejectedNoSuchProcedure, rejectedInvalidArgument, argsError, resultsError, bulkDataError, protocolError, notImplemented, unknownOperation => {
ERROR Error[protocol, text];
};
rejectedUnspecified, remoteError, remoteClose => {
ERROR Error[connection, text]; };
ENDCASE  => {
ERROR Error[unknown, text];
};
};
};
h: CrRPC.Handle Ź CrHandleFromRope[request.context.printerName, HACK].h;
realStatus: Printing.RequestStatus Ź Printing.GetPrintRequestStatus[h, request.requestID];
CrRPC.DestroyClientHandle[h];
status Ź MungeRequestStatus[realStatus];
};

PrintFromFile: PUBLIC PROC [file: ROPE, context: Context, update: StatusChangedProc Ź NIL, clientData: REF Ź NIL] RETURNS [request: PrintRequest] ~ {
ENABLE {
FS.Error => {
ERROR Error[file, error.explanation];
};
Printing.Busy => {
ERROR Error[connection, "Busy"];
};
Printing.ConnectionError => {
ERROR Error[connection, "Connection Error"];
};
Printing.InsufficientSpoolSpace => {
ERROR Error[service, "Insufficient Spool Space"];
};
Printing.InvalidPrintParameters => {
ERROR Error[service, "Invalid Print Parameters"];
};
Printing.MasterTooLarge => {
ERROR Error[service, "Master Too Large"];
};
Printing.MediumUnavailable => {
ERROR Error[service, "Medium Unavailable"];
};
Printing.ServiceUnavailable => {
ERROR Error[connection, "Service Unavailable"];
};
Printing.SpoolingDisabled => {
ERROR Error[service, "Spooling Disabled"];
};
Printing.SpoolingQueueFull => {
ERROR Error[service, "Spooling Queue Full"];
};
Printing.SystemError => {
ERROR Error[service, "System Error"];
};
Printing.TooManyClients => {
ERROR Error[service, "Too Many Clients"];
};
Printing.TransferError => {
ERROR Error[service, "Transfer Error"];
};
Printing.Undefined => {
ERROR Error[service, "Undefined"];
};
CrRPC.Error => {
SELECT errorReason FROM
courierVersionMismatch, rejectedNoSuchProgram, rejectedNoSuchVersion, cantConnectToRemote, communicationFailure => {
ERROR Error[connection, text];
};
rejectedNoSuchProcedure, rejectedInvalidArgument, argsError, resultsError, bulkDataError, protocolError, notImplemented, unknownOperation => {
ERROR Error[protocol, text];
};
rejectedUnspecified, remoteError, remoteClose => {
ERROR Error[connection, text]; };
ENDCASE  => {
ERROR Error[unknown, text];
};
};
};
distingName: XNSCHName.Name; h: CrRPC.Handle Ź NIL;
ctx: Context Ź CopyContext[context];
[h, distingName] Ź CrHandleFromRope[ctx.printerName, HACK];
IF ( ctx.printObjectCreateDate = BasicTime.nullGMT )
THEN ctx.printObjectCreateDate Ź FS.FileInfo[file].created;
IF ( ctx.printObjectName = NIL ) THEN ctx.printObjectName Ź file;
request Ź CreatePrintRequest[ctx, FALSE];
request.clientData Ź clientData;
request.distinguishedName Ź XNSCHName.RopeFromName[distingName];
request.fileName Ź file;
request.ipMasterStream Ź FS.StreamOpen[file];
h.clientData Ź request;
request.requestID Ź Printing.Print[h, Xfer, request.attributes, request.options
];
CrRPC.DestroyClientHandle[h];
IF ( request.ipMasterStream # NIL ) THEN IO.Close[request.ipMasterStream];
IF ( update # NIL ) THEN RegisterPrintRequest[request, update];
};

Xfer: CrRPC.BulkDataXferProc ~ {
bufSize: NAT ~ 1024;
buf: REF TEXT ~ RefText.ObtainScratch[bufSize];
request: PrintRequest Ź NARROW [h.clientData];
abort Ź FALSE;
DO
IF ( IO.EndOf[request.ipMasterStream] ) THEN EXIT;
IF ( abort Ź checkAbort[h] ) THEN EXIT;
[] Ź IO.GetBlock[request.ipMasterStream, buf];
IO.PutBlock[s, buf];
ENDLOOP;
RefText.ReleaseScratch[buf];
};


mediaTable: RedBlackTree.Table; -- all values in this table are PaperInfo
unknownMedium: Printing.Medium; -- value from Init!

PaperInfo: TYPE ~ REF PaperInfoRep;	
PaperInfoRep: TYPE ~ RECORD [
kind: ROPE,
medium: Printing.Medium,
size: PaperDimensions
];

GetPaperDimensions: PUBLIC PROC [s: AvailableKind]
RETURNS [size: Printing.PaperDimensions Ź [0, 0]] ~ {
val: RedBlackTree.UserData ~ RedBlackTree.Lookup[mediaTable, s];
IF ( val # NIL ) THEN {
info: PaperInfo ~ NARROW [val, PaperInfo];
size Ź info.size;
};
};

ListAvailableKinds: PUBLIC PROC []
RETURNS [list: Media Ź NIL] ~ {
Append: RedBlackTree.EachNode ~ {
info: PaperInfo ~ NARROW[data];
list Ź CONS[info.kind, list];
};
RedBlackTree.EnumerateDecreasing[mediaTable, Append];
};

Insert: PUBLIC PROC [key: ROPE, medium: Printing.Medium, size: Printing.PaperDimensions] ~ {
ENABLE {
RedBlackTree.DuplicateKey => CONTINUE;
};
info: PaperInfo ~ NEW [PaperInfoRep Ź [key, medium, size]];
[] Ź RedBlackTree.Insert[mediaTable, info, key];
};

CreateAvailableKind: PUBLIC PROC [s: Printing.KnownPaperSize]
RETURNS [kind: AvailableKind] ~ {
kind Ź  PrintingAux.ExposeKnownPaperSize[s, 0];
};

CreateAvailableKindOther: PUBLIC PROC [size: Printing.PaperDimensions]
RETURNS [kind: AvailableKind] ~ {
kind Ź  PrintingAux.ExposePaperDimensions[size, 0];
};

CreateMedium: PUBLIC PROC [s: AvailableKind] RETURNS [medium: Printing.Medium] ~ {
val: RedBlackTree.UserData ~ RedBlackTree.Lookup[mediaTable, s];
IF ( val # NIL )
THEN {
info: PaperInfo ~ NARROW [val, PaperInfo];
medium Ź info.medium;
}
ELSE {
medium Ź unknownMedium;
};
};

MungeMedia: PUBLIC PROC [s: Printing.Media] RETURNS [media: Media] ~ {
FOR i: CARD16 IN [0..s.length) DO
medium: ROPE;
WITH s[i]­ SELECT FROM
mk: Printing.MediumObject.paper=> {
WITH mk.paper­ SELECT FROM
m: Printing.PaperObject.unknown => {
medium Ź "unknown";
};
m: Printing.PaperObject.knownSize => {
medium Ź CreateAvailableKind[m.knownSize];
};
m: Printing.PaperObject.otherSize => {
medium Ź CreateAvailableKindOther[m.otherSize];
Insert[medium, s[i], m.otherSize];
};
ENDCASE => ERROR FIREWALL;
};
ENDCASE => ERROR FIREWALL;
media Ź CONS [medium, media];
ENDLOOP;
};


GetDefaults: PUBLIC PROC [context: Context] RETURNS [Context] ~ {
IF ( context = NIL ) THEN context Ź NEW[ContextObject];
GetDefaultsFromProfile[context];
RETURN [context]
};

CreateAttributes: PUBLIC PROC [context: Context] RETURNS [attributes: Printing.PrintAttributes] ~ {
attributes Ź NEW[ Printing.PrintAttributesObject[3] ];
attributes.body[0] Ź NEW [Printing.AttributeObject.printObjectName Ź
[printObjectName[context.printObjectName]]];
attributes.body[1] Ź NEW [Printing.AttributeObject.printObjectCreateDate Ź
[printObjectCreateDate[BasicTime.ToNSTime[context.printObjectCreateDate]]]];
attributes.body[2] Ź NEW [Printing.AttributeObject.senderName Ź
[senderName[context.senderName]]];
};

CreateOptions: PUBLIC PROC [context: Context] RETURNS [Printing.PrintOptions] ~ {
result: Printing.PrintOptions Ź NIL;
medium: Printing.Medium Ź CreateMedium[context.mediumHint];
opt: ARRAY Printing.OptionKind OF Printing.Option Ź ALL[NIL];
CountOpt: PROC RETURNS [n: NAT Ź 0] = {
FOR o: Printing.OptionKind IN Printing.OptionKind DO
IF opt[o] # NIL THEN n Ź n+1;
ENDLOOP;
};
PlugOpt: PROC [options: Printing.PrintOptions] RETURNS [Printing.PrintOptions] = {
i: NAT Ź 0;
FOR o: Printing.OptionKind IN Printing.OptionKind DO
IF opt[o] # NIL THEN { options[i] Ź opt[o]; i Ź i+1 };
ENDLOOP;
RETURN [options]
};
IF context.recipientName # NIL THEN {
opt[recipientName] Ź NEW [Printing.OptionObject.recipientName Ź
[recipientName[context.recipientName]]];
};
IF context.message.Size # 0 THEN {
opt[message] Ź NEW [Printing.OptionObject.message Ź
[message[context.message]]];
};
IF context.copyCount # 0 THEN {
opt[copyCount] Ź NEW [Printing.OptionObject.copyCount Ź
[copyCount[context.copyCount]]];
};
IF context.pageFirst # 1 OR context.pageLast # 177777B THEN {
opt[pagesToPrint] Ź NEW [Printing.OptionObject.pagesToPrint Ź
[pagesToPrint[[context.pageFirst, context.pageLast]]]];
};
SELECT GetStapling[context] FROM
$default => {};
$unstapled => {
opt[staple] Ź NEW [Printing.OptionObject.staple Ź [staple[FALSE]]];
};
$stapled => {
opt[staple] Ź NEW [Printing.OptionObject.staple Ź [staple[TRUE]]];
};
ENDCASE => ERROR;
SELECT GetPlex[context] FROM
$default => {};
$simplex => {
opt[twoSided] Ź NEW [Printing.OptionObject.twoSided Ź [twoSided[FALSE]]];
};
$duplex => {
opt[twoSided] Ź NEW [Printing.OptionObject.twoSided Ź [twoSided[TRUE]]];
};
ENDCASE => ERROR;
IF medium # unknownMedium THEN {
opt[mediumHint] Ź NEW [Printing.OptionObject.mediumHint Ź [mediumHint[medium]]];
};
IF context.printObjectSize # 0 THEN {
opt[printObjectSize] Ź NEW [Printing.OptionObject.printObjectSize Ź
[printObjectSize[context.printObjectSize]]];
};
IF context.priorityHint # NIL THEN {
priorityNames: ARRAY Printing.Priority OF ROPE = [
low: "low", normal: "normal", high: "high"
];
FOR p: Printing.Priority IN Printing.Priority DO
IF Rope.Equal[context.priorityHint, priorityNames[p], FALSE] THEN {
opt[priorityHint] Ź NEW [Printing.OptionObject.priorityHint Ź
[priorityHint[p]]];
};
ENDLOOP;
};
IF context.releaseKey # 0 THEN {
opt[releaseKey] Ź NEW [Printing.OptionObject.releaseKey Ź
[releaseKey[context.releaseKey]]];
};
result Ź PlugOpt[NEW[Printing.PrintOptionsObject[CountOpt[]]]];
RETURN [result]
};

CopyContext: PROC [context: Context] RETURNS [new: Context] = {
new Ź NEW [ContextObject Ź context­];
SetStapling[new, GetStapling[context]];
SetPlex[new, GetPlex[context]];
};

CreatePrintRequest: PUBLIC PROC [context: Context, copyContext: BOOL Ź TRUE] RETURNS [request: PrintRequest] ~ {
privateContext: Context Ź IF ( copyContext ) THEN CopyContext[context] ELSE context;
request Ź NEW[PrintRequestObject];
request.context Ź privateContext;
request.update Ź NIL;
request.distinguishedName Ź NIL;
request.requestID Ź ALL[0];
request.lastStatus Ź [unknown, "uninitialized lastStatus"];
request.attributes Ź CreateAttributes[context];
request.options Ź CreateOptions[context];
request.ipMasterStream Ź NIL;
};

MungeProperties: PUBLIC PROC [s: Printing.PrinterProperties]
RETURNS [properties: Properties] ~ {
FOR i: CARD16 IN [0 .. s.length) DO
WITH s.body[i]­ SELECT FROM
v: ppmedia Printing.PropertyObject => { properties.media Ź MungeMedia[v.ppmedia]; };
v: ppstaple Printing.PropertyObject => { properties.staple Ź v.ppstaple; };
v: pptwoSided Printing.PropertyObject => { properties.twoSided Ź v.pptwoSided; };
ENDCASE => { ERROR FIREWALL };
ENDLOOP;
};

MungePrinterStatus: PUBLIC PROC [s: Printing.PrinterStatus]
RETURNS [printerstatus: PrinterStatus] ~ {
FOR i: CARD16 IN [0 .. s.length) DO
WITH s.body[i]­ SELECT FROM
v: spooler Printing.ServiceStatusObject => { printerstatus.spooler Ź v.spooler; };
v: formatter Printing.ServiceStatusObject => { printerstatus.formatter Ź v.formatter; };
v: printer Printing.ServiceStatusObject => { printerstatus.printer Ź v.printer; };
v: media Printing.ServiceStatusObject => {
printerstatus.media Ź MungeMedia[v.media];
};
ENDCASE => { ERROR FIREWALL };
ENDLOOP;
};

MungeRequestStatus: PUBLIC PROC [s: Printing.RequestStatus]
RETURNS [requeststatus: RequestStatus] ~ {
FOR i: CARD16 IN [0 .. s.length) DO
WITH s.body[i]­ SELECT FROM
v: status Printing.JobStatusObject => { requeststatus.status Ź v.status; };
v: statusMessage Printing.JobStatusObject => {
requeststatus.statusMessage Ź v.statusMessage;
};
ENDCASE => { ERROR FIREWALL };
ENDLOOP;
};

CrHandleFromRope: PROC [pattern: ROPE, smash: BOOL Ź FALSE, socket: XNS.Socket Ź XNS.unknownSocket] RETURNS [h: CrRPC.Handle, name: XNSCHName.Name] ~ {
addr: XNS.Address;
[name, addr] Ź XNSCH.LookupAddressFromRope[pattern];
IF ( addr = XNS.unknownAddress ) THEN ERROR Error[name, "Address not found"];
IF ( ( addr.socket # XNS.unknownSocket ) AND ( smash ) ) THEN addr.socket Ź socket;
h Ź CrRPC.CreateClientHandle[$CMUX, NEW[XNS.Address Ź addr]];
};

GetDefaultsFromProfile: PROC [context: Context] ~ {
me: ROPE ~ SystemNames.UserName[];
context Ź IF ( context = NIL ) THEN NEW [ContextObject] ELSE context;

context.copyCount Ź UserProfile.Number[COPYCOUNT, 1];
context.mediumHint Ź UserProfile.Line[MEDIUM, "usLetter"];
context.message Ź UserProfile.Line[BANNER, ""];
context.pageFirst Ź UserProfile.Number[PAGEFIRST, 1];
context.pageLast Ź UserProfile.Number[PAGELAST, 177777B];
context.printerName Ź UserProfile.Line[IPPRINTER, "Huh? -- no printer!"];
context.printObjectCreateDate Ź BasicTime.nullGMT;
context.printObjectName Ź NIL; --UserProfile.Line[SILLYNAME];
context.printObjectSize Ź 0; --UserProfile.Number[SIZE];
context.priorityHint Ź UserProfile.Line[PRIORITY, "normal"];
context.recipientName Ź UserProfile.Line[PIGEONHOLE, me];
context.releaseKey Ź UserProfile.Number[KEY, 0];
context.senderName Ź me;
SetStapling[context, SELECT TRUE FROM
Rope.Match["*default*", UserProfile.Token[STAPLED, NIL], FALSE] => $default,
ENDCASE => IF UserProfile.Boolean[STAPLED, FALSE] THEN $stapled ELSE $unstapled
];
context.telephone Ź UserProfile.Line[FAX, ""];
SetPlex[context, SELECT TRUE FROM
Rope.Match["*default*", UserProfile.Token[TWOSIDED, NIL], FALSE] => $default,
ENDCASE => IF UserProfile.Boolean[TWOSIDED, TRUE] THEN $duplex ELSE $simplex
];
context.twoSided Ź UserProfile.Boolean[TWOSIDED, TRUE];
};


GetKey: RedBlackTree.GetKey ~ {
info: PaperInfo ~ NARROW[data];
RETURN[info.kind];
};

Compare: RedBlackTree.Compare ~ {
info: PaperInfo ~ NARROW[data];
thisKey: ROPE ~ NARROW[k];
RETURN[Rope.Compare[info.kind, thisKey, FALSE]];
};

InitializeMediaTable: PROC [] ~ {
AddKnown: PROC [k: Printing.KnownPaperSize, size: Printing.PaperDimensions] ~ {
key: ROPE ~ CreateAvailableKind[k];
paper: Printing.Paper ~ NEW [Printing.PaperObject Ź [knownSize[k]]];
medium: Printing.Medium ~ NEW [Printing.MediumObject Ź [paper[paper]]];
Insert[key, medium, size]
};

mediaTable Ź RedBlackTree.Create[GetKey, Compare];

AddKnown[usLetter,	[ 216,  279]];
AddKnown[usLegal,	[ 216,  356]];
AddKnown[a0,	[ 841, 1189]];
AddKnown[a1,	[ 594,  841]];
AddKnown[a2,	[ 420,  594]];
AddKnown[a3,	[ 297,  420]];
AddKnown[a4,	[ 210,  297]];
AddKnown[a5,	[ 148,  210]];
AddKnown[a6,	[ 105,  148]];
AddKnown[a7,	[  74,  105]];
AddKnown[a8,	[  52,   74]];
AddKnown[a9,	[  37,   52]];
AddKnown[a10,	[  26,   37]];

AddKnown[isoB0,	[1000, 1414]];
AddKnown[isoB1,	[ 707, 1000]];
AddKnown[isoB2,	[ 500,  707]];
AddKnown[isoB3,	[ 353,  500]];
AddKnown[isoB4,	[ 250,  353]];
AddKnown[isoB5,	[ 176,  250]];
AddKnown[isoB6,	[ 125,  176]];
AddKnown[isoB7,	[  88,  125]];
AddKnown[isoB8,	[  62,   88]];
AddKnown[isoB9,	[  44,   62]];
AddKnown[isoB10,	[  31,   44]];

AddKnown[jisB0,	[1030, 1456]];
AddKnown[jisB1,	[ 728, 1030]];
AddKnown[jisB2,	[ 515,  728]];
AddKnown[jisB3,	[ 364,  515]];
AddKnown[jisB4,	[ 257,  364]];
AddKnown[jisB5,	[ 182,  257]];
AddKnown[jisB6,	[ 128,  182]];
AddKnown[jisB7,	[  91,  128]];
AddKnown[jisB8,	[  64,   91]];
AddKnown[jisB9,	[  45,   64]];
AddKnown[jisB10,	[  32,   45]];
};

Init: ENTRY PROC ~ {
ENABLE { UNWIND => NULL };
TRUSTED {
Process.SetTimeout[@RequestListChanged, Process.SecondsToTicks[QUANTUS]];
Process.Detach[FORK WatchRequestList];
};
{
paper: Printing.Paper ~ NEW [Printing.PaperObject Ź [unknown[NULL]]];
unknownMedium Ź NEW [Printing.MediumObject Ź [paper[paper]]];
}
};

Init[];
InitializeMediaTable[];

}...

  
"  
XNSPrintImpl.mesa
Copyright Ó 1985, 1986, 1987, 1992, 1993 by Xerox Corporation.  All rights reserved.
Bill Jackson (bj) April 9, 1987 1:16:54 am PDT
Tim Diebert: February 9, 1987 11:08:15 am PST
Russ Atkinson (RRA) April 9, 1987 11:43:00 am PDT
Jean-Marc Frailong April 21, 1987 2:53:24 pm PDT
Michael Plass, June 2, 1993 3:13 pm PDT
Foote, February 10, 1992 4:20 pm PST
Willie-s, April 2, 1992 2:21 pm PST

UserProfile Tags

Global State (atomically altered under the monitor)

Extensions
StatusWatcher Procs


Request Manager Procs


Watcher process
( oldStatus IN [rejected..canceled] ) => {
UnRegisterPrintRequest[tail.first];
}
Reschedule this guy?

Errors


Print Service Interaction

REPORTS [ServiceUnavailable, SystemError, Undefined]
REPORTS [ServiceUnavailable, SystemError, Undefined]
REPORTS [ServiceUnavailable, SystemError, Undefined]
REPORTS [Busy, ConnectionError, InsufficientSpoolSpace, InvalidPrintParameters, MasterTooLarge, MediumUnavailable, ServiceUnavailable, SpoolingDisabled, SpoolingQueueFull, SystemError, TooManyClients, TransferError, Undefined]
An abstract representation of "Media"

General comments:
A RedBlackTree keeps track of the association ROPE -> (medium, size). It is initialized with all the known paper sizes. For otherSize papers, an entry in the table is created each time a media description is returned by a printer. This ensures that (legally) only the names in the RedBlackTree are recognizable by printer, and therefore, only these may be quoted by the user.
The unknown medium raises a problem. This medium is sent back by a printer when it cannot determine the size of the paper. The reference says that in that case, it is the only medium description returned (i.e. media are either the single unknown medium, or a sequence of decent media). The solution used here is to never enter unknown in the table. This implies that there is an asymmetry here in that users could see "unknown", and if a user selects "unknown", we won't have a table entry, and will use some special value (=  unknown), in which case the user will get whatever medium the printer wants, and will get a size info of [0, 0]. Too bad for him...
Return the size of this medium in millimeters.
A length of 0 means roll paper (indefinite length).
A width of 0 will be returned if the medium is not (currently) known.
When converting to a medium, a unknown is returned if the entry is not found.
Insert[medium, s[i], [x, x]]; -- guaranteed to be in table (well known sizes).
Context Procs
Internal Procs

Initialization

sizes are from Printing Protocol XSIS 118404
Ę-  (cedarcode) styleNewlineDelimiter
 Icode
ĎeITK..K*Ďk-K1K0K'K$K#J 		K
)KKLWK	K'K$4K/<Ki{K!.K/KK 1K2;K$K
%KKK		KK ĎnKaK$KDKK K KĐbkĎbĄ!K 	ĄĄ	'K Ą&K 	Ą/K ĄĄK ĄĄ!K 
ĄĄ
)K 	ĄĄ	'K ĄĄ%K ĄĄ%K ĄĄ#K ĄĄ%K 3K K)-K K K
Ďc>K 
K1$KKK	KK 2K PKK)*SK#MKK/S=EKKKKKRYK+KK	KK 0c%K	
	_KKKK :R%K$K&KKKK ,[%K			YKKKK 2F%KK"KKKK K K	%K K K	%K 5{KK!;KK ;K	KK EK#KK--K1K:YKKKKK	KK 
KKKKK K )KKKK K
K#˘%H˘
K,:
VKK
+KK) K##K*K##KK:K.6K55KKK'K55K##KK
K˘
KK K K
!AK	 ˘+JK K aJ-4  K',KK %KK"KttKKKK22K!KKKKK/3K''K- 3K.KK%K.KK `J-4  K',KK %KK"KttKKKK22K!KKKKK/3K##K- 3K*KK(K.K ^J-4  K',KK %KK"KttKKKK22K!KKKKK@ HKZKK(KK 0JŰâK %KK KK',K$$K,1K$$K,1KK$)KK&+K  K*/KK%*KK',KK %KK$)KK"'KK"KttKKKK22K!KKKKK/3K$K5 ;24K;KAK")K K@KK-KOKKKJK'?KK  K	K"/K.KK!2K'K'.KKKKK %K K.Ĺ÷KĄźĄUĄčK KĄ
˘)IKĄ˘3K K$KKKK .hK.K3KEK1Ą
@	K*KKKK 
B!K%clearTabStops 25 sp flushLeft tabStopKKK!Ą

5KK >\K&KK&;KĄ
0KK _K-Ďt/KK "hK1Ł3KK RKĄ'MK1Ą
@	K*KKK	ĄKKK 
F!K##$$KK&&K*KNNK&&K/K""KKKKKKKK K AK7K K
KK +cK&6KYqKKJbKK QK $K;K	=	'4K
	KK"RK4K
"6KK
K%KPhK"K>PKKDXK=K^uK KK)CKK)BKKKK-IKK-HKK
Ą K;PK%KVpK$2K*K04CK:QKKK KG\KK+?K	KK ?K%K'KKK !pK	TK
"K!KK KK;K/K)KKK !a#KTKKKQK KKK #f#KRKXKR**K*KK KKK #f#KK..K.KK KKK K 	

,K	K 4K
"MKSK$=KK 3K"K
	EK K' 	5K& :K# /K' 	5K& 9K' 	IK2K˘Đbc	˘=K˘¤˘8K( <K) 
9K( 0K%K* LK 
OKK% .!K* MK 		LKK' 7KK K %clearTabStops 25 sp flushLeft tabStoppostfix%clearTabStops 30 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStop %clearTabStops 30 sp flushLeft tabStop%clearTabStops 25 sp flushLeft tabStop!K%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStop	K%clearTabStops 25 sp flushLeft tabStop"0K%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStop %clearTabStops 25 sp flushLeft tabStop!%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopAOK%clearTabStops 25 sp flushLeft tabStop#K)DK%clearTabStops 25 sp flushLeft tabStop*GK%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStop K%clearTabStops 25 sp flushLeft tabStopĄ
(2K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStop K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStop,,K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStop K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁ!K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁ K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop K%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStop K%clearTabStops 25 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopŁŁK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStopK%clearTabStops 25 sp flushLeft tabStop%clearTabStops 30 sp flushLeft tabStop K	K? IK&KK"EKĄ*=KKK KKK KK      Zö  ˛  