%!
% Date: Tue, 18 Apr 89 19:19:37 EDT
% To: NeWS-makers@brillig.umd.edu
% Subject: Wrappingpaper
% From: pterodactyl.cis.ohio-state.edu!zwicky@tut.cis.ohio-state.edu  (Elizabeth D Zwicky)
%
% Well, now that wallpaper is working, I'd thought I'd give you all
% another way to waste time. This one lets you waste paper, too, if you
% have a PostScript printer. It also has a lot of small and not-so-small
% useful tricks coded into it, and is possibly the most egregious example
% of overuse of items and windows I've ever seen, much less perpetrated.
% I realize that the user interface leaves something to be desired, but
% my theory about a better one involves several new item types, so
% I thought I'd save it for a later release.
%
% wrappingpaper:  Written and conceived by Elizabeth D. Zwicky
% Send comments to zwicky@cis.ohio-state.edu
false setautobind
%Install LiteItem if nothing else has
systemdict /Item known not { (NeWS/liteitem.ps) run } if
% Start a new dictionary; we've outgrown the default one
/partsdict dictbegin

    /name (PostScript) def % default printer name
    /tilewin null def
    /startup{ %defines all the drawing variables; it is wrapped like this
	% so that it is simple to make sure that everything will be
	% initialized both in the window and in the printer.
	/times 3 def
	/times2 4 def
	/hoffset 0 def /voffset 0 def
	/hoffset2 0 def /voffset2 0 def
	/slant 0 def /slant2 0 def
	/prerotate 0 def /prerotate2 0 def
	/prescale 1 def /prescale2 1 def
	/alternate null def  /alterdo {-1 1 scale} def
	/alternate2 null def  /alterdo2 {-1 1 scale} def
	/alterrotate 180 def /alterrotate2 180 def
	/on false def /arow false def /offrow false store
	/on2 false def /arow2 false def /offrow2 false store
	/drawone{}def /drawtwo{}def
	/dimen 25 store /dimen2 25 store
	/dimen2 25 store /dimen22 25 store
	/firsttile true def
	/firstdraw true def
	/shape null def /starty null def 
	/drawitems null def 
	/over null def 
	/startx null def 
	/tmpx 0 def /tmpy 0 def
	/tox null def /toy null def 
	/canvas null def 
	/lastx 0 def /lasty 0 def
	/execshape {shape cvx exec} def
	/tofile false def
	/n 3 def /n2 3 def /nn 3 def
	/nstarn 5 def /nstarn2 5 def /nstarnn 5 def
	/nstarangle {180 360 nstarnn div sub 3 div}  def
	/second false def /second2 false def
	/unit2 false def
	/ontop false def
    }def
    startup

    /MySliderItem SliderItem dictbegin dictend classbegin
	/XToValue { % x -> value
	    ObjectX sub
	    0 max ObjectWidth SliderWidth sub min
	    Scale div SliderMin add 
	    Round {round} {round .1 mul}ifelse
	} def
	/ValueToX{
	    Round
	    {SliderMin sub Scale mul ObjectX add}
	    {SliderMin sub Scale mul 10 mul ObjectX add}
	    ifelse
	} def
    classend def

	
    /disappear {% Takes an item  and makes it invisible
	dup /ItemCanvas get /Transparent false put 
	dup /unmap exch send  
	/ItemCanvas get /Transparent true put
    } def

    /reappear { % makes a disappeared item reappear
	dup /map exch send /paint exch send
    } def

% These are the possible smallest units

    /paisle{
	30 0 30 40 0 40 rcurveto
	-40 0 -50 -10 -50 -40 rcurveto
	5 20 30 30 30 20 rcurveto
	5 -10 10 -20 20 -20 rcurveto
	closepath 
    } def

    /ngon{ % polygon of n sides, n determined by nslider
	nn {150 nn div 0 rlineto 
	    360 360 nn div sub rotate 
	} repeat
	closepath
    } def

    /nstar{ % star of n points, n determined by nstarslider
	nstarnn { 150 nstarnn div 0 rlineto
	    180 180 nstarangle 2 mul sub sub  rotate
	    150 nstarnn div 0 rlineto
	    180 180 360 nstarnn div sub nstarangle 2 mul sub sub neg rotate
	} repeat
	closepath
    } def

    /crescent {
	40 20 40 50 0 70 rcurveto
	20 -20 20 -50 0 -70 rcurveto
	closepath
    } def

    /tri{
	70 0 rlineto 
	-35 30 rlineto 
	-35 -30 rlineto 
	closepath
    }def


