Re: "Jaguar" additions

[Adam Fedor]

BALATON Zoltan wrote:
> On Mon, 26 Aug 2002, Alexander Malmberg wrote:
>
> > There are methods for setting the colorspace (-GSSetFillColorspace: and
> > -GSSetStrokeColorspace:), but they're neither documented nor
> > implemented.
>
>
> Furthermore the methods to actually create color spaces are missing. (Same
> for imagerefs.) Without this it is not possible to implement these
> methods.

Creating a colorspace in GNUstep would be as simple as creating a 
dictionary with the correct keys and values (I've attached an updated 
file that has those filled in). Then pass that dictionary to 
-GSSetFillColorspace: or -GSSetStrokeColorspace:

I've added more documentation to NSGraphicsContext.m (you have to run 
autogsdoc yourself to format it).

> Me either, see above. It seems the current tendency is to implement
> graphics features in the gui however they should be implemented in the
> backend and allow backends to implement them as they see fit. This applies
> to at least NSAffineTransform, NSBezierPath, NSColor, NSFont,
> NSGraphicsState, probably more. (They could probably be moved to gsc.)

Those classes are implemented that way because that is how the need to 
be implemented in order to fit the API and interact with other objects. 
There HAS to be a translations between objects and 
C-structures/backend-structures SOMEWHERE. However, since we've already 
implemented NSAffineTransform, NSBezierPath, etc. it makes sense to use 
those implementations in our graphics implementation, and just do the 
translation to the "native" format in the backend.



--
Adam Fedor, Digital Optics Corp.      | I'm glad I hate spinach, because
http://www.doc.com                    | if I didn't, I'd eat it, and you
                                      | know how I hate the stuff.

/*---------------------------------------------------------------------------*/
/* Data Types */

typedef struct CGAffineTransform {
  float a, b, c, d, tx, ty;
} CGAffineTransform;
typedef struct {
  float m11, m12, m21, m22, tx, ty;
} NSAffineTransformStruct;
typedef struct gs_matrix_s {
  float xx, xy, yx, yy, tx, ty;
} gs_matrix;

typedef struct CGPoint {
  float x, y;
} CGPoint;
typedef struct _NSPoint {
  float x, y;
} NSPoint;
typedef struct gs_point_s {
  double x, y;
} gs_point;

typedef struct CGSize {
  float width;
  float height;
} CGSize;
typedef struct _NSSize {
  float width;
  float height;
} NSSize;
?

typedef struct CGRect {
  CGPoint origin;
  CGSize size;
} CGRect;
typedef struct _NSRect {
  NSPoint origin;
  NSSize size;
} NSRect;
typedef struct gs_rect_s {
    gs_point p, q;              /* origin point, corner point */
} gs_rect;

typedef void * CGColorSpaceRef;
?
gs_color_space *

typedef void * CGContextRef;
NSGraphicsContext *
gs_state * /* Probably more, but that could be client_data */

typedef void * CGFontRef;
NSFont *
gs_font *

typedef UInt16 CGGlyph;
typedef unsigned int NSGlyph;
typedef ulong gs_glyph;

typedef void * CGImageRef;
?
?gs_image_t * /* Probably more */

typedef void * CGPatternRef;
?
?gs_pattern_template_t *

/*---------------------------------------------------------------------------*/
/* Constants */

const CGAffineTransform CGAffineTransformIdentity = {1,0,0,1,0,0};
NSAffineTransform - (void)makeIdentityMatrix;
void gs_make_identity(gs_matrix *);

typedef enum CGColorRenderingIntent
{
  kCGRenderingIntentDefault = 0,
  kCGRenderingIntentAbsoluteColorimetric = 1,
  kCGRenderingIntentRelativeColorimetric = 2,
  kCGRenderingIntentPerceptual = 3,
  kCGRenderingIntentSaturation = 4
} CGColorRenderingIntent;
?
?

typedef enum CGImageAlphaInfo
{
  kCGImageAlphaNone = 0,
  kCGImageAlphaPremultipliedLast = 1,
  kCGImageAlphaPremultipliedFirst = 2,
  kCGImageAlphaLast = 3,
  kCGImageAlphaFirst = 4,
  kCGImageAlphaNoneSkipLast = 5,
  kCGImageAlphaNoneSkipFirst = 6
} CGImageAlphaInfo;
?
typedef enum {
    gs_image_alpha_none = 0,
    gs_image_alpha_first,
    gs_image_alpha_last
} gs_image_alpha_t;

typedef enum CGInterpolationQuality
{
  kCGInterpolationDefault = 0,
  kCGInterpolationNone = 1,
  kCGInterpolationLow = 2,
  kCGInterpolationHigh = 3
} CGInterpolationQuality;
typedef enum _NSImageInterpolation
{
  NSImageInterpolationDefault,
  NSImageInterpolationNone,
  NSImageInterpolationLow,
  NSImageInterpolationHigh
} NSImageInterpolation;
gs_data_image_t.(bool)Interpolate

