DIRECTORY
BitmapEdit USING [CreateBitmapViewer, GetBitmap, SetBitmap],
Commander USING [CommandProc, Handle, Register],
Convert USING [AppendInt, AppendReal, AppendRope, Error, IntFromRope, RealFromRope],
FontEdit USING [CharRange],
FS USING [ComponentPositions, Error, ExpandName],
Imager USING [black, MaskRectangle, ClipRectangleI, Context, DoSave, DoSaveAll, MaskBits, MaskBox, SetColor, SetXY, SetXYRel, Trans, VEC, white],
ImagerBackdoor USING [GetCP],
ImagerPixelMap USING [Clear, Clip, Create, DeviceRectangle, Fill, PixelMap, ShiftMap, Transfer, Trim, Window],
IO USING [Backup, CharClass, EndOf, EndOfStream, GetChar, GetIndex, GetTokenRope, int, PutF, PutFR, PutRope, RIS, rope, SetIndex, STREAM],
Menus USING [AppendMenuEntry, ClickProc, CreateEntry, CreateMenu, Menu],
MessageWindow USING [Append, Blink],
Process USING [MsecToTicks, Pause],
RasterFontIO USING [ComputeFontMetrics, Create, FormatError, InternalCharRep, InternalFont, InternalFontRep, Load, Trim, WriteAC, WriteKernedStrike, WriteStrike],
Real USING [Round, RoundI],
Rope USING [Concat, Equal, Fetch, FromRefText, Length, Map, ROPE, Substr],
TIPUser USING [InstantiateNewTIPTable, TIPScreenCoords, TIPScreenCoordsRec],
ViewerClasses USING [AdjustProc, NotifyProc, PaintProc, SaveProc, Viewer, ViewerClass, ViewerClassRec],
ViewerOps USING [CreateViewer, MoveViewer, PaintViewer, RegisterViewerClass, SaveViewer, SetNewVersion],
ViewerTools USING [GetSelectedViewer];

FontEditImpl: CEDAR PROGRAM
IMPORTS BitmapEdit, Commander, Convert, FS, Imager, ImagerBackdoor, ImagerPixelMap, IO, Menus, MessageWindow, Process, RasterFontIO, Real, Rope, TIPUser, ViewerOps, ViewerTools
EXPORTS FontEdit
~ BEGIN

ROPE: TYPE ~ Rope.ROPE;
InternalFont: TYPE ~ RasterFontIO.InternalFont; 

Data: TYPE ~ REF DataRep;
DataRep: TYPE ~ RECORD [
fileName: ROPE,
font: InternalFont,
refreshing: BOOLEAN _ FALSE,
hasAChar: BOOLEAN _ FALSE,
curCharCode: CHAR,
savedCharRep: RasterFontIO.InternalCharRep,
bitmapViewer: ViewerClasses.Viewer,
textBaseline: INTEGER _ 4,
textDepth: INTEGER _ 2,
text: ROPE,
paintProcess: PROCESS _ NIL
];

defaultText: ROPE _ "the quick brown fox jumps over lazy dogs; THE QUICK BROWN FOX JUMPS OVER LAZY DOGS.";
allChars: ROPE _ AllChars[];
AllChars: PROC RETURNS [ROPE] ~ {
text: REF TEXT _ NEW[TEXT[256]];
FOR i: NAT IN [0..256) DO
text[i] _ '\000 + i;
ENDLOOP;
text.length _ 256;
RETURN [Rope.FromRefText[text]]
};

DrawBitmapChar: PROC [context: Imager.Context, char: RasterFontIO.InternalCharRep, xMinGarbage: INT] RETURNS [xMaxGood: INT] ~ {
inner: PROC ~ {
cp: Imager.VEC ~ ImagerBackdoor.GetCP[context, TRUE];
xMaxGood _ MAX[Real.Round[cp.x]+char.pixels.fSize+char.pixels.fMin+char.pixels.fOrigin, xMinGarbage];
Imager.SetColor[context, Imager.white];
Imager.MaskBox[context, [xMinGarbage, -9999, xMaxGood, 9999]];
Imager.SetColor[context, Imager.black];
Imager.Trans[context];
Imager.MaskBits[context: context, base: char.pixels.refRep.pointer, wordsPerLine: char.pixels.refRep.rast, sMin: char.pixels.sMin, fMin: char.pixels.fMin, sSize: char.pixels.sSize, fSize: char.pixels.fSize, tx: char.pixels.fOrigin+char.pixels.fMin, ty: -(char.pixels.sOrigin+char.pixels.sMin)];
Imager.SetXYRel[context, [char.fWidth, -char.sWidth]];
};
Imager.DoSave[context, inner];
};

DrawText: PROC [viewer: ViewerClasses.Viewer, context: Imager.Context] ~ {
data: Data _ NARROW[viewer.data];
proc: PROC ~ {
xMinGarbage: INT _ 0;
Action: PROC [c: CHAR] RETURNS [quit: BOOLEAN _ FALSE] ~ {
IF xMinGarbage > viewer.cw THEN RETURN [TRUE];
xMinGarbage _ DrawBitmapChar[context, data.font.charRep[c], xMinGarbage];
};
IF data.font = NIL THEN RETURN;
StoreCurrent[viewer];
Imager.SetXY[context, [4, viewer.ch-data.textBaseline]];
Imager.MaskRectangle[context, [0,viewer.ch-data.textBaseline, 10000, 1]];
Imager.ClipRectangleI[context, 0, viewer.ch-data.textBaseline-data.textDepth, viewer.cw, data.textBaseline+data.textDepth];
[] _ data.text.Map[action: Action];
Imager.SetColor[context, Imager.white];
Imager.MaskBox[context, [xMinGarbage, -9999, 9999, 9999]];
};
Imager.DoSaveAll[context, proc];
};

FindSelectedChar: PROC [viewer: ViewerClasses.Viewer, where: TIPUser.TIPScreenCoordsRec] RETURNS [index: INT] ~ {
data: Data _ NARROW[viewer.data];
fMouse: INT _ where.mouseX;
cpf: INT _ 4;
Action: PROC [c: CHAR] RETURNS [quit: BOOLEAN _ FALSE] ~ {
charRep: RasterFontIO.InternalCharRep _ data.font.charRep[c];
window: ImagerPixelMap.DeviceRectangle _ charRep.pixels.Window;
IF fMouse-cpf IN [window.fMin..window.fMin+window.fSize) THEN RETURN [TRUE];
cpf _ cpf + Real.Round[charRep.fWidth];
index _ index + 1;
};
index _ 0;
IF NOT data.text.Map[action: Action] THEN index _ -1;
};

RefreshProcess: PROC [viewer: ViewerClasses.Viewer] ~ {
data: Data _ NARROW[viewer.data];
WHILE data.refreshing AND NOT viewer.destroyed DO
IF data.bitmapViewer.newVersion THEN {
ViewerOps.PaintViewer[viewer, client, FALSE, $Text];
ViewerOps.SetNewVersion[viewer];
};
Process.Pause[Process.MsecToTicks[300]];
ENDLOOP;
};

GetSelection: PROC RETURNS [selectionContents: ROPE] ~ {
selectedViewer: ViewerClasses.Viewer _ ViewerTools.GetSelectedViewer[];
IF selectedViewer = NIL OR selectedViewer.class.get = NIL THEN RETURN [NIL];
selectionContents _ NARROW[selectedViewer.class.get[selectedViewer, $SelChars]];
};