% Rotation or reflection chooses how the larger pieces are made
% out of the smaller ones.

    /rotation{
	/drawone{
	    alternate
	    prerotate rotate 
	    prescale prescale scale
	    times{
		hoffset voffset rmoveto
		gsave
		slant rotate
		part stroke pause
		grestore
		hoffset neg voffset neg rmoveto
		360 times div rotate
	    }repeat 
	}store
	/rot true store
    }def

    /rotation2{
	/drawtwo {
	    alternate2
	    prerotate2 rotate
	    prescale2 prescale2 scale
	    times2{
		hoffset2 voffset2 rmoveto
		gsave
		slant2 rotate
		part2 stroke pause
		grestore
		hoffset2 neg voffset2 neg rmoveto
		360 times2 div rotate
	    }repeat
	}store
	/rot2 true store
    }def

    /reflection{
	/drawone{
	    alternate
	    prerotate rotate
	    prescale prescale scale
	    times{
		gsave
		hoffset voffset rmoveto
		slant rotate
		part stroke pause
		grestore
		gsave
		-1 1 scale
		hoffset voffset rmoveto
		slant rotate
		part stroke pause
		grestore
		360 times div rotate
	    }repeat 
	}store
	/rot false store
    }def

    /reflection2{
	/drawtwo{
	    alternate2
	    prerotate2 rotate
	    prescale2 prescale2 scale
	    times2{
		gsave
		hoffset2 voffset2 rmoveto
		slant2 rotate
		part2 stroke pause
		grestore  
		gsave
		-1 1 scale
		hoffset2 voffset2 rmoveto
		slant2 rotate
		part2 stroke pause
		grestore
		360 times2 div rotate
	    }repeat 
	}store
	/rot2 false store
    }def

    /loopstart{% precalculates values used in the tiling loops
	/hexdimen dimen def
	/hexdimen2 
	   hexdimen hexdimen mul
	   hexdimen 2 div hexdimen 2 div mul
	   sub sqrt 
	def
	/outloop height hexdimen 3 mul div ceiling cvi 1 add def
	/inloop width hexdimen2 2 mul div ceiling cvi 1 add def
	/yincr hexdimen 1.5 mul def
	/xincr hexdimen2 2 mul def
	/firstcorrect inloop xincr mul neg hexdimen2 add def
	/lastcorrect inloop xincr mul neg hexdimen2 neg add def
	/correct inloop xincr mul neg def
	/sqoutloop height dimen div ceiling cvi 1 add def
	/sqinloop width dimen div ceiling cvi 1 add def
	/hincr dimen def
	/vincr dimen2 def
	/hinloop width dimen div ceiling cvi 1 add def
	/1correct hinloop hincr mul hincr 2 div sub neg def
	/2correct hinloop hincr mul hincr 2 div add neg def
	/houtloop height dimen2 div ceiling cvi 1 add def
    }def