typedef enum CGLineCap
{
  kCGLineCapButt = 0,
  kCGLineCapRound = 1,
  kCGLineCapSquare = 2
} CGLineCap;
typedef enum {
  NSButtLineCapStyle = 0,
  NSRoundLineCapStyle = 1,
  NSSquareLineCapStyle = 2
} NSLineCapStyle;
typedef enum {
    gs_cap_butt = 0,
    gs_cap_round = 1,
    gs_cap_square = 2,
    gs_cap_triangle = 3         /* not supported by PostScript */
} gs_line_cap;

typedef enum CGLineJoin
{
  kCGLineJoinMiter = 0,
  kCGLineJoinRound = 1,
  kCGLineJoinBevel = 2
} CGLineJoin;
typedef enum {
  NSMiterLineJoinStyle = 0,
  NSRoundLineJoinStyle = 1,
  NSBevelLineJoinStyle = 2
} NSLineJoinStyle;
typedef enum {
    gs_join_miter = 0,
    gs_join_round = 1,
    gs_join_bevel = 2,
    gs_join_none = 3,           /* not supported by PostScript */
    gs_join_triangle = 4        /* not supported by PostScript */
} gs_line_join;

typedef enum CGPathDrawingMode
{
  kCGPathFill = 0,
  kCGPathEOFill = 1,
  kCGPathStroke = 2,
  kCGPathFillStroke = 3,
  kCGPathEOFillStroke = 4
} CGPathDrawingMode;
?
?

const CGPoint CGPointZero = {0,0};
static const NSPoint NSZeroPoint;
?

typedef enum CGRectEdge
{
  CGRectMinXEdge = 0,
  CGRectMinYEdge = 1,
  CGRectMaxXEdge = 2,
  CGRectMaxYEdge = 3
} CGRectEdge;
typedef enum _NSRectEdge
{
  NSMinXEdge,
  NSMinYEdge,
  NSMaxXEdge,
  NSMaxYEdge
} NSRectEdge;
?

const CGRect CGRectNull;
?
?

const CGSize CGSizeZero = {0,0};
static const NSSize NSZeroSize;
?

const CGRect CGRectZero = {{0,0},{0,0}};
static const NSRect NSZeroRect;
?

typedef enum CGTextDrawingMode
{
  kCGTextFill = 0,
  kCGTextStroke = 1,
  kCGTextFillStroke = 2,
  kCGTextInvisible = 3,
  kCGTextFillClip = 4,
  kCGTextStrokeClip = 5,
  kCGTextFillStrokeClip = 6,
  kCGTextClip = 7
} CGTextDrawingMode;
typedef enum _GSTextDrawingMode
{
  GSTextFill,
  GSTextStroke,
  GSTextClip
} GSTextDrawingMode;
gs:#define TEXT_DO_NONE              0x00200    /* stringwidth or cshow only */
gs:#define TEXT_DO_DRAW              0x00400
gs:#define TEXT_DO_CHARWIDTH         0x00800    /* rmoveto by width */
gs:#define TEXT_DO_FALSE_CHARPATH    0x01000
gs:#define TEXT_DO_TRUE_CHARPATH     0x02000
gs:#define TEXT_DO_FALSE_CHARBOXPATH 0x04000
gs:#define TEXT_DO_TRUE_CHARBOXPATH  0x08000

typedef enum CGTextEncoding
{
  kCGEncodingFontSpecific = 0,
  kCGEncodingMacRoman = 1
} CGTextEncoding;
?NSStringEncoding
typedef enum { /* defined as postscript arrays */
    ENCODING_INDEX_UNKNOWN = -1,
        /* Real encodings.  These must come first. */
    ENCODING_INDEX_STANDARD = 0,
    ENCODING_INDEX_ISOLATIN1,
    ENCODING_INDEX_SYMBOL,
    ENCODING_INDEX_DINGBATS,
    ENCODING_INDEX_WINANSI,
    ENCODING_INDEX_MACROMAN,
    ENCODING_INDEX_MACEXPERT,
#define NUM_KNOWN_REAL_ENCODINGS 7
        /* Pseudo-encodings (glyph sets). */
    ENCODING_INDEX_MACGLYPH,    /* Mac glyphs */
    ENCODING_INDEX_ALOGLYPH,    /* Adobe Latin glyph set */
    ENCODING_INDEX_ALXGLYPH,    /* Adobe Latin Extended glyph set */
    ENCODING_INDEX_CFFSTRINGS   /* CFF StandardStrings */
#define NUM_KNOWN_ENCODINGS 11
} gs_encoding_index_t;

/*---------------------------------------------------------------------------*/
/* Transforming the Coordinate Space of the Page */