ComputeCaption: PROC [viewer: ViewerClasses.Viewer, paint: BOOLEAN _ TRUE] ~ {
data: Data _ NARROW[viewer.data];
text: REF TEXT _ NEW[TEXT[200]];
PutRope: PROC [rope: ROPE] ~ {text _ Convert.AppendRope[text, rope, FALSE]};
PutInt: PROC [int: INT] ~ {text _ Convert.AppendInt[text, int]};
PutReal: PROC [real: REAL] ~ {text _ Convert.AppendReal[text, real]};
PutRope[data.fileName];
PutRope[CharEncode[data.curCharCode]];
PutRope[" ("];
PutRope[data.font.family];
PutRope[" Face"];
PutInt[data.font.face];
PutRope[" "];
PutReal[data.font.bitsPerEmQuad];
PutRope["bpm "];
PutReal[data.font.bitsPerInch];
PutRope["bpi)"];
viewer.name _ Rope.FromRefText[text];
IF paint THEN ViewerOps.PaintViewer[viewer, caption];
text _ NIL;
};

Create: PUBLIC PROC [fontFileName: ROPE] RETURNS [viewer: ViewerClasses.Viewer] ~ {
menu: Menus.Menu _ Menus.CreateMenu[];
data: Data _ NEW[DataRep];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Undo",
proc: UndoButton,
documentation: "Undo edits to the current character"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Get",
proc: GetButton,
documentation: "Get a raster font"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Store",
proc: StoreButton,
documentation: "Store a raster font"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Save",
proc: SaveButton,
documentation: "Save the raster font"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Char",
proc: CharButton,
documentation: "Edit a new character"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Next/Prev",
proc: NextPrevButton,
documentation: "Move to the next or previous char"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Text",
proc: TextButton,
documentation: "See what some text looks like"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Family",
proc: FamilyButton,
documentation: "Set the family"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Face",
proc: FaceButton,
documentation: "Set the face code"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Em",
proc: EmButton,
documentation: "Set the number of bits per em"
]
];
Menus.AppendMenuEntry[
menu: menu,
entry: Menus.CreateEntry[
name: "Res",
proc: ResButton,
documentation: "Set the number of bits per inch for AC fonts"
]
];
viewer _ ViewerOps.CreateViewer[$FontEdit, [menu: menu, name: "Font Editor", data: data], FALSE];
data.bitmapViewer _ BitmapEdit.CreateBitmapViewer[4, 4, [border: FALSE, parent: viewer, wh: 20, ww: 20]];
Get[viewer, fontFileName];
IF data.font = NIL THEN data.font _ RasterFontIO.Create[[-5, 1, 6, 4], 6];
data.text _ defaultText;
ViewerOps.PaintViewer[viewer, all];
};

Get: PROC [viewer: ViewerClasses.Viewer, fontFileName: ROPE] ~ {
data: Data _ NARROW[viewer.data];
Complain: PROC [expl: ROPE] ~ {
MessageWindow.Append[expl, TRUE];
MessageWindow.Blink[];
};
fontFileName _ FS.ExpandName[fontFileName ! FS.Error => CONTINUE].fullFName;
data.font _ RasterFontIO.Load[fontFileName !
RasterFontIO.FormatError => {
Complain[IO.PutFR["Font file format error at byte index %g", IO.int[byteIndex]]];
GOTO Bad
};
FS.Error => {Complain[error.explanation]; GOTO Bad};
];
RasterFontIO.Trim[data.font];
data.fileName _ fontFileName;
SetChar[viewer, 'A];
EXITS Bad => NULL;
};

WriteFormatDerivedFromName: PUBLIC PROC [internalFont: InternalFont, fileName: Rope.ROPE] ~ {
ENABLE FS.Error => {
MessageWindow.Append[error.explanation, TRUE];
MessageWindow.Blink[];
GOTO Quit;
};
firstChar: CHAR _ fileName.Fetch[0];
fontFileType: FontFileType _ FontFileNameType[fileName];
RasterFontIO.Trim[internalFont];
SELECT fontFileType FROM
ac => RasterFontIO.WriteAC[internalFont, fileName];
ks => RasterFontIO.WriteKernedStrike[internalFont, fileName];
strike => {
FOR c: CHAR IN CHAR DO
charRep: RasterFontIO.InternalCharRep _ internalFont.charRep[c];
IF charRep # internalFont.defaultChar THEN {
box: ImagerPixelMap.DeviceRectangle _ charRep.pixels.Window;
IF box.fMin < 0 THEN {
charRep.pixels _ charRep.pixels.ShiftMap[0, -box.fMin];
box _ charRep.pixels.Window;
};
IF box.fMin < 0 THEN ERROR;
charRep.fWidth _ MAX[charRep.fWidth, box.fMin+box.fSize];
internalFont.charRep[c] _ charRep;
};
ENDLOOP;
RasterFontIO.WriteStrike[internalFont, fileName];
};
ENDCASE => {
MessageWindow.Append["Cannot figure out what file format to use for ", TRUE];
MessageWindow.Append[fileName, FALSE];
MessageWindow.Blink[];
};
EXITS Quit => NULL;
};

Save: ViewerClasses.SaveProc ~ {
data: Data _ NARROW[self.data];
StoreCurrent[self];
WriteFormatDerivedFromName[data.font, data.fileName];
SetChar[self, data.curCharCode];
};

GetButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
rope: ROPE _ GetSelection[];
IF rope.Length = 0 THEN {
MessageWindow.Append["Please select a font file name.", TRUE];
MessageWindow.Blink[];
}
ELSE Get[viewer, rope];
};

FontFileType: TYPE ~ {invalid, unknown, ac, strike, ks};
FontFileNameType: PROC [rope: ROPE] RETURNS [FontFileType] ~ {
fullFName: ROPE _ NIL;
cp: FS.ComponentPositions;
bad: BOOLEAN _ FALSE;
extension: ROPE _ NIL;
[fullFName, cp] _ FS.ExpandName[rope ! FS.Error => {bad _ TRUE; CONTINUE}];
IF bad THEN RETURN [invalid];
extension _ fullFName.Substr[cp.ext.start, cp.ext.length];
SELECT TRUE FROM
extension.Equal["ac", FALSE] => RETURN [ac];
extension.Equal["strike", FALSE] => RETURN [strike];
extension.Equal["ks", FALSE] => RETURN [ks];
ENDCASE => RETURN [unknown];
};

StoreButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
rope: ROPE _ GetSelection[];
fontFileType: FontFileType _ FontFileNameType[rope];
IF fontFileType = invalid THEN {
MessageWindow.Append["Please select a valid font file name.", TRUE];
MessageWindow.Blink[];
}
ELSE {
data.fileName _ IF fontFileType = unknown THEN rope.Concat[".ks"] ELSE rope;
ComputeCaption[viewer];
ViewerOps.SaveViewer[viewer];
};
};

SaveButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
ViewerOps.SaveViewer[viewer];
};

CharButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
rope: ROPE _ GetSelection[];
IF rope.Length = 0 THEN {
MessageWindow.Append["Please select a character.", TRUE];
MessageWindow.Blink[];
}
ELSE {
SetChar[viewer, rope.Fetch[0]];
};
};

UndoButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
charRep: RasterFontIO.InternalCharRep _ data.savedCharRep;
badCharRep: RasterFontIO.InternalCharRep;
StoreCurrent[viewer];
badCharRep _ data.font.charRep[data.curCharCode];
data.font.charRep[data.curCharCode] _ charRep;
SetChar[viewer, data.curCharCode];
data.savedCharRep _ badCharRep;
};

NextPrevButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
newChar: CHAR _ data.curCharCode;
IF mouseButton = blue THEN {
IF newChar = FIRST[CHAR] THEN newChar _ LAST[CHAR] ELSE newChar _ newChar-1
};
IF mouseButton = red THEN {
IF data.curCharCode = LAST[CHAR] THEN newChar _ FIRST[CHAR] ELSE newChar _ newChar+1
};
SetChar[viewer, newChar];
};

TextButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
IF mouseButton = red THEN data.text _ GetSelection[];
IF mouseButton = yellow THEN data.text _ defaultText;
IF mouseButton = blue THEN data.text _ allChars.Substr[MAX[data.curCharCode-'\000-2, 0]];
ViewerOps.PaintViewer[viewer, client, FALSE, $Text];
};

FamilyButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
data.font.family _ GetSelection[];
ComputeCaption[viewer];
};

FaceButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
data.font.face _ Convert.IntFromRope[GetSelection[] ! Convert.Error => CONTINUE];
ComputeCaption[viewer];
};

EmButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
new: REAL _ -1;
new _ Convert.IntFromRope[GetSelection[] ! Convert.Error => CONTINUE];
IF new = -1 THEN new _ Convert.RealFromRope[GetSelection[] ! Convert.Error => CONTINUE];
IF new >= 1 THEN data.font.bitsPerEmQuad _ new;
ComputeCaption[viewer];
};

ResButton: Menus.ClickProc ~ {
viewer: ViewerClasses.Viewer _ NARROW[parent];
data: Data _ NARROW[viewer.data];
new: REAL _ -1;
new _ Convert.IntFromRope[GetSelection[] ! Convert.Error => CONTINUE];
IF new = -1 THEN new _ Convert.RealFromRope[GetSelection[] ! Convert.Error => CONTINUE];
IF new > 0 THEN data.font.bitsPerInch _ new;
ComputeCaption[viewer];
};

StoreCurrent: PROC [viewer: ViewerClasses.Viewer] ~ {
data: Data _ NARROW[viewer.data];
IF data.hasAChar AND data.bitmapViewer.newVersion THEN {
charRep: RasterFontIO.InternalCharRep;
[sWidth: charRep.sWidth, fWidth: charRep.fWidth, pixelMap: charRep.pixels] _ BitmapEdit.GetBitmap[data.bitmapViewer];
charRep.pixels _ charRep.pixels.Trim[0];
IF charRep.pixels.sSize = 0 OR charRep.pixels.fSize = 0 THEN {
charRep.pixels.sOrigin _ 0;
charRep.pixels.fOrigin _ 0;
charRep.pixels.sSize _ 0;
charRep.pixels.fSize _ 0;
};
IF Real.RoundI[data.font.charRep[data.curCharCode].sWidth] = charRep.sWidth AND Real.RoundI[data.font.charRep[data.curCharCode].fWidth] = charRep.fWidth THEN
data.font.charRep[data.curCharCode].pixels _ charRep.pixels
ELSE data.font.charRep[data.curCharCode] _ charRep;
};
data.bitmapViewer.newVersion _ FALSE;
};

CharEncode: PROC [char: CHAR] RETURNS [rope: ROPE] ~ {
text: REF TEXT _ NEW[TEXT[7]];
charVal: NAT _ char - '\000;
text[0] _ text[1] _ text[2] _ text[3] _ ' ;
IF char IN [' ..'~] THEN {
text[1] _ '';
text[2] _ char;
};
text[4] _ '0 + charVal/64;
text[5] _ '0 + charVal/8 MOD 8;
text[6] _ '0 + charVal MOD 8;
text.length _ 7;
rope _ Rope.FromRefText[text];
};

SetChar: PROC [viewer: ViewerClasses.Viewer, char: CHAR] ~ {
data: Data _ NARROW[viewer.data];
window: ImagerPixelMap.DeviceRectangle _ data.font.charRep[char].pixels.Window;
sMax: INTEGER _ window.sMin+window.sSize;
fMax: INTEGER _ window.fMin+window.fSize;
pixelMap: ImagerPixelMap.PixelMap;
data.refreshing _ FALSE;
IF data.paintProcess # NIL THEN TRUSTED {[] _ JOIN data.paintProcess};
data.paintProcess _ NIL;
StoreCurrent[viewer];
window.sMin _ MIN[window.sMin, 0, Real.RoundI[data.font.charRep[char].sWidth], 4-data.textBaseline]-1;
window.fMin _ MIN[window.fMin, 0, Real.RoundI[data.font.charRep[char].fWidth]]-1;
sMax _ MAX[sMax, 0, Real.RoundI[data.font.charRep[char].sWidth], data.textDepth-2]+1;
fMax _ MAX[fMax, 0, Real.RoundI[data.font.charRep[char].fWidth]]+1;
window.sSize _ sMax - window.sMin;
window.fSize _ fMax - window.fMin;
data.curCharCode _ char;
data.hasAChar _ TRUE;
data.savedCharRep _ data.font.charRep[char];
pixelMap _ ImagerPixelMap.Create[0, window];
pixelMap.Clear;
pixelMap.Transfer[data.savedCharRep.pixels];
{  x: INTEGER ~ data.bitmapViewer.wx;
y: INTEGER ~ data.bitmapViewer.wy;
w: INTEGER ~ data.bitmapViewer.ww;
h: INTEGER ~ data.bitmapViewer.wh;
ViewerOps.MoveViewer[data.bitmapViewer, 2000, 2000, 0, 0, FALSE];
BitmapEdit.SetBitmap[data.bitmapViewer, pixelMap, Real.RoundI[data.savedCharRep.sWidth], Real.RoundI[data.savedCharRep.fWidth]];
ViewerOps.MoveViewer[data.bitmapViewer, x, y, w, h, FALSE];
};
ComputeCaption[viewer, FALSE];
ViewerOps.PaintViewer[viewer, all];
data.refreshing _ TRUE;
data.paintProcess _ FORK RefreshProcess[viewer];
};

FontEditPaintProc: ViewerClasses.PaintProc ~ {
data: Data _ NARROW[self.data];
IF whatChanged = NIL OR whatChanged = $Text THEN {
DrawText[self, context];
};
quit _ whatChanged = $Text;
};

FontEditAdjustProc: ViewerClasses.AdjustProc ~ {
data: Data _ NARROW[self.data];
IF data # NIL THEN {
data.textBaseline _ 4;
data.textDepth _ 2;
IF data.font # NIL THEN {
bc, ec: CHAR;
sMin, fMin, sMax, fMax: INTEGER;
maxWidth, totalWidth, fSizeStrike: CARDINAL;
[bc, ec, sMin, fMin, sMax, fMax, maxWidth, totalWidth, fSizeStrike] _ data.font.ComputeFontMetrics;
data.textBaseline _ 4-sMin;
data.textDepth _ 2+sMax;
WHILE data.textBaseline+data.textDepth > 2 AND INTEGER[self.ch]-(data.textBaseline+data.textDepth) < sMax-sMin DO
data.textBaseline _ data.textBaseline - data.textBaseline/2;
data.textDepth _ data.textDepth - data.textDepth/2;
ENDLOOP;
};
IF data.bitmapViewer#NIL THEN {
data.bitmapViewer.wx _ data.bitmapViewer.cx _ 0;
data.bitmapViewer.wy _ data.bitmapViewer.cy _ 0;
data.bitmapViewer.ww _ data.bitmapViewer.cw _ self.cw;
data.bitmapViewer.wh _ data.bitmapViewer.ch _ self.ch-(data.textBaseline+data.textDepth);
};
adjusted _ TRUE;
};
};
FontEditNotifyProc: ViewerClasses.NotifyProc = {
IF ISTYPE[input.first, TIPUser.TIPScreenCoords] THEN {
data: Data _ NARROW[self.data];
mousePlace: TIPUser.TIPScreenCoords _ NARROW[input.first];
SELECT input.rest.first FROM
$SelectChar => {
index: INT _ FindSelectedChar[self, mousePlace^];
IF index >= 0 THEN {
char: CHAR _ data.text.Fetch[index];
IF char # data.curCharCode THEN {
SetChar[self, char];
};
};
};
$CopyChar => {
index: INT _ FindSelectedChar[self, mousePlace^];
IF index >= 0 THEN {
char: CHAR _ data.text.Fetch[index];
IF char # data.curCharCode THEN {
charRep: RasterFontIO.InternalCharRep _ data.font.charRep[char];
BitmapEdit.SetBitmap[data.bitmapViewer, charRep.pixels, Real.RoundI[charRep.sWidth], Real.RoundI[charRep.fWidth]];
data.font.charRep[data.curCharCode] _ charRep;
data.bitmapViewer.newVersion _ TRUE;
};
};
};
ENDCASE => NULL;
};
}; 