% These procedures actually do the tiling
    /hextile{
	/on false store /prev on store
	outloop{
	    inloop{
		0 0 moveto
		gsave drawone stroke grestore
		newpath
		ontop {0 0 moveto gsave drawtwo stroke grestore} if
		xincr 0 translate
	    } repeat 
	    arow {/on true store} {/on false store} ifelse
	    second {/on prev store} if
	    firstcorrect yincr translate
	    inloop{
		0 0 moveto
		gsave drawone stroke grestore
		newpath
		ontop {0 0 moveto gsave drawtwo stroke grestore} if
		xincr 0 translate
	    } repeat
	    /on false store
	    second {/on prev not store /prev on store} if
	    lastcorrect yincr translate
	}repeat
	0 0 moveto
	gsave drawone grestore
    } store

    /halftile{
	/on false store /prev on store
	houtloop{
	    hinloop{
		0 0 moveto
		gsave drawone stroke grestore
		newpath
		ontop {0 0 moveto gsave drawtwo stroke grestore} if
		hincr 0 translate
	    } repeat 
	    arow {/on true store} {/on false store} ifelse
	    second {/on prev store} if
	    1correct vincr translate
	    hinloop{
		0 0 moveto
		gsave drawone stroke grestore
		newpath	 
		ontop {0 0 moveto gsave drawtwo stroke grestore} if
		hincr 0 translate
	    } repeat
	    /on false store
	    second {/on prev not store /prev on store} if
	    2correct vincr translate
	}repeat
	0 0 moveto
	gsave drawone grestore
    } store

    /squaretile{
	/on false store /prev on store
	sqoutloop{
	    sqinloop{
		0 0 moveto
		gsave drawone stroke grestore
		newpath
		ontop { 0 0 moveto gsave drawtwo stroke grestore} if
		dimen 0 translate
	    } repeat
	    arow 
	    {offrow 
		{/on false store /offrow false store} 
		{/on true store /offrow true store} 
		ifelse
	    }
	    {second
		{offrow
		    {/on prev store /offrow false store}
		    {/on prev not store /prev on store /offrow true store}
		    ifelse} 
		{/on false store}
		ifelse
	    }
	    ifelse
	    dimen sqinloop mul neg 0 translate 
	    0 dimen translate
	}repeat
	0 0 moveto
	gsave drawone stroke grestore
	/offrow false store
    } store

% This sets what smallest unit is the default
    /part {ngon} def
    /part2 {crescent} def

% Sets the default for both parts to reflection
    reflection
    reflection2

% Sets the default tiling to hexagonal
    /tile{hextile}store

    /tmpstring 30 string def
    /recurse{% Given an array, write a representation of it to a file whose
	% filehandle is "tmp"
	tmp ({ ) writestring 
	    {dup type (arraytype) eq {recurse}
		{dup type (nametype) eq 
		    exch dup xcheck not
		    exch 3 1 roll and 
		    {tmp (/) writestring}
		    if 
		    tmp exch tmpstring cvs writestring 
		    tmp ( ) writestring
		} ifelse
	    } forall 
	    tmp (} ) writestring
    } def

    /dump{ % given the name of something currently defined, dump its
	% definition to a file whose filehandle is tmp using recurse
	dup tmp (/) writestring
	tmp exch tmpstring cvs writestring 
	tmp ( ) writestring 
	load dup type (arraytype) eq 
	{recurse} 
	{dup type (nametype) eq
	    exch dup xcheck not
	    exch 3 1 roll  and 
	    {tmp (/) writestring} 
	    if
	    tmp exch tmpstring cvs writestring 
	    tmp ( ) writestring
	}
	ifelse 
	tmp (def \n) writestring
    } def

    /printdump{% Use dump to print the current filing to a printer or
	% to a file
	/tmp (tmp) (w) file def
	tmp (%! \n /height 700 def  /width 500 def /pause {} def \n) writestring
	/startup dump
	tmp (startup \n) writestring
	/hoffset dump /hoffset2 dump
	/voffset dump /voffset2 dump
	/slant dump /slant2 dump
	/times dump /times2 dump
	/prerotate dump /prerotate2 dump
	/prescale dump /prescale2 dump
	/alterrotate dump /alterrotate2 dump
	/dimen dump
	/dimen2 dump
	/shape dump 
	/ontop dump
	/loopstart dump
	/second dump
	/n dump /n2 dump /nn dump
	/part load {} forall dump /part2 load {} forall dump
	tmp  (/on false def /offrow false def /execshape {shape} def \n) writestring
	/alternate dump
	/alterdo dump
	/part dump /part2 dump
	/arow dump
	/drawone dump /drawtwo dump
	/tile load {} forall dump
	/tile dump
	tmp (loopstart 0 0 moveto tile showpage \n) writestring
	tmp closefile
	tofile 
	{(cp tmp ) name append forkunix} 
	{(lpr -P) name append ( tmp)  append forkunix} 
	ifelse
    } def

