public class SJCanvas{
	/**
	*	This class is the programmer's interface to the PDF file format.  Methods
	*	are (or will be) provided here to do just about everything PDF can do.<br>
	*	<br>
	*	The underlying model to the canvas concept is that of a graphics state machine
	*	that at any given point in time has a current font, fill color (for figure
	*	interiors), stroke color (for figure borders), line width and geometric transform, among
	*	many other characteristics.<br>
	*	<br>
	*	Canvas methods generally either draw something (like canvas.line) using the
	*	current state of the canvas or change some component of the canvas
	*	state (like canvas.setFont).  The current state can be saved and restored
	*	using the saveState/restoreState methods.<br>
	*	<br>
	*	Objects are "painted" in the order they are drawn so if, for example
	*	two rectangles overlap the last draw will appear "on top".  PDF form
	*	objects (supported here) are used to draw complex drawings only once,
	*	for possible repeated use.<br>
	*	<br>
	*	There are other features of canvas which are not visible when printed,
	*	such as outlines and bookmarks which are used for navigating a document
	*	in a viewer.<br>
	*	<br>
	*	Here is a very silly example usage which generates a Hello World pdf document.
	*	<pre>
	*	int inch = 72;
	*	JCanvas c = new JCanvas("hello.pdf");
	*	//move the origin up and to the left
	*	c.translate(inch, inch);
	*	//define a large font
	*	c.setFont("Helvetica", 80);
	*	//choose some colors
	*	c.setStrokeColorRGB(0.2, 0.5, 0.3);
	*	c.setFillColorRGB(1, 0, 1);
	*	//draw a rectangle
	*	c.rect(inch, inch, 6*inch, 9*inch, 1);
	*	//make text go straight up
	*	c.rotate(90);
	*	//change color
	*	c.setFillColorRGB(0.0, 0.0, 0.77);
	*	//say hello (note after rotate the y coord needs to be negative!)
	*	c.drawString(3*inch, -3*inch, "Hello World");
	*	c.showPage();
	*	c.save();
	*	</pre>
	*/
	public SJCanvas(){}
	/**
	*	See above.
	*	@param filename	The Filename in which this drawing will be saved.
	*/
	public SJCanvas(String filename){}

	/**
	*	PageCatcher utility method.<br>
	*	Copies the content of the given pdf file into the JCanvas instance.
	*	@param pdfFileName The name of the PDF file whose content will be copied.
	*/
	public void copyPages(String pdfFileName){}

	/**
	*	PageCatcher utility method.<br>
	*	Writes the string over pdfInFile content and saves the output in pdfOutFile.
	*	@param pdfOutFile Name of the output PDF file.
	*	@param pdfInFile Name of the input PDF file.
	*	@param x X coordinate
	*	@param y Y coordinate
	*	@param font Name of the Font to be used.
	*	@param fontSize Font size.
	*	@param text Text to be drawn on JCanvas.
	*/
	public void annotate(String pdfOutFile, String pdfInFile, double x, double y, String font, int fontSize, String text){}

	/**
	*	See above.
	*/
	public void annotate(String pdfOutFile, String pdfInFile, int x, int y, String font, int fontSize, String text){}

	/**
	*	rml2pdf utility method.<br>
	*	@param xmlInputFile The name of the RML (XML) file to be converted.
	*/
	public void rml_to_pdf(String xmlInputFile){}

	/**
	*	Identify the author for invisible embedding inside the PDF document.
	*   the author annotation will appear in the the text of the file but will
	*   not automatically be seen when the document is viewed.
	*	@param author Name of the author.
	*/
	public void setAuthor(String author){}

