libgeda-common 1:1.8.2-4 / usr / share / gEDA / prolog.ps

% Prolog for gEDA, define all the functions needed for rendering
% schematics on Postscript devices


% Draw a line from the second coordinate to the first
% x2 y2 x1 y1 width line -
/line {
    setlinewidth
    % pop off first element and moveto
    moveto
    % pop off remaining elements and draw a line segment
    lineto
    % draw it
    stroke
} bind def


% Draw a dot
% x y r dot -
/dot {
    0 360 arc fill
} bind def

% Draw a dot-dashed line, a bunch of lined segments,
% if the array element only has length two, draw a dot.
% [ [x2 y2 x1 y1] [x4 y4 x3 y3] [x5 y5] ... ] width dashed -
/width 0 def
/dashed {
    dup 2.0 div /width exch def
    setlinewidth
    % pop off each line segment and draw it as a dot or as a line
    {
	aload length 2 gt
	{ moveto lineto stroke}
	{ width dot } ifelse
    } forall
} bind def

% Draw an arc segment
% x y r ang1 ang2 width darc -
/darc {
    setlinewidth
    arc stroke
} bind def

% Draw a series of arc segment bits, if the array element only has a single
% element in it, draw a dot.
% [ [sa1 ea1] [sa2 ea2] ... ] x y r width dashedarc -
/x 0 def
/y 0 def
/dashedarc {
    dup /width exch def
    setlinewidth
    /r exch def  
    /y exch def
    /x exch def
    { aload length 1 gt
	{
	    % this element had two angles in it
	    % extract start and stop angles
	    x y r   % drop x y and r onto stack
		    % at this point we have: sa ea x y r
		    % we need                      x y r sa ea
		    % so..
	    5 -2 roll
	    % and add it to the current path, and draw it
	    arc stroke
	} {
	    % this element only had one angle in it, place a
	    % filled dot at the appropriate place
	    % compute center point of the arc using the angle
	    % that is on the top of the stack
	    dup   		% angle angle
	    cos r mul x add 	% angle x
	    exch		% x angle
	    sin r mul y add	% x y
	    width		% x y width/2
	    dot			% draw the dot
	} ifelse
    } forall

    % Now draw it
    stroke
} bind def

% Draw a box
% width height x y linethickness box -
/box {
    setlinewidth
    moveto
    exch dup 0 rlineto	 % w h, h w w 0      -- Draw bottom line
    exch 0 exch rlineto	 % h w, w h 0, w 0 h -- Draw right line 
    neg 0 rlineto	 % w, -w 0           -- Draw Top line
    closepath		 % finish and draw it
    stroke
} bind def			     

% Draw a filled box
% width height x y fbox -
/fbox {
    moveto
    exch dup 0 rlineto	
    exch 0 exch rlineto	
    neg 0 rlineto		
    closepath			
    fill			
} bind def

% Font reincoding utilities

% ISOLatin1Encoding, extended with remaining uncoded glyphs
/ISOLatin1Extended [
    /.notdef /Lslash /lslash /OE /oe /Scaron /scaron /Zcaron /zcaron
    /Ydieresis /trademark /bullet /dagger /daggerdbl /ellipsis /emdash
    /endash /fi /fl /florin /fraction /guilsinglleft /guilsinglright
    /perthousand /quotedblbase /quotedblleft /quotedblright
    /quotesinglbase /quotesingle /.notdef /.notdef /.notdef /space
    /exclam /quotedbl /numbersign /dollar /percent /ampersand
    /quoteright /parenleft /parenright /asterisk /plus /comma /minus
    /period /slash /zero /one /two /three /four /five /six /seven /eight
    /nine /colon /semicolon /less /equal /greater /question /at /A /B /C
    /D /E /F /G /H /I /J /K /L /M /N /O /P /Q /R /S /T /U /V /W /X /Y /Z
    /bracketleft /backslash /bracketright /asciicircum /underscore
    /quoteleft /a /b /c /d /e /f /g /h /i /j /k /l /m /n /o /p /q /r /s
    /t /u /v /w /x /y /z /braceleft /bar /braceright /asciitilde
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef /.notdef
    /.notdef /.notdef /.notdef /dotlessi /grave /acute /circumflex
    /tilde /macron /breve /dotaccent /dieresis /.notdef /ring /cedilla
    /.notdef /hungarumlaut /ogonek /caron /space /exclamdown /cent
    /sterling /currency /yen /brokenbar /section /dieresis /copyright
    /ordfeminine /guillemotleft /logicalnot /hyphen /registered /macron
    /degree /plusminus /twosuperior /threesuperior /acute /mu /paragraph
    /periodcentered /cedilla /onesuperior /ordmasculine /guillemotright
    /onequarter /onehalf /threequarters /questiondown /Agrave /Aacute
    /Acircumflex /Atilde /Adieresis /Aring /AE /Ccedilla /Egrave /Eacute
    /Ecircumflex /Edieresis /Igrave /Iacute /Icircumflex /Idieresis /Eth
    /Ntilde /Ograve /Oacute /Ocircumflex /Otilde /Odieresis /multiply
    /Oslash /Ugrave /Uacute /Ucircumflex /Udieresis /Yacute /Thorn
    /germandbls /agrave /aacute /acircumflex /atilde /adieresis /aring
    /ae /ccedilla /egrave /eacute /ecircumflex /edieresis /igrave
    /iacute /icircumflex /idieresis /eth /ntilde /ograve /oacute
    /ocircumflex /otilde /odieresis /divide /oslash /ugrave /uacute
    /ucircumflex /udieresis /yacute /thorn /ydieresis
] def