void CGContextScaleCTM(CGContextRef ctx, float sx, float sy);
- (void) DPSscale: (float)x : (float)y;
int gs_scale(gs_state * pgs, floatp sx, floatp sy);

void CGContextTranslateCTM(CGContextRef ctx, float tx, float ty);
- (void) DPStranslate: (float)x : (float)y;
int gs_translate(gs_state * pgs, floatp dx, floatp dy);

void CGContextRotateCTM(CGContextRef ctx, float angle); /* angle in rad */
- (void) DPSrotate: (float)angle;
int gs_rotate(gs_state * pgs, floatp ang); /* ang in deg! */

void CGContextConcatCTM(CGContextRef ctx, CGAffineTransform transform);
- (void) DPSconcat: (const float*)m;
- (void) GSConcatCTM: (NSAffineTransform *)ctm;
int gs_concat(gs_state * pgs, const gs_matrix * pmat);

CGAffineTransform CGContextGetCTM(CGContextRef ctx);
- (NSAffineTransform *) GSCurrentCTM;
int gs_currentmatrix(const gs_state * pgs, gs_matrix * pmat);

?
- (void) DPSinitmatrix;
int gs_initmatrix(gs_state * pgs);

?
- (void) GSSetCTM: (NSAffineTransform *)ctm;
int gs_setmatrix(gs_state * pgs, const gs_matrix * pmat);

/* Saving and Restoring the Graphics State */

void CGContextSaveGState(CGContextRef ctx);
- (void) DPSgsave;
int gs_gsave(gs_state * pgs);

void CGContextRestoreGState(CGContextRef ctx);
- (void) DPSgrestore;
int gs_grestore(gs_state * pgs);

?
- (void) DPSinitgraphics;
int gs_initgraphics(gs_state * pgs);

?
- (void) DPSsetgstate: (int)gst;
int gs_setgstate(gs_state * pgs, const gs_state * pfrom);

?
- (int)  GSDefineGState;
gs_state *gs_gstate(gs_state * pgs);

?
- (void) GSUndefineGState: (int)gst;
int gs_state_free(gs_state * pgs);

?
- (void) GSReplaceGState: (int)gst;
int gs_copygstate(gs_state * pto, const gs_state * pfrom);

/* Setting Graphics State Attributes */

void CGContextSetShouldAntialias(CGContextRef ctx, int shouldAntialias);
NSGraphicsState - (void) setShouldAntialias: (BOOL)antialias;
gs:TextAlphaBits and GraphicsAlphaBits device parameters

void CGContextSetLineWidth(CGContextRef ctx, float width);
- (void) DPSsetlinewidth: (float)width;
int gs_setlinewidth(gs_state * pgs, floatp width);

void CGContextSetLineJoin(CGContextRef ctx, CGLineJoin join);
- (void) DPSsetlinejoin: (int)linejoin;
int gs_setlinejoin(gs_state * pgs, gs_line_join join);

void CGContextSetMiterLimit(CGContextRef ctx, float limit);
- (void) DPSsetmiterlimit: (float)limit;
int gs_setmiterlimit(gs_state * pgs, floatp limit);

void CGContextSetLineCap(CGContextRef ctx, CGLineCap cap);
- (void) DPSsetlinecap: (int)linecap;
int gs_setlinecap(gs_state * pgs, gs_line_cap cap);

void CGContextSetLineDash(CGContextRef ctx, float phase, const float *lengths, 
size_t count);
- (void) DPSsetdash: (const float*)pat : (int)size : (float)offset;
int gs_setdash(gs_state * pgs, const float *pattern, uint length, floatp 
offset);

void CGContextSetFlatness(CGContextRef ctx, float flatness);
- (void) DPSsetflat: (float)flatness;
int gs_setflat(gs_state * pgs, floatp flat);

?
- (void) DPSsethalftonephase: (float)x : (float)y;
#define gs_sethalftonephase(pgs, px, py) gs_setscreenphase(pgs, px, py, 
gs_color_select_all)

?
- (void) DPSsetstrokeadjust: (int)b;
int gs_setstrokeadjust(gs_state * pgs, bool stroke_adjust);

/*---------------------------------------------------------------------------*/
/* Constructing Paths */

void CGContextBeginPath(CGContextRef ctx);
- (void) DPSnewpath;
int gs_newpath(gs_state * pgs);

void CGContextMoveToPoint(CGContextRef ctx, float x, float y);
- (void) DPSmoveto: (float)x : (float)y;
int gs_moveto(gs_state * pgs, floatp x, floatp y);

void CGContextAddLineToPoint(CGContextRef ctx, float x, float y);
- (void) DPSlineto: (float)x : (float)y;
int gs_lineto(gs_state * pgs, floatp x, floatp y);

void CGContextAddLines(CGContextRef ctx, const CGPoint *points, size_t count);

