转一个类： ESCursors提供了各种各样的箭头光标

 ESCursors提供了各种各样的箭头光标。
 
 特别是它提供旋转版本的游标其中NSCursor 不提供。 
  
 对于每一个游标类型有一个类方法提供了游标
 这些所谓的辅助方法，创造的Bézier路径
 形状，利用它的大小合适的黑色与白色的边界，
 旋转和缩放理想的规模和回报它作为NSCursor

1. //ESCursors.h
3. #import <Cocoa/Cocoa.h>
6. @interface ESCursors : NSObject {
7. }
10. #pragma mark CURVED CURSORS
12. /*
13.     CURVED CURSORS
15.     A cross shaped cursor whose horizontal stroke is slightly curved to the bottom.
16.     The options specify which of the arrows should exist, not all of them should be NO.
18.     The arrow heads in these cursors overlap which gives the right look at small size but looks bad at huge sizes.
20.     The third variant with an 'underlay' lets you pass an image that is drawn beneath the cursor image. 
21. */
23. + (NSBezierPath *) curvedCursorBezierPathWithRightArrow:(BOOL) rightArrow
24.                                                 upArrow:(BOOL) upArrow 
25.                                               leftArrow:(BOOL) leftArrow 
26.                                               downArrow: (BOOL) downArrow 
27.                                                forAngle: (CGFloat) angle;
29. + (NSCursor *) curvedCursorWithRightArrow:(BOOL) rightArrow 
30.                                   upArrow:(BOOL) upArrow 
31.                                 leftArrow:(BOOL) leftArrow downArrow: (BOOL) downArrow 
32.                                  forAngle: (CGFloat) angle 
33.                                      size: (CGFloat) size;
35. + (NSCursor *) curvedCursorWithRightArrow:(BOOL) rightArrow 
36.                                   upArrow:(BOOL) upArrow 
37.                                 leftArrow:(BOOL) leftArrow 
38.                                 downArrow: (BOOL) downArrow 
39.                                  forAngle: (CGFloat) angle 
40.                                      size: (CGFloat) size 
41.                                  underlay:(NSImage*) underlay;
45. #pragma mark STRAIGHT CURSORS
47. /*
48.     STRAIGHT CURSORS
49.     
50.     cross shaped
51.     threePronged (oriented like an upside-down T)
52.     right angle shaped (oriented like an L)
53.     straight line shaped (horizontal)
54.     semi-straight line shaped (horizontal, shorter and with a bar at the left end)
55. */
57. + (NSBezierPath *) crossCursorBezierPathForAngle: (CGFloat) angle;
58. + (NSCursor *) crossCursorForAngle: (CGFloat) angle withSize: (CGFloat) size;
60. + (NSBezierPath *) threeProngedCursorBezierPathForAngle: (CGFloat) angle;
61. + (NSCursor *) threeProngedCursorForAngle: (CGFloat) angle withSize: (CGFloat) size;
63. + (NSBezierPath *) angleCursorBezierPathForAngle: (CGFloat) angle;
64. + (NSCursor *) angleCursorForAngle: (CGFloat) angle withSize: (CGFloat) size;
66. + (NSBezierPath *) straightCursorBezierPathForAngle: (CGFloat) angle;
67. + (NSCursor *) straightCursorForAngle: (CGFloat) angle withSize: (CGFloat) size;
69. + (NSBezierPath *) halfStraightCursorBezierPathForAngle: (CGFloat) angle;
70. + (NSCursor *) halfStraightCursorForAngle: (CGFloat) angle withSize: (CGFloat) size;
75. #pragma mark HELPER METHODS
77. /* 
78.     HELPER METHODS
80.     to do the actual drawing.
81. */
82. + (NSCursor *) cursorForBezierPath: (NSBezierPath *) path 
83.                       withRotation: (CGFloat) angle 
84.                            andSize: (CGFloat) size;
86. + (NSCursor *) cursorForBezierPath: (NSBezierPath *) bP 
87.                       withRotation: (CGFloat) angle 
88.                               size: (CGFloat) size 
89.                        andUnderlay:(NSImage *) underlay;
90. @end