% Printer dialog box
    /printwin framebuffer /new DefaultWindow send def
    100 100 200 200 /reshape printwin send
    /printcan printwin /ClientCanvas get def
    /printitems 10 dict def
    printitems begin
	/nametext 
	   (Name of File or Printer)
	   (PostScript)
	   /Bottom
   	   {}
	   printcan 100 20
	   /new TextItem send
	   10 100 /move 3 index send
	def
	/printit
	   (Print)
	   {/name printitems /nametext get /ItemValue get store
	       printdump /unmap printwin send}
	   printcan 20 20 
	   /new ButtonItem send
	   70 10 /move 3 index send
	def
	/cancel 
	   (Cancel)
	   {/unmap printwin send}
	   printcan 20 20 
	   /new ButtonItem send
	   10 10 /move 3 index send
	def
	/filecycle
	   (Print to File:)
	   [/panel_check_off /panel_check_on]
	   /Right
	   {tofile
	       {/tofile false store}
	       {/tofile true store}
	    ifelse
	   }
	   printcan 20 20
	   /new CycleItem send
	   10 65 /move 3 index send
	def
    end

    printitems forkitems

    {/PaintClient{erasepage printitems paintitems} def
	/destroy {/unmap printwin send} def
    } printwin send

% Window for the tiling
    /tilemain{
	/firsttile false store
	/tilewin framebuffer /new DefaultWindow send store
	{
	    /PaintClient{
		erasepage 
		clippath pathbbox 
		/height exch store /width exch store 
		loopstart 
		0 0 moveto 
		tile
	    }def
	    /destroy{ %Gentle destroy
		/firsttile true store
		/unmap tilewin send
		tilewin /FrameEventMgr get killprocess
	    }def 
	} tilewin send
	/reshapefromuser tilewin send
	/map tilewin send
    }def


% Window for the controls
    /itemwin framebuffer /new DefaultWindow send def

    {/PaintClient{erasepage items paintitems} def } itemwin send 
    100 100 500 310 /reshape itemwin send
    /can itemwin /ClientCanvas get def
    
% Window for Unit One
    /win framebuffer /new DefaultWindow send def
    /reshapefromuser  win send
    {
	/PaintClient{
	    erasepage 
	    clippath pathbbox 
	    /y exch def /x exch def
	    x 2 div y 2 div moveto 
	    drawone
	}def 
	/FrameLabel (Unit One) def
	/ClientMenu [
	    (Show me a tiling)
	    {first 
		{tilemain}
		{/paint tilewin send}
		ifelse}
	]/new DefaultMenu send def
    } win send