void CGContextAddCurveToPoint(
  CGContextRef ctx,
  float cp1x,
  float cp1y,
  float cp2x,
  float cp2y,
  float x,
  float y
);
- (void) DPScurveto: (float)x1 : (float)y1 : (float)x2 : (float)y2 : (float)x3 
: (float)y3;
int gs_curveto(gs_state * pgs, floatp x1, floatp y1, floatp x2, floatp y2, 
floatp x3, floatp y3);

void CGContextAddQuadCurveToPoint(
  CGContextRef ctx,
  float cpx,
  float cpy,
  float x,
  float y
);
?
{gstype42.c: private int add_quadratic_curve();}

void CGContextAddRect(CGContextRef ctx, CGRect rect);

void CGContextAddRects(CGContextRef ctx, const CGRect *rects, size_t count);
?
int gs_rectappend(gs_state * pgs, const gs_rect * pr, uint count);

void CGContextAddArc(
  CGContextRef ctx,
  float x,
  float y,
  float radius,
  float startAngle,
  float endAngle,
  int clockwise
);
- (void) DPSarc: (float)x : (float)y : (float)r : (float)angle1 : (float)angle2;
- (void) DPSarcn: (float)x : (float)y : (float)r : (float)angle1 : 
(float)angle2;
int gs_arc_add_inline(gs_state * pgs, bool clockwise, floatp axc, floatp ayc,
                      floatp arad, floatp aang1, floatp aang2, bool add_line);

void CGContextAddArcToPoint(
  CGContextRef ctx,
  float x1,
  float y1,
  float x2,
  float y2,
  float radius
);
- (void) DPSarct: (float)x1 : (float)y1 : (float)x2 : (float)y2 : (float)r;
int gs_arcto(gs_state * pgs, floatp ax1, floatp ay1, floatp ax2, floatp ay2,
             floatp arad, float retxy[4]);

void CGContextClosePath(CGContextRef ctx);
- (void) DPSclosepath;
int gs_closepath(gs_state * pgs);

- (void) DPSrmoveto: (float)x : (float)y;
- (void) DPSrlineto: (float)x : (float)y;
- (void) DPSrcurveto: (float)x1 : (float)y1 : (float)x2 : (float)y2 : (float)x3 
: (float)y3;
- (void) DPSreversepath;
- (void) DPSflattenpath;

/*---------------------------------------------------------------------------*/
/* Painting Paths */

void CGContextDrawPath(CGContextRef ctx, CGPathDrawingMode mode);

void CGContextStrokePath(CGContextRef ctx);
- (void) DPSstroke;
int gs_stroke(gs_state * pgs);

void CGContextFillPath(CGContextRef ctx);
- (void) DPSfill;
int gs_fill(gs_state * pgs);

void CGContextEOFillPath(CGContextRef ctx);
- (void) DPSeofill;
int gs_eofill(gs_state * pgs);

void CGContextStrokeRect(CGContextRef ctx, CGRect rect);
- (void) DPSrectstroke: (float)x : (float)y : (float)w : (float)h;
int gs_rectstroke(gs_state * pgs, const gs_rect * pr, uint count, const 
gs_matrix * pmat);

void CGContextStrokeRectWithWidth(CGContextRef ctx, CGRect rect, float width);

void CGContextFillRect(CGContextRef ctx, CGRect rect);
- (void) DPSrectfill: (float)x : (float)y : (float)w : (float)h;

void CGContextFillRects(CGContextRef ctx, const CGRect *rects, size_t count);
void NSRectFillList(const NSRect *rects, int count);
- (void) GSRectFillList: (const NSRect *)rects : (int) count;
int gs_rectfill(gs_state * pgs, const gs_rect * pr, uint count);

void CGContextClearRect(CGContextRef c, CGRect rect);
- (void) DPScompositerect: (float)x : (float)y : (float)w : (float)h : (int)op;
{zdpnext.c: private int zcompositerect();}

?
- (void) GSSendBezierPath: (NSBezierPath *)path;
?

/*---------------------------------------------------------------------------*/
/* Obtaining Path Information */

int CGContextIsPathEmpty(CGContextRef ctx);
NSBezierPath: - (BOOL)isEmpty;
bool gx_path_is_null_inline(gx_current_path(const gs_state * pgs));

CGPoint CGContextGetPathCurrentPoint(CGContextRef ctx);
- (void) DPScurrentpoint: (float*)x : (float*)y;
int gs_currentpoint(gs_state * pgs, gs_point * ppt);

CGRect CGContextGetPathBoundingBox(CGContextRef ctx);
- (void) DPSpathbbox: (float*)llx : (float*)lly : (float*)urx : (float*)ury;
#define gs_pathbbox(pgs, prect) gs_upathbbox(pgs, prect, false)

/*---------------------------------------------------------------------------*/
/* Clipping Paths */