1. //  Cursors.m
2. //  NSBezierPath+Cursors.m
3. //  Copyright 2008 earthlingsoft. All rights reserved.
4. //
6. #import "ESCursors.h"
8. #define ARROWSIZE 0.525
9. #define LINETHICKNESS 0.18
12. @implementation ESCursors
14. #pragma mark CURVED CURSORS 
17. + (NSBezierPath *) curvedCursorBezierPathWithRightArrow:(BOOL) rightArrow upArrow:(BOOL) upArrow leftArrow:(BOOL) leftArrow downArrow: (BOOL) downArrow forAngle: (CGFloat) angle {
18.     const CGFloat handleFraction = 1.0 / 8.0;
19.     const CGFloat phi = pi / 20.0;
20.     NSAffineTransform * rotate = [NSAffineTransform transform];
21.     [rotate rotateByRadians:-phi];
22.     NSAffineTransform * rotate2 = [NSAffineTransform transform];
23.     [rotate2 rotateByRadians:-2.0 * phi];
24.     NSPoint pt;
25.     
26.     // left / right end points
27.     const NSPoint p1 = NSMakePoint(1.0, - sin(phi));
28.     const NSPoint p20 = NSMakePoint(-p1.x, p1.y);
29.     
30.     // left / right arrow top corner
31.     pt = [rotate transformPoint: NSMakePoint(-ARROWSIZE, ARROWSIZE)];
32.     const NSPoint p2 = NSMakePoint(p1.x + pt.x, p1.y + pt.y);
33.     const NSPoint p19 = NSMakePoint(-p2.x, p2.y);
34.     const NSPoint p38 = NSMakePoint(p1.x - pt.y, p1.y + pt.x);
35.     const NSPoint p21 = NSMakePoint(-p38.x, p38.y);
36.     
37.     // left/ right arrow bottom corner
38.     pt = [rotate transformPoint: NSMakePoint(0.0,  -(ARROWSIZE - LINETHICKNESS))];
39.     const NSPoint p3 = NSMakePoint(p2.x +  pt.x, p2.y + pt.y);
40.     const NSPoint p18 = NSMakePoint(-p3.x, p3.y);
41.     const NSPoint p37 = NSMakePoint(p38.x - pt.x, p38.y - pt.y);
42.     const NSPoint p22 = NSMakePoint(-p37.x, p37.y);
43.     
44.     // start handles for Bezier path
45.     pt = [rotate2 transformPoint: NSMakePoint(-handleFraction, 0.0)];
46.     const NSPoint p4 = NSMakePoint(p3.x + pt.x * 1.1, p3.y + pt.y * 1.1);
47.     const NSPoint p17 = NSMakePoint(-p4.x, p4.y);
48.     const NSPoint p36 = NSMakePoint(p37.x + pt.x * 0.9, p37.y + pt.y * 0.9);
49.     const NSPoint p23 = NSMakePoint(-p36.x, p36.y); 
50.     
51.     // off centre arrive point for Bezier path
52.     const CGFloat theta = asin(LINETHICKNESS);
53.     CGFloat correction = (1 - cos(theta));
54.     const NSPoint p7 = NSMakePoint(LINETHICKNESS, LINETHICKNESS - correction);
55.     const NSPoint p14 = NSMakePoint(-LINETHICKNESS, p7.y);
56.     const NSPoint p33 = NSMakePoint(LINETHICKNESS, - LINETHICKNESS - correction);
57.     const NSPoint p26 = NSMakePoint(-LINETHICKNESS, p33.y);
59.     // off centre arrive handles for Bezier path
60.     correction = 0.0;
61.     const NSPoint p5 = NSMakePoint(p7.x + 0.9 * handleFraction, p7.y - correction);
62.     const NSPoint p16 = NSMakePoint(- p5.x, p5.y);
63.     const NSPoint p35 = NSMakePoint(p33.x + 0.81 * handleFraction, p33.y - correction);
64.     const NSPoint p24 = NSMakePoint(-p35.x, p35.y);
65.     
66.     // central points and handles for Bezier path
67.     const NSPoint p8 = NSMakePoint(0.0, LINETHICKNESS);
68.     const NSPoint p27 = NSMakePoint(0.0, -LINETHICKNESS);
69.     const NSPoint p6 = NSMakePoint(handleFraction, LINETHICKNESS);
70.     const NSPoint p15 = NSMakePoint(-handleFraction, LINETHICKNESS);
71.     const NSPoint p34 = NSMakePoint(handleFraction, LINETHICKNESS);
72.     const NSPoint p25 = NSMakePoint(-handleFraction, LINETHICKNESS);
73.     
74.     // up arrow 
75.     NSPoint upArrowPoints [6];
76.     upArrowPoints[0] = NSMakePoint(LINETHICKNESS, 1.0 - ARROWSIZE);
77.     upArrowPoints[1] = NSMakePoint(ARROWSIZE, 1.0 - ARROWSIZE);
78.     upArrowPoints[2] = NSMakePoint(0.0, 1.0);
79.     upArrowPoints[3] = NSMakePoint(- ARROWSIZE, 1.0 - ARROWSIZE);
80.     upArrowPoints[4] = NSMakePoint(-LINETHICKNESS, 1.0 - ARROWSIZE);
81.     upArrowPoints[5] = p14;
82.     
83.     // down arrow
84.     NSPoint downArrowPoints [6];
85.     downArrowPoints[0] = NSMakePoint(-LINETHICKNESS, -1.0 + ARROWSIZE);
86.     downArrowPoints[1] = NSMakePoint(-ARROWSIZE, -1.0 + ARROWSIZE);
87.     downArrowPoints[2] = NSMakePoint(0.0, -1.0);
88.     downArrowPoints[3] = NSMakePoint(ARROWSIZE, -1.0 + ARROWSIZE);
89.     downArrowPoints[4] = NSMakePoint(LINETHICKNESS, -1.0 + ARROWSIZE);
90.     downArrowPoints[5] = p33;
91.     
92.     // now draw the paths
93.     NSBezierPath * bP = [NSBezierPath bezierPath];
94.     
95.     if (rightArrow) {
96.         [bP moveToPoint:p1];
97.         [bP lineToPoint:p2];
98.         [bP lineToPoint:p3];
99.         if (upArrow || !leftArrow) {
100.             // we are not drawing the long curve
101.             [bP curveToPoint:p7 controlPoint1:p4 controlPoint2:p5];
102.         }
103.         else {
104.             // we are going all the way to the left
105.             [bP curveToPoint:p8 controlPoint1:p4 controlPoint2:p6];
106.             [bP curveToPoint:p18 controlPoint1:p15 controlPoint2:p17];
107.         }
108.     }
109.     else {
110.         // there is no right arrow, begin at p7
111.         [bP moveToPoint:p7];
112.     }
113.     
114.     if (upArrow) {
115.         // we are at p7 now, draw the arrow
116.         [bP appendBezierPathWithPoints:upArrowPoints count:6];
117.     }
118.     else if (!upArrow && (!rightArrow || ! leftArrow) && !(rightArrow && leftArrow)) {
119.         // just move on in a straight line
120.         [bP lineToPoint:p14];
121.     }
122.     // we already covered the !upArrow && leftArrow situation above
123.     
124.     
125.     if (leftArrow) {
126.         if (upArrow || (!upArrow && !rightArrow)) {
127.             // we are at p14 and draw line to the the left arrow
128.             [bP curveToPoint:p18 controlPoint1:p16 controlPoint2:p17];
129.         }
130.         
131.         // We're at p18 now and draw the arrow tip itself
132.         [bP lineToPoint:p19];
133.         [bP lineToPoint:p20];
134.         [bP lineToPoint:p21];
135.         [bP lineToPoint:p22];
137.         if (downArrow || !rightArrow) {
138.             // we need to go to p26
139.             [bP curveToPoint:p26 controlPoint1:p23 controlPoint2:p24];
140.         }
141.         else {
142.             // we need to stroke all the way to the right arrow
143.             [bP curveToPoint:p27 controlPoint1:p23 controlPoint2:p25];
144.             [bP curveToPoint:p37 controlPoint1:p34 controlPoint2:p36];
145.         }
146.     
147.     }
150.     if (downArrow) {
151.         // we are at p26 (if leftArrow) or p14 (if !leftArrow) now, insert the arrow
152.         [bP appendBezierPathWithPoints:downArrowPoints count:6];
153.     }
154.     else {
155.         if (leftArrow) {
156.             if (!rightArrow) {
157.                 // we are at p26, move to p33
158.                 [bP lineToPoint:p33];
159.             }
160.         }
161.         else {
162.             // we are at p14, stroke to p33
163.             [bP lineToPoint:p26];
164.             [bP lineToPoint:p33];
165.         }
166.     }
167.     
168.     if (rightArrow) {
169.         if (! (leftArrow && !downArrow)) {
170.             // we are at p33, curve to p37
171.             [bP curveToPoint:p37 controlPoint1:p35 controlPoint2:p36];
172.         }
173.         // finishing stroke
174.         [bP lineToPoint:p38];
175.     }
176.     // if !rightArrow we started at p7
177.     
178.     // close path to get the missing stroke
179.     [bP closePath];
180.     
181.     return bP;
182.     }
183.     
184.     
185.     
186. + (NSCursor *) curvedCursorWithRightArrow:(BOOL) rightArrow upArrow:(BOOL) upArrow leftArrow:(BOOL) leftArrow downArrow: (BOOL) downArrow forAngle: (CGFloat) angle size: (CGFloat) size {
187.     NSBezierPath * bP = [ESCursors curvedCursorBezierPathWithRightArrow:rightArrow upArrow:upArrow leftArrow:leftArrow downArrow:downArrow forAngle: angle];
188.     
189.     return [ESCursors cursorForBezierPath:bP withRotation: angle andSize: size];        
190. }
193. + (NSCursor *) curvedCursorWithRightArrow:(BOOL) rightArrow upArrow:(BOOL) upArrow leftArrow:(BOOL) leftArrow downArrow: (BOOL) downArrow forAngle: (CGFloat) angle size: (CGFloat) size underlay:(NSImage*) underlay {
194.     NSBezierPath * bP = [ESCursors curvedCursorBezierPathWithRightArrow:rightArrow upArrow:upArrow leftArrow:leftArrow downArrow:downArrow forAngle: angle];
195.     
196.     return [ESCursors cursorForBezierPath:bP withRotation: angle size: size andUnderlay: underlay];     
197. }
202. #pragma mark CROSSED CURSORS
204. + (NSBezierPath *) crossCursorBezierPathForAngle: (CGFloat) angle {
205.     NSPoint pointArray[6];
206.     pointArray[0] = NSMakePoint(1.0 - ARROWSIZE, ARROWSIZE);
207.     pointArray[1] = NSMakePoint(1.0 - ARROWSIZE, LINETHICKNESS);
208.     pointArray[2] = NSMakePoint(LINETHICKNESS, LINETHICKNESS);
209.     pointArray[3] = NSMakePoint(LINETHICKNESS, 1.0 - ARROWSIZE);
210.     pointArray[4] = NSMakePoint(ARROWSIZE, 1.0 - ARROWSIZE);
211.     pointArray[5] = NSMakePoint(0.0, 1.0);
212.     
213.     NSBezierPath * bP = [NSBezierPath bezierPath];
214.     [bP moveToPoint:NSMakePoint(1.0, 0.0)];
215.     
216.     NSAffineTransform * aT = [NSAffineTransform transform];
217.     [aT rotateByDegrees:-90.0];
219.     for (NSUInteger i=0; i<4; i++) {
220.         [bP appendBezierPathWithPoints:pointArray count:6];
221.         [bP transformUsingAffineTransform:aT];
222.     }
223.     
224.     [bP closePath];
225.     
226.     return bP;
227. }
231. + (NSCursor *) crossCursorForAngle: (CGFloat) angle withSize: (CGFloat) size {
232.     NSBezierPath * bP = [ESCursors crossCursorBezierPathForAngle: angle];
233.     
234.     return [ESCursors cursorForBezierPath:bP withRotation: angle andSize: size];    
235. }
240. #pragma mark THREE PRONGED CURSORS
243. + (NSBezierPath *) threeProngedCursorBezierPathForAngle: (CGFloat) angle {
244.     NSPoint pointArray[17];
245.     pointArray[0] = NSMakePoint(1.0 - ARROWSIZE, ARROWSIZE);
246.     pointArray[1] = NSMakePoint(1.0 - ARROWSIZE, LINETHICKNESS);
247.     pointArray[2] = NSMakePoint(LINETHICKNESS, LINETHICKNESS);
248.     pointArray[3] = NSMakePoint(LINETHICKNESS, 1.0 - ARROWSIZE);
249.     pointArray[4] = NSMakePoint(ARROWSIZE, 1.0 - ARROWSIZE);
250.     pointArray[5] = NSMakePoint(0.0, 1.0);
251.     pointArray[6] = NSMakePoint(- ARROWSIZE, 1.0 - ARROWSIZE);
252.     pointArray[7] = NSMakePoint(- LINETHICKNESS, 1.0 - ARROWSIZE);
253.     pointArray[8] = NSMakePoint(- LINETHICKNESS, LINETHICKNESS);
254.     pointArray[9] = NSMakePoint(-1.0 + ARROWSIZE, LINETHICKNESS);
255.     pointArray[10] = NSMakePoint(-1.0 + ARROWSIZE, ARROWSIZE);
256.     pointArray[11] = NSMakePoint(-1.0 , 0.0);
257.     pointArray[12] = NSMakePoint(- ARROWSIZE, - ARROWSIZE);
258.     pointArray[13] = NSMakePoint(- ARROWSIZE, - LINETHICKNESS);
259.     pointArray[14] = NSMakePoint(1.0 - ARROWSIZE, - LINETHICKNESS);
260.     pointArray[15] = NSMakePoint(1.0 - ARROWSIZE, - ARROWSIZE);
261.     pointArray[16] = NSMakePoint(1.0, 0.0);
262.     
263.     NSBezierPath * bP = [NSBezierPath bezierPath];
264.     
265.     [bP appendBezierPathWithPoints:pointArray count:17];
266.     [bP closePath];
267.     
268.     return bP;
269. }
273. + (NSCursor *) threeProngedCursorForAngle: (CGFloat) angle withSize: (CGFloat) size {
274.     NSBezierPath * bP = [ESCursors threeProngedCursorBezierPathForAngle: angle];
275.     
276.     return [ESCursors cursorForBezierPath: bP withRotation: angle andSize: size];   
277. }
282. #pragma mark ANGLE CURSORS
285. + (NSBezierPath *) angleCursorBezierPathForAngle: (CGFloat) angle {
286.     NSPoint pointArray[12];
287.     pointArray[0] = NSMakePoint(1.0 - ARROWSIZE, ARROWSIZE);
288.     pointArray[1] = NSMakePoint(1.0 - ARROWSIZE, LINETHICKNESS);
289.     pointArray[2] = NSMakePoint(LINETHICKNESS, LINETHICKNESS);
290.     pointArray[3] = NSMakePoint(LINETHICKNESS, 1.0 - ARROWSIZE);
291.     pointArray[4] = NSMakePoint(ARROWSIZE, 1.0 - ARROWSIZE);
292.     pointArray[5] = NSMakePoint(0.0, 1.0);
293.     pointArray[6] = NSMakePoint(- ARROWSIZE, 1.0 - ARROWSIZE);
294.     pointArray[7] = NSMakePoint(- LINETHICKNESS, 1.0 - ARROWSIZE);
295.     pointArray[8] = NSMakePoint(- LINETHICKNESS, -LINETHICKNESS);
296.     pointArray[9] = NSMakePoint(1.0 - ARROWSIZE, - LINETHICKNESS);
297.     pointArray[10] = NSMakePoint(1.0 - ARROWSIZE, - ARROWSIZE);
298.     pointArray[11] = NSMakePoint(1.0, 0.0);
299.     
300.     NSBezierPath * bP = [NSBezierPath bezierPath];
301.     
302.     [bP appendBezierPathWithPoints:pointArray count:12];
303.     [bP closePath];
304.     
305.     return bP;
306. }
310. + (NSCursor *) angleCursorForAngle: (CGFloat) angle withSize: (CGFloat) size {
311.     NSBezierPath * bP = [ESCursors angleCursorBezierPathForAngle: angle];
312.     
313.     return [ESCursors cursorForBezierPath: bP withRotation: angle andSize: size];   
314. }
318. #pragma mark STRAIGHT CURSORS
320. + (NSBezierPath *) straightCursorBezierPathForAngle: (CGFloat) angle {
321.     NSPoint pointArray[5];
322.     pointArray[0] = NSMakePoint(1.0 - ARROWSIZE, ARROWSIZE);
323.     pointArray[1] = NSMakePoint(1.0 - ARROWSIZE, LINETHICKNESS);
324.     pointArray[2] = NSMakePoint(-1.0 + ARROWSIZE, LINETHICKNESS);
325.     pointArray[3] = NSMakePoint(-1.0 + ARROWSIZE, ARROWSIZE);
326.     pointArray[4] = NSMakePoint(-1.0, 0.0);
327.     
328.     NSBezierPath * bP = [NSBezierPath bezierPath];
329.     [bP moveToPoint:NSMakePoint(1.0, 0.0)];
330.     
331.     NSAffineTransform * aT = [NSAffineTransform transform];
332.     [aT rotateByDegrees:180.0];
333.     
334.     [bP appendBezierPathWithPoints:pointArray count:5];
335.     [bP transformUsingAffineTransform:aT];
336.     [bP appendBezierPathWithPoints:pointArray count:5];
337.     [bP closePath];
338.     
339.     return bP;
340. }
344. + (NSCursor *) straightCursorForAngle: (CGFloat) angle withSize: (CGFloat) size {
345.     NSBezierPath * bP = [ESCursors straightCursorBezierPathForAngle: angle];
346.     
347.     return [ESCursors cursorForBezierPath: bP withRotation: angle andSize: size];   
348. }
353. + (NSBezierPath *) halfStraightCursorBezierPathForAngle: (CGFloat) angle {
354.     NSPoint pointArray[10];
355.     pointArray[0] = NSMakePoint(1.0 - ARROWSIZE, ARROWSIZE);
356.     pointArray[1] = NSMakePoint(1.0 - ARROWSIZE, LINETHICKNESS);
357.     pointArray[2] = NSMakePoint(-0.2 * LINETHICKNESS, LINETHICKNESS);
358.     pointArray[3] = NSMakePoint(-0.2 * LINETHICKNESS, 1.0);
359.     pointArray[4] = NSMakePoint(- 2.5 * LINETHICKNESS, 1.0);
360.     pointArray[5] = NSMakePoint(- 2.5 * LINETHICKNESS, -1.0);
361.     pointArray[6] = NSMakePoint(-0.2 * LINETHICKNESS, - 1.0);
362.     pointArray[7] = NSMakePoint(-0.2 * LINETHICKNESS, - LINETHICKNESS);
363.     pointArray[8] = NSMakePoint(1.0 - ARROWSIZE, - LINETHICKNESS);
364.     pointArray[9] = NSMakePoint(1.0 - ARROWSIZE, - ARROWSIZE);
365.     
366.     NSBezierPath * bP = [NSBezierPath bezierPath];
367.     [bP moveToPoint:NSMakePoint(1.0, 0.0)];
368.     
369.     [bP appendBezierPathWithPoints:pointArray count:10];
370.     [bP closePath];
371.     
372.     return bP;
373. }
377. + (NSCursor *) halfStraightCursorForAngle: (CGFloat) angle withSize: (CGFloat) size {
378.     NSBezierPath * bP = [ESCursors halfStraightCursorBezierPathForAngle: angle];
379.     
380.     return [ESCursors cursorForBezierPath: bP withRotation: angle andSize: size];   
381. }
385. #pragma mark HELPER METHODS
387. #define OUTLINEWIDTH 1.0
389. + (NSCursor *) cursorForBezierPath: (NSBezierPath *) bP withRotation: (CGFloat) angle andSize: (CGFloat) size {
390.     return [ESCursors  cursorForBezierPath: bP withRotation: angle size: size andUnderlay:nil];
391. }
394. + (NSCursor *) cursorForBezierPath: (NSBezierPath *) bP withRotation: (CGFloat) angle size: (CGFloat) size andUnderlay:(NSImage *) underlay {
395.     // NSLog(@"Redrawing cursor");
396.     const CGFloat s = size * sqrt(2.0);     
398.     NSAffineTransform * aT = [NSAffineTransform transform];
399.     [aT rotateByRadians:angle];
400.     [aT scaleBy:size / 2.0 ];
401.     [bP transformUsingAffineTransform:aT];
402.     
403.     aT = [NSAffineTransform transform];
404.     [aT translateXBy: s/2.0 + 0.65 yBy: s/2.0 + 0.65];
405.     [bP transformUsingAffineTransform:aT];
406.     
407.     NSImage * image = [[NSImage alloc] initWithSize:NSMakeSize(s, s)];
408.     [image lockFocus];
409.     if (underlay) {
410.         [underlay compositeToPoint:NSMakePoint(s/2.0 - underlay.size.width / 2.0 + 0.65, s/2.0 - underlay.size.height/2.0 + 0.65) operation:NSCompositeCopy];
411.     }
412.     [[NSColor blackColor] set];
413.     [bP fill];
414.     [[NSColor whiteColor] set];
415.     bP.lineWidth = 1.0;
416.     [bP stroke];
417.     // [bP drawPointsAndHandles];
418.     [image unlockFocus];
419.     
420.     NSCursor * theCursor = [[NSCursor alloc] initWithImage:image hotSpot:NSMakePoint(s/2.0, s/2.0)];
421.     
422.     return theCursor;
423. }
426. @end