GetToken: PROC [stream: IO.STREAM] RETURNS [token: ROPE _ NIL] = {
token _ stream.GetTokenRope[Break ! IO.EndOfStream => CONTINUE].token;
};
Break: PROC [char: CHAR] RETURNS [IO.CharClass] = {
IF char = '_ OR char = '; THEN RETURN [break];
IF char = '  OR char = '	 OR char = ', OR char = '\n THEN RETURN [sepr];
RETURN [other];
};

SpecError: PUBLIC ERROR [offset: INT] ~ CODE;
CharRange: TYPE ~ FontEdit.CharRange;
defaultChar: CARDINAL ~ 400B;
ParseCharSpec: PUBLIC PROC [stream: IO.STREAM] RETURNS [LIST OF CharRange] ~ {
i: NAT _ 0;
c: CHAR _ IF stream.EndOf THEN '\377  ELSE stream.GetChar;
GetChar: PROC ~ {c _ IF stream.EndOf THEN '\377  ELSE stream.GetChar};
SkipSpaces: PROC ~ {WHILE (c = ', OR c = ' OR c = '	OR c = '\n) DO GetChar[] ENDLOOP};
Char: PROC RETURNS [value: CARDINAL_0] ~ {
SkipSpaces[];
IF c # '' THEN ERROR SpecError[stream.GetIndex];
GetChar[];
IF c='\\ THEN {
GetChar[];
SELECT c FROM
IN ['0..'7] => {
WHILE c IN ['0..'7] DO
value _ value * 8 + (c-'0);
GetChar[];
ENDLOOP;
};
'\\ => {value _ '\\-'\000; GetChar[]};
ENDCASE => ERROR SpecError[stream.GetIndex];
}
ELSE {value _ c-'\000; GetChar[]};
};
spec: LIST OF CharRange _ NIL;
SkipSpaces[];
WHILE c # '\377 DO
SELECT c FROM
'' => {spec _ CONS[[Char[], 1], spec]};
'D => {
savedIndex: INT _ stream.GetIndex;
i: INT _ 0;
efault: ROPE ~ "EFAULT";
WHILE i < efault.Length DO
GetChar[];
IF c = efault.Fetch[i] THEN i _ i + 1 ELSE EXIT;
ENDLOOP;
IF i = efault.Length THEN {spec _ CONS[[defaultChar, 1], spec]; GetChar[]}
ELSE {stream.SetIndex[savedIndex]; EXIT};
};
'[,  '( => {
open: CHAR _ c;
start, end: CARDINAL;
GetChar[];
start _ Char[];
SkipSpaces[];
IF c = '. THEN GetChar[] ELSE ERROR SpecError[stream.GetIndex];
IF c = '. THEN GetChar[] ELSE ERROR SpecError[stream.GetIndex];
end _ Char[];
SkipSpaces[];
IF c = '] OR c = ') THEN {
IF open = '( THEN start _ start + 1;
IF c = '] THEN end _ end + 1;
IF end > start THEN spec _ CONS[[start, end-start], spec];
GetChar[];
}
ELSE ERROR SpecError[stream.GetIndex];
};
ENDCASE => EXIT;
SkipSpaces[];
ENDLOOP;
IF c # '\377 THEN stream.Backup[c];
RETURN [Reverse[spec]]
};

Reverse: PROC [charSpec: LIST OF CharRange] RETURNS [reversed: LIST OF CharRange] ~ {
WHILE charSpec # NIL DO
t: LIST OF CharRange _ charSpec;
charSpec _ t.rest;
t.rest _ reversed;
reversed _ t;
ENDLOOP;
};

SlantChar: PROC [charRep: RasterFontIO.InternalCharRep] RETURNS [RasterFontIO.InternalCharRep] ~ {
new: RasterFontIO.InternalCharRep;
window: ImagerPixelMap.DeviceRectangle;
sMin, fMin, sMax, fMax: INTEGER;
charRep.pixels _ ImagerPixelMap.Trim[charRep.pixels, 0];
window _ ImagerPixelMap.Window[charRep.pixels];
sMin _ window.sMin;
fMin _ window.fMin;
sMax _ sMin + window.sSize;
fMax _ fMin + window.fSize;
fMax _ fMax + MAX[0, (-sMin+1)/2];
fMin _ fMin - MAX[0, (sMax+1)/2];
new.fWidth _ charRep.fWidth;
new.sWidth _ charRep.sWidth;
new.pixels _ ImagerPixelMap.Create[0, [sMin, fMin, sMax-sMin, fMax-fMin]];
ImagerPixelMap.Clear[new.pixels];
CHECKED {
s: INTEGER _ -3;
shift: INTEGER _ 0;
WHILE s>sMin DO s _ s - 3; shift _ shift + 1 ENDLOOP;
WHILE s<sMax DO
new.pixels.Clip[[s, fMin, 3, fMax-fMin]].Transfer[charRep.pixels.ShiftMap[0, shift]];
s _ s + 3;
shift _ shift - 1;
ENDLOOP;
};
RETURN [new]
};

MakeSlantedFont: PUBLIC PROC [font: InternalFont] RETURNS [InternalFont] ~ {
new: InternalFont _ NEW [RasterFontIO.InternalFontRep _ font^];
new.defaultChar _ SlantChar[font.defaultChar];
FOR c: CHAR IN CHAR DO
IF font.charRep[c] = font.defaultChar THEN new.charRep[c] _ new.defaultChar
ELSE new.charRep[c] _ SlantChar[font.charRep[c]];
ENDLOOP;
RETURN [new]
};

BoldChar: PROC [charRep: RasterFontIO.InternalCharRep] RETURNS [RasterFontIO.InternalCharRep] ~ {
new: RasterFontIO.InternalCharRep;
window: ImagerPixelMap.DeviceRectangle;
charRep.pixels _ ImagerPixelMap.Trim[charRep.pixels, 0];
window _ ImagerPixelMap.Window[charRep.pixels];
new.fWidth _ charRep.fWidth+1;
new.sWidth _ charRep.sWidth;
new.pixels _ ImagerPixelMap.Create[0, [window.sMin, window.fMin, window.sSize, window.fSize+1]];
ImagerPixelMap.Clear[new.pixels];
new.pixels.Transfer[charRep.pixels];
new.pixels.Transfer[charRep.pixels.ShiftMap[0, 1], [or, null]];
RETURN [new]
};

MakeBoldFont: PUBLIC PROC [font: InternalFont] RETURNS [InternalFont] ~ {
new: InternalFont _ NEW [RasterFontIO.InternalFontRep _ font^];
new.defaultChar _ BoldChar[font.defaultChar];
FOR c: CHAR IN CHAR DO
IF font.charRep[c] = font.defaultChar THEN new.charRep[c] _ new.defaultChar
ELSE new.charRep[c] _ BoldChar[font.charRep[c]];
ENDLOOP;
RETURN [new]
};

ComplementChar: PROC [charRep: RasterFontIO.InternalCharRep] RETURNS [RasterFontIO.InternalCharRep] ~ {
new: RasterFontIO.InternalCharRep;
window: ImagerPixelMap.DeviceRectangle;
window _ ImagerPixelMap.Window[charRep.pixels];
window.fMin _ 0;
window.fSize _ Real.Round[charRep.fWidth];
new.fWidth _ charRep.fWidth;
new.sWidth _ charRep.sWidth;
new.pixels _ ImagerPixelMap.Create[0, window];
ImagerPixelMap.Clear[new.pixels];
ImagerPixelMap.Fill[dest: new.pixels, area: window, value: 1];
new.pixels.Transfer[charRep.pixels, [and, complement]];
RETURN [new]
};

MakeComplementaryFont: PUBLIC PROC [font: InternalFont] RETURNS [InternalFont] ~ {
new: InternalFont _ NEW [RasterFontIO.InternalFontRep _ font^];
new.defaultChar _ ComplementChar[font.defaultChar];
FOR c: CHAR IN CHAR DO
IF font.charRep[c] = font.defaultChar THEN new.charRep[c] _ new.defaultChar
ELSE new.charRep[c] _ ComplementChar[font.charRep[c]];
ENDLOOP;
RETURN [new]
};


deltaX: INTEGER _ 0;
deltaY: INTEGER _ 0;
MakeTranslatedFont: PROC [font: InternalFont] RETURNS [InternalFont] ~ {
new: InternalFont _ NEW [RasterFontIO.InternalFontRep _ font^];
new.defaultChar.pixels.fOrigin _ new.defaultChar.pixels.fOrigin+deltaX;
new.defaultChar.pixels.sOrigin _ new.defaultChar.pixels.sOrigin-deltaY;
FOR c: CHAR IN CHAR DO
new.charRep[c].pixels.fOrigin _ new.charRep[c].pixels.fOrigin+deltaX;
new.charRep[c].pixels.sOrigin _ new.charRep[c].pixels.sOrigin-deltaY;
ENDLOOP;
RETURN [new]
};

FontSlantCommand: Commander.CommandProc ~ {
ModifyFont[cmd, MakeSlantedFont];
};

FontBoldCommand: Commander.CommandProc ~ {
ModifyFont[cmd, MakeBoldFont];
};

FontComplementCommand: Commander.CommandProc ~ {
ModifyFont[cmd, MakeComplementaryFont];
};

FontTranslateCommand: Commander.CommandProc ~ {
ModifyFont[cmd, MakeTranslatedFont];
};

FontWidthsCopyCommand: Commander.CommandProc ~ {
stream: IO.STREAM _ IO.RIS[cmd.commandLine];
outputName: ROPE _ GetToken[stream];
fontFileType: FontFileType _ FontFileNameType[outputName];
gets: ROPE _ GetToken[stream];
inputName: ROPE _ GetToken[stream];
font: InternalFont;
otherFont: InternalFont;
errIndex: INT _ -1;
IF NOT gets.Equal["_"] THEN {
cmd.out.PutRope["Specify output _ input, please"];
RETURN;
};
IF fontFileType = invalid OR fontFileType = unknown THEN {
cmd.out.PutRope[outputName];
cmd.out.PutRope[": invalid font file name"];
IF fontFileType # invalid THEN cmd.out.PutRope[" (must have .ac, .ks or .strike extension)"];
RETURN;
};
font _ RasterFontIO.Load[outputName !
RasterFontIO.FormatError => {errIndex _ byteIndex; CONTINUE};
FS.Error => CONTINUE
];
IF font = NIL THEN {
InputError[cmd.out, outputName, errIndex];
RETURN;
};
otherFont _ RasterFontIO.Load[inputName !
RasterFontIO.FormatError => {errIndex _ byteIndex; CONTINUE};
FS.Error => CONTINUE
];
IF otherFont = NIL THEN {
InputError[cmd.out, inputName, errIndex];
RETURN;
};
FOR c: CHAR IN CHAR DO
IF font.charRep[c] # font.defaultChar AND otherFont.charRep[c] # otherFont.defaultChar THEN {
font.charRep[c].sWidth _ otherFont.charRep[c].sWidth;
font.charRep[c].fWidth _ otherFont.charRep[c].fWidth
};
ENDLOOP;
WriteFormatDerivedFromName[font, outputName];
cmd.out.PutRope[outputName];
cmd.out.PutRope[" written."];
};