void CGContextClip(CGContextRef ctx);
- (void) DPSclip;
int gs_clip(gs_state * pgs);

void CGContextEOClip(CGContextRef ctx);
- (void) DPSeoclip;
int gs_eoclip(gs_state * pgs);

void CGContextClipToRect(CGContextRef ctx, CGRect rect);
- (void) DPSrectclip: (float)x : (float)y : (float)w : (float)h;

void CGContextClipToRects(CGContextRef ctx, const CGRect *rects, size_t count);
?- (void) GSRectClipList: (const NSRect *)rects : (int) count;
int gs_rectclip(gs_state * pgs, const gs_rect * pr, uint count);

- (void) DPSinitclip;

/*---------------------------------------------------------------------------*/
/* Setting the Color Space */

CGColorSpaceRef CGColorSpaceCreateDeviceGray(void);
NSDictionary:{GSColorSpaceName=NSDeviceWhiteColorSpace;}
int gs_cspace_build_DeviceGray(gs_color_space ** ppcspace, gs_memory_t * pmem);

CGColorSpaceRef CGColorSpaceCreateDeviceRGB(void);
NSDictionary:{GSColorSpaceName=NSDeviceRGBColorSpace;}
int gs_cspace_build_DeviceRGB(gs_color_space ** ppcspace, gs_memory_t * pmem);

CGColorSpaceRef CGColorSpaceCreateDeviceCMYK(void);
NSDictionary:{GSColorSpaceName=NSDeviceCMYKColorSpace;}
int gs_cspace_build_DeviceCMYK(gs_color_space ** ppcspace, gs_memory_t * pmem);

CGColorSpaceRef CGColorSpaceCreateCalibratedGray(
  const float *whitePoint,
  const float *blackPoint,
  float gamma
);
NSDictionary:{
  GSColorSpaceName=NSCalibratedWhiteColorSpace;
  GSColorSpaceWhitePoint=(1, 1, 1);
  GSColorSpaceBlackPoint=(0, 0, 0);
  GSColorSpaceGamma=(1,1,1);
}
?

CGColorSpaceRef CGColorSpaceCreateCalibratedRGB(
  const float *whitePoint,
  const float *blackPoint,
  const float *gamma,
  const float *matrix
);
NSDictionary:{
  GSColorSpaceName=NSCalibratedRGBColorSpace;
  GSColorSpaceWhitePoint=(1, 1, 1);
  GSColorSpaceBlackPoint=(0, 0, 0);
  GSColorSpaceGamma=(1,1,1};
  GSColorSpaceMatrix=(1,0,0,0,1,0,0,0,1);
}
?

CGColorSpaceRef CGColorSpaceCreateLab(
  const float *whitePoint,
  const float *blackPoint,
  const float *range
);
NSDictionary:{
  GSColorSpaceName=GSLabColorSpace;
  GSColorSpaceWhitePoint=(1, 1, 1);
  GSColorSpaceBlackPoint=(0, 0, 0);
  GSColorSpaceRange=(0,1,0,1};
}
?

CGColorSpaceRef CGColorSpaceCreateICCBased(
  size_t nComponents,
  const float *range,
  CGDataProviderRef profile,
  CGColorSpaceRef alternateSpace
);
NSDictionary:{
  GSColorSpaceName=GSICCBasedColorSpace;
  GSColorSpaceComponents=3;
  GSColorSpaceRange=(0,1,0,1,0,1};
  GSColorSpaceProfile=<NSData values>;
  GSAlternateColorSpace=NSDeviceRGBColorSpace;
}
int gs_cspace_build_CIEICC(
  gs_color_space ** ppcspace,
  void * client_data,
  gs_memory_t * pmem
);

CGColorSpaceRef CGColorSpaceCreateIndexed(
  CGColorSpaceRef baseSpace,
  size_t lastIndex,
  const UInt8 *colorTable
);
NSDictionary:{
  GSBaseColorSpace = NSDeviceRGBColorSpace;
  GSColorSpaceColorTable=(0,0,0,0.1,....);
}
int gs_cspace_build_Indexed(
  gs_color_space ** ppcspace,
  const gs_color_space * pbase_cspace,
  uint num_entries,
  const gs_const_string * ptbl,
  gs_memory_t * pmem
);

size_t CGColorSpaceGetNumberOfComponents(CGColorSpaceRef cs);
?
int gs_color_space_num_components(const gs_color_space * pcs);

void CGContextSetFillColorSpace(CGContextRef ctx, CGColorSpaceRef colorspace);
- (void) GSSetFillColorspace: (NSDictionary *)dict;
?int gs_setcolorspace(gs_state * pgs, const gs_color_space * pcs);


void CGContextSetStrokeColorSpace(CGContextRef ctx, CGColorSpaceRef colorspace);
- (void) GSSetStrokeColorspace: (NSDictionary *)dict;
?int gs_setcolorspace(gs_state * pgs, const gs_color_space * pcs);