% `new-font-name' `encoding-vector' `old-font-name' RE -
/RE {
    findfont
    dup maxlength dict begin {
        1 index /FID ne { def } { pop pop } ifelse
    } forall
    /Encoding exch def
    dup /FontName exch def
    currentdict end definefont pop
} bind def

% Text handling functions, select the font and scale it, then we need
% only to apply the appropriate transformations to get the text
% justified into the right spots.  The bad thing here is that we don't
% do any kerning, so the output may look a bit strange.

% compute the height of one character and return lly and ury
% (char) charheight lly ury
/charheight {
    gsave			% push graphics state
	newpath			% clear current path
	0 0 moveto		% Set current point
	false charpath		% get path
	flattenpath		% flatten path
	pathbbox		% stack = llx lly urx ury
	exch pop		% stack = llx lly ury
	3 -1 roll pop		% stack = lly ury
    grestore			% pop graphics state
} bind def

% compute the height of a string, one character at a time
% (string) stringheight lly ury
/lly 0.0 def
/ury 0.0 def

/stringheight {
    /lly 0.0 def			% initial value of heightmin
    /ury 0.0 def			% initial value of heightmax
    {				% work through string
	( ) dup 0 4 -1 roll put	% create one character string
	charheight		% measure it's height
	dup ury gt {		% if ury gt heightmax
	    /ury exch def	% update with new value
	} {
	    pop			% else discard ury
	} ifelse
	dup lly lt {		% if lly lt heightmin
	    /lly exch def	% update with new value
	} {
	    pop			% else discard lly
	} ifelse
    } forall
    lly ury			% Return the results
} bind def

% calculate the string width taking into account the escapes.
/mystrx 0.0 def
/mystry 0.0 def
/mystresc false def

/mystringwidth {
    /mystrx 0.0 def
    /mystry 0.0 def
    /mystresc false def
    {				% work through string
	% did we process the escape character last?
	mystresc {
	    % last character was escape
	    % handle the escape
	    % is it an _ = 95?
	    dup 95 eq {
		pop  % we don't need the character anymore
		% toggle drawing overbars
		0.0 0.0 % make it like it never happened...
	    } {
		% otherwise measure the character 
		(\\ ) dup 1 4 -1 roll put % count a \ and the character
		stringwidth
	    } ifelse
	    % and reset the flag
	    /mystresc false def
	} {
	    % last character was not escape
	    % is this escape
	    dup 92 eq {
		% yes, escape character, set flag
		/mystresc true def
		pop % drop character
		0.0 0.0 % make like this character has no width and height
	    } {
		( ) dup 0 4 -1 roll put	% create one character string
		stringwidth		% measure it's height/width
	    } ifelse
	} ifelse
	% accumulate x and y movements
	mystry add /mystry exch def
	mystrx add /mystrx exch def
    } forall
    mystrx mystry % drop results on stack
} bind def

% Render a string with overbars
%
/escaped false def
/drawoverbar false def
/fontsize 0.0 def

%string1 string2 append -
/append {
    2 copy length exch length add % find new length
    string dup % string1 string2 string string
    4 2 roll % string string string1 string2
    2 index 0 3 index
    % string string string1 string2 string 0 string1
    putinterval % string string string1 string2
    exch length exch putinterval
} bind def