	/**
	*	Adds a new entry to the outline at given level.  If LEVEL not specified,
	*	entry goes at the top level.  If level specified, it must be
	*	no more than 1 greater than the outline level in the last call.<br>
	*	<br>
	*	The key must be the (unique) name of a bookmark.
	*	the title is the (non-unique) name to be displayed for the entry.<br>
	*	<br>
	*	If closed is set then the entry should show no subsections by default
	*	when displayed.<br>
	*	<br>
	*	Example
	*	<pre>
	*	   c.addOutlineEntry("first section", "section1");
	*	   c.addOutlineEntry("introduction", "s1s1", 1, 1);
	*	   c.addOutlineEntry("body", "s1s2", 1);
	*	   c.addOutlineEntry("detail1", "s1s2s1", 2);
	*	   c.addOutlineEntry("detail2", "s1s2s2", 2);
	*	   c.addOutlineEntry("conclusion", "s1s3", 1);
	*	   c.addOutlineEntry("further reading", "s1s3s1", 2);
	*	   c.addOutlineEntry("second section", "section1");
	*	   c.addOutlineEntry("introduction", "s2s1", 1);
	*	   c.addOutlineEntry("body", "s2s2", 1, closed=1);
	*	   c.addOutlineEntry("detail1", "s2s2s1", 2);
	*	   c.addOutlineEntry("detail2", "s2s2s2", 2);
	*	   c.addOutlineEntry("conclusion", "s2s3", 1);
	*	   c.addOutlineEntry("further reading", "s2s3s1", 2);
	*	</pre>
	*	generated outline looks like
	*	<pre>
	*		- first section
	*		|- introduction
	*		|- body
	*		|  |- detail1
	*		|  |- detail2
	*		|- conclusion
	*		|  |- further reading
	*		- second section
	*		|- introduction
	*		|+ body
	*		|- conclusion
	*		|  |- further reading
	*	</pre>
	*	Note that the second "body" is closed.<br>
	*	<br>
	*	Note that you can jump from level 5 to level 3 but not
	*	from 3 to 5: instead you need to provide all intervening
	*	levels going down (4 in this case).  Note that titles can
	*	collide but keys cannot.
	*	@param title Title of the entry.
	*	@param key Unique name of the bookmark.
	*	@param level Level of the bookmark tree nesting.
	*	@param closed Sets the flag that indicates whether the bookmark
	*			should show subsections when displayed.
	*/
	public void addOutlineEntry(String title, String key, int level, int closed){}

	/**
	*	See above.
	*/
	public void addOutlineEntry(String title, String key, int level){}

	/**
	*	See above.
	*/
	public void addOutlineEntry(String title, String key){}

	/**
	*	Write a title into the PDF file that won't automatically display
	*	in the document itself.
	*	@param title Title string.
	*/
	public void setTitle(String title){}

	/**
	*	Write a subject into the PDF file that won't automatically display
	*   in the document itself.
	*	@param subject Subject string.
	*/
	public void setSubject(String subject){}

	/**
	*	Info function - app can call it after showPage to see if it needs a save
	*/
	public void pageHasData(){}

	/**
	*	Specify that Acrobat Reader should start with the outline tree visible.
	*	showFullScreen() and showOutline() conflict; the one called last
	*	wins.
	*/
	public void showOutline(){}

	/**
	*	Specify that Acrobat Reader should start in full screen mode.
	*	showFullScreen() and showOutline() conflict; the one called last
	*	wins.
	*/
	public void showFullScreen0(){}

	/**
	*	Close the current page and possibly start on a new page.
	*/
	public void showPage(){}

	/**
	*	func(pageNum) will be called on each page end.<br>
	*	<br>
	*	This is mainly a hook for progress monitoring.
	*	Call setPageCallback(None) to clear a callback.
	* @param callback An object that implements Pager interface.
	*/
	public void setPageCallBack(Pager callback){}

	/**
	*	This creates a bookmark to the current page which can
	*	be referred to with the given key elsewhere.<br>
	*	<br>
	*	PDF offers very fine grained control over how Acrobat
	*	reader is zoomed when people link to this. The default
	*	is to keep the user's current zoom settings. the last
	*	arguments may or may not be needed depending on the
	*	choice of 'fitType'.<br>
	*	<br>
	*	Fit types and the other arguments they use are:
	*	<ul>
	*	<li>/XYZ left top zoom - fine grained control.  nlil
	*	  or zero for any of the parameters means 'leave
	*	  as is', so "0,0,0" will keep the reader's settings.
	*	  NB. Adobe Reader appears to prefer "nlil" to 0's.</li>
	*
	*	<li>/Fit - entire page fits in window</li>
	*
	*	<li>/FitH top - top coord at top of window, width scaled
	*				to fit.</li>
	*
	*	<li>/FitV left - left coord at left of window, height
	*				scaled to fit</li>
	*
	*	<li>/FitR left bottom right top - scale window to fit
	*								the specified rectangle</li>
	*	</ul>
	*	(question: do we support /FitB, FitBH and /FitBV
	*	which are hangovers from version 1.1 / Acrobat 3.0?)
	*	@param key Bookmark key.
	*	@param fitType Fit type string.
	*	@param left Left coordinate.
	*	@param top Top coord.
	*	@param bottom Bottom coord.
	*	@param right Right coord.
	*	@param zoom Zoom factor.
	*/
	public void bookmarkPage(String key, String fitType, String left, String top, String bottom, String right, String zoom){}

