#import "DPS.h"

@implementation DPS

+ defineUserObject:(int)index							{ DPSDefineUserObject( index ); return self;  }
//+ undefineUserObject:(int)index							{ DPSUndefineUserObject( index ); return self;  }

+ doUserPath:(void *)coords :(int)numCoords :(int)numType :(unsigned char *)ops :(int)numOps :(void *)bbox :(int)actions 
{
	DPSDoUserPath(coords, numCoords, numType, ops, numOps, bbox, actions); 
	return self; 	
}

+ doUserPath:(void *)coords :(int)numCoords :(int)numType :(unsigned char *)ops :(int)numOps :(void *)bbox :(int)actions :(float *)matrix 
{
	DPSDoUserPathWithMatrix(coords, numCoords, numType, ops, numOps, bbox, actions, matrix); 
	return self; 		
}

+ colorImage											{ PScolorimage(); return self;  }
+ currentBlackGeneration								{ PScurrentblackgeneration(); return self;  }
+ currentCMYKColor:(float *)c :(float *)m :(float *)y :(float *)k 	{ PScurrentcmykcolor(c, m, y, k); return self;  }
+ currentCMYKColor:(NXColor *)c 	
{
	float cy,m,y,k; 
	PScurrentcmykcolor(&cy, &m, &y, &k); 
	*c = NXConvertCMYKToColor(cy,m,y,k);
	return self;  
}
+ currentColorTransfer									{ PScurrentcolortransfer(); return self;  }
+ currentUnderColorRemoval								{ PScurrentundercolorremoval(); return self;  }
+ setBlackGeneration									{ PScurrentundercolorremoval(); return self;  }
+ setCMYKColor:(float)c :(float)m :(float)y :(float)k 	{ PSsetcmykcolor(c, m, y, k); return self;  }
+ setCMYKColor:(NXColor *)c 	
{ 
	float cy,m,y,k;
	cy = NXCyanComponent(*c);
	m = NXMagentaComponent(*c);
	y = NXYellowComponent(*c);
	k = NXBlackComponent(*c);
	PSsetcmykcolor(cy, m, y, k); 
	return self;  
}
+ setColorScreen										{ PSsetcolorscreen(); return self;  }
+ setColorTransfer										{ PSsetcolortransfer(); return self;  }
+ setUnderColorRemoval									{ PSsetundercolorremoval(); return self;  }
	
+ condition												{ PScondition(); return self;  }
+ currentContext:(int *)cid								{ PScurrentcontext(cid); return self;  }
+ currentObjectFormat:(int *)code						{ PScurrentobjectformat(code); return self;  }
+ defineUserName:(int)i :(const char *)username			{ PSdefineusername(i, username); return self;  }
+ defineUserName:(const char *)username at:(int)i		{ PSdefineusername(i, username); return self;  }
+ defineUserObject										{ PSdefineuserobject(); return self;  }
+ detach												{ PSdetach(); return self;  }
+ execUserObject:(int)index								{ PSexecuserobject(index); return self;  }
+ fork													{ PSfork(); return self;  }
+ join													{ PSjoin(); return self;  }
+ lock													{ PSlock(); return self;  }
+ monitor												{ PSmonitor(); return self;  }
+ notify												{ PSnotify(); return self;  }
+ setObjectFormat:(int)code								{ PSsetobjectformat(code); return self;  }
+ setVMThreshold:(int)i									{ PSsetvmthreshold(i); return self;  }
+ undefineUserObject:(int)index							{ PSundefineuserobject(index); return self;  }
+ userObject											{ PSuserobject(); return self;  }
+ wait													{ PSwait(); return self;  }
+ yield													{ PSyield(); return self;  }