void CGContextSetRenderingIntent(CGContextRef c, CGColorRenderingIntent intent);
?
?

/*---------------------------------------------------------------------------*/
/* Setting Colors */

void CGContextSetFillColor(CGContextRef ctx, const float *value);
- (void) GSSetFillColor: (float *)values;
?int gs_setcolor(gs_state * pgs, const gs_client_color * pcc);

void CGContextSetStrokeColor(CGContextRef ctx, const float *value);
- (void) GSSetStrokeColor: (float *)values;
?int gs_setcolor(gs_state * pgs, const gs_client_color * pcc);

void CGContextSetGrayFillColor(CGContextRef ctx, float gray, float alpha);
- (void) GSSetFillColorspace: (NSDictionary *)dict;- (void) GSSetFillColor: 
(float *)values;
?int gs_setgray(gs_state * pgs, floatp gray);

void CGContextSetGrayStrokeColor(CGContextRef ctx, float gray, float alpha);
- (void) GSSetStrokeColorspace: (NSDictionary *)dict;- (void) GSSetStrokeColor: 
(float *)values;
?int gs_setgray(gs_state * pgs, floatp gray);

void CGContextSetRGBFillColor(
    CGContextRef ctx,
    float r,
    float g,
    float b,
    float alpha
);
- (void) GSSetFillColorspace: (NSDictionary *)dict;- (void) GSSetFillColor: 
(float *)values;
?int gs_setrgbcolor(gs_state * pgs, floatp r, floatp g, floatp b);

void CGContextSetRGBStrokeColor(
  CGContextRef ctx,
  float r,
  float g,
  float b,
  float alpha
);
- (void) GSSetStrokeColorspace: (NSDictionary *)dict;- (void) GSSetStrokeColor: 
(float *)values;
?int gs_setrgbcolor(gs_state * pgs, floatp r, floatp g, floatp b);

void CGContextSetCMYKFillColor(
  CGContextRef ctx,
  float c,
  float m,
  float y,
  float k,
  float alpha
);
- (void) GSSetFillColorspace: (NSDictionary *)dict;- (void) GSSetFillColor: 
(float *)values;
?int gs_setcmykcolor(gs_state * pgs, floatp c, floatp m, floatp y, floatp k);

void CGContextSetCMYKStrokeColor(
  CGContextRef ctx,
  float c,
  float m,
  float y,
  float k,
  float alpha
);
- (void) GSSetStrokeColorspace: (NSDictionary *)dict;- (void) GSSetStrokeColor: 
(float *)values;
?int gs_setcmykcolor(gs_state * pgs, floatp c, floatp m, floatp y, floatp k);

void CGContextSetAlpha(CGContextRef ctx, float alpha);
?- (void) DPSsetalpha: (float)a;
?int gs_setalpha(gs_state * pgs, floatp alpha);

- (void) DPSsethsbcolor: (float)h : (float)s : (float)b;
/* What to do with alpha values of colors? */

/*---------------------------------------------------------------------------*/
/* Drawing Images */

CGImageRef CGImageCreate(
  size_t width,
  size_t height,
  size_t bitsPerComponent,
  size_t bitsPerPixel,
  size_t bytesPerRow,
  CGColorSpaceRef colorspace,
  CGImageAlphaInfo alphaInfo,
  CGDataProviderRef provider,
  const float *decode,
  int shouldInterpolate,
  CGColorRenderingIntent intent
);
?
?void gs_image_t_init_adjust(
  gs_image_t * pim,
  const gs_color_space * color_space,
  bool adjust
);

CGImageRef CGImageMaskCreate(
  size_t width,
  size_t height,
  size_t bitsPerComponent,
  size_t bitsPerPixel,
  size_t bytesPerRow,
  CGDataProviderRef provider,
  const float *decode,
  int shouldInterpolate
);
?
?void gs_image_t_init_mask_adjust(
  gs_image_t * pim,
  bool write_1s,
  bool adjust
);

void CGContextDrawImage(CGContextRef ctx, CGRect rect, CGImageRef image);
- (void) NSDrawBitmap: (NSRect) rect : (int) pixelsWide : (int) pixelsHigh
                     : (int) bitsPerSample : (int) samplesPerPixel 
                     : (int) bitsPerPixel : (int) bytesPerRow : (BOOL) isPlanar
                     : (BOOL) hasAlpha : (NSString *) colorSpaceName
                     : (const unsigned char *const [5]) data;
- (void) GSDrawImage: (NSRect)rect : (void *)imageref;
gs_image_{init,next,cleanup}();

- (void) DPScomposite: (float)x : (float)y : (float)w : (float)h : 
(int)gstateNum : (float)dx : (float)dy : (int)op;
- (void) DPSdissolve: (float)x : (float)y : (float)w : (float)h : 
(int)gstateNum : (float)dx : (float)dy : (float)delta;