	/**
	*	See above.
	*/
	public void bookmarkPage(String key, String fitType){}

	/**
	*	See above.
	*/
	public void bookmarkPage(String key){}

	/**
	*	Bind a bookmark (destination) to the current page at a horizontal position.
	*	Note that the yhorizontal of the book mark is with respect to the default
	*   user space (where the origin is at the lower left corner of the page)
	*   and completely ignores any transform (translation, scale, skew, rotation,
	*	etcetera) in effect for the current graphics state.  The programmer is
	*   responsible for making sure the bookmark matches an appropriate item on
	*   the page.
	*	@param key Bookmark key.
	*	@param yhorizontal Y horizontal coordinate.
	*/
	public void bookmarkHorizontalAbsolute(String key, String yhorizontal){}

	/**
	*	w.r.t. the current transformation, bookmark this horizontal.
	*	@param key Bookmark key.
	*	@param relativeX Relative X coord.
	*	@param relativeY Relative Y coord.
	*/
	public void bookmarkHorizontal(String key, double relativeX, double relativeY){}

	/**
	*	See above.
	*/
	public void bookmarkHorizontal(String key, int relativeX, int relativeY){}

	/**
	*	use a form XObj in current operation stream.<br>
	*	<br>
	*	The form should either have been defined previously using
	*	beginForm ... endForm, or may be defined later.  If it is not
	*	defined at save time, an exception will be raised. The form
	*	will be drawn within the context of the current graphics
	*	state.
	*	@param name Form name.
	*/
	public void doForm(String name){}

	/**
	*	Query whether form XObj really exists yet.
	*	@param name Form name.
	*/
	public void hasForm(String name){}

	//	######################################################
	//	#
	//	#   Image routines
	//	#
	//	######################################################

	/**
	*	Draw an Image into the specified rectangle.  If width and
	*	height are omitted, they are calculated from the image size.
	*	Also allow file names as well as images.  The size in pixels
	*	of the image is returned.
	* 	@param imageFilename Filename of the image file to be drawn.
	*	@param x X coord.
	*	@param y Y coord.
	*	@param width Width of the image to be drawn.
	*	@param height Height of the image to be drawn.
	*	@return Two element array of integers - width and height of the image.
	*/
	public int[] drawInlineImage(String imageFilename, double x, double y, int width, int height){return null;}

	/**
	*	See above.
	*/
	public int[] drawInlineImage(String imageFilename, int x, int y, int width, int height){return null;}

	/**
	*	See above.
	*/
	public int[] drawInlineImage(String imageFilename, double x, double y){return null;}

	/**
	*	See above.
	*/
	public int[] drawInlineImage(String imageFilename, int x, int y){return null;}

	/**
	*	Draws the image from the specified file.<br>
	*	<br>
	*	If width
	*	and height are not given, the "natural" width and height in pixels
	*	is used at a scale of 1 point to 1 pixel.<br>
	*	<br>
	*	The mask parameter takes 6 numbers and defines the range of
	*	RGB values which will be masked out or treated as transparent.
	*	For example with [0,2,40,42,136,139], it will mask out any
	*	pixels with a Red value from 0-2, Green from 40-42 and
	*	Blue from 136-139  (on a scale of 0-255)<br>
	*	<br>
	*	The method returns the width and height of the underlying image since
	*	this is often useful for layout algorithms.<br>
	*	<br>
	*	Unlike drawInlineImage, this creates 'external images' which
	*	are only stored once in the PDF file but can be drawn many times.
	*	If you give it the same filename twice, even at different locations
	*	and sizes, it will reuse the first occurrence.  If you use ImageReader
	*	objects, it tests whether the image content has changed before deciding
	*	whether to reuse it.<br>
	*	<br>
	*	In general you should use drawImage in preference to drawInlineImage
	*	unless you have read the PDF Spec and understand the tradeoffs.
	* 	@param imageFilename Filename of the image file to be drawn.
	*	@param x X coord.
	*	@param y Y coord.
	*	@return Two element array of integers - width and height of the image.
	*/
	public int[] drawImage(String imageFilename, double x, double y){return null;}

	/**
	*	See above.
	*/
	public int[] drawImage(String imageFilename, int x, int y){return null;}

	/**
	*	See above.
	*/
	public int[] drawImage(String imageFilename, double x, double y, int width, int height, int[] mask){return null;}