% If drawoverbar is set, draw a line of the same length as the given string
% string overbarshowline -
/overbarshowline {
    % print overbar if necessary
    stringwidth pop 0
    drawoverbar {
        rlineto
        gsave stroke grestore
    } {
        rmoveto
    } ifelse
} bind def

% Draws overbars for the given string, then shows the string itself
% string overbarshow
/overbarshow {
    /overbarshowacc () def
    /overbarshowtxt () def

    gsave
    fontsize 10.0 div setlinewidth
    0 fontsize rmoveto  % move to (0,overbarheight)

    {				% work through string
	escaped {
	    % the last character was the escape
	    % handle the escape
	    % is it an _ = 95?
	    dup 95 eq {
		pop  % we don't need the character anymore
                overbarshowacc overbarshowline
                % toggle drawing overbars
		/drawoverbar drawoverbar not def

                % Append the contents off the accumulator to the text
                % string we're eventually going to show
                /overbarshowtxt overbarshowtxt overbarshowacc append def

                % clear accumulator
                /overbarshowacc () def
	    } {
                % add to accumulator
                (\\ ) dup 1 4 -1 roll put
                overbarshowacc exch append
                /overbarshowacc exch def
	    } ifelse
	    % and reset the flag
	    /escaped false def
	} {
	    % check for escape character \ = 92
	    dup 92 eq {
		% yes, escape character, set flag
		/escaped true def
		pop % drop character
	    } {
                % add to accumulator
                ( ) dup 0 4 -1 roll put
                overbarshowacc exch append
                /overbarshowacc exch def
	    } ifelse
	} ifelse
    } forall
    % Catch any leftovers
    overbarshowacc overbarshowline
    overbarshowtxt overbarshowacc append

    grestore
    show
} bind def

% 
% hcenter rjustify vcenter vjustify spacing [(line1) (line2) ... ] rot x y size text -
/stringw 0.0 def
/stringh 0.0 def
/spacing 0.0 def
/strings [ ] def
/stringtxt ( ) def
/stringcount 0 def
/rot 0.0 def

/text {
    gsave	        % save state for later
    /drawoverbar false def      % start by not drawing overbars

    dup /fontsize exch def  % save font size for corrections later
    % do font selection 
    /gEDAFont findfont
    exch scalefont
    setfont

    % set up coordinates
    translate           % move origin to given point
    rotate		% rotate so that text is drawn
    0 0 moveto
    dup length /stringcount exch def			% Get number of strings
    /strings exch def     				% save strings
    /spacing exch def
    % do we have more than 1 string to render?
    stringcount 1 eq {
	/stringtxt strings aload pop def		% get the string 
	/stringw stringtxt mystringwidth pop neg def	% get the -width
	/stringh stringtxt stringheight exch pop neg def% get the -height

	% First do vertical calculations
	% hcenter rjustify vcenter vjustify 
	% vertical justification
	{ 0 stringh rmoveto } if 
	% vertical center
	{ 0 stringh 0.3571425 mul rmoveto } if  % not 0.5, so that
						% it looks nicer
	% Then do horizontal calculations
	% right justify
	{ stringw 0 rmoveto } if
	% center
	{ stringw 2.0 div 0 rmoveto } if
	% Draw the text
	stringtxt overbarshow
    } {
	% More than one line, compute bounding box for the text

	% vertical height, don't use the actual hieght of the characters
	% assume that the user wants to make the baselines line up with two
	% text boxes placed side by side
	/stringh stringcount spacing mul neg def
	% Now figure out horizontal size, this amounts to keeping track
	% of the longest string
	/stringw 0.0 def
	strings {
	    mystringwidth pop
	    dup stringw gt {
		/stringw exch def
	    } {
		pop
	    } ifelse
	} forall
	/stringw stringw neg def 	% get the -width
	
	% First do vertical calculations
	% hcenter rjustify vcenter vjustify 
	% vertical justification
	{ 0 stringh fontsize add rmoveto } if 
	% vertical center
	{ 0 stringh 0.5 mul rmoveto } if 
	% Then do horizontal calculations
	% right justify
	{ stringw 0 rmoveto } if
	% center
	{ stringw 2.0 div 0 rmoveto } if
	% now move up to the first line and begin rendering
	0 stringcount 1 sub spacing mul rmoveto
	strings {
	    gsave		% Save starting point
	    overbarshow		% render the text
	    grestore
	    0 spacing neg rmoveto
	} forall
    } ifelse
    grestore 	% Restore old state
} bind def