+ fontDirectory											{ PSFontDirectory(); return self;  }
+ ISOLatin1Encoding										{ PSISOLatin1Encoding(); return self;  }
+ sharedFontDirectory									{ PSSharedFontDirectory(); return self;  }
+ standardEncoding										{ PSStandardEncoding(); return self;  }
+ cacheStatus:(int *)bsize :(int *)bmax :(int *)msize 	{ PScachestatus(bsize, bmax, msize); return self;  }
+ currentCacheParams									{ PScurrentcacheparams(); return self;  }
+ currentFont											{ PScurrentfont(); return self;  }
+ defineFont											{ PSdefinefont(); return self;  }
+ findFont:(const char *)name							{ PSfindfont(name); return self;  }
+ makeFont												{ PSmakefont(); return self;  }
+ scaleFont:(float)size									{ PSscalefont(size); return self;  }
+ selectFont:(const char *)name :(float)scale 			{ PSselectfont(name, scale); return self;  }
+ selectFont:(const char *)name scale:(float)scale 		{ PSselectfont(name, scale); return self;  }
+ setCacheDevice:(float)wx :(float)wy :(float)llx :(float)lly :(float)urx :(float)ury 
{
	PSsetcachedevice(wx, wy, llx, lly, urx, ury);
	return self; 
}
+ setCacheLimit:(int)n									{ PSsetcachelimit(n); return self;  }
+ setCacheParams										{ PSsetcacheparams(); return self;  }
+ setCharWidth:(float)x :(float)y 						{ PSsetcharwidth(x, y); return self;  }
+ setCharWidth:(NXSize *)size 							{ PSsetcharwidth(size->width, size->height); return self;  }
+ setFont:(int)f										{ PSsetfont(f); return self;  }
+ undefineFont:(const char *)name						{ PSundefinefont(name); return self;  }


+ concat:(float *)m										{ PSconcat(m); return self;  }
+ currentDash											{ PScurrentdash(); return self;  }
+ currentFlat:(float *)flatness							{ PScurrentflat(flatness); return self;  }
+ currentGray:(float *)gray								{ PScurrentgray(gray); return self;  }
+ currentGState:(int)gst								{ PScurrentgstate(gst); return self;  }
+ currentHalftone										{ PScurrenthalftone(); return self;  }
+ currentHalfTonePhase:(float *)x :(float *)y 			{ PScurrenthalftonephase(x, y); return self;  }
+ currentHSBColor:(float *)h :(float *)s :(float *)b 	{ PScurrenthsbcolor(h,s,b); return self;  }
+ currentHSBColor:(NXColor *)c
{
	float h,s,b;
	PScurrenthsbcolor(&h,&s,&b); 
	*c = NXConvertHSBToColor(h, s, b); 
	return self; 
}
+ currentLineCap:(int *)linecap							{ PScurrentlinecap(linecap); return self;  }
+ currentLineJoin:(int *)linejoin						{ PScurrentlinejoin(linejoin); return self;  }
+ currentLineWidth:(float *)width							{ PScurrentlinewidth(width); return self; }
+ currentMatrix											{ PScurrentmatrix(); return self; }
+ currentMiterLimit:(float *)limit						{ PScurrentmiterlimit(limit); return self; }
+ currentPoint:(float *)x :(float *)y 					{ PScurrentpoint(x, y); return self; }
+ currentPoint:(NXPoint *)p 								
{ 
	float x, y;
	PScurrentpoint(&x, &y);
	p->x = x;
	p->y = y; 
	return self; 	
}
+ currentRGBColor:(float *)r :(float *)g :(float *)b 	{PScurrentrgbcolor(r,g,b); return self; }
+ currentRGBColor:(NXColor *)c 
{
	float r,g,b;
	PScurrentrgbcolor(&r,&g,&b);
	*c = NXConvertRGBToColor(r,g,b); 
	return self; 
}
+ currentScreen											{PScurrentscreen(); return self; }
+ currentStrokeAdjust:(int *)b							{PScurrentstrokeadjust(b); return self; }
+ currentTransfer										{PScurrenttransfer(); return self; }
+ defaultMatrix											{PSdefaultmatrix(); return self; }
+ gRestore												{PSgrestore(); return self; }
+ gRestoreAll											{PSgrestoreall(); return self; }
+ gSave													{PSgsave(); return self; }
+ gState												{PSgstate(); return self; }
+ initGraphics											{PSinitgraphics(); return self; }
+ initMatrix											{PSinitmatrix(); return self; }
+ rotate:(float)angle									{PSrotate(angle); return self; }
+ scale:(float)x :(float)y 								{PSscale(x,y); return self; }
+ scale:(NXSize *)size 									{PSscale(size->width, size->height); return self; }
+ setDash:(const float *)path :(int)size :(float)offset {PSsetdash(path,size,offset); return self; }
+ setDash:(const float *)path size:(int)size offset:(float)offset 	{PSsetdash(path,size,offset); return self; }
+ setFlat:(float)flatness								{PSsetflat(flatness); return self; }
+ setGray:(float)gray									{PSsetgray(gray); return self; }
+ setGState:(int)gst									{PSsetgstate(gst); return self; }
+ setHalftone											{PSsethalftone(); return self; }
+ setHalftonePhase:(float)x :(float)y 					{PSsethalftonephase(x, y); return self; }
+ setHSBColor:(float)h :(float)s :(float)b				{PSsethsbcolor(h, s, b); return self; }
+ setHSBColor:(NXColor *)c
{
	float h,s,b;
	NXConvertColorToHSB(*c, &h, &s, &b);
	PSsethsbcolor(h, s, b); return self; 
}
+ setLineCap:(int)linecap								{PSsetlinecap(linecap); return self; }
+ setLineJoin:(int)linejoin								{PSsetlinejoin(linejoin); return self; }
+ setLineWidth:(float)width								{PSsetlinewidth(width); return self; }
+ setMatrix												{PSsetmatrix(); return self; }
+ setMiterLimit:(float)limit							{PSsetmiterlimit(limit); return self; }
+ setRGBColor:(float)r :(float)g :(float)b 				{PSsetrgbcolor(r,g,b); return self; }
+ setRGBColor:(NXColor *)c
{
	float r,g,b;
	NXConvertColorToRGB(*c, &r, &g, &b);
	PSsetrgbcolor(g, r, b); return self; 
}
+ setScreen												{PSsetscreen(); return self; }
+ setStrokeAdjust:(int)b								{PSsetstrokeadjust(b); return self; }
+ setTransfer											{PSsettransfer(); return self; }
+ translate:(float)x :(float)y 							{PStranslate(x, y); return self; }
+ translate:(NXPoint *)p 								{PStranslate(p->x,  p->y); return self; }