	/**
	*	See above.
	*/
	public int[] drawImage(String imageFilename, int x, int y, int width, int height, int[] mask){return null;}

	/**
	*	Declare the current graphics stream to be a named form.
	*   A graphics stream can either be a page or a form, not both.
	*   Some operations (like bookmarking) are permitted for pages
	*   but not forms.  The form will not automatically be shown in the
	*   document but must be explicitly referenced using doForm in pages
	*   that require the form.
	*	@param name Name of the form.
	*	@param lowerx Lower X coord.
	*	@param lowery Lower Y coord.
	*	@param upperx  Upper X coord.
	*	@param uppery Upper Y coord.
	*/
	public void beginForm(String name, double lowerx, double lowery, double upperx, double uppery){}

	/**
	*	See above.
	*/
	public void beginForm(String name, int lowerx, int lowery, int upperx, int uppery){}

	/**
	*	See above.
	*/
	public void beginForm(String name, double lowerx, double lowery){}

	/**
	*	See above.
	*/
	public void beginForm(String name, int lowerx, int lowery){}

	/**
	*	Emit the current collection of graphics operations as a Form
	*   as declared previously in beginForm.
	*/
	public void endForm(){}

	//public void textAnnotation0(self, contents, Rect=None, addtopage=1, name=None, **kw){}

	//public void inkAnnotation0(self, contents, InkList=None, Rect=None, addtopage=1, name=None, **kw){}

	//public void linkAbsolute(self, contents, destinationname, Rect=None, addtopage=1, name=None, **kw){}

	//public void linkRect(self, contents, destinationname, Rect=None, addtopage=1, name=None, **kw){}

	//public void linkURL(self, url, rect, relative=0, thickness=0, color=None, dashArray=None):

	/**
	*	Get the page number for the current page being generated.
	*	@return Page number.
	*/
	public int getPageNumber(){return 0;}

	/**
	*	Saves and close the PDF document in the file.
	*	If there is current data a ShowPage is executed automatically.
	*   After this operation the canvas must not be used further.
	*/
	public void save(){}

	/**
	*	Returns the PDF data that would normally be written to a file.
	*	If there is current data a ShowPage is executed automatically.
	*	After this operation the canvas must not be used further.
	* @return PDF data string.
	*/
	public String getpdfdata(){return null;}

	/**
	*	Accepts points for paper size for this
	*	and subsequent pages
	*	@param width Paper width.
	*	@param height Paper height.
	*/
	public void setPageSize(int width, int height){}

	/**
	*	Instruct display device that this page is to be rotated
	*	@param rot Rotation degree.
	*/
	public void setPageRotation(int rot){}

	/**
	*	Introduce the literal text of PDF operations s into the current stream.
	*   Only use this if you are an expert in the PDF file format.
	*	@param s String to be passed into the PDF stream.
	*	@param escaped Flag that switches escaping of PDF characters.
	*/
	public void addLiteral(String s, int escaped){}

	/**
	*	See above.
	*/
	public void addLiteral(String s){}

	//	######################################################################
	//	#
	//	#      coordinate transformations
	//	#
	//	######################################################################

	/**
	*	I want to draw something (eg, string underlines) w.r.t. the default user space.
	*   Reset the matrix! This should be used usually as follows:
	*	<pre>
	*	  canv.saveState();
	*	  canv.resetTransforms();
	*	  ...draw some stuff in default space coords...
	*	  canv.restoreState(); // go back!
	*	</pre>
	*/
	public void resetTransforms(){}

	/**
	*	Adjoin a mathematical transform to the current graphics state matrix.
	*   Not recommended for beginners.
	*	@param a A coord.
	*	@param b B coord.
	*	@param c C coord.
	*	@param d D coord.
	*	@param e E coord.
	*	@param f F coord.
	*/
	public void transform(double a, double b, double c, double d, double e, double f){}

	/**
	*	See above.
	*/
	public void transform(int a, int b, int c, int d, int e, int f){}

	/**
	*	Return the absolute position of x,y in user space w.r.t. default user space
	*	@param x X coord.
	*	@param y Y coord.
	*	@return Two element int array containing absolute X and Y positions.
	*/
	public int[] absolutePosition(double x, double y){return null;}

	/**
	*	See above.
	*/
	public int[] absolutePosition(int x, int y){return null;}

	/**
	*	Move the origin from the current (0,0) point to the (dx,dy) point
	*   (with respect to the current graphics state).
	*	@param dx X point.
	*	@param dy Y point.
	*/
	public void translate(double dx, double dy){}