/*---------------------------------------------------------------------------*/
/* Drawing Text */

CGFontRef CGFontCreateWithPlatformFont(void *platformFontReference);
?
?

void CGContextSelectFont(
  CGContextRef ctx,
  const char *name,
  float size,
  CGTextEncoding textEncoding
);
?GSSetFont: [NSFont fontWithName:(NSString *)aFontName size:(float)fontSize];
{gs: font loading (and selectfont) is implemented in postscript}

void CGContextSetFont(CGContextRef ctx, CGFontRef font);
- (void) GSSetFont: (NSFont*)font;
int gs_setfont(gs_state * pgs, gs_font * pfont);

void CGContextSetFontSize(CGContextRef ctx, float size);
- (void) GSSetFontSize: (float)size;
/* NSFontManager: - (NSFont *)convertFont:(NSFont *)fontObject 
toSize:(float)size; */
int gs_scalefont(gs_font_dir * pdir, const gs_font * pfont, floatp scale, 
gs_font ** ppfont);

void CGContextSetCharacterSpacing(CGContextRef ctx, float spacing);
- (void) GSSetCharacterSpacing: (float)extra;
?

void CGContextSetTextDrawingMode(CGContextRef ctx, CGTextDrawingMode mode);
- (void) GSSetTextDrawingMode: (GSTextDrawingMode)mode;
?

void CGContextSetTextPosition(CGContextRef ctx, float x, float y);
- (void) GSSetTextPosition: (NSPoint)loc;
?

CGPoint CGContextGetTextPosition(CGContextRef ctx);
- (NSPoint) GSGetTextPosition;
?

void CGContextSetTextMatrix(CGContextRef ctx, CGAffineTransform transform);
- (void) GSSetTextCTM: (NSAffineTransform *)ctm;
?

CGAffineTransform CGContextGetTextMatrix(CGContextRef ctx);
- (NSAffineTransform *) GSGetTextCTM;
?

void CGContextShowText(CGContextRef ctx, const char *cstring, size_t length);
- (void) DPSashow: (float)x : (float)y : (const char*)s;
- (void) DPScharpath: (const char*)s : (int)b;
- (void) GSShowText: (const char *)string : (size_t) length;
?gs_show_next(gs_show_enum *penum); /*or*/ gs_text_process(gs_text_enum_t *pte);

void CGContextShowGlyphs(CGContextRef ctx, const CGGlyph *g, size_t count);
- (void) GSShowGlyphs: (const NSGlyph *)glyphs : (size_t) length;
gs:#define TEXT_FROM_GLYPHS          0x00008
int gs_text_begin(
  gs_state * pgs,
  const gs_text_params_t * text,
  gs_memory_t * mem,
  gs_text_enum_t ** ppte
);

void CGContextShowTextAtPoint(
  CGContextRef ctx,
  float x,
  float y,
  const char *cstring,
  size_t length
);

void CGContextShowGlyphsAtPoint(
  CGContextRef ctx,
  float x,
  float y,
  const CGGlyph *g,
  size_t count
);

/*---------------------------------------------------------------------------*/
/* Modifying Geometric Forms */

CGPoint CGPointMake(float x, float y);
NSPoint NSMakePoint(float x, float y);
?

CGSize CGSizeMake(float width, float height);
NSSize NSMakeSize(float w, float h);
?

CGRect CGRectMake(float x, float y, float width, float height);
NSRect NSMakeRect(float x, float y, float w, float h);
?

CGRect CGRectStandardize(CGRect rect);
?
?

CGRect CGRectInset(CGRect rect, float dx, float dy);
NSRect NSInsetRect(NSRect aRect, float dX, float dY);
?

CGRect CGRectOffset(CGRect rect, float dx, float dy);
NSRect NSOffsetRect(NSRect aRect, float dx, float dy);
?

CGRect CGRectIntegral(CGRect rect);
NSRect NSIntegralRect(NSRect aRect);
?

CGRect CGRectUnion(CGRect r1, CGRect r2);
NSRect NSUnionRect(NSRect aRect, NSRect bRect);
?

CGRect CGRectIntersection(CGRect r1, CGRect r2);
NSRect NSIntersectionRect(NSRect aRect, NSRect bRect);
?

void CGRectDivide(
  CGRect rect,
  CGRect *slice,
  CGRect *remainder,
  float amount,
  CGRectEdge edge
);
void NSDivideRect(
  NSRect aRect,
  NSRect *slice,
  NSRect *remainder,
  float amount,
  NSRectEdge edge
);
?

/*---------------------------------------------------------------------------*/
/* Accessing Geometric Attributes */

float CGRectGetMinX(CGRect rect);
float NSMinX(NSRect aRect);
?

float CGRectGetMidX(CGRect rect);
float NSMidX(NSRect aRect);
?