+ concatMatrix												{PSconcatmatrix(); return self; }
+ dtransform:(float)x1 :(float)y1 :(float *)x2 :(float *)y2 {PSdtransform(x1, y1, x2, y2); return self; }
+ identMatrix												{PSidentmatrix(); return self; }
+ idTransfrom:(float)x1 :(float)y1 :(float *)x2 :(float *)y2 	{PSidtransform(x1,y1,x2,y2); return self; }
+ invertMatrix												{PSinvertmatrix(); return self; }
+ iTransfrom:(float)x1 :(float)y1 :(float *)x2 :(float *)y2 {PSitransform(x1,y1,x2,y2); return self; }
+ transfrom:(float)x1 :(float)y1 :(float *)x2 :(float *)y2 	{PStransform(x1,y1,x2,y2); return self; }

+ getBoolean:(int *)it								{PSgetboolean(it); return self; }
+ getCharArray:(char *)s size:(int)size 			{PSgetchararray(size, s); return self; }
+ getFloat:(float *)it								{PSgetfloat(it); return self; }
+ getFloatArray:(float *)a size:(int)size 			{PSgetfloatarray(size,a); return self; }
+ getInt:(int *)it									{PSgetint(it); return self; }
+ getIntArray:(int *)a size:(int)size 				{PSgetintarray(size,a ); return self; }
+ getString:(char *)s								{PSgetstring(s); return self; }
+ sendBoolean:(int)it								{PSsendboolean(it); return self; }
+ sendCharArray:(const char *)s size:(int)size 		{PSsendchararray(s, size); return self; }
+ sendFloat:(float)it								{PSsendfloat(it); return self; }
+ sendFloatArray:(const float *)a size:(int)size 	{PSsendfloatarray(a, size); return self; }
+ sendInt:(int)it									{PSsendint(it); return self; }
+ sendIntArray:(const int *)a size:(int)size 		{PSsendintarray(a, size); return self; }
+ sendString:(const char *)s						{PSsendstring(s); return self; }