	/**
	*	See above.
	*/
	public void translate(int dx, int dy){}

	/**
	*	Scale the horizontal dimension by x and the vertical by y
	*   (with respect to the current graphics state).<br>
	*   For example canvas.scale(2.0, 0.5) will make everything short and fat.
	*	@param x Horizontal dimension.
	*	@param y Vertical dimension.
	*/
	public void scale(double x, double y){}

	/**
	*	See above.
	*/
	public void scale(int x, int y){}

	/**
	*	Canvas.rotate(theta);<br>
	*	<br>
	*	Rotate the canvas by the angle theta (in degrees).
	*	@param theta Degree of rotation.
	*/
	public void rotate(double theta){}

	/**
	*	See above.
	*/
	public void rotate(int theta){}

	/**
	*	This method skews the canvas by alpha, beta.
	*	@param alpha Alpha degree.
	*	@param beta Beta degree.
	*/
	public void skew(double alpha, double beta){}

	/**
	*	See above.
	*/
	public void skew(int alpha, int beta){}

	//	######################################################################
	//	#
	//	#      graphics state management
	//	#
	//	######################################################################

	/**
	*	Save the current graphics state to be restored later by restoreState.
	*
	*	For example:
	*	<pre>
	*		canvas.setFont("Helvetica", 20);
	*		canvas.saveState();
	*		...
	*		canvas.setFont("Courier", 9);
	*		...
	*		canvas.restoreState();
	*		// if the save/restore pairs match then font is Helvetica 20 again.
	*	</pre>
	*/
	public void saveState(){}

	/**
	*	Restore the graphics state to the matching saved state (see saveState).
	*/
	public void restoreState(){}

	//	###############################################################
	//	#
	//	#   Drawing methods.  These draw things directly without
	//	#   fiddling around with Path objects.  We can add any geometry
	//	#   methods we wish as long as their meaning is precise and
	//	#   they are of general use.
	//	#
	//	#   In general there are two patterns.  Closed shapes
	//	#   have the pattern shape(self, args, stroke=1, fill=0);
	//	#   by default they draw an outline only. Line segments come
	//	#   in three flavours: line, bezier, arc (which is a segment
	//	#   of an elliptical arc, approximated by up to four bezier
	//	#   curves, one for each quadrant.
	//	#
	//	#   In the case of lines, we provide a 'plural' to unroll
	//	#   the inner loop; it is useful for drawing big grids
	//	################################################################

	//	#--------first the line drawing methods-----------------------

	/**
	*	Draw a line segment from (x1,y1) to (x2,y2) (with color, thickness and
	*	other attributes determined by the current graphics state).
	*	@param x1 Start X coord.
	*	@param y1 Start Y coord.
	*	@param x2 End X coord.
	*	@param y2 End Y coord.
	*/
	public void line(double x1, double y1, double x2, double y2){}

	/**
	*	See above.
	*/
	public void line(int x1, int y1, int x2, int y2){}

	/**
	*	Like line(), permits many lines to be drawn in one call.
	*   for example for the figure
	*	<pre>
	*	   |
	*	 -- --
	*	   |
	*
	*	 int[][] crosshairs = {{20,0,20,10}, {20,30,20,40}, {0,20,10,20}, {30,20,40,20}};
	*	 canvas.lines(crosshairs);
	*	</pre>
	*	@param linelist matrix of line coords.
	*/
	public void lines(double[][] linelist){}

	/**
	*	See above.
	*/
	public void lines(int[][] linelist){}

	/**
	*	Lays out a grid in current line style.  Supply list of
	*	x an y positions.
	*	@param xlist matrix of X coords.
	*	@param ylist matrix of Y coords.
	*/
	public void grid(double[] xlist, double[] ylist){}

	/**
	*	See above.
	*/
	public void grid(int[] xlist, int[] ylist){}

	/**
	*	Bezier curve with the four given control points
	*	@param x1 X point 1.
	*	@param y1 Y point 1.
	*	@param x2 X point 2.
	*	@param y2 Y point 2.
	*	@param x3 X point 3.
	*	@param y3 Y point 3.
	*	@param x4 X point 4.
	*	@param y4 Y point 4.
	*/
	public void bezier(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4){}

	/**
	*	See above.
	*/
	public void bezier(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4){}