/first true def /helpwindow null def
/help {% Put up help file in window
    % Make help window
    /helpwindow framebuffer /new ScrollWindow send store
    0 0  390 460 /reshape helpwindow send
    framebuffer setcanvas 
    itemwin /FrameCanvas get getcanvaslocation  exch 200 add exch 460 sub
    /move helpwindow send
    { /NotifyUser
	{ /PaintClient helpwindow send}
	def
    } dup  helpwindow /VScrollbar get send helpwindow /HScrollbar get send

    helpwindow /ClientCanvas get setcanvas
	{
	    /PaintClient{ ClientCanvas setcanvas erasepage
		clippath pathbbox  /place exch def /urx exch def
		/lly exch def /llx exch def /width urx llx sub def
		/height place lly sub def
		HScrollbar /ItemValue get width mul neg VScrollbar /ItemValue get height mul translate
		helptext
		 { 
		     /place place 14 sub def
		     5 place moveto
		     show
		 } forall
	     } def 
	     /destroy { % Gentle destroy; does not take other things with it
		 helpwindow /IconCanvas get /Mapped false put
		 helpwindow /FrameCanvas get /Mapped false put
		 helpwindow /ClientCanvas get /Mapped false put
		 helpwindow /FrameEventMgr get killprocess
		 /first true store
	     }def
	 } helpwindow send
     /first false store
     /map helpwindow send
 } def
    /helptext [
	(This program allows you to create interesting repeating)
	(patterns and print them. It is called "wrappingpaper")
	(partly because of an earlier program named "wallpaper")
	(by the same author, and partly because it has often been)
	(suggested that the printouts would make good wrapping)
	(paper for small gifts.)
	( )
	(The repeating patterns are built up from "units" made)
	(by repeating, by rotation or rotation and reflection,)
	("parts". The parts can be moved around the axis of)
	(rotation horizontally and vertically, and scaled and tilted)
	(before the repetitions are made. The units can also be)
	(rotated as wholes. The first unit is always visible; to)
	(see the tiling, hit the tile button, and it will give you)
	(yet another window.)
	( )
	(Three possible tilings are available, with various sorts)
	(of alternation. The best way to get an idea of what the)
	(different tiling options do is to tile a single paisle.)
	(Since the paisle is neither vertically nor horizontally)
	(symmetrical, all rotations and reflections are visible)
	(when applied to it.)
	( )
	(If you choose to draw your own part, you will get a)
	(very primitive drawing window. Click to place the)
	(endpoint of the line; doubleclick to end the shape.)
	( )
	(You can add a second unit, which is currently treated just)
	(like the first one \(you can't alternate between the two )
	(units\). More features for the second unit will be added)
	(later, as will a more intuitive interface.)
 	( )
	(This program will only print to a PostScript printer.)
	(It is addictive and you may waste a lot of paper!)
	(Written and conceived by Elizabeth D. Zwicky.)
	(Send comments to zwicky@cis.ohio-state.edu)
    ] def
	

% Window for the second part
    /win2 null def /made2win false def
    /make2win{made2win not
	{/win2 framebuffer /new DefaultWindow send store
	    /reshapefromuser  win2 send
	    {
		/PaintClient{
		    erasepage 
		    clippath pathbbox 
		    /y exch def /x exch def
		    x 2 div y 2 div moveto 
		    drawtwo
		}def 
		/FrameLabel (Unit Two) def
		/ClientMenu [
		    (Show me a tiling)
		    {first 
			{tilemain}
			{/paint tilewin send}
			ifelse}
		]/new DefaultMenu send def
	    } win2 send
	    /map win2 send  /made2win true store}
	{/map win2 send}
	ifelse
    }def

% Long notify procedures
    /alternotify{ 
	ItemValue [
	    0 {/arow false store /alternate {} store /second false store itemwin items 
		/alterdocycle get disappear items /alterrotateslider get
	    disappear}
	    1 {/on false store /arow false store /second false store
		/alternate{
		    on {alterdo /on false store} {/on true store} ifelse
		} store 
		itemwin items /alterdocycle get reappear}
	    2 {/on false store /arow true store /second false store
		/alternate{ on {alterdo} if} store}
	    3 {/on false store /arow true store /second false store
		/alternate{
		    on { alterdo /on false store} {/on true store} ifelse
		} store}
	    4 {/on false store /second true store /arow false store
		/alternate{
		    on {alterdo /on false store} {/on true store} ifelse
		} store}
	] case
    } def

    /oneify{%set controls to match Unit One
	items begin
	    {hoffset setvalue} hoffsetslider send
	    {voffset setvalue} voffsetslider send
	    {slant setvalue} slantslider send 
	    {times setvalue} timesslider send
	    {n setvalue} nslider send
	    /part load {} forall dup
	    [ (ngon) {{0 setvalue} partcycle send}
		(tri) {{1 setvalue} partcycle send}
		(paisle) {{2 setvalue} partcycle send}
		(crescent) {{3 setvalue} partcycle send}
		(nstar) {{4 setvalue} partcycle send}
		(execshape) {{5 setvalue} partcycle send}
	    ] 
	    case
	    dup (ngon) eq  
	    {nslider reappear}
	    {nslider disappear}
	    ifelse
	    (nstar) eq
	    {nstarslider reappear}
	    {nstarslider disappear}
	    ifelse
	    {prerotate setvalue} rotateslider send
	    {prescale setvalue} scaleslider send
	    rot {{1 setvalue} reflectcycle send}
	    {{0 setvalue} reflectcycle send}
	    ifelse
	end
    } def
    
    /twoify{% Set controls to match Unit Two
	items begin
	    {hoffset2 setvalue} hoffsetslider send
	    {voffset2 setvalue} voffsetslider send
	    {slant2 setvalue} slantslider send 
	    {times2 setvalue} timesslider send
	    {n2 setvalue} nslider send
	    /part2 load {} forall dup
	    [ /ngon {{0 setvalue} partcycle send}
		/tri {{1 setvalue} partcycle send}
		/paisle {{2 setvalue} partcycle send}
		/crescent {{3 setvalue} partcycle send}
		/nstar {{4 setvalue} partcycle send}
		/execshape {{5 setvalue} partcycle send}
	    ] 
	    case
	    dup (ngon) eq  
	    {nslider reappear}
	    {nslider disappear}
	    ifelse
	    (nstar) eq
	    {nstarslider reappear}
	    {nstarslider disappear}
	    ifelse
	    {prerotate2 setvalue} rotateslider send
	    {prescale2 setvalue} scaleslider send
	    rot2 {{1 setvalue} reflectcycle send}
	    {{0 setvalue} reflectcycle send}
	    ifelse
	end
    }def

    /drawnotify {
	/firstdraw false store
	items /partcycle get begin 
	    /Cycle 
	    [(N-gon)(Triangle)(Paisle)(Crescent)(N-star)(NewPart)] 
	    def 
	end
	/drawwin framebuffer /new DefaultWindow send def
	/reshapefromuser drawwin send
	/canvas drawwin /ClientCanvas get store
	{
	     /destroy { % Gentle destroy; does not take other things with it
		 drawwin /IconCanvas get /Mapped false put
		 drawwin /FrameCanvas get /Mapped false put
		 drawwin /ClientCanvas get /Mapped false put
		 drawwin /FrameEventMgr get killprocess
		 /firstdraw true store
	     }def
	} drawwin send
	/startx 0 store /starty 0 store
	/tox 100 store /toy 100 store
	/shape null store
	/gstate null def
	
	canvas setcanvas
	/over currentcanvas createoverlay store
	/drawitems dictbegin
	    /shapebutton (Make a Shape) 
	    {/gstate null store 
		shape null ne {
		    canvas setcanvas
		    100 75 translate 
		    1 setgray 0 0 moveto
		    shape cvx exec stroke
		    0 setgray 
		    /shape null store 
		    /lastx 0 store /lasty 0 store
		} if 
		{
		    over setcanvas 
		    100 75 translate
		    startx starty {x y lineto} getanimated
		    waitprocess aload pop /toy exch def /tox exch def

		    canvas setcanvas
		    gstate null ne 
		       {gstate setstate} 
		       {100 75 translate}  
		    ifelse
		    startx starty moveto
		    tox toy lineto
		    /gstate currentstate store
		    gsave  stroke grestore 
		    /shape
		       mark
		       /lastx 0 store /lasty 0 store
		       {/tmpy exch store /tmpx exch store 
			   tmpx lastx sub tmpy lasty sub
			   /lastx tmpx store /lasty tmpy store 
			   /rmoveto cvx }
		        {/tmpy exch store /tmpx exch store 
			    tmpx lastx sub tmpy lasty sub
			    /lastx tmpx store /lasty tmpy store 
			    /rlineto cvx}
		        {/curveto cvx}
		        {/closepath cvx}
		        pathforall 
		        counttomark array astore exch pop
		    store 
		    startx tox eq starty toy eq and {exit} if   	   
		    /startx tox def /starty toy def
		} loop 
		/startx 0 def /starty 0 def
	    } canvas 100 20
	    /new ButtonItem send 10 10 /move 3 index send def
	dictend 
	store
	drawitems forkitems drawitems paintitems 
	{ 
	    /PaintClient{
		erasepage 
		drawitems paintitems 
		shape null ne 
		{100 75 translate 0 0 moveto shape cvx exec stroke}
		if 
	    } def
	} drawwin send
	/map drawwin send
    } def 

% Define a *lot* of items
    /items dictbegin

    /altercycle 
       (Alternation:) 
       [(No Alternation) (Alternate Items) (Alternate Rows) (Checkerboard)
          (Stretched Checkerboard) ]
       /Right
       /alternotify
        can 100 20 
       /new CycleItem send
        200 70 /move 3 index send 
    def

    /alterdocycle 
       (Do Alternate:) 
       [(Reflect Vertical) (Rotate) (Reflect Horizontal)] 
       /Right
       {unit2
	   {ItemValue{
	       0 {/alterdo2 {-1 1 scale} store}
	       1 {/alterdo2 {alterrotate2 rotate} store itemwin  items /alterrotateslider get reappear}
	       2 {/alterdo2 {1 -1 scale} store itemwin items /alterrotateslider get disappear}
	   } case  }
	   {ItemValue{
	       0 {/alterdo {-1 1 scale} store}
	       1 {/alterdo {alterrotate rotate} store itemwin items /alterrotateslider get reappear}
	       2 {/alterdo {1 -1 scale} store itemwin items /alterrotateslider get disappear}
	   } case  }
	   ifelse
       }
       can 100 20 
       /new CycleItem send 
       200 40 /move 3 index send 
    def

    /hoffsetslider 
       (Horizontal Offset:)
       [-50 50 0]
       /Right 
       {unit2 {/hoffset2 ItemValue store /paintclient win2 send}
	   {/hoffset ItemValue store /paintclient win send} ifelse}
       can 120 10
       /new SliderItem send
       10 190 /move 3 index send 
    def
    
    /voffsetslider
       (Vertical Offset:)
       [-50 50 0]
       /Right
       {unit2 {/voffset2 ItemValue store /paintclient win2 send}
	   {/voffset ItemValue store /paintclient win send} ifelse}
       can 120 10 
       /new SliderItem send 
       230 190 /move 3 index send 
    def

    /slantslider
       (Slant:)
       [-180 180 0] 
       /Right
       {unit2 {/slant2 ItemValue store /paintclient win2 send}
          {/slant ItemValue store /paintclient win send} ifelse}
       can 120 10 
       /new SliderItem send 
       48 160 /move 3 index send
    def

    /timesslider 
       (Number:)
       [1 20 3]
       /Right
       {unit2 {/times2 ItemValue store /paintclient win2 send}
	   {/times ItemValue store /paintclient win send} ifelse}
       can 120 10
       /new SliderItem send 
       110 250 /move 3 index send 
    def

    /nslider
       (N:)
       [3 20 3]
       /Right
       {unit2 {/n2 ItemValue store /nn n2 store /paintclient win2 send}
	   {/n ItemValue store /nn n store /paintclient win send} ifelse}
       can 120 10
       /new SliderItem send
       10 230 /move 3 index send
    def

    /nstarslider
       (N:)
       [3 20 5]
       /Right
       {unit2 {/nstarn2 ItemValue store /nstarnn nstarn2 store /paintclient win2 send}
	   {/nstarn ItemValue store /nstarnn nstarn store /paintclient win send} ifelse}
       can 120 10
       /new SliderItem send
       10 230 /move 3 index send
    def

    /partcycle 
       (Unit:)
       [(N-gon)(Triangle)(Paisle)(Crescent)(N-star)]
       /Right
       {unit2 
	   {ItemValue{
	       0 {/part2 {ngon} store itemwin items /nstarslider get disappear
		   items /nslider get reappear}
	       1 {/part2 {tri} store itemwin items /nslider get disappear}
	       2 {/part2 {paisle} store}
	       3 {/part2 {crescent} store}
	       4 {/part2 {nstar} store items /nstarslider get reappear}
	       5 {/part2 {execshape} store items /nstarslider get disappear}
	       
	   } case
	   /paintclient win2 send}
	   {ItemValue{
	       0 {/part {ngon} store itemwin items /nstarslider get disappear
		   items /nslider get reappear}
	       1 {/part {tri} store itemwin items /nslider get disappear}
	       2 {/part {paisle} store}
	       3 {/part {crescent} store}
	       4 {/part {nstar} store items /nstarslider get reappear}
	       5 {/part {execshape} store items /nstarslider get disappear}
	   } case
	   /paintclient win send} 
	   ifelse
       }
       can 100 20 /new CycleItem send 
       10 250 /move 3 index send 
    def

    /reflectcycle 
        (Symmetry Type:)
       [(Reflection)(Rotation)]
       /Right
       {unit2
	   {ItemValue {
	       0 {reflection2}
	       1 {rotation2}
	   } case 
	   /paintclient win2 send}
	   {ItemValue {
	       0 {reflection}
	       1 {rotation}
	   } case 
	   /paintclient win send}
	   ifelse
       }
       can 100 20
       /new CycleItem send 
       10 215 /move 3 index send 
    def

    /tilecycle
       (Tiling Type:)
       [(Hexagonal)(Half Drop)(Square)]
       /Right
       {
	   ItemValue{
	       0 {/tile {hextile} store }
	       1 {/tile {halftile} store
		   itemwin items /dimen2slider get reappear}
	       2 {/tile {squaretile} store
		   itemwin items /dimen2slider get disappear}
	   } case
       }
       can 120 10 
       /new CycleItem send 
       10 70 /move 3 index send 
    def

    /tilebutton 
       (Tile) 
       {firsttile {tilemain} {/paintclient tilewin send} ifelse}
       can 50 10
       /new ButtonItem send 
       130 95 /move 3 index send 
    def

    /unitswitch
       (Settings:)
       [(First Unit) (Second Unit)]
       /Right
       {ItemValue
	  [ 0 {/unit2 false store oneify}
	    1 {/unit2 true store twoify}
	  ] case }
       can 60 10
       /new CycleItem send
       300 215 /move 3 index send
    def
/foo{
    /unitcycle
       (Second Unit Placed:)
       [(On Top) (At Corners) (Interleaved)]
 } def
    /secondcycle
       (Second Unit)
        [(Off) (On)]
       /Right
       {ItemValue 0 eq
	   { /ontop false store
	     /unmap win2 send
	    itemwin items /unitswitch get disappear
	      /unit2 false store oneify
	%    items /unitcycle get disappear
	   }
	   {/ontop true store
	       make2win
	    itemwin items /unitswitch get reappear
	%     items /unitcycle get reappear
	   }
       ifelse}
       can 120 10 
       /new CycleItem send
       185 215 /move 3 index send
    def

    /printbutton
       (Print)
       {printwin /FrameCanvas get /Mapped get true eq 
	   {/totop printwin send} 
	   {/totop printwin send /map printwin send} 
	   ifelse
       }
       can 50 10
       /new ButtonItem send
       195 95 /move 3 index send
    def

    /helpbutton
       (Help)
       {first {help} if}
       can 50 10
       /new ButtonItem send
       250 95 /move 3 index send
    def

    /newpartbutton 
       (Draw New Part) 
       {firstdraw {drawnotify} if}
       can 100 10
       /new ButtonItem send 
       10 95 /move 3 index send 
    def

    /dimenslider 
       (Dimension 1:)
       [1 100 25]
       /Right
       {/dimen ItemValue store}
       can 120 10 
       /new SliderItem send 
       10 45 /move 3 index send
    def

    /dimen2slider 
       (Dimension 2:)
       [1 100 25] 
       /Right
       {/dimen2 ItemValue store}
       can 120 10 
       /new SliderItem send 
       10 20 /move 3 index send 
    def
	
    /rotateslider
       (Rotate Unit:)
       [-180 180 0]
       /Right 
       {unit2 { /prerotate2 ItemValue store /paintclient win2 send}
	   { /prerotate ItemValue store /paintclient win send}
	   ifelse}
       can 120 10 
       /new SliderItem send 
       10 130 /move 3 index send 
    def

    /alterrotateslider
       (Alternate Rotation:)
       [-180 180 180]
       /Right 
       {unit2 { /alterrotate2 ItemValue store /paintclient win2 send}
	   { /alterrotate ItemValue store /paintclient win send}
	   ifelse}
       can 120 10 
       /new SliderItem send 
       10 0 /move 3 index send 
    def

    /scaleslider 
       (Scale Unit:) 
       [0 100 1]
       /Right 
       {unit2 {/prescale2 ItemValue store /paintclient win2 send}
	   {/prescale ItemValue store /paintclient win send}
	   ifelse}
       can 120 10 
       /new MySliderItem send 
       250 250 /move 3 index send 
    def
    scaleslider /Round false put
	
dictend def
items /foo undef
items forkitems   
/map win send
win /FrameCanvas get getcanvaslocation 310 sub /move itemwin send
    /map itemwin send
itemwin /ClientCanvas get /Retained false put 
itemwin /FrameCanvas get getcanvaslocation 200 sub /move printwin send
 items begin
     dimen2slider disappear
     alterdocycle  disappear
     unitswitch  disappear
     alterrotateslider disappear
 end
dictend def