InputError: PROC [out: IO.STREAM, inputName: ROPE, errIndex: INT] ~ {
IF errIndex >= 0 THEN {
out.PutF["Format error in %g at byte index %g", IO.rope[inputName], IO.int[errIndex]];
}
ELSE {
out.PutRope[inputName];
out.PutRope[" not found"];
};
RETURN;
};

ModifyFont: PROC [cmd: Commander.Handle, fontFunction: PROC [InternalFont] RETURNS [InternalFont]] ~ {
stream: IO.STREAM _ IO.RIS[cmd.commandLine];
outputName: ROPE _ GetToken[stream];
fontFileType: FontFileType _ FontFileNameType[outputName];
gets: ROPE _ GetToken[stream];
inputName: ROPE _ GetToken[stream];
font: InternalFont;
errIndex: INT _ -1;
IF NOT gets.Equal["_"] THEN {
cmd.out.PutRope["Specify output _ input, please"];
RETURN;
};
IF fontFileType = invalid OR fontFileType = unknown THEN {
cmd.out.PutRope[outputName];
cmd.out.PutRope[": invalid font file name"];
IF fontFileType # invalid THEN cmd.out.PutRope[" (must have .ac, .ks or .strike extension)"];
RETURN;
};
font _ RasterFontIO.Load[inputName !
RasterFontIO.FormatError => {errIndex _ byteIndex; CONTINUE};
FS.Error => CONTINUE
];
IF font = NIL THEN {
InputError[cmd.out, inputName, errIndex];
RETURN;
};
font _ fontFunction[font];
RasterFontIO.Trim[font];
WriteFormatDerivedFromName[font, outputName];
cmd.out.PutRope[outputName];
cmd.out.PutRope[" written.\n"];
};