+ aShow:(float)x :(float)y :(const char *)s 		{PSashow(x,y,s); return self; }
+ aWidthShow:(float)cx :(float)cy :(int)c :(float)ax :(float)ay :(const char *)s	{PSawidthshow(cx, cy, c, ax, ay, s); return self; }
+ copyPage											{PScopypage(); return self; }
+ eoFill											{PSeofill(); return self; }
+ erasePage											{PSerasepage(); return self; }
+ fill												{PSfill(); return self; }
+ image												{PSimage(); return self; }
+ imageMask											{PSimagemask(); return self; }
+ kShow:(const char *)s								{PSkshow(s); return self; }
+ rectFill:(float)x :(float)y :(float)w :(float)h 	{PSrectfill(x,y,w,h); return self; }
+ rectFill:(NXRect *)r 								{PSrectfill(r->origin.x, r->origin.y, r->size.width, r->size.height); return self; }
+ rectStroke:(float)x :(float)y :(float)w :(float)h {PSrectstroke(x,y,w,h); return self; }
+ rectStroke:(NXRect *)r 							{PSrectstroke(r->origin.x, r->origin.y, r->size.width, r->size.height); return self; }
+ show:(const char *)s								{PSshow(s); return self; }
+ show:(const char *)s addWidth:(NXSize *)p 		{PSashow(p->width,p->height,s); return self; }
+ show:(const char *)s addWidth:(NXSize *)a char:(int)c addWidth:(NXSize *)cs 	{PSawidthshow(cs->width, cs->height, c, a->width, a->height, s); return self; }
+ showPage											{PSshowpage(); return self; }
+ stroke											{PSstroke(); return self; }
+ strokePath										{PSstrokepath(); return self; }
+ ueoFill:(const char *)nums :(int)n :(const char *)ops :(int)l 	{PSueofill(nums, n, ops, l); return self; }
+ uFill:(const char *)nums :(int)n :(const char *)ops :(int)l 		{PSufill(nums, n, ops, l); return self; }
+ uStroke:(const char *)nums :(int)n :(const char *)ops :(int)l 	{PSustroke(nums, n, ops, l); return self; }
+ uStrokePath:(const char *)nums :(int)n :(const char *)ops :(int)l	{PSustrokepath(nums, n, ops, l); return self; } 
+ widthShow:(float)x :(float)y :(int)c :(const char *)s 			{PSwidthshow(x, y, c, s); return self; }
+ xShow:(const char *)s :(const float *)numarray :(int)size			{PSxshow(s, numarray, size); return self; } 
+ xyShow:(const char *)s :(const float *)numarray :(int)size 		{PSxyshow(s, numarray, size); return self; }
+ yShow:(const char *)s :(const float *)numarray :(int)size 		{PSyshow(s, numarray, size); return self; }

