251 }
252 else if (c1 > c2)
253 {
254 *out++ = c1 - ((c1-c2)*range);
255 }
256 else// if (c1 < c2)
257 {
258 *out++ = c1 + ((c2-c1)*range);
259 }
260 }
261 }
262 }
263
264 // this function MUST NOT be inlined!
265 void gradientPaintReleaseFunction(void *info)
266 {
267 PRINT(" gradientPaintReleaseFunction")
268 free(info);
269 }
270
271 static inline void contextGradientPath(QuartzSDOps* qsdo)
272 {
273 PRINT(" ContextGradientPath")
274 CGContextRef cgRef = qsdo->cgRef;
275 StateShadingInfo* shadingInfo = qsdo->shadingInfo;
276
277 CGRect bounds = CGContextGetClipBoundingBox(cgRef);
278
279 static const CGFloat domain[2] = {0.0f, 1.0f};
280 static const CGFloat range[8] = {0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};
281 CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
282 CGFunctionRef shadingFunc = NULL;
283 CGShadingRef shading = NULL;
284 if (shadingInfo->cyclic == NO)
285 {
286 static const CGFunctionCallbacks callbacks = {0, &gradientLinearPaintEvaluateFunction, &gradientPaintReleaseFunction};
287 shadingFunc = CGFunctionCreate((void *)shadingInfo, 1, domain, 4, range, &callbacks);
288 shading = CGShadingCreateAxial(colorspace, shadingInfo->start, shadingInfo->end, shadingFunc, 1, 1);
289 }
290 else
291 {
292 //fprintf(stderr, "BOUNDING BOX x1=%f, y1=%f x2=%f, y2=%f\n", bounds.origin.x, bounds.origin.y, bounds.origin.x+bounds.size.width, bounds.origin.y+bounds.size.height);
293 // need to extend the line start-end
810 }
811
812 BOOL cocoaPaint = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorSystem);
813 BOOL complexPaint = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorGradient) ||
814 (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorTexture);
815 if ((everyThingChanged == YES) || (paintChanged == YES) || (cocoaPaint == YES) || (complexPaint == YES))
816 {
817 // rdar://problem/5214320
818 // Gradient fills of Java GeneralPath don't respect the even odd winding rule (quartz pipeline).
819 // Notice the side effect of the stmt after this if-block.
820 if (renderType == SD_EOFill) {
821 qsdo->isEvenOddFill = YES;
822 }
823
824 renderType = SetUpPaint(env, qsdo, renderType);
825 }
826
827 qsdo->renderType = renderType;
828 }
829
830 SDRenderType SetUpPaint(JNIEnv *env, QuartzSDOps *qsdo, SDRenderType renderType)
831 {
832 CGContextRef cgRef = qsdo->cgRef;
833
834 jint *javaGraphicsStates = qsdo->javaGraphicsStates;
835 jfloat *javaFloatGraphicsStates = (jfloat*)(qsdo->javaGraphicsStates);
836
837 static const CGFloat kColorConversionMultiplier = 1.0f/255.0f;
838 jint colorState = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex];
839
840 switch (colorState)
841 {
842 case sun_java2d_OSXSurfaceData_kColorSimple:
843 {
844 if (qsdo->graphicsStateInfo.simpleColor == NO)
845 {
846 setDefaultColorSpace(cgRef);
847 }
848 qsdo->graphicsStateInfo.simpleColor = YES;
849
881 renderType = SD_Shade;
882
883 qsdo->shadingInfo->start.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx1Index];
884 qsdo->shadingInfo->start.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory1Index];
885 qsdo->shadingInfo->end.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx2Index];
886 qsdo->shadingInfo->end.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory2Index];
887 jint c1 = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorRGBValue1Index];
888 qsdo->shadingInfo->colors[0] = ((c1>>16)&0xff)*kColorConversionMultiplier;
889 qsdo->shadingInfo->colors[1] = ((c1>>8)&0xff)*kColorConversionMultiplier;
890 qsdo->shadingInfo->colors[2] = ((c1>>0)&0xff)*kColorConversionMultiplier;
891 qsdo->shadingInfo->colors[3] = ((c1>>24)&0xff)*kColorConversionMultiplier;
892 jint c2 = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorRGBValue2Index];
893 qsdo->shadingInfo->colors[4] = ((c2>>16)&0xff)*kColorConversionMultiplier;
894 qsdo->shadingInfo->colors[5] = ((c2>>8)&0xff)*kColorConversionMultiplier;
895 qsdo->shadingInfo->colors[6] = ((c2>>0)&0xff)*kColorConversionMultiplier;
896 qsdo->shadingInfo->colors[7] = ((c2>>24)&0xff)*kColorConversionMultiplier;
897 qsdo->shadingInfo->cyclic = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorIsCyclicIndex] == sun_java2d_OSXSurfaceData_kColorCyclic);
898
899 break;
900 }
901 case sun_java2d_OSXSurfaceData_kColorTexture:
902 {
903 qsdo->patternInfo = (StatePatternInfo*)malloc(sizeof(StatePatternInfo));
904 if (qsdo->patternInfo == NULL)
905 {
906 [JNFException raise:env as:kOutOfMemoryError reason:"Failed to malloc memory for texture paint"];
907 }
908
909 qsdo->graphicsStateInfo.simpleStroke = NO;
910 qsdo->graphicsStateInfo.simpleColor = NO;
911
912 renderType = SD_Pattern;
913
914 qsdo->patternInfo->tx = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColortxIndex];
915 qsdo->patternInfo->ty = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColortyIndex];
916 qsdo->patternInfo->sx = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorsxIndex];
917 if (qsdo->patternInfo->sx == 0.0f)
918 {
919 return SD_Fill; // 0 is an invalid value, fill argb rect
920 }
1059 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1060 {
1061 CGContextStrokePath(qsdo->cgRef);
1062 }
1063 break;
1064
1065 case SD_Fill:
1066 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1067 {
1068 CGContextFillPath(qsdo->cgRef);
1069 }
1070 break;
1071
1072 case SD_Shade:
1073 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1074 {
1075 contextGradientPath(qsdo);
1076 }
1077 break;
1078
1079 case SD_Pattern:
1080 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1081 {
1082 //TODO:BG
1083 //contextTexturePath(env, qsdo);
1084 }
1085 break;
1086
1087 case SD_EOFill:
1088 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1089 {
1090 CGContextEOFillPath(qsdo->cgRef);
1091 }
1092 break;
1093
1094 case SD_Image:
1095 break;
1096
1097 case SD_Text:
1098 break;
1099
1100 case SD_CopyArea:
1101 break;
1102
1103 case SD_Queue:
1104 break;
1105
1106 case SD_External:
1107 break;
1108 }
1109
1110 if (qsdo->shadingInfo != NULL) {
1111 gradientPaintReleaseFunction(qsdo->shadingInfo);
1112 qsdo->shadingInfo = NULL;
1113 }
1114 }
|
251 }
252 else if (c1 > c2)
253 {
254 *out++ = c1 - ((c1-c2)*range);
255 }
256 else// if (c1 < c2)
257 {
258 *out++ = c1 + ((c2-c1)*range);
259 }
260 }
261 }
262 }
263
264 // this function MUST NOT be inlined!
265 void gradientPaintReleaseFunction(void *info)
266 {
267 PRINT(" gradientPaintReleaseFunction")
268 free(info);
269 }
270
271 static inline void contextQuartzLinearGradientPath(QuartzSDOps* qsdo)
272 {
273
274 PRINT(" contextQuartzLinearGradientPath");
275
276 CGContextRef cgRef = qsdo->cgRef;
277 StateGradientInfo *gradientInfo = qsdo->gradientInfo;
278
279 CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
280 size_t num_locations = gradientInfo->fractionsLength;
281 CGFloat *locations = (CGFloat *) malloc(sizeof(CGFloat) * num_locations);
282 int i = 0;
283 size_t component_size = num_locations * 4;
284 CGFloat components[component_size];
285 CGGradientRef gradient = NULL;
286
287 for (int i = 0; i < num_locations; i++) {
288 locations[i] = gradientInfo->fractionsdata[i];
289 //fprintf(stderr, "locations[%d] %f\n", i, locations[i]);
290 }
291 for (i = 0; i < component_size; i++) {
292 components[i] = gradientInfo->colordata[i];
293 //fprintf(stderr, "components[%d] %f, gradientInfo->colordata[%d] %f\n",
294 // i, components[i], i, gradientInfo->colordata[i]);
295 }
296 CGContextSaveGState(cgRef);
297 gradient = CGGradientCreateWithColorComponents(colorspace, components, locations, num_locations);
298 //fprintf(stderr, "gradientInfo->start.x %f, gradientInfo->start.y %f\n",
299 // gradientInfo->start.x, gradientInfo->start.y);
300 //fprintf(stderr, "gradientInfo->end.x %f, gradientInfo->end.y %f\n",
301 // gradientInfo->end.x, gradientInfo->end.y);
302 if (qsdo->isEvenOddFill) {
303 CGContextEOClip(cgRef);
304 } else {
305 CGContextClip(cgRef);
306 }
307 CGContextDrawLinearGradient(cgRef, gradient, gradientInfo->start, gradientInfo->end, kCGGradientDrawsAfterEndLocation);
308
309 CGContextRestoreGState(cgRef);
310 CGColorSpaceRelease(colorspace);
311 CGGradientRelease(gradient);
312 free(locations);
313 free(gradientInfo->colordata);
314 free(gradientInfo->fractionsdata);
315 }
316
317 static inline void contextQuartzRadialGradientPath(QuartzSDOps* qsdo)
318 {
319
320 PRINT(" contextQuartzRadialGradientPath");
321
322 CGContextRef cgRef = qsdo->cgRef;
323 StateGradientInfo *gradientInfo = qsdo->gradientInfo;
324
325 CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
326 size_t num_locations = gradientInfo->fractionsLength;
327 CGFloat *locations = (CGFloat *) malloc(sizeof(CGFloat) * num_locations);
328 int i = 0;
329 size_t component_size = num_locations * 4;
330 CGFloat components[component_size];
331 CGGradientRef gradient = NULL;
332 CGFloat startRadius = gradientInfo->radius;
333 CGFloat endRadius = gradientInfo->radius;
334
335 for (int i = 0; i < num_locations; i++) {
336 locations[i] = gradientInfo->fractionsdata[i];
337 //fprintf(stderr, "locations[%d] %f\n", i, locations[i]);
338 }
339 for (i = 0; i < component_size; i++) {
340 components[i] = gradientInfo->colordata[i];
341 //fprintf(stderr, "components[%d] %f, gradientInfo->colordata[%d] %f\n",
342 // i, components[i], i, gradientInfo->colordata[i]);
343 }
344 CGContextSaveGState(cgRef);
345 gradient = CGGradientCreateWithColorComponents(colorspace, components, locations, num_locations);
346 //fprintf(stderr, "gradientInfo->start.x %f, gradientInfo->start.y %f\n",
347 // gradientInfo->start.x, gradientInfo->start.y);
348 //fprintf(stderr, "gradientInfo->end.x %f, gradientInfo->end.y %f\n",
349 // gradientInfo->end.x, gradientInfo->end.y);
350 if (qsdo->isEvenOddFill) {
351 CGContextEOClip(cgRef);
352 } else {
353 CGContextClip(cgRef);
354 }
355 //fprintf(stderr, "gradientInfo->startRadius %f, gradientInfo->endRadius %f\n",startRadius,endRadius);
356 CGContextDrawRadialGradient(cgRef, gradient, gradientInfo->start, 0, gradientInfo->end, endRadius, kCGGradientDrawsAfterEndLocation);
357
358 CGContextRestoreGState(cgRef);
359 CGColorSpaceRelease(colorspace);
360 CGGradientRelease(gradient);
361 free(locations);
362 free(gradientInfo->colordata);
363 free(gradientInfo->fractionsdata);
364 }
365
366 static inline void contextGradientPath(QuartzSDOps* qsdo)
367 {
368 PRINT(" ContextGradientPath")
369
370 CGContextRef cgRef = qsdo->cgRef;
371 StateShadingInfo* shadingInfo = qsdo->shadingInfo;
372
373 CGRect bounds = CGContextGetClipBoundingBox(cgRef);
374
375 static const CGFloat domain[2] = {0.0f, 1.0f};
376 static const CGFloat range[8] = {0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f};
377 CGColorSpaceRef colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
378 CGFunctionRef shadingFunc = NULL;
379 CGShadingRef shading = NULL;
380 if (shadingInfo->cyclic == NO)
381 {
382 static const CGFunctionCallbacks callbacks = {0, &gradientLinearPaintEvaluateFunction, &gradientPaintReleaseFunction};
383 shadingFunc = CGFunctionCreate((void *)shadingInfo, 1, domain, 4, range, &callbacks);
384 shading = CGShadingCreateAxial(colorspace, shadingInfo->start, shadingInfo->end, shadingFunc, 1, 1);
385 }
386 else
387 {
388 //fprintf(stderr, "BOUNDING BOX x1=%f, y1=%f x2=%f, y2=%f\n", bounds.origin.x, bounds.origin.y, bounds.origin.x+bounds.size.width, bounds.origin.y+bounds.size.height);
389 // need to extend the line start-end
906 }
907
908 BOOL cocoaPaint = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorSystem);
909 BOOL complexPaint = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorGradient) ||
910 (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex] == sun_java2d_OSXSurfaceData_kColorTexture);
911 if ((everyThingChanged == YES) || (paintChanged == YES) || (cocoaPaint == YES) || (complexPaint == YES))
912 {
913 // rdar://problem/5214320
914 // Gradient fills of Java GeneralPath don't respect the even odd winding rule (quartz pipeline).
915 // Notice the side effect of the stmt after this if-block.
916 if (renderType == SD_EOFill) {
917 qsdo->isEvenOddFill = YES;
918 }
919
920 renderType = SetUpPaint(env, qsdo, renderType);
921 }
922
923 qsdo->renderType = renderType;
924 }
925
926 void setupGradient(JNIEnv *env, QuartzSDOps* qsdo, jfloat* javaFloatGraphicsStates)
927 {
928 static const CGFloat kColorConversionMultiplier = 1.0f/255.0f;
929 qsdo->gradientInfo = (StateGradientInfo*)malloc(sizeof(StateGradientInfo));
930 if (qsdo->gradientInfo == NULL)
931 {
932 [JNFException raise:env as:kOutOfMemoryError reason:"Failed to malloc memory for gradient paint"];
933 }
934
935 qsdo->graphicsStateInfo.simpleStroke = NO;
936 qsdo->graphicsStateInfo.simpleColor = NO;
937
938 qsdo->gradientInfo->start.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx1Index];
939 qsdo->gradientInfo->start.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory1Index];
940 qsdo->gradientInfo->end.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx2Index];
941 qsdo->gradientInfo->end.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory2Index];
942
943 jobject colorArray = ((*env)->GetObjectArrayElement(env, qsdo->javaGraphicsStatesObjects, sun_java2d_OSXSurfaceData_kColorArrayIndex));
944 if (colorArray != NULL)
945 {
946 jint length = (*env)->GetArrayLength(env, colorArray);
947 //fprintf(stderr, "length %d\n", length);
948
949 jint* jcolorData = (jint*)(*env)->GetPrimitiveArrayCritical(env, colorArray, NULL);
950 CGFloat* colors= (CGFloat*)calloc(0, sizeof(CGFloat)*length);
951 if (jcolorData != NULL)
952 {
953 jint i;
954 for (i=0; i<length; i++)
955 {
956 colors[i] = (CGFloat)jcolorData[i];
957 }
958 }
959 (*env)->ReleasePrimitiveArrayCritical(env, colorArray, jcolorData, 0);
960 qsdo->gradientInfo->colordata = (CGFloat*)calloc(0, sizeof(CGFloat)*4*length);
961 for (int i = 0; i < length; i++)
962 {
963 jint c1 = colors[i];
964 //fprintf(stderr, "c1 %x\n", c1);
965 qsdo->gradientInfo->colordata[i*4] = ((c1>>16)&0xff)*kColorConversionMultiplier;
966 //fprintf(stderr, "qsdo->gradientInfo->colordata[%d] %f\n", i*4, qsdo->gradientInfo->colordata[i*4]);
967
968 qsdo->gradientInfo->colordata[i*4+1] = ((c1>>8)&0xff)*kColorConversionMultiplier;
969 //fprintf(stderr, "qsdo->gradientInfo->colordata[%d] %f\n", i*4+1, qsdo->gradientInfo->colordata[i*4+1]);
970
971 qsdo->gradientInfo->colordata[i*4+2] = ((c1>>0)&0xff)*kColorConversionMultiplier;
972 //fprintf(stderr, "qsdo->gradientInfo->colordata[%d] %f\n", i*4+2, qsdo->gradientInfo->colordata[i*4+2]);
973
974 qsdo->gradientInfo->colordata[i*4+3] = ((c1>>24)&0xff)*kColorConversionMultiplier;
975 //fprintf(stderr, "qsdo->gradientInfo->colordata[%d] %f\n", i*4+3, qsdo->gradientInfo->colordata[i*4+3]);
976 }
977 free(colors);
978 }
979 jobject fractionsArray = ((*env)->GetObjectArrayElement(env, qsdo->javaGraphicsStatesObjects, sun_java2d_OSXSurfaceData_kFractionsArrayIndex));
980 if (fractionsArray != NULL)
981 {
982 jint length = (*env)->GetArrayLength(env, fractionsArray);
983 //fprintf(stderr, "fractions length %d\n", length);
984 qsdo->gradientInfo->fractionsLength = length;
985
986 jfloat* jfractionsData = (jfloat*)(*env)->GetPrimitiveArrayCritical(env, fractionsArray, NULL);
987 if (jfractionsData != NULL)
988 {
989 qsdo->gradientInfo->fractionsdata = (CGFloat *)malloc(sizeof(CGFloat) *length);
990 jint i;
991 for (i=0; i<length; i++)
992 {
993 qsdo->gradientInfo->fractionsdata[i] = jfractionsData[i];
994 //fprintf(stderr, "jfrationsData[%d] %f, qsdo->gradientInfo->fractionsdata[%d] = %f\n", i, jfractionsData[i], i, qsdo->gradientInfo->fractionsdata[i]);
995 }
996 (*env)->ReleasePrimitiveArrayCritical(env, fractionsArray, jfractionsData, 0);
997 }
998 }
999 }
1000
1001 SDRenderType SetUpPaint(JNIEnv *env, QuartzSDOps *qsdo, SDRenderType renderType)
1002 {
1003 CGContextRef cgRef = qsdo->cgRef;
1004
1005 jint *javaGraphicsStates = qsdo->javaGraphicsStates;
1006 jfloat *javaFloatGraphicsStates = (jfloat*)(qsdo->javaGraphicsStates);
1007
1008 static const CGFloat kColorConversionMultiplier = 1.0f/255.0f;
1009 jint colorState = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorStateIndex];
1010
1011 switch (colorState)
1012 {
1013 case sun_java2d_OSXSurfaceData_kColorSimple:
1014 {
1015 if (qsdo->graphicsStateInfo.simpleColor == NO)
1016 {
1017 setDefaultColorSpace(cgRef);
1018 }
1019 qsdo->graphicsStateInfo.simpleColor = YES;
1020
1052 renderType = SD_Shade;
1053
1054 qsdo->shadingInfo->start.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx1Index];
1055 qsdo->shadingInfo->start.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory1Index];
1056 qsdo->shadingInfo->end.x = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorx2Index];
1057 qsdo->shadingInfo->end.y = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColory2Index];
1058 jint c1 = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorRGBValue1Index];
1059 qsdo->shadingInfo->colors[0] = ((c1>>16)&0xff)*kColorConversionMultiplier;
1060 qsdo->shadingInfo->colors[1] = ((c1>>8)&0xff)*kColorConversionMultiplier;
1061 qsdo->shadingInfo->colors[2] = ((c1>>0)&0xff)*kColorConversionMultiplier;
1062 qsdo->shadingInfo->colors[3] = ((c1>>24)&0xff)*kColorConversionMultiplier;
1063 jint c2 = javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorRGBValue2Index];
1064 qsdo->shadingInfo->colors[4] = ((c2>>16)&0xff)*kColorConversionMultiplier;
1065 qsdo->shadingInfo->colors[5] = ((c2>>8)&0xff)*kColorConversionMultiplier;
1066 qsdo->shadingInfo->colors[6] = ((c2>>0)&0xff)*kColorConversionMultiplier;
1067 qsdo->shadingInfo->colors[7] = ((c2>>24)&0xff)*kColorConversionMultiplier;
1068 qsdo->shadingInfo->cyclic = (javaGraphicsStates[sun_java2d_OSXSurfaceData_kColorIsCyclicIndex] == sun_java2d_OSXSurfaceData_kColorCyclic);
1069
1070 break;
1071 }
1072 case sun_java2d_OSXSurfaceData_kColorLinearGradient:
1073 {
1074 renderType = SD_LinearGradient;
1075 setupGradient(env, qsdo, javaFloatGraphicsStates);
1076 break;
1077 }
1078
1079 case sun_java2d_OSXSurfaceData_kColorRadialGradient:
1080 {
1081 renderType = SD_RadialGradient;
1082 setupGradient(env, qsdo, javaFloatGraphicsStates);
1083 qsdo->gradientInfo->radius = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kRadiusIndex];
1084 break;
1085 }
1086
1087 case sun_java2d_OSXSurfaceData_kColorTexture:
1088 {
1089 qsdo->patternInfo = (StatePatternInfo*)malloc(sizeof(StatePatternInfo));
1090 if (qsdo->patternInfo == NULL)
1091 {
1092 [JNFException raise:env as:kOutOfMemoryError reason:"Failed to malloc memory for texture paint"];
1093 }
1094
1095 qsdo->graphicsStateInfo.simpleStroke = NO;
1096 qsdo->graphicsStateInfo.simpleColor = NO;
1097
1098 renderType = SD_Pattern;
1099
1100 qsdo->patternInfo->tx = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColortxIndex];
1101 qsdo->patternInfo->ty = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColortyIndex];
1102 qsdo->patternInfo->sx = javaFloatGraphicsStates[sun_java2d_OSXSurfaceData_kColorsxIndex];
1103 if (qsdo->patternInfo->sx == 0.0f)
1104 {
1105 return SD_Fill; // 0 is an invalid value, fill argb rect
1106 }
1245 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1246 {
1247 CGContextStrokePath(qsdo->cgRef);
1248 }
1249 break;
1250
1251 case SD_Fill:
1252 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1253 {
1254 CGContextFillPath(qsdo->cgRef);
1255 }
1256 break;
1257
1258 case SD_Shade:
1259 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1260 {
1261 contextGradientPath(qsdo);
1262 }
1263 break;
1264
1265 case SD_LinearGradient:
1266 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1267 {
1268 contextQuartzLinearGradientPath(qsdo);
1269 }
1270 break;
1271
1272 case SD_RadialGradient:
1273 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1274 {
1275 contextQuartzRadialGradientPath(qsdo);
1276 }
1277 break;
1278
1279 case SD_Pattern:
1280 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1281 {
1282 contextTexturePath(env, qsdo);
1283 }
1284 break;
1285
1286 case SD_EOFill:
1287 if (CGContextIsPathEmpty(qsdo->cgRef) == 0)
1288 {
1289 CGContextEOFillPath(qsdo->cgRef);
1290 }
1291 break;
1292
1293 case SD_Image:
1294 break;
1295
1296 case SD_Text:
1297 break;
1298
1299 case SD_CopyArea:
1300 break;
1301
1302 case SD_Queue:
1303 break;
1304
1305 case SD_External:
1306 break;
1307 }
1308
1309 if (qsdo->shadingInfo != NULL) {
1310 gradientPaintReleaseFunction(qsdo->shadingInfo);
1311 qsdo->shadingInfo = NULL;
1312 }
1313 if (qsdo->gradientInfo != NULL) {
1314 gradientPaintReleaseFunction(qsdo->gradientInfo);
1315 qsdo->gradientInfo = NULL;
1316 }
1317 }
|