float CGRectGetMaxX(CGRect rect);
float NSMaxX(NSRect aRect);
?

float CGRectGetMinY(CGRect rect);
float NSMinY(NSRect aRect);
?

float CGRectGetMidY(CGRect rect);
float NSMidY(NSRect aRect);
?

float CGRectGetMaxY(CGRect rect);
float NSMaxY(NSRect aRect);
?

float CGRectGetWidth(CGRect rect);
float NSWidth(NSRect aRect);
?

float CGRectGetHeight(CGRect rect);
float NSHeight(NSRect aRect);
?

int CGRectIsNull(CGRect rect);
?
?

int CGRectIsEmpty(CGRect rect);
BOOL NSIsEmptyRect(NSRect aRect);
?

int CGRectIntersectsRect(CGRect rect1, CGRect rect2);
BOOL NSIntersectsRect(NSRect aRect, NSRect bRect);
?

int CGRectContainsRect(CGRect rect1, CGRect rect2);
BOOL NSContainsRect(NSRect aRect, NSRect bRect);
?

int CGRectContainsPoint(CGRect rect, CGPoint point);
BOOL NSPointInRect(NSPoint aPoint, NSRect aRect);
?

int CGRectEqualToRect(CGRect rect1, CGRect rect2);
BOOL NSEqualRects(NSRect aRect, NSRect bRect);
?

int CGSizeEqualToSize(CGSize size1, CGSize size2);
BOOL NSEqualSizes(NSSize aSize, NSSize bSize);
?

int CGPointEqualToPoint(CGPoint point1, CGPoint point2);
BOOL NSEqualPoints(NSPoint aPoint, NSPoint bPoint);
?

/*---------------------------------------------------------------------------*/
/* Affine Transform Utility Functions */

CGAffineTransform CGAffineTransformMake(
  float a,
  float b,
  float c,
  float d,
  float tx,
  float ty
);
NSAffineTransform: - (void) setTransformStruct: (NSAffineTransformStruct)val;
#define constant_matrix_body(xx, xy, yx, yy, tx, ty)\
  (float)(xx), (float)(xy), (float)(yx),\
  (float)(yy), (float)(tx), (float)(ty)

CGAffineTransform CGAffineTransformMakeTranslation(float tx, float ty);
?
int gs_make_translation(floatp dx, floatp dy, gs_matrix * pmat);

CGAffineTransform CGAffineTransformMakeScale(float sx, float sy);
?
int gs_make_scaling(floatp sx, floatp sy, gs_matrix * pmat);

CGAffineTransform CGAffineTransformMakeRotation(float angle); /* angle in rad */
?
int gs_make_rotation(floatp ang, gs_matrix * pmat) /* ang in deg! */

CGAffineTransform CGAffineTransformTranslate(CGAffineTransform t, float tx, 
float ty);
NSAffineTransform: - (void) translateXBy: (float)tranX yBy: (float)tranY;
int gs_matrix_translate(const gs_matrix * pm, floatp dx, floatp dy, gs_matrix * 
pmr);

CGAffineTransform CGAffineTransformScale(CGAffineTransform t, float sx, float 
sy);
NSAffineTransform: - (void) scaleXBy: (float)scaleX yBy: (float)scaleY;
int gs_matrix_scale(const gs_matrix * pm, floatp sx, floatp sy, gs_matrix * 
pmr);

CGAffineTransform CGAffineTransformRotate(CGAffineTransform t, float angle); /* 
angle in rad */
NSAffineTransform: - (void) rotateByRadians: (float)angleRad;
int gs_matrix_rotate(const gs_matrix * pm, floatp ang, gs_matrix * pmr); /* ang 
in deg! */

CGAffineTransform CGAffineTransformInvert(CGAffineTransform t);
NSAffineTransform: - (void) invert;
int gs_matrix_invert(const gs_matrix * pm, gs_matrix * pmr);

CGAffineTransform CGAffineTransformConcat(
  CGAffineTransform t1,
  CGAffineTransform t2
);
NSAffineTransform: - (void) concatenateWith: (NSAffineTransform*)anotherMatrix;
int gs_matrix_multiply(const gs_matrix * pm1, const gs_matrix * pm2, gs_matrix 
* pmr);

CGPoint CGPointApplyAffineTransform(CGPoint point, CGAffineTransform t);
NSAffineTransform: - (NSPoint) transformPoint: (NSPoint)aPoint;
int gs_point_transform(floatp x, floatp y, const gs_matrix * pmat, gs_point * 
ppt);

CGSize CGSizeApplyAffineTransform(CGSize size, CGAffineTransform t);
NSAffineTransform: - (NSSize) transformSize: (NSSize)aSize;
int gs_distance_transform(floatp dx, floatp dy, const gs_matrix * pmat, 
gs_point * pdpt);