+ arc:(float)x :(float)y :(float)r :(float)angle1 :(float)angle2 						{PSarc(x,y,r,angle1,angle2); return self; }
+ arcAt:(NXPoint *)p radius:(float)r startAngle:(float)angle1 endAngle:(float)angle2 	{PSarc(p->x, p->y,r,angle1,angle2); return self; }
+ arcN:(float)x :(float)y :(float)r :(float)angle1 :(float)angle2 						{PSarcn(x,y,r,angle1,angle2); return self; }
+ arcNAt:(NXPoint *)p radius:(float)r startAngle:(float)angle1 endAngle:(float)angle2 	{PSarcn(p->x, p->y, r, angle1, angle2); return self; }
+ arcT:(float)x1 :(float)y1 :(float)x2 :(float)y2 :(float)r 							{PSarct(x1,y1,x2,y2,r); return self; }
+ arcTo:(float)x1 :(float)y1 :(float)x2 :(float)y2 :(float)r :(float *)xt1 :(float *)yt1 :(float *)xt2 :(float *)yt2		{PSarcto(x1,y1,x2,y2,r,xt1,yt1,xt2,yt2); return self; }
+ charPath:(const char *)s :(int)b 						{PScharpath(s,b); return self; }
+ clip													{PSclip(); return self; }
+ clipPath												{PSclippath(); return self; }
+ closePath												{PSclosepath(); return self; }
+ curveTo:(float)x1 :(float)y1 :(float)x2 :(float)y2 :(float)x3 :(float)y3 	{PScurveto(x1,y1,x2,y2,x3,y3); return self; }
+ curveTo:(NXPoint *)p1 :(NXPoint *)p2 :(NXPoint *)p3 						{PScurveto(p1->x, p1->y, p2->x, p2->y, p3->x, p3->y); return self; }
+ eoClip												{PSeoclip(); return self; }
+ eoViewClip											{PSeoviewclip(); return self; }
+ flattenPath											{PSflattenpath(); return self; }
+ initClip												{PSinitclip(); return self; }
+ initViewClip											{PSinitviewclip(); return self; }
+ lineTo:(float)x :(float)y 							{PSlineto(x,y); return self; }
+ lineTo:(NXPoint *)p 									{PSlineto(p->x,p->y); return self; }
+ moveTo:(float)x :(float)y 							{PSmoveto(x,y); return self; }
+ moveTo:(NXPoint *)p		 							{PSmoveto(p->x, p->y); return self; }
+ newPath												{PSnewpath(); return self; }
+ pathBox:(float *)llx :(float *)lly :(float *)urx :(float *)ury	{PSpathbbox(llx, lly, urx, ury); return self; }
+ pathBox:(NXRect *)r									
{
	float llx, lly, urx, ury;
	PSpathbbox(&llx, &lly, &urx, &ury);
	r->origin.x = llx;
	r->origin.y = lly;
	r->size.width = fabs(urx - llx);
	r->size.height = fabs(ury - lly); 
	return self; 
}
+ pathForAll											{PSpathforall(); return self; }
+ rCurveTo:(float)x1 :(float)y1 :(float)x2 :(float)y2 :(float)x3 :(float)y3 	{PSrcurveto(x1,y1,x2,y2,x3,y3); return self; }
+ rectClip:(float)x :(float)y :(float)w :(float)h 		{PSrectclip(x,y,w,h); return self; }
+ rectClip:(NXRect *)r 									{PSrectclip(r->origin.x, r->origin.y, r->size.width, r->size.height); return self; }
+ rectViewClip:(float)x :(float)y :(float)w :(float)h 	{PSrectviewclip(x,y,w,h); return self; }
+ rectViewClip:(NXRect *)r 								{PSrectviewclip(r->origin.x, r->origin.y, r->size.width, r->size.height); return self; }
+ reversePath											{PSreversepath(); return self; }	
+ rLineTo:(float)x :(float)y 							{PSrlineto(x,y); return self; }
+ rLineTo:(NXPoint *)p	 								{PSrlineto(p->x, p->y); return self; }
+ rMoveTo:(float)x :(float)y 							{PSrmoveto(x,y); return self; }
+ rMoveTo:(NXPoint *)p	 								{PSrmoveto(p->x, p->y); return self; }
+ setBBox:(float)llx :(float)lly :(float)urx :(float)ury	{PSsetbbox(llx,lly,urx,ury); return self; }
+ setBBox:(NXRect *)r									{PSsetbbox(NX_X(r), NX_Y(r), NX_MAXX(r), NX_MAXY(r)); return self; }
+ setUCacheParams										{PSsetucacheparams(); return self; }
+ uAppend:(const char *)nums :(int)n :(const char *)ops :(int)l 	{PSuappend(nums,n,ops,l); return self; }
+ uCache												{PSucache(); return self; }
+ uPath:(int)b											{PSupath(b); return self; }
+ uCacheStatus											{PSucachestatus(); return self; }
+ viewClip												{PSviewclip(); return self; }
+ viewClipPath											{PSviewclippath(); return self; }

+ ineoFill:(float)x :(float)y :(int *)b					{PSineofill(x,y,b); return self; }
+ inFill:(float)x :(float)y :(int *)b 					{PSinfill(x,y,b); return self; }
+ inStroke:(float)x :(float)y :(int *)b 				{PSinstroke(x,y,b); return self; }
+ inueoFill:(float)x :(float)y :(const char *)nums :(int)n :(const char*)ops :(int)l :(int *)b 	{PSinueofill(x,y,nums,n,ops,l,b); return self; }
+ inuFill:(float)x :(float)y :(const char *)nums :(int)n :(const char*)ops :(int)l :(int *)b 		{PSinufill(x,y,nums,n,ops,l,b); return self; }
+ inuStroke:(float)x :(float)y :(const char *)nums :(int)n :(const char*)ops :(int)l :(int *)b 	{PSinustroke(x,y,nums,n,ops,l,b); return self; }
+ wTranslation:(float *)x :(float *)y 				{PSwtranslation(x,y); return self; }

@end

