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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
IDrawStr.c
资源名称：ilib　[点击查看]
上传用户：changbiao
上传日期：2007-01-13
资源大小：141k
文件大小：11k
源码类别：

图片显示

开发平台：

C/C++

IDrawStr.c：源码内容
  1. /*
  2.  * IDrawStr.c
  3.  *
  4.  * Image library
  5.  *
  6.  * Description:
  7.  * Portable routines to manipulate raster images.
  8.  *
  9.  * History:
  10.  * 21-Jan-00 Geovan Rodriguez <geovan@cigb.edu.cu>
  11.  * Added IDrawStringRotatedAngle()
  12.  * 23-Aug-99 Craig Knudsen cknudsen@radix.net
  13.  * Added support for text styles:
  14.  * ITEXT_NORMAL, ITEXT_ETCHED_IN, 
  15.  * ITEXT_ETCHED_OUT, ITEXT_SHADOWED
  16.  * 21-Aug-99 Craig Knudsen cknudsen@radix.net
  17.  * Added IDrawStringRotated()
  18.  * Removed anti-aliasing stuff since it didn't really
  19.  * work.  Eventually, true type fonts will be used
  20.  * for this (FreeType lib).
  21.  * 18-May-98 Craig Knudsen cknudsen@radix.net
  22.  * Added support for anti-aliasing fonts by using a
  23.  * font 2X bigger than we need.
  24.  * 20-May-96 Craig Knudsen cknudsen@radix.net
  25.  * Created
  26.  *
  27.  ****************************************************************************/
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <ctype.h>
  32. #include <memory.h>
  33. #include <math.h>
  35. #include "Ilib.h"
  36. #include "IlibP.h"
  37. #include "IFontBDF.h"
  40. #define SPACES_PER_TAB 8
  44. static IError draw_string_rotated_90 (
  45. #ifndef _NO_PROTO
  46.   IImage image,
  47.   IGC gc,
  48.   int x,
  49.   int y,
  50.   char *text,
  51.   unsigned int len,
  52.   ITextDirection direction
  53. #endif
  54. );
  58. IError IDrawString ( image, gc, x, y, text, len )
  59. IImage image;
  60. IGC gc;
  61. int x;
  62. int y;
  63. char *text;
  64. unsigned int len;
  65. {
  66.   return IDrawStringRotated ( image, gc, x, y, text, len, ITEXT_LEFT_TO_RIGHT );
  67. }
  71. /* calculate values for topshadow and bottomshadow */
  72. static void make_top_and_bottom_shadow ( incolorp, top, bottom )
  73. IColorP *incolorp;
  74. IColor *top, *bottom;
  75. {
  76.   unsigned int topr, topg, topb, bottomr, bottomg, bottomb;
  78.   if ( incolorp == NULL ) {
  79.     *top = 0;
  80.     *bottom = 1;
  81.   } else {
  82.     topr = incolorp->red > 205 ? 255 : incolorp->red + 50;
  83.     topg = incolorp->green > 205 ? 255 : incolorp->green + 50;
  84.     topb = incolorp->blue > 205 ? 255 : incolorp->blue + 50;
  85.     *top = IAllocColor ( topr, topg, topb );
  86.     bottomr = incolorp->red < 50 ? 0 : incolorp->red - 50;
  87.     bottomg = incolorp->green < 50 ? 0 : incolorp->green - 50;
  88.     bottomb = incolorp->blue < 50 ? 0 : incolorp->blue - 50;
  89.     *bottom = IAllocColor ( bottomr, bottomg, bottomb );
  90.   }
  91. }
  94. /* calculate values for shadows  */
  95. static void make_shadows ( incolorp, shadows, nshadows )
  96. IColorP *incolorp;
  97. IColor *shadows;
  98. int nshadows;
  99. {
  100.   unsigned int rinc, ginc, binc, rstart, gstart, bstart;
  101.   int loop;
  103.   rstart = ( incolorp->red / 2 );
  104.   gstart = ( incolorp->green / 2 );
  105.   bstart = ( incolorp->blue / 2 );
  107.   if ( incolorp != NULL ) {
  108.     rinc = ( incolorp->red - rstart ) / nshadows;
  109.     ginc = ( incolorp->green - gstart ) / nshadows;
  110.     binc = ( incolorp->blue - bstart ) / nshadows;
  111.     for ( loop = 0; loop < nshadows; loop++ )
  112.       shadows[loop] = IAllocColor ( rstart + rinc * loop,
  113.         gstart + ginc * loop, bstart + binc * loop );
  114.   }
  115. }
  118. IError IDrawStringRotated ( image, gc, x, y, text, len, direction )
  119. IImage image;
  120. IGC gc;
  121. int x;
  122. int y;
  123. char *text;
  124. unsigned int len;
  125. ITextDirection direction;
  126. {
  127.   IGCP *gcp = (IGCP *)gc;
  128.   IError ret = INoError;
  129.   IColor shadows[20], top, bottom;
  130.   IColorP *fgsave;
  131.   int loop, nshadows;
  132.   unsigned int font_height;
  134.   if ( ! gcp )
  135.     return ( IInvalidGC );
  137.   fgsave = gcp->foreground;
  139.   switch ( gcp->text_style ) {
  140.     case ITEXT_NORMAL:
  141.       ret = draw_string_rotated_90 ( image, gc, x, y, text, len, direction );
  142.       break;
  143.     case ITEXT_ETCHED_IN:
  144.     case ITEXT_ETCHED_OUT:
  145.       if ( gcp->background != NULL ) {
  146.         if ( gcp->text_style == ITEXT_ETCHED_OUT )
  147.           make_top_and_bottom_shadow ( gcp->background, &top, &bottom );
  148.         else
  149.           make_top_and_bottom_shadow ( gcp->background, &bottom, &top );
  150.         ISetForeground ( gc, top );
  151.         ret = draw_string_rotated_90 ( image, gc, x - 1, y - 1,
  152.           text, len, direction );
  153.         if ( ! ret ) {
  154.           ISetForeground ( gc, bottom );
  155.           ret = draw_string_rotated_90 ( image, gc, x + 1, y + 1,
  156.             text, len, direction );
  157.         }
  158.       }
  159.       if ( ! ret ) {
  160.         gcp->foreground = gcp->background;
  161.         ret = draw_string_rotated_90 ( image, gc, x, y,
  162.           text, len, direction );
  163.       }
  164.       break;
  165.     case ITEXT_SHADOWED:
  166.       if ( gcp->background != NULL ) {
  167.         IFontSize ( (IFont)gcp->font, &font_height );
  168.         nshadows = font_height / 5;
  169.         make_shadows ( gcp->background, shadows, nshadows );
  170.         gcp->foreground = fgsave;
  171.         for ( loop = nshadows; loop > 0; loop-- ) {
  172.           ISetForeground ( gc, shadows[loop-1] );
  173.           ret = draw_string_rotated_90 ( image, gc, x + loop, y + loop,
  174.             text, len, direction );
  175.         }
  176.         gcp->foreground = fgsave;
  177.       }
  178.       if ( ! ret )
  179.         ret = draw_string_rotated_90 ( image, gc, x, y, text, len, direction );
  180.       break;
  181.   }
  183.   gcp->foreground = fgsave;
  185.   return ( ret );
  186. }
  189. static IError draw_string_rotated_90 ( image, gc, x, y, text, len, direction )
  190. IImage image;
  191. IGC gc;
  192. int x;
  193. int y;
  194. char *text;
  195. unsigned int len;
  196. ITextDirection direction;
  197. {
  198.   IGCP *gcp = (IGCP *)gc;
  199.   IImageP *imagep = (IImageP *)image;
  200.   unsigned int *bitdata;
  201.   unsigned int height, width, actual_width, size, font_height;
  202.   int xoffset, yoffset, charx, chary;
  203.   char ch[256], *ptr;
  204.   int loop, loop2, loop3;
  205.   IError ret;
  206.   int myx, myy;
  207.   int char_num = 0;
  209.   if ( ! gcp )
  210.     return ( IInvalidGC );
  211.   if ( gcp->magic != IMAGIC_GC )
  212.     return ( IInvalidGC );
  214.   if ( ! imagep )
  215.     return ( IInvalidImage );
  216.   if ( imagep->magic != IMAGIC_IMAGE )
  217.     return ( IInvalidImage );
  219.   if ( ! gcp->font )
  220.     return ( INoFontSet );
  222.   charx = x;
  223.   chary = y;
  225.   IFontSize ( (IFont)gcp->font, &font_height );
  227.   for ( ptr = text, loop = 0; loop < len; loop++, ptr++ ) {
  228.     if ( *ptr == '12' ) {
  229.       switch ( direction ) {
  230.         case ITEXT_LEFT_TO_RIGHT:
  231.           charx = x;
  232.           chary += font_height;
  233.           break;
  234.         case ITEXT_TOP_TO_BOTTOM:
  235.           chary = y;
  236.           charx -= font_height;
  237.           break;
  238.         case ITEXT_BOTTOM_TO_TOP:
  239.           chary = y;
  240.           charx += font_height;
  241.           break;
  242.       }
  243.       char_num = 0;
  244.       continue;
  245.     }
  246.     else if ( *ptr == 't' ) {
  247.       ret = IFontBDFGetChar ( gcp->font->name, ch, &bitdata, &width, &height,
  248.         &actual_width, &size, &xoffset, &yoffset );
  249.       switch ( direction ) {
  250.         case ITEXT_LEFT_TO_RIGHT:
  251.           charx += ( 8 - ( char_num % 8 ) ) * actual_width;
  252.           break;
  253.         case ITEXT_TOP_TO_BOTTOM:
  254.           chary -= ( 8 - ( char_num % 8 ) ) * actual_width;
  255.           break;
  256.         case ITEXT_BOTTOM_TO_TOP:
  257.           chary += ( 8 - ( char_num % 8 ) ) * actual_width;
  258.           break;
  259.       }
  260.       continue;
  261.     }
  262.     else if ( *ptr != '33' ) {
  263.       ch[0] = *ptr;
  264.       ch[1] = '';
  265.     }
  266.     else {
  267.       loop2 = 0;
  268.       ptr++;
  269.       while ( *ptr != ';' && loop < len && loop2 < 256 ) {
  270.         ch[loop2] = *ptr;
  271.         ptr++;
  272.         loop++;
  273.         loop2++;
  274.       }
  275.       ch[loop2] = '';
  276.       if ( *ptr != ';' ) {
  277.         return ( IInvalidEscapeSequence );
  278.       }
  279.     }
  280.     ret = IFontBDFGetChar ( gcp->font->name, ch, &bitdata, &width, &height,
  281.       &actual_width, &size, &xoffset, &yoffset );
  282.     if ( ! ret ) {
  283.       for ( loop3 = 0; loop3 < height; loop3++ ) {
  284.         switch ( direction ) {
  285.           case ITEXT_LEFT_TO_RIGHT:
  286.             myy = chary - ( height + yoffset ) + loop3;
  287.             for ( loop2 = 0; loop2 < width; loop2++ ) {
  288.               if ( bitdata[loop3 * width + loop2] ) {
  289.                 myx = charx + xoffset + loop2;
  290.                 _ISetPoint ( imagep, gcp, myx, myy );
  291.               }
  292.             }
  293.             break;
  294.           case ITEXT_TOP_TO_BOTTOM:
  295.             myx = charx + ( height + yoffset ) - loop3;
  296.             for ( loop2 = 0; loop2 < width; loop2++ ) {
  297.               if ( bitdata[loop3 * width + loop2] ) {
  298.                 myy = chary + xoffset + loop2;
  299.                 _ISetPoint ( imagep, gcp, myx, myy );
  300.               }
  301.             }
  302.             break;
  303.           case ITEXT_BOTTOM_TO_TOP:
  304.             myx = charx - ( height + yoffset ) + loop3;
  305.             for ( loop2 = 0; loop2 < width; loop2++ ) {
  306.               if ( bitdata[loop3 * width + loop2] ) {
  307.                 myy = chary - xoffset - loop2;
  308.                 _ISetPoint ( imagep, gcp, myx, myy );
  309.               }
  310.             }
  311.             break;
  312.         }
  313.       }
  314.       switch ( direction ) {
  315.         case ITEXT_LEFT_TO_RIGHT:
  316.           charx += actual_width;
  317.           break;
  318.         case ITEXT_TOP_TO_BOTTOM:
  319.           chary += actual_width;
  320.           break;
  321.         case ITEXT_BOTTOM_TO_TOP:
  322.           chary -= actual_width;
  323.           break;
  324.       }
  325.       char_num++;
  326.     }
  327.   }
  329.   return ( INoError );
  330. }
  336. IError IDrawStringRotatedAngle ( image, gc, x, y, text, len, angle )
  337. IImage image;
  338. IGC gc;
  339. int x;
  340. int y;
  341. char *text;
  342. unsigned int len;
  343. double angle;
  344. {
  345.   IGCP *gcp = (IGCP *)gc;
  346.   IImageP *imagep = (IImageP *)image;
  347.   unsigned int *bitdata;
  348.   unsigned int height, width, actual_width, size, font_height;
  349.   int xoffset, yoffset, charx, chary;
  350.   char ch[256], *ptr;
  351.   int loop, loop2, loop3;
  352.   IError ret;
  353.   int myx, myy;
  354.   int char_num = 0;
  356.   double x1, y1, x2, y2;
  357.   int alpha;
  358.     
  359.   if ( ! gcp )
  360.     return ( IInvalidGC );
  361.   if ( gcp->magic != IMAGIC_GC )
  362.     return ( IInvalidGC );
  364.   if ( ! imagep )
  365.     return ( IInvalidImage );
  366.   if ( imagep->magic != IMAGIC_IMAGE )
  367.     return ( IInvalidImage );
  369.   if ( ! gcp->font )
  370.     return ( INoFontSet );
  372.   charx = x;
  373.   chary = y;
  375.   IFontSize ( (IFont)gcp->font, &font_height );
  377.   for ( ptr = text, loop = 0; loop < len; loop++, ptr++ ) {
  378.     
  379.     if ( *ptr == '12' ) {
  380.       chary += font_height;
  381.       charx = x;
  382.       char_num = 0;
  383.       continue;
  384.     }
  385.     else if ( *ptr == 't' ) {
  386.       ret = IFontBDFGetChar ( gcp->font->name, ch, &bitdata, &width, &height,
  387.         &actual_width, &size, &xoffset, &yoffset );
  388.       chary += ( 8 - ( char_num % 8 ) ) * actual_width;
  389.       continue;
  390.     }
  391.     else if ( *ptr != '33' ) {
  392.       ch[0] = *ptr;
  393.       ch[1] = '';
  394.     }
  395.     else {
  396.       loop2 = 0;
  397.       ptr++;
  398.       while ( *ptr != ';' && loop < len && loop2 < 256 ) {
  399.         ch[loop2] = *ptr;
  400.         ptr++;
  401.         loop++;
  402.         loop2++;
  403.       }
  404.       ch[loop2] = '';
  405.       
  406.       if ( *ptr != ';' ) {
  407.         return ( IInvalidEscapeSequence );
  408.       }
  409.     }
  410.     
  411.     ret = IFontBDFGetChar ( gcp->font->name, ch, &bitdata, &width, &height,
  412.       &actual_width, &size, &xoffset, &yoffset );
  414.     alpha=angle;
  415.           
  416.     if ( ! ret ) {
  417.       for ( loop3 = 0; loop3 < height; loop3++ ) {
  418.         for ( loop2 = 0; loop2 < width; loop2++ ) {
  419.           if ( bitdata[loop3 * width + loop2] ) {
  420.             x1 = loop2 + xoffset;
  421.             y1 = loop3 + size - height;
  422.             x2 = x1 * cos ( alpha * M_PI / 180 ) +
  423.               y1 * sin ( alpha * M_PI / 180 );
  424.             y2 = -1 * x1 * sin ( alpha * M_PI / 180 ) +
  425.               y1 * cos ( alpha * M_PI / 180 );
  426.             myy = chary - (size + yoffset ) + y2;
  427.             myx = charx + x2;
  428.             _ISetPoint ( imagep, gcp, myx, myy );
  429.           }
  430.         }  
  431.       }
  432.       x1 = actual_width+xoffset;      
  433.       y1 = 0;      
  434.       x2 = x1 * cos ( alpha * M_PI / 180 ) +
  435.         y1 * sin ( alpha * M_PI / 180 );      
  436.       y2 = -1 * x1 * sin ( alpha * M_PI / 180 ) +
  437.         y1 * cos ( alpha * M_PI / 180 );      
  438.       charx += x2;      
  439.       chary += y2;      
  440.       char_num++;
  441.     }
  442.   }
  444.   return ( INoError );
  445. }