FontMergeCommand: Commander.CommandProc ~ {
stream: IO.STREAM _ IO.RIS[cmd.commandLine];
outputName: ROPE _ GetToken[stream];
fontFileType: FontFileType _ FontFileNameType[outputName];
token: ROPE _ GetToken[stream];
font: InternalFont _ RasterFontIO.Create[[-1,0,1,1],1];
IF NOT token.Equal["_"] THEN {
cmd.out.PutRope["Specify output _ input, please"];
RETURN;
};
IF fontFileType = invalid OR fontFileType = unknown OR fontFileType = ac THEN {
cmd.out.PutRope[outputName];
cmd.out.PutRope[": invalid font file name"];
IF fontFileType # invalid THEN cmd.out.PutRope[" (must have .ks or .strike extension)"];
RETURN;
};
token _ GetToken[stream];
WHILE token # NIL DO
inputName: ROPE;
inputFont: InternalFont;
badSpecIndex: INT _ -1;
errIndex: INT _ -1;
WHILE token.Equal[";"] OR token.Equal["FONT"] DO
token _ GetToken[stream];
ENDLOOP;
IF token = NIL THEN EXIT;
inputName _ token;
inputFont _ RasterFontIO.Load[inputName !
RasterFontIO.FormatError => {errIndex _ byteIndex; CONTINUE};
FS.Error => CONTINUE
];
IF inputFont = NIL THEN {
InputError[cmd.out, inputName, errIndex];
RETURN;
};
token _ GetToken[stream];
IF token.Equal["CHAR"] OR token.Equal["CHARS"] THEN {
charSpec: LIST OF CharRange;
charSpec _ ParseCharSpec[stream ! SpecError => {badSpecIndex _ offset; CONTINUE}];
IF badSpecIndex # -1 THEN {
cmd.out.PutRope["Bad specification: "];
cmd.out.PutRope[cmd.commandLine.Substr[0, badSpecIndex]];
cmd.out.PutRope[" *^* "];
cmd.out.PutRope[cmd.commandLine.Substr[badSpecIndex]];
RETURN;
};
FOR cr: LIST OF CharRange _ charSpec, cr.rest UNTIL cr = NIL DO
IF cr.first.startChar = defaultChar THEN {
FOR c: CHAR IN CHAR DO
IF font.charRep[c] = font.defaultChar THEN font.charRep[c] _ inputFont.defaultChar;
ENDLOOP;
font.defaultChar _ inputFont.defaultChar;
}
ELSE {
FOR c: CHAR IN ['\000+cr.first.startChar..'\000+cr.first.startChar+cr.first.nChars) DO
font.charRep[c] _ inputFont.charRep[c];
ENDLOOP;
};
ENDLOOP;
token _ GetToken[stream];
}
ELSE {font _ inputFont};
ENDLOOP;
WriteFormatDerivedFromName[font, outputName];
};

FontEditCommand: Commander.CommandProc ~ {
stream: IO.STREAM _ IO.RIS[cmd.commandLine];
name: ROPE _ GetToken[stream];
IF name.Length = 0 THEN cmd.out.PutRope["Please supply a font file name (.ks or .strike or .ac)\n"]
ELSE {
[] _ Create[name];
};
};

fontEditClass: ViewerClasses.ViewerClass _ NEW[ViewerClasses.ViewerClassRec _ [
paint:  FontEditPaintProc,
adjust: FontEditAdjustProc,
notify: FontEditNotifyProc,
save: Save,
tipTable: TIPUser.InstantiateNewTIPTable["FontEdit.TIP"]
]];
ViewerOps.RegisterViewerClass[$FontEdit, fontEditClass];
Commander.Register["FontEdit", FontEditCommand, "Edit the named strike or kerned-strike font."];
Commander.Register["FontMerge", FontMergeCommand, "Merge font files, e.g. new.ks _ one.strike CHARS ['a..'z]; two.strike CHARS ['0..'1], ['A..'Z]; three.strike CHAR '?; four.ks CHAR DEFAULT;"];
Commander.Register["FontSlant", FontSlantCommand, "Make a slanted font (output _ input)"];
Commander.Register["FontBold", FontBoldCommand, "Make a bold font (output _ input)"];
Commander.Register["FontComplement", FontComplementCommand, "Make a complemented (white chars on black backing) font (output _ input)"];
Commander.Register["FontWidthsCopy", FontWidthsCopyCommand, "Copy widths from another font (output _ input)"];
Commander.Register["FontTranslate", FontTranslateCommand, "Translate each character in the font by the amount (FontEditImpl.deltaX, FontEditImpl.deltaY) (output _ input)"];
END.