	/**
	*	Draw a partial ellipse inscribed within the rectangle x1,y1,x2,y2,
	*	starting at startAng degrees and covering extent degrees.<br>Angles
	*	start with 0 to the right (+x) and increase counter-clockwise.
	*	These should have x1&ltx2 and y1&lty2.<br>
	*	<br>
	*	The algorithm is an elliptical generalization of the formulae in
	*	Jim Fitzsimmon's TeX tutorial <a href='http://www.tinaja.com/bezarc1.pdf'>
	*	http://www.tinaja.com/bezarc1.pdf</a>, contributed by Robert Kern.
	*	@param x1 X point 1.
	*	@param y1 Y point 1.
	*	@param x2 X point 2.
	*	@param y2 Y point 2.
	*	@param startAng Starting angle point.
	*	@param extent Ending angle point.
	*/
	public void arc(double x1, double y1, double x2, double y2, double startAng, double extent){}

	/**
	*	See above.
	*/
	public void arc(int x1, int y1, int x2, int y2, int startAng, int extent){}

	/**
	*	See above.
	*/
	public void arc(double x1, double y1, double x2, double y2){}

	/**
	*	See above.
	*/
	public void arc(int x1, int y1, int x2, int y2){}

	/**
	*	Draws a rectangle with lower left corner at (x,y) and width and height as given.
	*	@param x Rectangle's X coord.
	*	@param y Rectangle's Y coord.
	*	@param width Rectangle's width.
	*	@param height Rectangle's X height.
	*	@param stroke 0 or 1 - set stroke on or off
	*	@param fill 0 or 1 - set fill on or off
	*/

	public void rect(double x, double y, double width, double height, double stroke, double fill){}

