开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 系统/网络安全 > 破解 > 查看源码
magick_DrawInfo.c
资源名称：verifidecoder_src.rar　[点击查看]
上传用户：qingzhou
上传日期：2013-04-21
资源大小：733k
文件大小：14k
源码类别：

破解

开发平台：

Java

magick_DrawInfo.c：源码内容
  1. #include <jni.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <time.h>
  6. #include <sys/types.h>
  7. #include <magick/api.h>
  8. #include "jmagick.h"
  9. #include "magick_DrawInfo.h"
  12. /*
  13.  * Class:     magick_DrawInfo
  14.  * Method:    init
  15.  * Signature: (Lmagick/ImageInfo;)V
  16.  */
  17. JNIEXPORT void JNICALL Java_magick_DrawInfo_init
  18.   (JNIEnv *env, jobject self, jobject jImageInfo)
  19. {
  20.     jfieldID drawInfoFieldID = 0;
  21.     ImageInfo *imageInfo = NULL;
  22.     DrawInfo *drawInfo = NULL;
  24.     /* Get the ImageInfo handle. */
  25.     imageInfo = (ImageInfo*) getHandle(env, jImageInfo,
  26.        "imageInfoHandle", NULL);
  27.     if (imageInfo == NULL) {
  28. throwMagickException(env, "Unable to get ImageInfo handle");
  29. return;
  30.     }
  32.     /* If the DrawInfo handle is not NULL, we destroy the old
  33.      * handle before creating a new one.
  34.      */
  35.     drawInfo = (DrawInfo*) getHandle(env, self,
  36.      "drawInfoHandle",
  37.      &drawInfoFieldID);
  38.     if (drawInfo != NULL) {
  39. DestroyDrawInfo(drawInfo);
  40.     }
  42.     /* Initialise and set the new DrawInfo handle. */
  43.     drawInfo = (DrawInfo*) AcquireMemory(sizeof(DrawInfo));
  44.     if (drawInfo == NULL) {
  45. throwMagickException(env, "Memory allocation failure");
  46. return;
  47.     }
  48.     GetDrawInfo(imageInfo, drawInfo);
  49.     // drawInfo->encoding = (char *) AcquireString("Unicode");
  50.     if (!setHandle(env, self, "drawInfoHandle",
  51.    drawInfo, &drawInfoFieldID)) {
  52. throwMagickException(env, "Unable to set DrawInfo handle");
  53. return;
  54.     }
  55. }
  58. /*
  59.  * Class:     magick_DrawInfo
  60.  * Method:    destroyDrawInfo
  61.  * Signature: ()V
  62.  */
  63. JNIEXPORT void JNICALL Java_magick_DrawInfo_destroyDrawInfo
  64.   (JNIEnv *env, jobject self)
  65. {
  66.     DrawInfo *info = NULL;
  67.     jfieldID fieldID = 0;
  69.     info = (DrawInfo*) getHandle(env, self,
  70.  "drawInfoHandle", &fieldID);
  71.     if (info != NULL) {
  72. DestroyDrawInfo(info);
  73. setHandle(env, self, "drawInfoHandle", NULL, &fieldID);
  74.     }
  75. }
  79. /*
  80.  * Class:     magick_DrawInfo
  81.  * Method:    setPrimitive
  82.  * Signature: (Ljava/lang/String;)V
  83.  */
  84. JNIEXPORT void JNICALL Java_magick_DrawInfo_setPrimitive
  85.     (JNIEnv *env, jobject self, jstring primitive)
  86. {
  87.     DrawInfo *info = NULL;
  88.     const char *cstr = NULL;
  89.     const jchar *jstr = NULL;
  90.     int i, len, is8bits;
  92.     info = (DrawInfo *) getHandle(env, self, "drawInfoHandle", NULL);
  93.     if (info == NULL) {
  94. throwMagickException(env, "Unable to retrieve handle");
  95. return;
  96.     }
  98.     if (info->primitive != NULL) {
  99. LiberateMemory((void**) &info->primitive);
  100.     }
  102.     jstr = (*env)->GetStringChars(env, primitive, 0);
  103.     len = (*env)->GetStringLength(env, primitive);
  104.     is8bits = JNI_TRUE;
  105.     for (i = 0; i < len; i++) {
  106.         if (jstr[i] > 255) {
  107.             is8bits = JNI_FALSE;
  108.             break;
  109.         }
  110.     }
  112.     if (is8bits) {
  113.         char *str = (char *) AcquireMemory(len+1);
  114.         if (str == NULL) {
  115.             throwMagickException(env, "Unable to allocate memory");
  116.             (*env)->ReleaseStringChars(env, primitive, jstr);
  117.             return;
  118.         }
  119.         for (i = 0; i < len; i++) {
  120.             str[i] = (char) jstr[i];
  121.         }
  122.         str[len] = '';
  123.         info->primitive = str;
  124.         printf("String: %sn", str);
  125.         if (info->encoding != NULL) {
  126.             LiberateMemory((void **) &info->encoding);
  127.         }
  128.     }
  130.     (*env)->ReleaseStringChars(env, primitive, jstr);
  132.     if (!is8bits) {
  133.         cstr = (*env)->GetStringUTFChars(env, primitive, 0);
  134.         if (cstr == NULL) {
  135.             throwMagickException(env, "Unable to retrieve Java string chars");
  136.             return;
  137.         }
  138.         info->primitive = (char *) AcquireString(cstr);
  139.         (*env)->ReleaseStringUTFChars(env, primitive, cstr);
  140.         if (info->primitive == NULL) {
  141.             throwMagickException(env, "Unable to allocate memory");
  142.         }
  143.         if (info->encoding != NULL) {
  144.             LiberateMemory((void **) &info->encoding);
  145.         }
  146.         info->encoding = (char *) AcquireString("UTF-8");
  147.         if (info->encoding == NULL) {
  148.             throwMagickException(env, "Unable to allocate memory");
  149.         }
  150.     }
  151. }
  155. /*
  156.  * Class:     magick_DrawInfo
  157.  * Method:    getPrimitive
  158.  * Signature: ()Ljava/lang/String;
  159.  */
  160. getStringMethod(Java_magick_DrawInfo_getPrimitive,
  161. primitive,
  162. "drawInfoHandle",
  163. DrawInfo)
  165. /*
  166.  * Class:     magick_DrawInfo
  167.  * Method:    setGeometry
  168.  * Signature: (Ljava/lang/String;)V
  169.  */
  170. setStringMethod(Java_magick_DrawInfo_setGeometry,
  171. geometry,
  172. "drawInfoHandle",
  173. DrawInfo)
  178. /*
  179.  * Class:     magick_DrawInfo
  180.  * Method:    getGeometry
  181.  * Signature: ()Ljava/lang/String;
  182.  */
  183. getStringMethod(Java_magick_DrawInfo_getGeometry,
  184. geometry,
  185. "drawInfoHandle",
  186. DrawInfo)
  190. /*
  191.  * Class:     magick_DrawInfo
  192.  * Method:    setText
  193.  * Signature: (Ljava/lang/String;)V
  194.  */
  195. JNIEXPORT void JNICALL Java_magick_DrawInfo_setText
  196.     (JNIEnv *env, jobject self, jstring text)
  197. {
  198.     DrawInfo *info = NULL;
  199.     const char *cstr = NULL;
  200.     const jchar *jstr = NULL;
  201.     int i, len, is8bits;
  203.     info = (DrawInfo *) getHandle(env, self, "drawInfoHandle", NULL);
  204.     if (info == NULL) {
  205. throwMagickException(env, "Unable to retrieve handle");
  206. return;
  207.     }
  209.     if (info->text != NULL) {
  210. LiberateMemory((void**) &info->text);
  211.     }
  213.     jstr = (*env)->GetStringChars(env, text, 0);
  214.     len = (*env)->GetStringLength(env, text);
  215.     is8bits = JNI_TRUE;
  216.     for (i = 0; i < len; i++) {
  217.         if (jstr[i] > 255) {
  218.             is8bits = JNI_FALSE;
  219.             break;
  220.         }
  221.     }
  223.     if (is8bits) {
  224.         char *str = (char *) AcquireMemory(len+1);
  225.         if (str == NULL) {
  226.             throwMagickException(env, "Unable to allocate memory");
  227.             (*env)->ReleaseStringChars(env, text, jstr);
  228.             return;
  229.         }
  230.         for (i = 0; i < len; i++) {
  231.             str[i] = (char) jstr[i];
  232.         }
  233.         str[len] = '';
  234.         info->text = str;
  235.         printf("String: %sn", str);
  236.         if (info->encoding != NULL) {
  237.             LiberateMemory((void **) &info->encoding);
  238.         }
  239.     }
  241.     (*env)->ReleaseStringChars(env, text, jstr);
  243.     if (!is8bits) {
  244.         cstr = (*env)->GetStringUTFChars(env, text, 0);
  245.         if (cstr == NULL) {
  246.             throwMagickException(env, "Unable to retrieve Java string chars");
  247.             return;
  248.         }
  249.         info->text = (char *) AcquireString(cstr);
  250.         (*env)->ReleaseStringUTFChars(env, text, cstr);
  251.         if (info->text == NULL) {
  252.             throwMagickException(env, "Unable to allocate memory");
  253.         }
  254.         if (info->encoding != NULL) {
  255.             LiberateMemory((void **) &info->encoding);
  256.         }
  257.         info->encoding = (char *) AcquireString("UTF-8");
  258.         if (info->encoding == NULL) {
  259.             throwMagickException(env, "Unable to allocate memory");
  260.         }
  261.     }
  262. }
  266. /*
  267.  * Class:     magick_DrawInfo
  268.  * Method:    getText
  269.  * Signature: ()Ljava/lang/String;
  270.  */
  271. getStringMethod(Java_magick_DrawInfo_getText,
  272. text,
  273. "drawInfoHandle",
  274. DrawInfo)
  277. /*
  278.  * Class:     magick_DrawInfo
  279.  * Method:    setFont
  280.  * Signature: (Ljava/lang/String;)V
  281.  */
  282. setStringMethod(Java_magick_DrawInfo_setFont,
  283. font,
  284. "drawInfoHandle",
  285. DrawInfo)
  287. /*
  288.  * Class:     magick_DrawInfo
  289.  * Method:    getFont
  290.  * Signature: ()Ljava/lang/String;
  291.  */
  292. getStringMethod(Java_magick_DrawInfo_getFont,
  293. font,
  294. "drawInfoHandle",
  295. DrawInfo)
  298. /*
  299.  * Class:     magick_DrawInfo
  300.  * Method:    setStrokeAntialias
  301.  * Signature: (Z)V
  302.  */
  303. setBoolMethod(Java_magick_DrawInfo_setStrokeAntialias,
  304.       stroke_antialias,
  305.       "drawInfoHandle",
  306.       DrawInfo)
  309. /*
  310.  * Class:     magick_DrawInfo
  311.  * Method:    getStrokeAntialias
  312.  * Signature: ()Z
  313.  */
  314. getBoolMethod(Java_magick_DrawInfo_getStrokeAntialias,
  315.       stroke_antialias,
  316.       "drawInfoHandle",
  317.       DrawInfo)
  320. /*
  321.  * Class:     magick_DrawInfo
  322.  * Method:    setTextAntialias
  323.  * Signature: (Z)V
  324.  */
  325. setBoolMethod(Java_magick_DrawInfo_setTextAntialias,
  326.       text_antialias,
  327.       "drawInfoHandle",
  328.       DrawInfo)
  331. /*
  332.  * Class:     magick_DrawInfo
  333.  * Method:    getTextAntialias
  334.  * Signature: ()Z
  335.  */
  336. getBoolMethod(Java_magick_DrawInfo_getTextAntialias,
  337.       text_antialias,
  338.       "drawInfoHandle",
  339.       DrawInfo)
  342. /*
  343.  * Class:     magick_DrawInfo
  344.  * Method:    setGravity
  345.  * Signature: (I)V
  346.  */
  347. setIntMethod(Java_magick_DrawInfo_setGravity,
  348.      gravity,
  349.      "drawInfoHandle",
  350.      DrawInfo)
  352. /*
  353.  * Class:     magick_DrawInfo
  354.  * Method:    getGravity
  355.  * Signature: ()I
  356.  */
  357. getIntMethod(Java_magick_DrawInfo_getGravity,
  358.      gravity,
  359.      "drawInfoHandle",
  360.      DrawInfo)
  362. /*
  363.  * Class:     magick_DrawInfo
  364.  * Method:    setOpacity
  365.  * Signature: (I)V
  366.  */
  367. setIntMethod(Java_magick_DrawInfo_setOpacity,
  368.      opacity,
  369.      "drawInfoHandle",
  370.      DrawInfo)
  372. /*
  373.  * Class:     magick_DrawInfo
  374.  * Method:    getOpacity
  375.  * Signature: ()I
  376.  */
  377. getIntMethod(Java_magick_DrawInfo_getOpacity,
  378.      opacity,
  379.      "drawInfoHandle",
  380.      DrawInfo)
  382. /*
  383.  * Class:     magick_DrawInfo
  384.  * Method:    setDecorate
  385.  * Signature: (I)V
  386.  */
  387. setIntMethod(Java_magick_DrawInfo_setDecorate,
  388.      decorate,
  389.      "drawInfoHandle",
  390.      DrawInfo)
  392. /*
  393.  * Class:     magick_DrawInfo
  394.  * Method:    getDecorate
  395.  * Signature: ()I
  396.  */
  397. getIntMethod(Java_magick_DrawInfo_getDecorate,
  398.      decorate,
  399.      "drawInfoHandle",
  400.      DrawInfo)
  403. /*
  404.  * Class:     magick_DrawInfo
  405.  * Method:    setStrokeWidth
  406.  * Signature: (D)V
  407.  */
  408. setDoubleMethod(Java_magick_DrawInfo_setStrokeWidth,
  409. stroke_width,
  410. "drawInfoHandle",
  411. DrawInfo)
  413. /*
  414.  * Class:     magick_DrawInfo
  415.  * Method:    getStrokeWidth
  416.  * Signature: ()D
  417.  */
  418. getDoubleMethod(Java_magick_DrawInfo_getStrokeWidth,
  419. stroke_width,
  420. "drawInfoHandle",
  421. DrawInfo)
  425. /*
  426.  * Class:     magick_DrawInfo
  427.  * Method:    setPointsize
  428.  * Signature: (D)V
  429.  */
  430. setDoubleMethod(Java_magick_DrawInfo_setPointsize,
  431. pointsize,
  432. "drawInfoHandle",
  433. DrawInfo)
  435. /*
  436.  * Class:     magick_DrawInfo
  437.  * Method:    getPointsize
  438.  * Signature: ()D
  439.  */
  440. getDoubleMethod(Java_magick_DrawInfo_getPointsize,
  441. pointsize,
  442. "drawInfoHandle",
  443. DrawInfo)
  445. /*
  446.  * Class:     magick_DrawInfo
  447.  * Method:    setFill
  448.  * Signature: (Lmagick/PixelPacket;)V
  449.  */
  450. setPixelPacketMethod(Java_magick_DrawInfo_setFill,
  451.      fill,
  452.      "drawInfoHandle",
  453.      DrawInfo)
  455. /*
  456.  * Class:     magick_DrawInfo
  457.  * Method:    getFill
  458.  * Signature: ()Lmagick/PixelPacket;
  459.  */
  460. getPixelPacketMethod(Java_magick_DrawInfo_getFill,
  461.      fill,
  462.      "drawInfoHandle",
  463.      DrawInfo)
  465. /*
  466.  * Class:     magick_DrawInfo
  467.  * Method:    setStroke
  468.  * Signature: (Lmagick/PixelPacket;)V
  469.  */
  470. setPixelPacketMethod(Java_magick_DrawInfo_setStroke,
  471.      stroke,
  472.      "drawInfoHandle",
  473.      DrawInfo)
  475. /*
  476.  * Class:     magick_DrawInfo
  477.  * Method:    getStroke
  478.  * Signature: ()Lmagick/PixelPacket;
  479.  */
  480. getPixelPacketMethod(Java_magick_DrawInfo_getStroke,
  481.      stroke,
  482.      "drawInfoHandle",
  483.      DrawInfo)
  485. /*
  486.  * Class:     magick_DrawInfo
  487.  * Method:    setUnderColor
  488.  * Signature: (Lmagick/PixelPacket;)V
  489.  */
  490. setPixelPacketMethod(Java_magick_DrawInfo_setUnderColor,
  491.      undercolor,
  492.      "drawInfoHandle",
  493.      DrawInfo)
  495. /*
  496.  * Class:     magick_DrawInfo
  497.  * Method:    getUnderColor
  498.  * Signature: ()Lmagick/PixelPacket;
  499.  */
  500. getPixelPacketMethod(Java_magick_DrawInfo_getUnderColor,
  501.      undercolor,
  502.      "drawInfoHandle",
  503.      DrawInfo)
  505. /*
  506.  * Class:     magick_DrawInfo
  507.  * Method:    setBorderColor
  508.  * Signature: (Lmagick/PixelPacket;)V
  509.  */
  510. setPixelPacketMethod(Java_magick_DrawInfo_setBorderColor,
  511.      border_color,
  512.      "drawInfoHandle",
  513.      DrawInfo)
  515. /*
  516.  * Class:     magick_DrawInfo
  517.  * Method:    getBorderColor
  518.  * Signature: ()Lmagick/PixelPacket;
  519.  */
  520. getPixelPacketMethod(Java_magick_DrawInfo_getBorderColor,
  521.      border_color,
  522.      "drawInfoHandle",
  523.      DrawInfo)
  526. /*
  527.  * Class:     magick_DrawInfo
  528.  * Method:    setTile
  529.  * Signature: (Lmagick/MagickImage;)V
  530.  */
  531. JNIEXPORT void JNICALL Java_magick_DrawInfo_setTile
  532.   (JNIEnv *env, jobject self, jobject tileImage)
  533. {
  534.     DrawInfo *drawInfo;
  535.     Image *image, *imgCopy;
  536.     ExceptionInfo exception;
  538.     drawInfo = (DrawInfo*) getHandle(env, self, "drawInfoHandle", NULL);
  539.     if (drawInfo == NULL) {
  540.         throwMagickException(env, "Unable to obtain DrawInfo handle");
  541.         return;
  542.     }
  544.     image = (Image*) getHandle(env, tileImage, "magickImageHandle", NULL);
  545.     if (image == NULL) {
  546.         throwMagickException(env, "Unable to obtain MagickImage handle");
  547.         return;
  548.     }
  550.     GetExceptionInfo(&exception);
  551.     imgCopy = CloneImage(image, 0, 0, 1, &exception);
  552.     if (imgCopy == NULL) {
  553.         throwMagickApiException(env, "Unable to clone MagickImage",
  554.                                 &exception);
  555.         DestroyExceptionInfo(&exception);
  556.         return;
  557.     }
  558.     DestroyExceptionInfo(&exception);
  560.     if (drawInfo->tile != NULL) {
  561.         DestroyImages(drawInfo->tile);
  562.     }
  563.     drawInfo->tile = imgCopy;
  564. }
  566. /*
  567.  * Class:     magick_DrawInfo
  568.  * Method:    getTile
  569.  * Signature: ()Lmagick/MagickImage;
  570.  */
  571. JNIEXPORT jobject JNICALL Java_magick_DrawInfo_getTile
  572.   (JNIEnv *env, jobject self)
  573. {
  574.     DrawInfo *drawInfo;
  575.     Image *image;
  576.     ExceptionInfo exception;
  577.     jobject imgObj;
  579.     drawInfo = (DrawInfo*) getHandle(env, self, "drawInfoHandle", NULL);
  580.     if (drawInfo == NULL) {
  581.         throwMagickException(env, "Unable to obtain DrawInfo handle");
  582.         return NULL;
  583.     }
  585.     GetExceptionInfo(&exception);
  586.     image = CloneImage(drawInfo->tile, 0, 0, 1, &exception);
  587.     if (image == NULL) {
  588.         throwMagickApiException(env, "Unable to clone image", &exception);
  589.         DestroyExceptionInfo(&exception);
  590.         return NULL;
  591.     }
  592.     DestroyExceptionInfo(&exception);
  594.     imgObj = newImageObject(env, image);
  595.     if (imgObj == NULL) {
  596.         DestroyImages(image);
  597.         throwMagickException(env, "Unable to create image object from handle");
  598.         return NULL;
  599.     }
  600.     return imgObj;
  601. }