°FontEditImpl.mesa
Copyright (C) 1984, Xerox Corporation.  All rights reserved.
Michael Plass, May 20, 1985 5:06:52 pm PDT
Neil Gunther, October 24, 1985 12:46:45 pm PDT
Κ$Ζ˜™J™<J™*Icode™.K˜—š
Οk	˜	Kšœœ,˜<Kšœ
œ!˜0KšœœG˜TKšœ	œ
˜Kšœ
œ)˜1Kšœœyœ	˜‘
Kšœœ	˜KšœœZ˜nKšœ
œeœœ˜Š
Kšœœ=˜HKšœœ˜$Kšœœ˜#Kšœ
œ
˜’
Kšœœ˜Kšœœ2œ
˜JKšœœ?˜LKšœœT˜gKšœ
œY˜hKšœœ˜&—K˜KšΠblœœ
˜Kšœ!œ*œZ˜°
Kšœ	˜šœ˜K˜Kšœœœ
˜Kšœœ˜0K˜Kšœœœ	˜šœ	œœ˜Kšœ
œ
˜Kš
œ˜Kšœœœ
˜Kšœ
œœ
˜Kšœ
œ
˜Kš
œ+˜+Kš
œ#˜#Kšœœ˜Kšœœ˜Kšœœ
˜Kšœœ˜Kš
œ˜K˜—Kšœ
œY˜jKšœ
œ˜šΟnœœ
œœ˜!Kš	œœ
œœ
œ˜ šœœ
œ
˜K˜Kšœ
˜—Kš
œ˜Kšœ˜Kš
œ˜K˜—š
ŸœœLœœœ˜€
šœœ˜Kšœœ!œ˜5KšœœW˜eKš
œ'˜'Kš
œ>˜>Kš
œ'˜'K•StartOfExpansion’
[context: 
Imager.Context, base: 
LONG POINTER, wordsPerLine: 
NAT, sMin: 
NAT, fMin: 
NAT, sSize: 
NAT, fSize: 
NAT, tx: 
INTEGER _ 0, ty: 
INTEGER _ 0]š
œ˜Kš
œ¦˜¦Kš
œ6˜6Kš
œ˜—Kš
œ˜Kš
œ˜K˜—šŸœœ<˜JKšœ
œ˜!šœœ˜Kšœ
œ˜šŸœœœœœœ˜:Kšœœ
œœ˜.Kš
œI˜IKš
œ˜—Kšœ
œ
œ
œ
˜Kš
œ˜Kš
œ8˜8Kš
œI˜IKš
œ{˜{Kš
œ#˜#Kš
œ'˜'Kš
œ:˜:Kš
œ˜—Kš
œ ˜ Kš
œ˜K˜—šŸœœCœ	œ˜qKšœ
œ˜!Kšœœ˜Kšœœ˜
šŸœœœœœœ˜:Kš
œ=˜=Kš
œ?˜?Kš
œœ)œ
œœ˜LKš
œ'˜'Kš
œ˜Kš
œ˜—Kš
œ
˜
Kšœ
œœ˜5Kš
œ˜K˜—šŸœœ#˜7Kšœ
œ˜!šœœ
œ˜1šœœ˜&Kšœ&œ	˜4Kš
œ ˜ Kš
œ˜—K˜(Kšœ
˜—Kš
œ˜K˜—šŸœœ
œœ˜8K˜GKšœœ
œœ
œ
œœ˜LKšœœ6˜PKš
œ˜K˜—šŸœœ'œœ˜NKšœ
œ˜!Kš	œœ
œœ
œ˜ KšŸœœœ+œ˜LKšŸœœœ*˜@KšŸœœœ,˜EKš
œ˜Kš
œ&˜&Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ!˜!Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ%˜%Kšœœ(˜5Kšœœ
˜Kš
œ˜K˜—š
Ÿœœ
œœœ#˜SKš
œ&˜&Kšœ
œ
˜š
œ˜Kš
œ˜˜K˜
K˜K˜4K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜"K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜$K˜
—K˜—š
œ˜Kš
œ˜˜K˜
K˜K˜%K˜
—K˜—š
œ˜Kš
œ˜˜K˜
K˜K˜%K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜2K˜
—K˜—š
œ˜Kš
œ˜˜K˜
K˜K˜.K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜K˜
—K˜—š
œ˜Kš
œ˜˜K˜
K˜K˜"K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜.K˜
—K˜—š
œ˜Kš
œ˜˜K˜K˜K˜=K˜
—K˜—KšœZœ˜aKšœAœ#˜iKš
œ˜Kšœ
œ
œ3˜JK˜Kš
œ#˜#Kš
œ˜K˜—šŸœœ.œ˜@Kšœ
œ˜!šŸœœœ˜Kšœœ˜!Kš
œ˜Kš
œ˜—Kšœœœ
œ˜Lš
œ,˜,š
œ˜Kšœ	œ2œ˜QKšœ˜Kš
œ˜—Kšœ(œ˜4K˜—Kš
œ˜Kš
œ˜K˜Kšœœ
˜Kš
œ˜K˜—šŸœœ
œ-œ˜]šœ
œ˜Kšœ(œ˜.Kš
œ˜Kšœ˜
K˜—Kšœœ˜$Kš
œ8˜8Kš
œ ˜ šœ˜Kš
œ3˜3Kš
œ=˜=š
œ˜š	œœ
œ
œ
˜Kš
œ@˜@šœ$œ˜,Kš
œ<˜<šœœ˜Kš
œ7˜7Kš
œ˜Kš
œ˜—Kšœœ
œ
˜Kšœœ%˜9Kš
œ"˜"Kš
œ˜—Kšœ
˜—Kš
œ1˜1Kš
œ˜—šœ˜KšœGœ˜MKšœœ˜&Kš
œ˜Kš
œ˜——Kšœ	œ
˜Kš
œ˜K˜—šŸœ˜ Kšœ
œ˜Kš
œ˜Kš
œ5˜5Kš
œ ˜ Kš
œ˜K˜—šŸ	œ˜Kšœœ	˜.Kšœ
œ˜!Kšœœ˜šœœ˜Kšœ8œ˜>Kš
œ˜Kš
œ
˜
—Kšœ˜Kš
œ˜K˜—Kšœœ&˜8šŸœœœœ˜>Kšœœœ
˜K–x -- [server: FS.Position, dir: FS.Position, subDirs: FS.Position, base: FS.Position, ext: FS.Position, ver: FS.Position]šœœ˜Kšœœœ
˜Kšœœœ
˜Kš	œœœœœ˜KKšœœ
œ˜Kš
œ:˜:šœ
œ
˜Kšœœœ˜,Kšœœœ
˜4Kšœœœ˜,Kšœœ˜—Kš
œ˜K˜—šŸœ˜ Kšœœ	˜.Kšœ
œ˜!Kšœœ˜Kš
œ4˜4šœœ˜ Kšœ>œ˜DKš
œ˜Kš
œ
˜
—šœ˜Kšœœœœ˜LKš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šŸ
œ˜Kšœœ	˜.Kš
œ˜Kš
œ˜K˜—šŸ
œ˜Kšœœ	˜.Kšœ
œ˜!Kšœœ˜šœœ˜Kšœ3œ˜9Kš
œ˜Kš
œ
˜
—šœ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šŸ
œ˜Kšœœ	˜.Kšœ
œ˜!Kš
œ:˜:Kš
œ)˜)Kš
œ˜Kš
œ1˜1Kš
œ.˜.Kš
œ"˜"Kš
œ˜Kš
œ˜K˜—šŸœ˜#Kšœœ	˜.Kšœ
œ˜!Kšœ	œ˜!šœœ˜Kšœœ
œœœ
œœ˜KKš
œ˜—šœœ˜Kšœœ
œœœ
œœ˜TKš
œ˜—Kš
œ˜Kš
œ˜K˜—šŸ
œ˜Kšœœ	˜.Kšœ
œ˜!Kšœœ˜5Kšœœ˜5Kšœœœ˜YKšœ&œ	˜4Kš
œ˜K˜—šŸœ˜!Kšœœ	˜.Kšœ
œ˜!Kš
œ"˜"Kš
œ˜Kš
œ˜K˜—šŸ
œ˜Kšœœ	˜.Kšœ
œ˜!KšœGœ˜QKš
œ˜Kš
œ˜K˜—šŸœ˜Kšœœ	˜.Kšœ
œ˜!Kšœœ˜Kšœ<œ˜FKšœ
œ>œ˜XKšœ
œ˜/Kš
œ˜Kš
œ˜K˜—šŸ	œ˜Kšœœ	˜.Kšœ
œ˜!Kšœœ˜Kšœ<œ˜FKšœ
œ>œ˜XKšœ	œ˜,Kš
œ˜Kš
œ˜K˜—šŸœœ#˜5Kšœ
œ˜!šœœœ˜8Kš
œ&˜&Kš
œu˜uKš
œ(˜(šœœœ˜>Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—šœJœJ˜
Kš
œ;˜;—Kšœ/˜3Kš
œ˜—Kšœœ
˜%Kš
œ˜K˜—š
Ÿ
œœœœœ˜6Kš	œœ
œœ
œ˜Kšœ	œ˜Kš
œ+˜+šœœ
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜—Kš
œ˜Kšœœ˜Kšœœ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœœ&œ˜<Kšœ
œ˜!Kš
œO˜OKšœœ˜)Kšœœ˜)Kš
œ"˜"Kšœœ
˜Kš
œœ
œ
œœ˜FKšœœ
˜Kš
œ˜KšœœU˜fKšœœ@˜QKšœœK˜UKšœœ9˜CKš
œ"˜"Kš
œ"˜"Kš
œ˜Kšœœ
˜Kš
œ,˜,Kš
œ,˜,Kš
œ˜Kš
œ,˜,šœ
œ˜%Kšœ
œ˜"Kšœ
œ˜"Kšœ
œ˜"Kšœ:œ˜AKš
œ€
˜€
Kšœ4œ˜;K˜—Kšœœ˜Kš
œ#˜#Kšœœ
˜Kšœœ˜0Kš
œ˜K˜—šŸœ˜.Kšœ
œ˜šœœ
œœ˜2Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜K˜—šŸœ˜0Kšœ
œ˜šœœ
œ˜Kš
œ˜Kš
œ˜šœ
œ
œ˜Kšœœ
˜
Kšœœ
˜ Kšœ#œ
˜,Kš
œc˜cKš
œ˜Kš
œ˜šœ&œ
œ9˜qKš
œ<˜<Kš
œ3˜3Kš
˜—K˜—šœœ
œ˜K˜0K˜0K˜6Kš
œY˜YJš
œ˜—Kšœœ
˜Jš
œ˜—Kš
œ˜—šŸœ˜0šœ
œ'œ˜6Kšœ
œ˜Kšœ&œ˜:šœ˜š
œ˜Kšœœ'˜1šœœ˜Kšœœ˜$šœœ˜!Kš
œ˜Kš
œ˜—Kš
œ˜—Kš
œ˜—š
œ˜Kšœœ'˜1šœœ˜Kšœœ˜$šœœ˜!Kš
œ@˜@Kš
œr˜rKš
œ.˜.Kšœœ
˜$Kš
œ˜—Kš
œ˜—Kš
œ˜—Kšœœ
˜—K˜—K˜K˜—–

"cedar" stylešŸœœ
œ
œœ	œœ˜BKšœ$œœ˜FKš
œ˜—–

"cedar" styleš
Ÿœœœœœ˜3Kšœœœ
œ	˜.Kšœœœœœ
œ˜HKšœ	˜Kš
œ˜K˜—Kš	œœ
œ
œœ
˜-Kšœœ˜%Kšœ
œ˜šŸ
œœ
œ
	œœœ
œ˜NKšœœ˜Kš	œœœœœ˜:Kš
Ÿœœœœœ˜FKšŸ
œœœ	œœœ
œ
œ˜VšŸœœ
œ	œ˜*Kš
œ
˜
Kšœœ
œ˜0Kš
œ
˜
šœœ˜Kš
œ
˜
šœ˜
šœ˜šœœ
˜Kš
œ˜Kš
œ
˜
Kšœ
˜—Kš
œ˜—Kš
œ&˜&Kšœœ˜,—Kš
œ
˜
—Kšœ˜"Kš
œ˜—Kšœœ
œ
œ
˜Kš
œ
˜
šœ˜šœ˜
Kšœœ˜'˜Kšœœ˜"K˜Kšœœ˜šœ˜K˜
Kšœœœ
œ
˜0Kšœ
˜—Kšœœ	œ$˜JKšœœ˜)K˜—š
œ˜Kšœœ˜Kšœ	˜K˜
Kš
œ˜Kš
œ
˜
Kšœœœ
œ˜?Kšœœœ
œ˜?Kš
œ
˜
Kš
œ
˜
šœœœ˜Kšœœ˜$Kšœœ˜Kšœ
œœ˜:Kš
œ
˜
Kš
œ
˜
—Kšœ
œ˜&Kš
œ˜—Kšœœ
˜—Kš
œ
˜
Kšœ
˜—Kšœœ˜#Kšœ˜Kš
œ˜K˜—šŸœœœ
œœœ
œ˜Ušœœ
˜Kšœœ
œ˜ Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœ
˜—Kš
œ˜K˜—šŸ	œœ)œ#˜bKš
œ"˜"Kš
œ'˜'Kšœœ
˜ Kš
œ8˜8Kš
œ/˜/Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ˜"Kšœœ˜!Kš
œ˜Kš
œ˜Kš
œJ˜JKš
œ!˜!šœ˜	Kšœœ˜Kšœœ˜Kšœœœ
˜5šœ˜Kš
œU˜UK˜
Kš
œ˜Kšœ
˜—K˜—Kšœ˜Kš
œ˜K˜—šŸœœ
œœ˜LKšœœ(˜?Kš
œ.˜.š	œœ
œ
œ
˜Kšœ$œ!˜KKšœ-˜1Kšœ
˜—Kšœ˜Kš
œ˜K˜—šŸœœ)œ#˜aKš
œ"˜"Kš
œ'˜'Kš
œ8˜8Kš
œ/˜/Kš
œ˜Kš
œ˜Kš
œ`˜`Kš
œ!˜!Kš
œ$˜$Kš
œ?˜?Kšœ˜Kš
œ˜K˜—šŸœœ
œœ˜IKšœœ(˜?Kš
œ-˜-š	œœ
œ
œ
˜Kšœ$œ!˜KKšœ,˜0Kšœ
˜—Kšœ˜Kš
œ˜K˜—šŸœœ)œ#˜gKš
œ"˜"Kš
œ'˜'Kš
œ/˜/K˜K˜*K˜K˜K˜.Kš
œ!˜!K˜>K˜7Kšœ˜Kš
œ˜K˜—šŸœœ
œœ˜RKšœœ(˜?Kš
œ3˜3š	œœ
œ
œ
˜Kšœ$œ!˜KKšœ2˜6Kšœ
˜—Kšœ˜Kš
œ˜K˜K˜—Kšœœ˜Kšœœ˜šŸœœœ˜HKšœœ(˜?Kš
œG˜GKš
œG˜Gš	œœ
œ
œ
˜Kš
œE˜EKš
œE˜EKšœ
˜—Kšœ˜Kš
œ˜K˜—šŸœ˜+Kš
œ!˜!Kš
œ˜K˜—šŸœ˜*Kš
œ˜Kš
œ˜K˜—šŸœ˜0Kš
œ'˜'Kš
œ˜K˜—šŸœ˜/Kš
œ$˜$Kš
œ˜K˜—šŸœ˜0Kš	œœ
œœ
œ˜,Kšœœ˜$Kš
œ:˜:Kšœœ˜Kšœœ˜#Kš
œ˜Kš
œ˜Kšœ
œ˜šœ
œœ˜Kš
œ2˜2Kšœ
˜Kš
œ˜—šœœœ˜:Kš
œ˜Kš
œ,˜,Kšœœ?˜]Kšœ
˜Kš
œ˜—š
œ%˜%Kšœ3œ˜=Kšœ˜Kš
œ˜—šœœ
œ˜Kš
œ*˜*Kš
˜Kš
œ˜—š
œ)˜)Kšœ3œ˜=Kšœ˜Kš
œ˜—šœ
œ
œ˜Kš
œ)˜)Kš
˜Kš
œ˜—š	œœ
œ
œ
˜šœ$œ 
œœ˜]Kš
œ5˜5Kš
œ4˜4Kš
œ˜—Kšœ
˜—Kš
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸ
œœœ
œ
œœ˜Ešœœ˜Kšœ0œœ˜VKš
Οi
˜
—šœ˜Kš
œ˜Kš
œ˜K˜—Kš
˜Kš
œ˜K˜—šŸ
œœ'œœ˜fKš	œœ
œœ
œ˜,Kšœœ˜$Kš
œ:˜:Kšœœ˜Kšœœ˜#Kš
œ˜Kšœ
œ˜šœ
œœ˜Kš
œ2˜2Kšœ
˜Kš
œ˜—šœœœ˜:Kš
œ˜Kš
œ,˜,Kšœœ?˜]Kšœ
˜Kš
œ˜—š
œ$˜$Kšœ3œ˜=Kšœ˜Kš
œ˜—šœœ
œ˜Kš
œ)˜)Kš
˜Kš
œ˜—Kš
œ˜Kš
œ˜Kš
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœ˜+Kš	œœ
œœ
œ˜,Kšœœ˜$Kš
œ:˜:Kšœœ˜Kš
œ7˜7šœ
œœ˜Kš
œ2˜2Kšœ
˜Kš
œ˜—šœœœœ˜OKš
œ˜Kš
œ,˜,Kšœœ:˜XKšœ
˜Kš
œ˜—Kš
œ˜šœ	œ
˜Kšœœ
˜Kš
œ˜Kšœœ˜Kšœ
œ˜šœœ˜0Kš
œ˜Kšœ
˜—Kšœ	œ
œ
œ
˜Kš
œ˜š
œ)˜)Kšœ3œ˜=Kšœ˜Kš
œ˜—šœ
œ
œ˜Kš
œ)˜)Kš
˜Kš
œ˜—Kš
œ˜šœœœ˜5Kšœ
œ
œ˜KšœGœ˜Ršœœ˜Kš
œ'˜'Kš
œ9˜9Kš
œ˜Kš
œ6˜6Kšœ
˜Kš
œ˜—šœœ
œœœ
˜?šœ"œ˜*š	œœ
œ
œ
˜Kšœ$œ)˜SKšœ
˜—Kš
œ)˜)Kš
œ
˜
—šœ˜šœœ
œF˜VKš
œ'˜'Kšœ
˜K˜——Kšœ
˜—Kš
œ˜Kš
œ
˜
—Kšœ˜Kšœ
˜—Kš
œ-˜-Kš
œ˜K˜—šŸœ˜*Kš	œœ
œœ
œ˜,Kšœœ˜KšœœL˜cšœ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šœ+œ!˜OKš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ8˜8K˜—Kš
œ8˜8K˜`K˜Α
K˜ZK˜UKš
œˆ
˜ˆ
K˜nK˜¬
—Kšœ
˜J˜—…—zZŸΠ