	/**
	*	See above.
	*/
	public void rect(int x, int y, int width, int height, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void rect(double x, double y, double width, double height, double stroke){}

	/**
	*	See above.
	*/
	public void rect(int x, int y, int width, int height, int stroke){}

	/**
	*	See above.
	*/
	public void rect(double x, double y, double width, double height){}

	/**
	*	See above.
	*/
	public void rect(int x, int y, int width, int height){}

	/**
	*	Draw an ellipse defined by an enclosing rectangle.
	*
	*	Note that (x1,y1) and (x2,y2) are the corner points of
	*	the enclosing rectangle.
	*
	*	Uses bezierArc, which conveniently handles 360 degrees.
	*	@param x1 Ellipse's start X coord.
	*	@param y1 Ellipse's start Y coord.
	*	@param x2 Ellipse's end X coord.
	*	@param y2 Ellipse's end Y coord.
	*	@param stroke 0 or 1 - set stroke on or off
	*	@param fill 0 or 1 - set fill on or off
	*/
	public void ellipse(double x1, double y1, double x2, double y2, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void ellipse(int x1, int y1, int x2, int y2, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void ellipse(double x1, double y1, double x2, double y2){}

	/**
	*	See above.
	*/
	public void ellipse(int x1, int y1, int x2, int y2){}

	/**
	*	Like arc, but connects to the centre of the ellipse.
	*	Most useful for pie charts and PacMan!
	*	@param x1 Wedge's start X coord.
	*	@param y1 Wedge's start Y coord.
	*	@param x2 Wedge's end X coord.
	*	@param y2 Wedge's end Y coord.
	*	@param startAng Starting angle degree.
	*	@param extent Angle degree extent.
	*	@param stroke 0 or 1 - set stroke on or off
	*	@param fill 0 or 1 - set fill on or off
	*/
	public void wedge(double x1, double y1, double x2, double y2, int startAng, int extent, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void wedge(int x1, int y1, int x2, int y2, int startAng, int extent, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void wedge(double x1, double y1, double x2, double y2, int startAng, int extent){}

	/**
	*	See above.
	*/
	public void wedge(int x1, int y1, int x2, int y2, int startAng, int extent){}

	/**
	*	Draw a circle centered at (x_cen,y_cen) with radius r (special case of ellipse)
	*	@param x_cen Centre of the circle; X coord.
	*	@param y_cen Centre of the circle; Y coord.
	*	@param r Radius.
	*	@param stroke 0 or 1 - set stroke on or off
	*	@param fill 0 or 1 - set fill on or off
	*/
	public void circle(double x_cen, double y_cen, int r, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void circle(int x_cen, int y_cen, int r, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void circle(double x_cen, double y_cen, int r){}

	/**
	*	See above.
	*/
	public void circle(int x_cen, int y_cen, int r){}

	/**
	*	Draws a rectangle with rounded corners.  The corners are
	*	approximately quadrants of a circle, with the given radius.
	*	@param x Rectangle's X coord.
	*	@param y Rectangle's Y coord.
	*	@param width Rectangle's width.
	*	@param height Rectangle's X height.
	*	@param radius Radius.
	*	@param stroke 0 or 1 - set stroke on or off
	*	@param fill 0 or 1 - set fill on or off
	*/
	public void roundRect(double x, double y, int width, int height, int radius, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void roundRect(int x, int y, int width, int height, int radius, int stroke, int fill){}

	/**
	*	See above.
	*/
	public void roundRect(double x, double y, int width, int height, int radius){}

	/**
	*	See above.
	*/
	public void roundRect(int x, int y, int width, int height, int radius){}


	//	##################################################
	//	#
	//	#  Text methods
	//	#
	//	# As with graphics, a separate object ensures that
	//	# everything is bracketed between  text operators.
	//	# The methods below are a high-level convenience.
	//	# use PDFTextObject for multi-line text.
	//	##################################################

	/**
	*	Set the fill color useing negative color values
	*	(cyan, magenta, yellow and darkness value).
	*	Takes 4 arguments between 0.0 and 1.0
	*	@param c Cyan component; values from 0.0 to 1.0
	*	@param m Magenta component; values from 0.0 to 1.0
	*	@param y Yellow component; values from 0.0 to 1.0
	*	@param k Darkness value; values from 0.0 to 1.0
	*/
	public void setFillColorCMYK(double c, double m, double y, double k){}

	/**
	*	See above.
	*/
	public void setFillColorCMYK(int c, int m, int y, int k){}

   /**
	*	Set the stroke color useing negative color values
	*	(cyan, magenta, yellow and darkness value).
	*	Takes 4 arguments between 0.0 and 1.0
	*	@param c Cyan component; values from 0.0 to 1.0
	*	@param m Magenta component; values from 0.0 to 1.0
	*	@param y Yellow component; values from 0.0 to 1.0
	*	@param k Darkness value; values from 0.0 to 1.0
	*/
	public void setStrokeColorCMYK(double c, double m, double y, double k){}

	/**
	*	See above.
	*/
	public void setStrokeColorCMYK(int c, int m, int y, int k){}

	/**
	*	Draws a string in the current text styles.
	*	@param x String's X coord.
	*	@param y String's Y coord.
	*	@param text Text string.
	*/
	public void drawString(double x, double y, String text){}

	/**
	*	See above.
	*/
	public void drawString(int x, int y, String text){}

	/**
	*	Draws a string right-aligned with the x coordinate
	*	@param x String's X coord.
	*	@param y String's Y coord.
	*	@param text Text string
	*/
	public void drawRightString(double x, double y, String text){}

	/**
	*	See above.
	*/
	public void drawRightString(int x, int y, String text){}

	/**
	*	Draws a string centred on the x coordinate.
	*	@param x String's X coord.
	*	@param y String's Y coord.
	*	@param text Text string
	*/
	public void drawCentredString(double x, double y, String text){}

	/**
	*	See above.
	*/
	public void drawCentredString(int x, int y, String text){}

	/**
	*	Returns the list of PostScript font names available.
	*	Standard set now, but may grow in future with font embedding.
	*	@return List of available fonts.
	*/
	public String[] getAvailableFonts(){return null;}

	//def addFont(self, fontObj):

	/**
	*	Convenience function to list all loaded fonts
	*	@return List of loaded fonts.
	*/
	public String[] listLoadedFonts0(){return null;}

	/**
	*	Sets the font.  If leading not specified, defaults to 1.2 x
	*	font size. Raises a readable exception if an illegal font
	*	is supplied.  Font names are case-sensitive! Keeps track
	*	of font name and size for metrics.
	*	@param psfontname Font name.
	*	@param size Font size.
	*	@param leading Font leading.
	*/
	public void setFont(String psfontname, int size, int leading){}

	/**
	*	See above.
	*/
	public void setFont(String psfontname, int size){}

	/**
	*	gets width of a string in the given font and size
	*	@param text Text string.
	*	@param fontName Font name.
	*	@param fontSize Font size.
	*	@return Width of the string.
	*/
	public int stringWidth(String text, String fontName, int fontSize){return 0;}

	/**
	*	Sets line width.
	*	@param width Line width.
	*/
	public void setLineWidth(int width){}

	/**
	*	0=butt,1=round,2=square
	*	@param mode Array of Line cap modes.
	*/
	public void setLineCap(int[] mode){}

	/**
	*	0=mitre, 1=round, 2=bevel
	*	@param mode Array of Line join modes.
	*/
	public void setLineJoin(int[] mode){}

	/**
	*	This parameter limits the length of
	*	“spikes” produced when line segments join at sharp angles.
	*	Initial value:10.0, for a miter cutoff below approximately 11.5 degrees.
	*	@param limit Limit value.
	*/
	public void setMiterLimit(int limit){}

	/**
	*	Two notations.  pass two numbers, or an array and phase.
	*	@param array Array.
	*	@param phase Phase.
	*/
	public void setDash(int[] array, int phase){}

	/**
	*	Set the fill color using positive color description
	*   (Red,Green,Blue). Takes 3 arguments between 0.0 and 1.0
	*	@param r Red component; values from 0.0 to 1.0
	*	@param g Green component; values from 0.0 to 1.0
	*	@param b Blue component; values from 0.0 to 1.0
	*/
	public void setFillColorRGB(double r, double g, double b){}

	/**
	*	Set the stroke color using positive color description
	*   (Red,Green,Blue). Takes 3 arguments between 0.0 and 1.0
	*	@param r Red component; values from 0.0 to 1.0
	*	@param g Green component; values from 0.0 to 1.0
	*	@param b Blue component; values from 0.0 to 1.0
	*/
	public void setStrokeColorRGB(double r, double g, double b){}

	/**
	*	See above.
	*/
	public void setStrokeColorRGB(int r, int g, int b){}

	//def setFillColor(self, aColor):

	//def setStrokeColor(self, aColor):

	/**
	*	Sets the gray level; 0.0=black, 1.0=white
	*	@param gray values from 0.0 to 1.0
	*/
	public void setFillGray(double gray){}

	/**
	*	Sets the gray level; 0.0=black, 1.0=white
	*	@param gray values from 0.0 to 1.0
	*/
	public void setStrokeGray(double gray){}

	//def beginPath(self):
	//	return Canvas.beginPath(self)

	//def drawPath(self, aPath, stroke=1, fill=0):

	//def clipPath(self, aPath, stroke=1, fill=0):

	//def beginText(self, x=0, y=0):
	//	return Canvas.beginText(self, x, y)

	//def drawText(self, aTextObject):

	/**
	*	Possible values 1 or 0
	*	If on, the page data will be compressed, leading to much
	*	smaller files, but takes a little longer to create the files.
	*	This applies to all subsequent pages, or until setPageCompression()
	*	is next called.
	*	@param pageCompression Sets page compression flag; 0 or 1
	*/
	public void setPageCompression(int pageCompression){}

	/**
	*	The value from rl_config will be used to decide wheter to
	*	compress the file or not.
	*/
	public void setPageCompression(){}

	/**
	*	Allows hands-off animation of presentations :-)<br>
	*	<br>
	*	If this is set to a number, in full screen mode, Acrobat Reader
	*	will advance to the next page after this many seconds. The
	*	duration of the transition itself (fade/flicker etc.) is controlled
	*	by the 'duration' argument to setPageTransition; this controls
	*	the time spent looking at the page.  This is effective for all
	*	subsequent pages.
	*	@param duration Duration of transition in seconds.
	*/
	public void setPageDuration(int duration){}

	/**
	*	PDF allows page transition effects for use when giving
	*	presentations.  There are six possible effects.  You can
	*	just guive the effect name, or supply more advanced options
	*	to refine the way it works.  There are three types of extra
	*	argument permitted, and here are the allowed values:
	*		direction_arg = {0, 90, 180, 270}
	*		dimension_arg = {'H', 'V'}
	*		motion_arg = {'I','O'} (start at inside or outside)
	*
	*	This table says which ones take which arguments:
	*
	*	PageTransitionEffects = {
	*		'Split': [direction_arg, motion_arg],
	*		'Blinds': [dimension_arg],
	*		'Box': [motion_arg],
	*		'Wipe' : [direction_arg],
	*		'Dissolve' : [],
	*		'Glitter':[direction_arg]
	*		}
	*	Have fun!
	*	@param effectname Name of the transition effect.
	*	@param duration Duration of the transition.
	*	@param direction Direction.
	*	@param dimension Dimension.
	*	@param motion Motion.
	*/
	public void setPageTransition(String effectname, int duration, int direction, char dimension, char motion){}

	/**
	*	See above.
	*/
	public void setPageTransition(String effectname, int duration, int direction){}

	/**
	*	See above.
	*/
	public void setPageTransition(String effectname){}

}

