552 lines
22 KiB
PostScript
552 lines
22 KiB
PostScript
%!
|
|
% Copyright (C) 1994 , 1999 Aladdin Enterprises. All rights reserved.
|
|
%
|
|
% This software is provided AS-IS with no warranty, either express or
|
|
% implied.
|
|
%
|
|
% This software is distributed under license and may not be copied,
|
|
% modified or distributed except as expressly authorized under the terms
|
|
% of the license contained in the file LICENSE in this distribution.
|
|
%
|
|
% For more information about licensing, please refer to
|
|
% http://www.ghostscript.com/licensing/. For information on
|
|
% commercial licensing, go to http://www.artifex.com/licensing/ or
|
|
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
|
|
% San Rafael, CA 94903, U.S.A., +1(415)492-9861.
|
|
|
|
% $Id: ps2ai.ps,v 1.4 2002/02/21 21:49:28 giles Exp $
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
%
|
|
% ps2ai.ps - a postscript to editable adobe illustrator file filter
|
|
%
|
|
/vers {2.14} def % January 31, 1999
|
|
|
|
% conditional def ( if the key is already defined before, don't
|
|
% redefine it. This can be used by other programs to overwrite
|
|
% some settings from externally
|
|
%
|
|
/cdef { 1 index where { pop pop pop } { def } ifelse } def
|
|
%
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
%
|
|
% needs a postscript level 2 interpreter, like gnu ghostscript, to work
|
|
%
|
|
% Usage: gs -q -dNODISPLAY ps2ai.ps file.ps > file.aips
|
|
% or (see below)
|
|
% gs -q -dNODISPLAY ps2ai.ps file.ps
|
|
% or
|
|
% cat ps2ai.ps file.ps | lpr (then look in log file)
|
|
%
|
|
% or from within gsview via:
|
|
% Edit->Convert to vector format
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
% Options
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
% Output Options: directly to a file or standard out
|
|
%
|
|
/jout false cdef % true=file false=stdout (default=false)
|
|
/joutput (ps2ai.out.aips) cdef % Name of Output file
|
|
%
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
%
|
|
% Other Options
|
|
%
|
|
/jtxt3 true cdef % output text in AI3 form (false=ai88)
|
|
% for coreldraw/photoshop readable output
|
|
/joutln false cdef % use font outline instead of font
|
|
/jerr false def % use error handling (ie die gracefully)
|
|
/jbiterr false def % attempt to handle bitmap fonts (kludge)
|
|
/jMacGS false def % true if using MacGS (not fully implemented yet)
|
|
/jMacfix true def % convert filled boxes to lines (only usefull with
|
|
% laserwriter 8 postscript input)
|
|
|
|
%
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
% No options below here
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
%
|
|
% - Notes -
|
|
% ai uses cmykcolor, so level 1 interpreters don't work
|
|
% ai doesn't use image/imagemask - so bitmaps don't work correctly
|
|
% the output file has a header so it is viewable/printable/reconvertable
|
|
%
|
|
% Comments, suggestions, bug-fixes, etc send to:
|
|
%
|
|
% Jason Olszewski (olszewsk@splash.princeton.edu)
|
|
%
|
|
% anonymous ftp: toby.princeton.edu /pub/olszewsk/ps2ai.ps
|
|
% URL ftp://toby.princeton.edu/pub/olszewsk
|
|
%
|
|
% - Fix History -
|
|
% 2.14 added cdef to allow overwriting of certain values from externally
|
|
% 2.13 check for bitmap fonts, work better with TeX,WinPS,etc
|
|
% 2.12 fixed initclip to US letter size page
|
|
% 2.11 added header support for *u/*U compound paths
|
|
% 2.1 option of font outline instead of text(gwhite@trevnx.bio.dfo.ca)
|
|
% 2.0 major change to complex path handling
|
|
% 1.9 fixed text leaking ascii (,),\
|
|
% 1.85 added default font to handle no setfont (Courier)
|
|
% 1.84 added even-odd fill/clip (D)
|
|
% 1.83 undefined PPD PageSize printer specific info
|
|
% 1.82 added kludge to save clipping status through a restore
|
|
% 1.81 added custom color/gray support to header (x/X, g/G)
|
|
% 1.8 added newpath if clippath is not consumed correctly(amiga)
|
|
% 1.79 eliminated scientific notation of numbers less than 0.0001
|
|
% 1.78 fixed transposed h & H
|
|
% 1.77 made laserwriter 8 fixes optional
|
|
% 1.76 added margin fix for unix AI (brown@wi.extrel.com)
|
|
% 1.75 added kludge to handle bitmap font errors (TeX, Windows.ps)
|
|
% 1.74 made grestore a little smarter
|
|
% 1.73 included header handle encoded fontname (/_fontname)
|
|
% 1.72 fixed problem with restore/clip info - (not enough Qs problem)
|
|
% 1.71 filter font names to remove previous encoding (|,_,etc)
|
|
% 1.7 change text format to AI3, works better with PS & CD
|
|
% 1.67 deal with weird makefonts
|
|
% 1.66 handle to many bad stroke/fills (s s s w/o paths)
|
|
% 1.65 more useable with non-gs interpreters (defaultmatrix fix)
|
|
% 1.64 fixed "smart grestore" repeat bug
|
|
% 1.63 fixed ashow/awidthshow bug
|
|
% 1.62 check if cmykcolor is understood otherwise rgb
|
|
% 1.61 made grestore smarter (only print if different)
|
|
% 1.6 add better compatibility to CorelDraw and PhotoShop
|
|
% 1.53 make it more gs-backward compatible (clarke@lsl.co.uk)
|
|
% 1.52 handle clipping paths a little better (Posted)
|
|
% 1.51 improve mac lw8 output (lines instead of filled boxes)
|
|
% 1.5 handle some level 2 stuff (mac lw8)
|
|
% 1.4 fixed scaling of linewidth and dash
|
|
% 1.31 made trailer more AI88 friendly
|
|
% 1.3 add ablity to output to file directly
|
|
% 1.21 print matrix cleaner
|
|
% 1.2 fix rotated fonts, thanks to G.Cameron (g.cameron@biomed.abdn.ac.uk)
|
|
% 1.1 fix stroke/fill color difference (k vs K)
|
|
% 1.0 posted to comp.lang.postscript
|
|
%
|
|
% - To Do List -
|
|
% find real %%BoundingBox: llx lly urx ury
|
|
% make MacGS friendly (line-endings)
|
|
% handle eps w/o showpage:(append to end)
|
|
% write out image data to external file
|
|
%
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
% Nothing of Interest below here
|
|
%xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
|
matrix identmatrix setmatrix % make ctm [1 0 0 1 0 0]
|
|
/oldgsave {} def /oldgrestore {} def
|
|
/initgraphics {} def /initmatrix {} def
|
|
% undefine PPD PageSizes to be more printer independant
|
|
/letter {} def /legal {} def /a4 {} def /b5 {} def /lettersmall {} def
|
|
/setpagedevice { pop } def % for level 2 PPD PageSizes
|
|
/Courier findfont 12 scalefont setfont % handle no setfont
|
|
/initclip {0 0 moveto 0 792 lineto 612 792 lineto 612 0 lineto closepath
|
|
clip newpath } def
|
|
/xdef {exch def} def
|
|
/trx {transform exch} def
|
|
/cbdef {cvx bind def} def
|
|
/jltz {dup abs 0.0001 lt {pop 0} if} def % get rid of scientific notation bug
|
|
/clstate false def % closepath state
|
|
/dpth false def % destroy path (ie newpath)
|
|
/fclp false def % first paint after clip
|
|
/kscl {1.0} def % default current scale X-factor
|
|
/gcnt {1} def % graphics state counter
|
|
/spth {1} def % multiple paths on stack
|
|
/jeol (\n) def % default end-of-line
|
|
/jnump {0} def % number of paths on stack
|
|
/jx {0} def /jy {0} def /j_ax {0} def
|
|
/j3ftxt true def
|
|
/clarry 10 array def
|
|
0 1 9 {clarry exch false put} for % initilize no clipping path
|
|
%
|
|
% handle cmyk color on level 1 interpreters
|
|
/setcmykcolor where {pop}
|
|
{/setcmykcolor {
|
|
/blk exch def /yel exch def /mag exch def /cyan exch def
|
|
/ccomp {add dup 1 gt {pop 1} if} def
|
|
/red {1 cyan blk ccomp sub} def
|
|
/green {1 mag blk ccomp sub} def
|
|
/blue {1 yel blk ccomp sub} def
|
|
red green blue setrgbcolor
|
|
} def
|
|
} ifelse
|
|
/currentcmykcolor where {pop}
|
|
{/currentcmykcolor {
|
|
currentrgbcolor /bval xdef /gval xdef /rval xdef
|
|
/rawC 1 rval sub def /rawM 1 gval sub def /rawY 1 bval sub def
|
|
rawC rawM ge { rawY rawM ge { /blk rawM def} if } if
|
|
rawC rawY ge { rawM rawY ge { /blk rawY def} if } if
|
|
rawY rawC ge { rawM rawC ge { /blk rawC def} if } if
|
|
rawY rawC eq { rawM rawC eq { /blk rawC def} if } if
|
|
/cyan rawC blk sub def
|
|
/mag rawM blk sub def
|
|
/yel rawY blk sub def
|
|
/blk blk def
|
|
cyan mag yel blk
|
|
} def
|
|
} ifelse
|
|
% If using Mac Ghostscript
|
|
jMacGS {
|
|
% /jeol {(\r) jp} def
|
|
/jout true def
|
|
(%%Note: Loading ps2ai.ps\n) print
|
|
} if
|
|
/jstr 40 string def
|
|
jout {joutput (w) file /joutput xdef} if
|
|
%
|
|
% Output
|
|
%
|
|
jout {/jp { joutput exch writestring } bind def }{/jp {print}bind def} ifelse
|
|
/jpnum {jltz ( ) jp =string cvs jp } bind def
|
|
/jpmat { dup /jarry exch def length 1 sub /j_num exch def
|
|
(\[) jp 0 1 j_num {jarry exch get jpnum} for (\]) jp } def
|
|
%
|
|
% Stack to Paths converters
|
|
%
|
|
/ckpnt { % check which paint and clipping to use
|
|
dpth { % if there are multiple paths on the stack
|
|
clarry gcnt get fclp and {clstate {(h W\n) jp }{(H W\n) jp } ifelse} if
|
|
spth 0 eq {clstate {(n\n) jp }{(N\n) jp } ifelse} if
|
|
spth 1 eq {clstate {(s\n) jp }{(S\n) jp } ifelse} if
|
|
spth 2 eq {clstate {(f\n) jp }{(F\n) jp } ifelse} if
|
|
} if
|
|
} def
|
|
/jpm {
|
|
ckpnt
|
|
/dpth true def
|
|
transform 2 copy /yst xdef /xst xdef exch jpnum jpnum ( m\n) jp } bind def
|
|
/jpl { trx jpnum jpnum ( l\n) jp } bind def
|
|
/jpc { 6 4 roll trx jpnum jpnum 4 2 roll trx jpnum jpnum trx
|
|
jpnum jpnum ( c\n) jp } bind def
|
|
/jpp {xst jpnum yst jpnum ( l\n) jp /clstate true def} def
|
|
/cntpaths { % count paths on stack
|
|
oldgsave
|
|
{pop pop /jnump jnump 1 add def} {pop pop} {6 {pop} repeat}{} pathforall
|
|
oldgrestore
|
|
} def
|
|
/ppforall {
|
|
cntpaths % find out how many paths are on the stack
|
|
jnump 1 gt { (*u\n) jp } if
|
|
{jpm}{jpl}{jpc}{jpp} pathforall
|
|
ckpnt
|
|
jnump 1 gt { (*U\n) jp } if
|
|
/jnump 0 def /clstate false def /dpth false def /fclp false def
|
|
oldnewpath
|
|
} bind def
|
|
%
|
|
% Painting Operators
|
|
%
|
|
/oldnewpath [/newpath load] cbdef
|
|
/newpath { (\n) jp /spth 0 def ppforall} def
|
|
/stroke { (\n) jp /spth 1 def ppforall } def
|
|
/fill {(\n) jp /spth 2 def ppforall } def
|
|
/eofill {(1 D\n) jp fill (0 D\n) jp} def
|
|
/clip {clarry gcnt get {(Q\nq\n) jp}{(q\n) jp} ifelse
|
|
/fclp true def clarry gcnt true put} def
|
|
/eoclip {(1 D\n) jp clip (0 D\n) jp} def
|
|
%
|
|
% Text Operators
|
|
%
|
|
/oldshow [/show load] cbdef
|
|
/curpt {stringwidth pop jx add jy} def
|
|
/jNN {dup 0 eq {pop oldgsave currentfont /FontMatrix get setmatrix kscl
|
|
oldgrestore} if
|
|
} def
|
|
/curftmatrix {
|
|
currentfont /FontMatrix get dup 0 get jNN abs /norm exch def
|
|
dup 0 get norm div exch dup
|
|
1 get norm div exch dup 2 get norm div exch dup 3 get norm div exch dup
|
|
4 get exch 5 get 6 array astore matrix currentmatrix matrix concatmatrix
|
|
} def
|
|
% AI does not support negitive font sizes
|
|
/curftsize {currentfont /FontMatrix get 0 get jNN abs 1000 mul} def
|
|
/hstr (X) def
|
|
/vbar (|) 0 get def /undsc (_) 0 get def
|
|
/ftnamefix { % handle font names with |,_ (previously encoded)
|
|
jstr cvs
|
|
{ %forall
|
|
dup vbar eq {pop}{ %ifelse
|
|
dup undsc eq {pop}{ %ifelse
|
|
hstr exch 0 exch put hstr jp
|
|
} ifelse
|
|
} ifelse
|
|
} forall flush
|
|
} bind def
|
|
%/curftname {currentfont /FontName get ftnamefix}def
|
|
/curftname { currentfont /FontName known {currentfont /FontName get}
|
|
{ (Times-Roman)} ifelse ftnamefix } def
|
|
/lftpar (\() 0 get def
|
|
/rhtpar (\)) 0 get def
|
|
/bckslsh (\\) 0 get def
|
|
/handft { % handle strings with (,),\
|
|
(\() jp
|
|
{ %forall
|
|
dup lftpar eq { (\\\() jp }{ %ifelse
|
|
dup rhtpar eq { (\\\)) jp }{ %ifelse
|
|
dup bckslsh eq { (\\\\) jp }{ %ifelse
|
|
hstr exch 0 exch put hstr jp
|
|
} ifelse
|
|
} ifelse
|
|
} ifelse
|
|
} forall (\)) jp flush
|
|
} bind def
|
|
% AI 3 text format pieces
|
|
jtxt3 {
|
|
/j3txt { j3ftxt {(0 Ts 100 Tz 0 Tt 0 TA 0 0 5 TC 100 100 200 TW 0 0 0 Ti\n) jp
|
|
(0 Ta 0 Tq 0 0 TI 0 Tc 0 Tw\n) jp} if } def
|
|
/show {oldgsave (0 To\n) jp
|
|
currentpoint 2 copy /jy exch def /jx exch def translate
|
|
curftmatrix /jitm exch def
|
|
0 1 5 {jitm exch get jpnum} for ( 0 Tp\n) jp (TP\n) jp
|
|
(0 Tr\n) jp (\/_) jp curftname curftsize jpnum ( Tf\n) jp
|
|
(0) jp j_ax curftsize div 100 mul jpnum ( 100 TC\n) jp % percent(?)
|
|
dup curpt moveto mark exch handft ( Tx\n) jp (TO\n) jp /j3ftxt false def
|
|
cleartomark currentpoint oldgrestore moveto
|
|
} def
|
|
/ashow {exch pop exch /j_ax exch def show /j_ax {0} def } def
|
|
}
|
|
{
|
|
/show {oldgsave (u\n) jp currentpoint 2 copy /jy exch def /jx exch def translate
|
|
(\/) jp curftname jstr cvs jp
|
|
curftsize dup jpnum jpnum ( 0 0 z\n) jp
|
|
curftmatrix jpmat ( e\n) jp
|
|
dup curpt moveto mark exch handft ( t T U\n) jp
|
|
cleartomark currentpoint oldgrestore moveto} def
|
|
/ashow {oldgsave (u\n) jp currentpoint translate (\/) jp curftname jstr cvs jp
|
|
curftsize dup jpnum jpnum exch kscl mul jpnum ( 0 z\n) jp
|
|
curftmatrix jpmat ( e\n) jp dup curpt moveto mark exch handft
|
|
( t T U\n) jp cleartomark currentpoint oldgrestore moveto} def
|
|
} ifelse
|
|
/widthshow { show pop pop pop} def
|
|
/awidthshow {ashow pop pop pop} def
|
|
/kshow {show pop} def
|
|
%/show {true charpath fill} bind def % get outline of charactor
|
|
joutln {/show { true charpath currentpoint
|
|
/jy exch def /jx exch def fill jx jy moveto} bind def} if
|
|
%/show {oldshow} def % do nothing different
|
|
%
|
|
% Color Operators
|
|
%
|
|
/oldsetcmykcolor [/setcmykcolor load] cbdef
|
|
/setcmykcolor {oldsetcmykcolor
|
|
currentcmykcolor 4 -1 roll jpnum 3 -1 roll jpnum 2 -1 roll jpnum jpnum ( k\n) jp
|
|
currentcmykcolor 4 -1 roll jpnum 3 -1 roll jpnum 2 -1 roll jpnum jpnum ( K\n) jp
|
|
} def
|
|
/oldsetgray [/setgray load] cbdef
|
|
/setgray {0 0 0 4 -1 roll 1 exch sub setcmykcolor} def
|
|
/oldsethsbcolor [/sethsbcolor load] cbdef
|
|
/sethsbcolor {oldsethsbcolor currentcmykcolor setcmykcolor} def
|
|
/oldsetrgbcolor [/setrgbcolor load] cbdef
|
|
/setrgbcolor {oldsetrgbcolor currentrgbcolor /bval xdef /gval xdef /rval xdef
|
|
/rawC 1 rval sub def /rawM 1 gval sub def /rawY 1 bval sub def
|
|
rawC rawM ge { rawY rawM ge { /blk rawM def} if } if
|
|
rawC rawY ge { rawM rawY ge { /blk rawY def} if } if
|
|
rawY rawC ge { rawM rawC ge { /blk rawC def} if } if
|
|
rawY rawC eq { rawM rawC eq { /blk rawC def} if } if
|
|
/cyan rawC blk sub def
|
|
/mag rawM blk sub def
|
|
/yel rawY blk sub def
|
|
/blk blk def
|
|
cyan mag yel blk setcmykcolor } def
|
|
%
|
|
% State Operators
|
|
%
|
|
/oldsetlinewidth [/setlinewidth load] cbdef
|
|
/setlinewidth {kscl abs mul jltz oldsetlinewidth
|
|
currentlinewidth jpnum ( w\n) jp } def
|
|
/oldsetlinecap [/setlinecap load] cbdef
|
|
/setlinecap {dup oldsetlinecap jpnum ( J\n) jp} def
|
|
/oldsetlinejoin [/setlinejoin load] cbdef
|
|
/setlinejoin {dup oldsetlinejoin jpnum ( j\n) jp} def
|
|
/oldsetmiterlimit [/setmiterlimit load] cbdef
|
|
/setmiterlimit {dup oldsetmiterlimit jpnum ( M\n) jp}def
|
|
/oldsetdash [/setdash load] cbdef
|
|
/setdash {exch [ exch {kscl abs mul} forall ] exch kscl abs mul oldsetdash
|
|
currentdash exch jpmat jpnum ( d\n) jp } def
|
|
/oldsetflat [/setflat load] cbdef
|
|
/setflat {dup oldsetflat jpnum ( i\n) jp } def
|
|
%
|
|
% More State Operators
|
|
%
|
|
/kscl { % use just the x scale factor
|
|
oldgsave
|
|
matrix currentmatrix /jctm exch def
|
|
jctm 4 0 put jctm 5 0 put jctm setmatrix
|
|
1 0 moveto currentpoint transform
|
|
dup mul exch dup mul add sqrt 10000 mul round 10000 div
|
|
oldgrestore
|
|
} def
|
|
/currentstate {currentcmykcolor setcmykcolor
|
|
currentflat jpnum ( i) jp currentlinecap jpnum ( J) jp
|
|
currentlinejoin jpnum ( j) jp currentlinewidth jpnum ( w) jp
|
|
currentmiterlimit jpnum ( M ) jp currentdash exch jpmat jpnum ( d\n) jp
|
|
} def
|
|
/jdifG {
|
|
currentcmykcolor /jok xdef /joy xdef /jom xdef /joc xdef
|
|
currentflat /jof xdef currentlinecap /jolc xdef currentlinejoin /jolj xdef
|
|
currentlinewidth /jolw xdef currentmiterlimit /joml xdef
|
|
currentdash /jood xdef /joad xdef
|
|
oldgrestore
|
|
currentcmykcolor /jnk xdef /jny xdef /jnm xdef /jnc xdef
|
|
currentflat /jnf xdef currentlinecap /jnlc xdef currentlinejoin /jnlj xdef
|
|
currentlinewidth /jnlw xdef currentmiterlimit /jnml xdef
|
|
currentdash /jnod xdef /jnad xdef
|
|
% compare old gstate to new gstate
|
|
joc jnc ne jom jnm ne joy jny ne jok jnk ne
|
|
jof jnf ne jolc jnlc ne jolj jnlj ne jolw jnlw ne joml jnml ne
|
|
false joad {true exit} forall {pop pop true}{false} ifelse
|
|
false jnad {true exit} forall {pop pop true}{false} ifelse ne
|
|
jood jnod ne 10 {or} repeat {currentstate} if
|
|
} def
|
|
/oldgsave [/gsave load] cbdef
|
|
/gsave {oldgsave /gcnt gcnt 1 add def } def % clarry gcnt false put} def
|
|
% (%%Note:gsave ) jp gcnt jpnum (\n) jp} def
|
|
/oldgrestore [/grestore load] cbdef
|
|
/grestore {dpth {newpath} if clarry gcnt get {(Q\n) jp clarry gcnt false put} if
|
|
jdifG /gcnt gcnt 1 sub def } def
|
|
% oldgrestore currentstate } def
|
|
% (%%Note:grestore ) jp gcnt 1 add jpnum (\n) jp} def
|
|
/oldrestore [/restore load] cbdef
|
|
% a kludgy way of saving the clipping path status information
|
|
/restore {clarry aload pop 11 -1 roll oldrestore clarry astore pop} def
|
|
/showpage { 0 1 9 {clarry exch get {(Q\n) jp} if } for
|
|
(%%Note: If Error, make sure there are matched pairs of 'q's and 'Q's\n) jp
|
|
(%%Note: in the file. Add 'Q's before '%%Trailer' until equal\n) jp
|
|
(%%Trailer\n) jp
|
|
jtxt3 {(Adobe_IllustratorA_AI3 /terminate get exec\n) jp
|
|
(Adobe_typography_AI3 /terminate get exec\n) jp
|
|
(Adobe_customcolor /terminate get exec\n) jp
|
|
(Adobe_cshow /terminate get exec\n) jp
|
|
(Adobe_cmykcolor /terminate get exec\n) jp
|
|
(Adobe_packedarray /terminate get exec\n) jp
|
|
}{
|
|
(Adobe_Illustrator881 /terminate get exec\n) jp
|
|
(Adobe_customcolor /terminate get exec\n) jp
|
|
(Adobe_cshow /terminate get exec\n) jp
|
|
(Adobe_cmykcolor /terminate get exec\n) jp
|
|
(Adobe_packedarray /terminate get exec\n) jp
|
|
} ifelse
|
|
( showpage\n%EOF\n%%EndDocument\n) jp
|
|
jout {joutput closefile} if jMacGS not {quit} if /j3ftxt true def } def
|
|
%
|
|
% Error handling
|
|
%
|
|
errordict begin
|
|
% Attempt to handle the error caused by bitmap fonts (TeX,Windows.ps,etc)
|
|
% this is a big-time kludge
|
|
jbiterr {
|
|
/undefined {pop pop (Times-Roman)} def
|
|
/typecheck {pop pop} def
|
|
} if
|
|
jerr {
|
|
/handleerror {
|
|
(%%Note: ps2ai error, aborting rest of conversion\n) jp showpage
|
|
} def
|
|
} if
|
|
end
|
|
%
|
|
% Mac LW 8 improvements
|
|
%
|
|
/jmacimp { % stroked line instead of thin filled boxes
|
|
/@a { 3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch moveto
|
|
3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll exch sub exch lineto
|
|
abs setlinewidth stroke pop pop} def
|
|
/@b { 3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch moveto
|
|
pop
|
|
3 -1 roll 2 div dup 3 -1 roll add exch 3 -1 roll add exch lineto
|
|
abs setlinewidth stroke} def
|
|
/endp {showpage pm restore} def % because the restore stops clean up
|
|
} def
|
|
%
|
|
% Handle (some) PS Level 2
|
|
%
|
|
/rectstroke { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
|
|
closepath stroke} def
|
|
/rectfill { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
|
|
fill } def
|
|
/rectclip { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto
|
|
closepath clip newpath jMacfix {jmacimp} if } def
|
|
%
|
|
% Add a header prolog to the output file so it is still view/print-able
|
|
%
|
|
(%!PS-Adobe-2.0 EPSF-1.2\n%%BoundingBox: 0 0 612 792\n) jp
|
|
(%%Title: Adobe Illustator 3 Editable Document\n) jp
|
|
(%%Creator: ps2ai.ps vers.) jp vers jpnum ( \(C\) 1993-94 Jason Olszewski\n) jp
|
|
(%%TemplateBox: 0 0 612 792\n) jp
|
|
jtxt3 {(%%AI3_Margin:0 0 0 0\n) jp } if
|
|
(%%EndComments\n) jp
|
|
(%%BeginProlog\n) jp
|
|
(/m {moveto} def /l {lineto} def /c {curveto} def\n) jp
|
|
(/S {stroke} def /F {fill} def\n) jp
|
|
(/s {closepath S} def /f {closepath F} def\n) jp
|
|
(/q {gsave} def /Q {grestore} def /W {clip} def /k {setcmykcolor} def\n) jp
|
|
(/i {setflat} def /J {setlinecap} def /j {setlinejoin} def\n) jp
|
|
(/w {setlinewidth} def /M {setmiterlimit} def /d {setdash} def\n) jp
|
|
(/u {gsave} def /U {grestore} def /K {k} def\n) jp
|
|
(/N {newpath} def /n {closepath N} def\n) jp
|
|
(/g {setgray} def /G {g} def\n) jp
|
|
(/x {pop pop k} def /X {x} def\n) jp
|
|
(/H {} def /h {H closepath} def /D {pop} def\n) jp
|
|
(/*u { /N {/spth 0 def}def /S{/spth 1 def}def /F {/spth 2 def} def} def\n) jp
|
|
(/*U { spth 0 eq {newpath} if spth 1 eq {stroke} if spth 2 eq {fill} if\n) jp
|
|
( /N {newpath} def /S {stroke} def /F {fill} def } def\n) jp
|
|
%(\n) jp
|
|
jtxt3 {
|
|
(/TC {pop pop pop} def /Tr {pop} def\n) jp
|
|
(/To {pop gsave} def /TO {grestore} def\n) jp
|
|
(/Tp {pop matrix astore concat} def /TP {0 0 moveto} def\n) jp
|
|
(/a_str 40 string def /cnt 0 def /h_str (X) def /undsc (_) 0 get def\n) jp
|
|
(/fntfix {a_str cvs dup length 1 sub /f_str exch string def\n) jp
|
|
( {dup undsc eq {pop}{f_str cnt 3 -1 roll put /cnt cnt 1 add def\n) jp
|
|
( } ifelse } forall flush /cnt 0 def f_str cvn } bind def\n) jp
|
|
|
|
(/Tf {exch fntfix findfont exch scalefont setfont} def /Tx {show} def\n) jp
|
|
}{
|
|
(/z {pop pop pop exch findfont exch scalefont setfont} def\n) jp
|
|
(/e {concat 0 0 m} def /t {show} def /T {} def\n) jp
|
|
} ifelse
|
|
(\n) jp
|
|
jtxt3 {
|
|
(userdict /Adobe_packedarray 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_cmykcolor 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_cshow 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_customcolor 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_typography_AI3 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_IllustratorA_AI3 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
}{
|
|
(userdict /Adobe_packedarray 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_cmykcolor 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_cshow 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_customcolor 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
(userdict /Adobe_Illustrator881 2 dict dup begin put\n) jp
|
|
(/initialize {} def /terminate {} def\n) jp
|
|
} ifelse
|
|
(%%EndProlog\n) jp
|
|
(%%BeginSetup\n) jp
|
|
jtxt3 {
|
|
(Adobe_packedarray /initialize get exec\n) jp
|
|
(Adobe_cmykcolor /initialize get exec\n) jp
|
|
(Adobe_cshow /initialize get exec\n) jp
|
|
(Adobe_customcolor /initialize get exec\n) jp
|
|
(Adobe_typography_AI3 /initialize get exec\n) jp
|
|
(Adobe_IllustratorA_AI3 /initialize get exec\n) jp
|
|
}{
|
|
(Adobe_packedarray /initialize get exec\n) jp
|
|
(Adobe_cmykcolor /initialize get exec\n) jp
|
|
(Adobe_cshow /initialize get exec\n) jp
|
|
(Adobe_customcolor /initialize get exec\n) jp
|
|
(Adobe_Illustrator881 /initialize get exec\n) jp
|
|
} ifelse
|
|
(%%EndSetup\n) jp
|
|
0 0 0 1 oldsetcmykcolor
|
|
currentstate
|
|
|
|
jout {(%%Note: Load Postscript file to be converted now\n) print} if
|