%***************************************************************************** % Copyright (c) 1989 by N. N. Billawala %***************************************************************************** % pandor.mf a base file which contains the macros used for creating Pandora %*****MAJOR CHARACTER PART MACROS************************************** boolean its_a_leftserif; % in horizontal serif macro vardef full_serif_points@#(expr A,B,Bl,Br,leftlength,rightlength)= min_limit(join_radius)(.5serif_thickness); (z1-B)=whatever*(A@#-B@#); % makes center ref line (z1l-Bl)=whatever*(A@#-B@#); % makes parallel ref line on left (z1r-Br)=whatever*(A@#-B@#); % makes parallel ref line on right y2=y2l=y2r=ypart A; % base of serif y1=y1l=y1r=y3=y4=ypart A if ypart A>ypart B:-else:+fi serif_thickness; % puts |serif_thickness| between A and B x5=x2=.5[x1l,x1r]; % puts entasis at mid-base and makes it y5=entasis[y2l,y1l]; % a proportion of the |serif_thickness| if its_a_leftserif:x3=x2l=x1l-round(leftlength+serif_constant_amt); else:x4=x2r=x1r+round(rightlength+serif_constant_amt); fi enddef; vardef leftserif@#(expr A,B,Bl,Br,alength)=its_a_leftserif:=true; % left serif save x,y,p; path p[]; full_serif_points@#(A,B,Bl,Br,alength,0); p0:=Bl{z1l-Bl} if ctrls:..controls(onstem[z1l,Bl])and(onbase[z1l,z3]).. else:...fi {z3-z1l}z3; % the bracket curve if midbracket_pull<>0: z3'l=z1l; pos3'(alength+5pt,.5[angle(B-A),if ypart A>ypart B:-fi 180]); z8'=p0 intersectionpoint (z3'l--z3'r); % z3'l--z3'r bisects bracket z8=(midbracket_pull-eps)[z8',z1l];fi % bracket pulled in at z8 if ypart A>ypart B:reverse fi ((if midbracket_pull=0:p0 else:Bl{z1l-Bl}...z8...{z3-z1l}z3 fi if softpath:)softjoin(z3--z2l)softjoin(else:--fi z2l..z5{right})) enddef; vardef rightserif@#(expr A,B,Bl,Br,alength)=its_a_leftserif:=false;% right serif save x,y,p; path p[]; full_serif_points@#(A,B,Bl,Br,0,alength); p4:=z4{z1r-z4} if ctrls:..controls(onbase[z1r,z4])and(onstem[z1r,Br]).. else:...fi {Br-z1r}Br; % the bracket curve if midbracket_pull<>0: z4'l=z1r; pos4'(alength+5pt,.5[angle(B-A),0]); z9'=p4 intersectionpoint (z4'l--z4'r); % z4'l--z4'r bisects bracket z9=(midbracket_pull-eps)[z9',z1r];fi % bracket pulled in at z9 if ypart A>ypart B:reverse fi ((z5{right}..z2r if softpath:)softjoin(z2r--z4)softjoin(else:--fi if midbracket_pull=0:p4 else:z4{z1r-z4}...z9...{Br-z1r}Br fi)) enddef; vardef fullserif@#(expr A,B,Bl,Br,leftlength,rightlength)= % full serif save x,y,p; path p[]; p1=rightserif(A,B,Bl,Br,rightlength); p2=leftserif(A,B,Bl,Br,leftlength); if ypart A>ypart B:(p1--p2)else:(p2--p1)fi enddef; vardef terminalserif@#(expr A,B,Bl,Br,tip_length,base_angle)suffix$= save x,y,join_radius,aleft,atop,arc,ball,heel,midbracket_point,tip,p; boolean aleft,atop; pair arc,ball,heel,midbracket_point,tip; path p[]; aleft=(str@#="l"); atop=(ypart A>ypart B); heel- if aleft:Br else:Bl fi =whatever*(A-B); heel=A+(whatever,0)rotated(if not aleft:180+ fi base_angle); ball- if aleft:Bl else:Br fi =whatever*(A-B); ball=whatever[heel,A]; z0=A if atop:-else:+fi(0,terminal_thickness) rotated base_angle; % z0 added for cases of small |terminal_thickness| and length z2=whatever[ball,if aleft:Bl else:Br fi]; (z0-z2)=whatever*(ball-A); % |terminal_thickness| and stem intersection when no bracket z1=z2+(tip_length+serif_constant_amt,0)rotated angle(ball-A); % z1 is an inner tip point tip=whatever[heel,ball]; z1-tip=whatever*(z0-A); % places tip on base by an amount past the stem z3=heel if str$="soft":+(terminal_softness+1,0)rotated angle(tip-heel)fi; arc=.5[z3,tip]+(terminal_entasis*terminal_thickness,0)rotated angle(B-A); if aleft:z5=Bl; z6=Br; else:z5=Br; z6=Bl;fi p1=z5{ball-z5} if ctrls: ..controls(onstem[z2,z5])and(onbase[z2,(-eps)[z1,tip]]).. else:...fi {z1-z2}(-eps)[z1,tip]--z1; join_radius:=min(terminal_softness,abs(heel-z3),.5abs(heel-z6)); p2=(arc{heel-tip}...z3{heel-tip}...{heel-tip}heel if str$="soft":)softjoin(heel fi --z6); min_limit(join_radius)(.5terminal_thickness); if midbracket_pull<>0: bisecting_angle:=if aleft and(sign(angle(B-A))<>sign(angle(ball-A))): 180+fi .5[angle(B-A),angle(ball-A)]; % this angle bisects the inner angle/area of the bracket z4=z2+(tip_length+5pt+serif_constant_amt,0)rotated bisecting_angle; % sets point z4 for a reference path along bisecting angle midbracket_point=(z2--z4)intersectionpoint p1; % |midbracket_point| intersects the reference path along the % bisecting angle and the reference path of the bracket z9=(midbracket_pull-eps)[midbracket_point,z2]; % the final path goes through z9, which gives the amount of % "pull" toward the point where the stem meets the terminal fi % base with no bracketing if atop=aleft:reverse fi ((if midbracket_pull=0:p1 else:z5{ball-z5}...z9...{z1-z2}(-eps)[z1,z2]--z1 fi if softpath:)softjoin(z1--tip)softjoin(else:--fi tip..arc{heel-tip}--p2)) enddef; vardef arm@# % uses |@#| strings of tl,tr,bl,br (expr heel,inner_ref,outer_ref,tip_length,tipthickness,base_angle)suffix$= save x,y,innertip,outertip,toward,control_point,tip_direction,midbase,section; pair innertip,outertip,toward,control_point,tip_direction,midbase; path section[]; % separate parts of path for different |join_radii| save_bool(atop)=((str@#="tr")or(str@#="tl")); save_bool(curvedarm)=(atop and (ypart outer_ref>ypart heel)) or ((not atop) and (ypart outer_refabs(inner_ref-control_point): if atop:{downward} else:{upward} fi fi else:..controls(onstem[control_point,inner_ref])and (onbase[control_point,innertip])..{outertip-heel} fi innertip if softpath:)softjoin(innertip--outertip)softjoin( else:--fi outertip--midbase); if ((str@#="tl")or(str@#="br")):reverse fi (section2--section1) enddef; vardef bulb@# % like arm (expr heel,inner_ref,outer_ref,tip_length,tipthickness,base_angle)suffix$= save x,y,athickness,alength,bulb_taper_angle; z0=heel; if bulbs: save_bool(softpath)=true; fi if bulb_taper:athickness=1; bulb_thickness:=athickness; bulb_taper_angle=base_angle if((str@#="tr")or(str@#="bl")):-else:+fi taper_angle; alength=if (c_and_s.lc<>0)or(c_and_s.uc<>0):max else:min fi (abs(ypart outer_ref-ypart inner_ref),tip_length); else:athickness=tipthickness;alength=tip_length;bulb_taper_angle=base_angle;fi arm@#(z0,inner_ref,outer_ref,alength,athickness,bulb_taper_angle)$ enddef; vardef shortarm@#(expr AA,BB,CC,D,E,F)suffix$= % short form inspired by DEK save x,y,GG,HH,II,JJ,KK,LL,M; pair GG,HH,II,JJ,KK,LL; path M[]; save_bool(N)=((str@#="tr")or(str@#="tl")); save_bool(O)=(N and(ypart CC>ypart AA))or((not N)and(ypart CCabs(BB-JJ):if N:{downward}else:{upward} fi fi else:..controls(onstem[JJ,BB])and(onbase[JJ,GG])..{HH-AA} fi GG if softpath:)softjoin(GG--HH)softjoin( else:-- fi HH--LL); if ((str@#="tl")or(str@#="br")):reverse fi (M2--M1) enddef; % limiting directions for the joining point of the arch to the assumed stem vardef archlimit@#(expr p)= % limits dir at point 1 of path upward or downward save a,b; pair b; b=(direction 1 of p); a=angle(b)+oblique; if (tr and((a<-180)or(-90.5*arch_thickness$:x2l:=x0l if tl or bl:+else:-fi .5*arch_thickness$;fi onaline(0,2l)(2r); onaline(1l,1r)(11); y11=if ontop:min else:max fi (.75[y0l,y0r],y1r); if (tr or br):rt else:lft fi z10=.5[inner_tip_pt,z11]; pp0=z0r{toward}...z1r; % ref paths for direction limits pp1=z0l{toward}...z1l; pp2=z0{toward}...z1; pp3=outer_stem_pt{stem_dir} o_t z2r{toward}...z11{archlimit@#(pp0)}-- inner_tip_pt{neg_archlimit@#(pp1)}...z2l{-toward} o_t inner_stem_pt{-stem_dir}; if ensure_min_archthickness: % path ensures min thickness for n:=1,2:draw z0{toward}...z10{archlimit@#(pp2)};endfor fi if (tr or br)<>ontop:reverse fi pp3 enddef; vardef outer_juncture_path@#(expr arch_path,stem_path,atime)= % for |tr_bl| save x,y,t,tl,bl,tr,br,atop,aleft,pp,angle_limit; boolean tl,bl,tr,br,atop,aleft; path pp[]; tl=(str@#="tl"); tr=(str@#="tr"); bl=(str@#="bl"); br=(str@#="br"); atop=tl or tr; aleft=tl or bl; if softjuncture=false:save join_radius; join_radius:=eps;fi z10=point atime of arch_path; z11=point (atime-1) of arch_path; z12=z10+(eps,0)rotated angle(z10-precontrol atime of arch_path); pp1=subpath (0,atime) of arch_path--z12; z1=pp1 intersectionpoint stem_path; (t1,t2)=pp1 intersectiontimes stem_path; z2=z1+(juncture_opening,0)rotated(if aleft:180 else:0 fi-oblique); angle_limit1=max(if atop:0,else:-179,-fi 90-oblique-stemcut_angle); z3=z2 if juncture_opening>0:+(abs(z11-z10)+2,0)rotated angle_limit1 fi; z4=(z2--z3) intersectionpoint reverse stem_path; (t3,t4)=(z2--z3) intersectiontimes reverse stem_path; (t5,t6)=z4 intersectiontimes stem_path; if archcut_angle<>0: angle_limit2=if tl or br:max else:min fi (angle(z11-z10),angle(precontrol atime of arch_path-z10)-archcut_angle); z5=z1+(abs(z11-z10)+2,0)rotated angle_limit2; z6=(z5--z1) intersectionpoint pp1; (t7,t8)=(z5--z1) intersectiontimes pp1; (subpath(0,t8)of arch_path soften(z6,z1,z2,z4) % indent into arch else:(subpath(0,t1)of arch_path soften(z1,z2,z4) % indent into stem fi (subpath(t4,0)of reverse stem_path)) enddef; % Only used in the lower case characters vardef bowl@#(expr major_tip,yy,minor_tip,yyy,inner_bowl,outer_bowl)= save arch_thickness,arch_tip,arch_reference,arch_inner_amt; save major,minor; path major,minor; arch_thickness.lc:= minor_curve.lc; arch_tip.lc:= minor_bowl_tip.lc; arch_reference:= minor_bowl_reference; arch_inner_amt:= minor_bowl_inner_amt; minor=arch if str@#="r":br else:tl fi(minor_tip,yyy,inner_bowl,outer_bowl)lc; arch_thickness.lc:= major_curve.lc; arch_tip.lc:= major_bowl_tip.lc; arch_reference:= major_bowl_reference; arch_inner_amt:= major_bowl_inner_amt; major=arch if str@#="r":tr else:bl fi (major_tip,yy,inner_bowl,outer_bowl)lc; major--minor enddef; vardef bowl_counter(expr bowlpath)= % returns the counter of a bowl path save x,y; z1=point 3 of bowlpath; z2=point 8 of bowlpath; z3=.5[z1,z2]; min_limit(join_radius)(.5*abs(z1-z2)); if softpath:(z3--z1)softjoin(z1--subpath(3,8)of bowlpath--z2)softjoin(z2--z3) else:subpath(3,8)of bowlpath fi enddef; vardef outer_bowlpath(expr p)=subpath(9,11)of p--subpath(0,2)of p enddef; % return the major and minor outer paths of a bowl vardef circular_shape(expr ytop,ybot,xleft,xright,topstroke,sidestroke)= save x,y,amt,ref; path ref[],ref[]'; top y1r=ytop; bot y1l=top y1r-topstroke; bot y3r=ybot; top y3l=bot y3r+topstroke; lft z2r=(xleft,(1-v_stress)*h); rt z2l=(lft x2r+sidestroke,(1-v_stress)*h); rt z4r=(xright,v_stress*h); lft z4l=(rt x4r-sidestroke,v_stress*h); good_x_for(1r)(z2r,z4r,h_stress)a; good_x_for(1l)(z2l,z4l,(1-h_stress))b; good_x_for(3r)(z2r,z4r,(1-h_stress))c; good_x_for(3l)(z2l,z4l,h_stress)d; z1=.5[z1l,z1r]; amt1=.5*abs(y1r-y1l); z3=.5[z3l,z3r]; amt3=.5*abs(y3r-y3l); x1r:=inlimit(x1r)(x1-amt1,x1+amt1); x1l:=inlimit(x1l)(x1-amt1,x1+amt1); x3r:=inlimit(x3r)(x3-amt3,x3+amt3); x3l:=inlimit(x3l)(x3-amt3,x3+amt3); ref1=z1r{left} o_t_c z2r{downward} o_t_c z3r{right} o_t_c z4r{upward} o_t_c cycle; ref1'=z1l{left} i_t z2l{downward} i_t z3l{right} i_t z4l{upward} i_t cycle; if mode<>proof:fill ref1; unfill ref1'; else:pickup pencircle; draw ref1; draw ref1'; fi enddef; def o_t=..tension atleast circ1.. enddef; % outer curve tensions def i_t=..tension atleast circ2.. enddef; % inner curve tensions def o_t_c=..tension atleast circ3.. enddef; % outer |circular_shape| tensions %***** SOME ACCENT AND PUNCTUATION CHARACTER PART MACROS ***************** %***** % The dot macro specifies a round path of diameter to be placed from % a reference point. % Note that this dot does not slant with any obliqueness. % tension given the same as that for the circular shapes, since the actual % "roundness" of the dot isn't very important; more important is that there % is a mark there for distinguishing the character. % Used mostly in punctuation and accent characters vardef dot@#(expr ref_pt,size)= save x,y; if str@#="b":z1l=ref_pt; % dot placed above reference point elseif str@#="t":z1r=ref_pt; % dot placed below reference point elseif str@#="l":z2l=ref_pt; % dot placed to right of reference point elseif str@#="r":z2r=ref_pt; % dot placed to left of reference point else:z1=ref_pt; fi % reference point is in center of dot z2=z1; pos1(size,90); pos2(size,0); z1r{left} o_t z2l{down} o_t z1l{right} o_t z2r{up} o_t cycle enddef; %***** % The |prime_accent| macro makes a four-sided polygon. % It assumes that the top end is as thick or thicker than the bottom % end and rounds the thicker end. % Theta is the angle at the ends; flattened in bold chars, % but theta could be an arbitrary value. % Used in grave/acute/long Hungarian accents vardef prime_accent(expr top_pt,bot_pt,top_thickness,bot_thickness)= save x,y,theta,adjustment; z1=top_pt; z3=bot_pt; if y3=y1: x1:=x1+eps; fi % keeps from division by 0 error on next line if bold:theta=0;adjustment=1/cosd (angle(z3-z1)+90); else:theta=angle(z3-z1)+90; adjustment=1;fi pos1(top_thickness*adjustment,theta); pos3(bot_thickness*adjustment,theta); z2r=z1r+(min(.5top_thickness,.5*abs(z3-z1)),0)rotated angle(z3r-z1r); z2l=z1l+(min(.5top_thickness,.5*abs(z3-z1)),0)rotated angle(z3l-z1l); onaline(1l,3l)(6l,7l); onaline(1r,3r)(6r,7r); if x1>x3:y6l=y1r; y7r=y3l; else:y6r=y1l; y7l=y3r; fi if realsoft_accents: (z2r{z1r-z3r}...z1{z1l-z1r}...z2l{z3l-z1l} soften(z3l,z3r) z2r)--cycle elseif x1>x3:z6l--z3l--z7r--z1r--cycle else:z1l--z7l--z3r--z6r--cycle fi enddef; %***** % The comma macro makes a dot-like figure with a tail. % The reference point is placed in the center of the or . % The is the diameter of the . % The tail extends past the head by ||. % The thickness at the tip of the tail is ||. % The || positions the |tail_tip| in relation to the head. % And the || affects the transition from |tail_tip| to head. % Used in comma/semi-colon/left and right, single and double quotes vardef comma(expr pt,size,tail_length,tail_tip,tail_placement)= save x,y,ref; path ref; save_num(tail)=if prime:.5 else:tail_placement fi; z1=z2=pt; pos1(size,90-oblique); pos2(size,0-oblique); good_x_for(3)(z2l,z2r,comma_dot_indent)a; y3=y1l; z4=(tail[x2l,x2r],y1l-tail_length) rotatedaround (pt,-oblique); ref=pt{downward}...z4; pos4(tail_tip,angle(direction 1 of ref)+90); if prime:z1r{left} o_t {downward}z2l--z4l--z4r--z2r{upward}...cycle else:z1r{left} o_t z2l{downward} o_t z3...z4l{direction 1 of ref}-- z4r{-direction 1 of ref}...z2r{upward}...cycle fi enddef; % ***** % The arrowhead macro makes an arrowhead which is then rotated around its tip % point to the desired direction. % It points when |@#|=t:up,|@#|=b:down,|@#|=r:right,|@#|=l:left. % The |head_width| is the widest (horizontal) span of the arrowhead. % The |head_depth| is the perpendicular distance from the tip to widest part vardef arrow@#(expr tip,head_width,head_depth)= save x,y,p; path p[]; z1=tip; y2=y3=y1+head_depth; round x1=x2+.5head_width=x3-.5head_width; z4=(x2,y1-1.5head_depth); z5=(x3,y4); penpos1(head_thickness,90); penpos2(head_thickness,angle(z2-z1)-90); penpos3(head_thickness,angle(z3-z1)+90); p1=z1l--z2l--z2r--z1r--z1r-(eps,0)--z3r--z3l--z1l-(eps,0)--cycle; p2=z1l--z2l--z4--z5--z3l--z1l--cycle; save_num(turn)=if str@#="b":0-oblique elseif str@#="r":90 elseif str@#="t":180-oblique elseif str@#="l":270 fi; fill p1 rotatedaround (tip,turn); unfill p2 rotatedaround (tip,turn); enddef; %*** SHOW\_CHARACTER macros *********************************************** % These macros show the characters for different stages of development. % || fill p[1-4] unfill p'[1-4] % || draw p[1-4] draw p'[1-4] % || does || and || shifted % || does || and draw ref[1-6] % fixes size of terminalscreen window (altered from plain.mf) % makes a reference box for screen/proof chars (altered from plain.mf) % shows point positions on screen while working on char def fill_all= for n=1 upto 6:if known p[n]:fill p[n];fi if known p[n]':unfill p[n]';fi endfor enddef; def draw_outlines= pickup pencircle; for n=1 upto 6:if known p[n]:draw p[n];fi if known p[n]':draw p[n]';fi endfor enddef; def outline_and_fill= pickup pencircle; for n=1 upto 6: if known p[n]: draw p[n]; fill p[n] shifted (0,-(h+d+100)); fi if known p[n]':draw p[n]'; unfill p[n]' shifted (0,-(h+d+100)); fi endfor enddef; def draw_with_reference_paths= draw_outlines; pickup pencircle scaled .15pt; for=1 upto 6:if known p[n]: draw ref[n]; fi endfor enddef; def openit = openwindow currentwindow % fixes size of terminalscreen window from (0,0) to (1.5screen_rows,screen_cols) at (-100,300) enddef; def makebox(text rule)= % makes a reference box for screen and proof characters for y=0,h.o_,-d.o_: rule((l,y),(r,y)); endfor % horizontals for x=l,r: rule((x,-d.o_),(x,h.o_)); endfor % outer verticals for x=0,wsaved: rule((x,0),(x,.2h.o_)); endfor % inner verticals if charic<>0: rule((wsaved+charic*hppp,h.o_),(wsaved+charic*hppp,.5h.o_));fi enddef; def showpoints(text t)= % Shows point positions on screen while working on char if mode=proof:pickup pencircle scaled 3; forsuffixes $:=t:forsuffixes s:=l,,r:if known z$.s:draw z$s;fi endfor endfor pickup pencircle scaled 1; penlabels(t); fi enddef; %*****EXTRA*********************************************************** %*****VARIATIONS on some PLAIN.MF macros %***** % This allows a selection of chars to be tested, w/o losing memory to defs % An extra line [iff OK "":] must be added before each char let semi_ = ;; let colon_ = :; let endchar_ = endchar; def iff expr b = if b:let next_=use_it else:let next_=lose_it fi; next_ enddef; def use_it = let : = restore_colon; enddef; def restore_colon = let : = colon_; enddef; def lose_it = let endchar=fi; let ;=restore_endchar semi_ if false enddef; def restore_endchar=let ;=semi_; let endchar=endchar_; enddef; def always_iff expr b = use_it enddef; boolean wanted[]; % To use this bit of magic, include the following commented-out lines % for x:="I": % wanted[byte x]:=true; endfor % this allows specifying only those characters which are to be shown % the chars can be specified inside of quotes("c") or as a number(23) def OK expr x=known wanted[byte x] enddef; % let iff=|always_iff|; % allows testing of all chars in the file %***** % This allows adjustments to left and right sidebearings of characters, % so that the space in which the character sits can be different from % the space in which the reference points for the character are given. letter_fit#:=letter_fit:=0; def adjust(expr left_adjustment,right_adjustment) = l:=-round(left_adjustment*hppp)-letter_fit; interim xoffset:=-l; charwd:=charwd+2letter_fit#+left_adjustment+right_adjustment; r:=l+round(charwd*hppp); w:=r-round(right_adjustment*hppp)-letter_fit; enddef; %***** % Changes to and makes for multiple reference positions % with the same length and angle arguments vardef pos@#(expr b,d) = (x@#r-x@#l,y@#r-y@#l)=(b,0)rotated d;x@#=.5(x@#l+x@#r);y@#=.5(y@#l+y@#r)enddef; vardef multpos(text t)(expr b,d)=forsuffixes $=t:pos$(b,d); endfor enddef; %***** % A takeoff on flex, allows softening of paths if softpath is true. % This takes a list of points and softens the path between the straight % lines connecting these points; a or must follow this % macro, i.e., not a . def soften(text t)= % t is a list of pairs hide(n_:=0; for z=t: z_[incr n_]:=z; endfor;) if softpath: --z_1)for k=2 upto n_:softjoin(z_[k-1]--z_[k]) endfor softjoin(z_[n_]-- else: --z_1 for k=2 upto n_-1: --z_[k] endfor --z_[n_]-- fi enddef; newinternal n_; pair z_[],dz_; %***** %*****MISCELLANEOUS %**** fitbasis ***** % If the basis for figuring the sidebearings or fitting has not been set % to 0 by the |fixed_pitch_characters| macro, then this gives values to the % upper and lower case def makeknown(text t)(expr value)= forsuffixes $=t:if unknown $:$=value;fi endfor enddef; %***** booleans % These macros shorten the code def bool(text t)=boolean t; t enddef; def save_bool(text t)=save t;bool(t) enddef; def save_pair(text t)=save t;pair t; t enddef; def save_pairs(text t)=save t;pair t[]; enddef; def save_num(text t)=save t;t enddef; % The condition macro localizes a boolean and gives it a true or false value def condition(text t)suffix $$= save_bool(t):=if(str$$="t"):true else:false; fi enddef; %***** % The softenit macro softens the join for two paths that are always to % have some softness vardef softenit(expr path_one,path_two)= save x,y,t; (t1,t2)=path_one intersectiontimes reverse path_two; z1=path_one intersectionpoint reverse path_two; (subpath(0,t1)of path_one--z1)softjoin(z1--subpath(t2,0)of reverse path_two) enddef; %***** % The |define_minimums| macro makes minimum stroke amount of one pixel def define_minimums(text t)=forsuffixes $=t: $:=max($,minimum_linethickness); endfor enddef; %***** % For turning off overshoots when the resolution is too low def lowres_fix(text t)=forsuffixes $=t: $:=0; endfor enddef; %***** % The |fixed_pt| macro increases the length of the stem measurement dependent % on the obliqueness to maintain stem widths % Used only in global |bowlstem/stem/thin_stem| specs if unknown scale_factor:scale_factor=1; fi def fixed_pt=(scale_factor*1/(pt#*cosd oblique)) enddef; %***** % In the inlimit macro, the first argument gives the value, % and places this value between the arguments % The lower and upper bound values are just recommended values thought % to maintain "reasonable" shapes vardef inlimit(text amt)(expr lowerlimit,upperlimit)=save this; this:=max(amt,lowerlimit); this:=min(this,upperlimit);this enddef; % The |min_limit| macro maintains a minimum limit def min_limit(text this)(expr limit)=if this>limit:save this;this=limit;fi enddef; %***** % Gives value to the used in terminalserif def def sign(expr a)=if a<=0:0 else:1 fi enddef; %***** % The onaline macro allows thinking that a point be on a particular line; % an x or y value must be supplemented vardef onaline(suffix a,b)(text t)=forsuffixes $=t:z$=whatever[z.a,z.b]; endfor enddef; %***** % The |good_x_for| macro gives reference points horizontal placement, % and moves them appropriately, according to vertical height and obliqueness vardef good_x_for(text t)(expr leftpoint,rightpoint,amt)suffix$= z1$=(xpart leftpoint,y.t-ypart leftpoint)//; z2$=(xpart rightpoint,y.t-ypart rightpoint)//; x.t=amt[x1$,x2$]; enddef; %***** % The |constant_angle| macro keeps a constant angle so that the thickness % of the line can remain constant as the line may change, e.g., as width, % obliqueness changes. % The stem value should be zero if the reference points are on the same % side of the stem, and the value of the stem otherwise. % The suffix lr is used when the reference points are diagonally opposite % each other and the |top_pt| is on the left of the stem % and the |bot_pt| on the right. % This could probably be made more efficient, but it works as is... *** FIX vardef constant_angle(expr top_pt,bot_pt,stem)suffix $= save theta; theta=if str$="lr":-else:+fi (angle(length(top_pt-bot_pt) +-+ stem,stem)); angle(top_pt-bot_pt)+theta-90 enddef; %***** % The notch macro makes an indentation to compensate for filling in at junctures % Variation in the length and width or thickness of the cut can be specified % Ideally one might tailor the length of the cut dependent on the angle % of the two stems at the juncture, however, here they are all considered % together % The notch macros:upnotch,downnotch,leftnotch,rightnotch all assume % A three point counterclockwise path with the notching occuring at the % middle point; the points connect as straight lines and the notching % begins at a point .5 of the way from the endpoints to the apex vardef notch@#(expr apath,notch_direction,notch_length)= save a; def a=(max(notch_length,eps),0)rotated notch_direction; enddef; z0=point 1 of apath; z2=z1+a; z3=z6+a; z4=z5+a; z6=.5[z1,z5]; if str@#="r":reverse fi (point 0 of apath--point .5 of apath if nonotch:--z0--else: ..controls z1..z2--z4..controls z5.. fi point 1.5 of apath--point 2 of apath) enddef; vardef rightnotch@#(expr one,n_dir,n_l)suffix $= save x,y,a; def a(expr n)=(n*notch_width,0)rotated(n_dir+90); enddef; if center_notch: z6=z0; z1=z0-a(.5); elseif str$="etchup": z1=z0; z5=z0+a(1); elseif str$="etchdown": z5=z0; z1=z0-a(1);else:z6=z0; z1=z0-a(.5); fi notch@#(one,n_dir,n_l) enddef; vardef leftnotch@#(expr one,n_dir,n_l)suffix $= save x,y,a; def a(expr n)=(n*notch_width,0)rotated(n_dir-90); enddef; if center_notch: z6=z0; z5=z0-a(.5); elseif str$="etchup": z5=z0; z1=z0+a(1); elseif str$="etchdown": z1=z0; z5=z0-a(1);else:z6=z0; z5=z0-a(.5); fi notch@#(one,n_dir,n_l) enddef; vardef upnotch@#(expr one,n_dir,n_l)suffix $= save x,y,a; def a(expr n)=(n*notch_width,0)rotated(n_dir-90); enddef; if center_notch: z6=z0; z1=z0+a(.5); elseif str$="etchleft": z1=z0; z5=z0-a(1); elseif str$="etchright":z5=z0; z1=z0+a(1); else:z6=z0; z1=z0+a(.5); fi notch@#(one,n_dir,n_l) enddef; vardef downnotch@#(expr one,n_dir,n_l)suffix $= save x,y,a; def a(expr n)=(n*notch_width,0)rotated(n_dir+90); enddef; if center_notch: z6=z0; z5=z0+a(.5); elseif str$="etchleft": z5=z0; z1=z0-a(1); elseif str$="etchright":z1=z0; z5=z0+a(1); else:z6=z0; z5=z0+a(.5); fi notch@#(one,n_dir,n_l) enddef; %***** %***** % The |fixed_pitch_characters| macro takes a true/false(or otherwise) % and number of |characters_per_inch| arguments. % This macro sets the often used value and other values for % single pitch, where all characters have the same width. % Note that a slight alteration made to |mono#| will allow % the character width to be specified arbitrarily, e.g., setting % |mono#:=10.7pt#| makes a single pitch width of 10.7 points. def fixed_pitch_characters(text t)(expr characters_per_inch)= boolean narrow_condition; % are characters especially narrow? boolean singlepitch; % affects character shapes for ijlwIJMWO0 if t=true:mono#:=(72.27/characters_per_inch)*pt#; width#:=0; fitbasis.lc#:=fitbasis.uc#:=0; singlepitch:=true; else:mono#:=0; singlepitch:=false; fi define_pixels(mono,width); narrow_condition:=if (mono<>0)and(characters_per_inch>12):true else:false fi; enddef; %***** vardef testing_codes= % There are a number of alternate characters. The "alt[]" scheme gives these % alternate characters a different code number than the one they would % normally have, if used, for the purpose of testing. if test_all_characters: alt0:=if a_full_bowl:128 else:0 fi; % characters: a alt1:=if g_full_bowl:128 else:0 fi; % characters: g alt2:=if spur:0 else:128 fi; % characters: G,b,q (a,g) alt3:=if like_lowercase:128 else:0 fi; % characters: U alt4:=if flat_diagonal_endings:0 else:128 fi; % characters: v,w,x,y,V,W,X alt5:=if beveled_join:128 else:0 fi; % characters: R,K,k alt6:=if open_tail:0 else:128 fi; % characters: 3,5,6,9 alt7:=if diagonal_three:0 else:128 fi; % characters: 3 alt8:=if inflection_two:0 else:128 fi; % characters: 2 alt9:=if G_spur:128 else:0 fi; % characters: G alt10:=if open_four:0 else:128 fi; % characters: 4 else:alt0:=alt1:=alt2:=alt3:=alt4:=alt5:=alt6:=alt7:=alt8:=alt9:=alt10:=0; fi enddef; %******************************* makeknown(minimum_linethickness)(1); def vpix(text t)(text tt)= t:=tt; t:=vround(tt.#*hppp); enddef; % whole v pix def hpix(text t)(text tt)= t:=tt; t:=hround(tt.#*hppp); enddef; % whole h pix def define_pixels(text t) = forsuffixes $=t: $:=$.#*hppp; endfor enddef; def define_whole_pixels(text t) = forsuffixes $=t: $:=hround($.#*hppp); endfor enddef; def define_whole_vertical_pixels(text t) = forsuffixes $=t: $:=vround($.#*hppp); endfor enddef; def define_good_x_pixels(text t) = forsuffixes $=t: $:=good.x($.#*hppp); endfor enddef; def define_good_y_pixels(text t) = forsuffixes $=t: $:=good.y($.#*hppp); endfor enddef; def define_blacker_pixels(text t) = forsuffixes $=t: $:=$.#*hppp+blacker; endfor enddef; def define_whole_blacker_pixels(text t) = forsuffixes $=t: $:=hround($.#*hppp+blacker); if $<=0: $:=1; fi endfor enddef; def define_whole_vertical_blacker_pixels(text t) = forsuffixes $=t: $:=vround($.#*hppp+blacker); if $<=0: $:=1_o_; fi endfor enddef; def define_corrected_pixels(text t) = forsuffixes $=t: $:=vround($.#*hppp*o_correction)+eps; endfor enddef; def define_horizontal_corrected_pixels(text t) = forsuffixes $=t: $:=hround($.#*hppp*o_correction)+eps; endfor enddef;