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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
image.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：46k
源码类别：

浏览器

开发平台：

Unix_Linux

image.c：源码内容
  1. /* image.c - creates textured background and other pixmap stuff */
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include <math.h>
  10. #include "www.h"
  11. #include "www.bm"
  13. extern Display *display;
  14. extern int screen;
  15. extern Window win;
  16. extern Visual *visual;
  18. extern unsigned long labelColor, textColor, statusColor, strikeColor,
  19.             transparent, windowColor, windowBottomShadow, windowShadow;
  21. extern int RPixelShift, GPixelShift, BPixelShift;
  22. extern int RPixelMask, GPixelMask, BPixelMask;
  23. extern int depth;
  24. extern int IsIndex;
  25. extern Doc *CurrentDoc;
  26. extern Context *context;
  27. extern BOOL OwnColorMap; /* howcome 10/8/95 */
  29. extern int tileWidth, tileHeight;
  30. extern unsigned char *tileData;
  32. extern Pixmap default_pixmap;
  33. extern int default_pixmap_width, default_pixmap_height;
  34. extern Colormap colormap;
  35. extern int Magic256[256];
  36. extern int Magic16[256];
  37. extern int Magic32[256];
  38. extern int Magic64[256];
  40. extern GC disp_gc;
  41. extern unsigned int win_width, win_height;
  42. extern int debug;
  44. extern double Gamma;
  46. extern HTAtom *text_atom;
  47. extern HTAtom *html_atom;
  48. extern HTAtom *html3_atom;
  49. extern HTAtom *html_level3_atom;
  50. extern HTAtom *gif_atom;
  51. extern HTAtom *jpeg_atom;
  52. extern HTAtom *png_atom;
  53. extern HTAtom *png_exp_atom;
  54. extern HTAtom *xpm_atom;
  55. extern HTAtom *xbm_atom;
  58. Pixmap smile, frown, note_pixmap, caution_pixmap, warning_pixmap;
  59. int imaging; /* set to COLOR888, COLOR232, GREY4 or MONO */
  60. Image *images;  /* linked list of images */
  61. Image *note_image, *caution_image, *warning_image;  /* standard icons */
  63. unsigned long stdcmap[128];  /* 2/3/2 color maps for gifs etc */
  64. unsigned long greymap[16];  /* for mixing with unsaturated colors */
  66. extern unsigned long mycmap[256]; 
  68. Image *default_image = NULL;
  71. #define smile_xbm_width 15
  72. #define smile_xbm_height 15
  74. /* janet 21/07/95: declared and defined but not used 
  75. static char smile_xbm_bits[] = {
  76.    0x1f, 0x7c, 0xe7, 0x73, 0xfb, 0x6f, 0xfd, 0x5f, 0xfd, 0x5f, 0xce, 0x39,
  77.    0xce, 0x39, 0xfe, 0x3f, 0xfe, 0x3f, 0xee, 0x3b, 0xdd, 0x5d, 0x3d, 0x5e,
  78.    0xfb, 0x6f, 0xe7, 0x73, 0x1f, 0x7c};
  79.    */
  81. #define frown_xbm_width 15
  82. #define frown_xbm_height 15
  84. /* janet 21/07/95: defined but not used
  85. static char frown_xbm_bits[] = {
  86.    0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f,
  87.    0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f,
  88.    0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f};
  89.    */
  91. #define note_width 26
  92. #define note_height 39
  93. static char note_bits[] = {
  94.    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x38, 0xfc,
  95.    0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc,
  96.    0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc,
  97.    0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc, 0x00, 0x00, 0x7c, 0xfc,
  98.    0x30, 0xc6, 0x7c, 0xfc, 0x78, 0xef, 0x7d, 0xfc, 0x78, 0xef, 0x7f, 0xfc,
  99.    0x78, 0xef, 0x7f, 0xfc, 0x7c, 0x2f, 0x00, 0xfc, 0x7c, 0xcf, 0xff, 0xfc,
  100.    0x7c, 0xcf, 0xff, 0xfc, 0x7c, 0xcf, 0xff, 0xfc, 0x7c, 0x2f, 0xff, 0xfc,
  101.    0x7c, 0xef, 0xf8, 0xfc, 0x7c, 0xef, 0xfd, 0xfc, 0x38, 0xef, 0xfd, 0xfc,
  102.    0xc0, 0xf9, 0xff, 0xfc, 0xe0, 0xff, 0xff, 0xfc, 0xe0, 0xff, 0xff, 0xfc,
  103.    0xe0, 0xff, 0xff, 0xfc, 0xe0, 0xff, 0xff, 0xfc, 0xc0, 0xff, 0xff, 0xfc,
  104.    0x80, 0xff, 0x3f, 0xfc, 0x00, 0xff, 0x1f, 0xfc, 0x00, 0xff, 0x0f, 0xfc,
  105.    0x00, 0xff, 0x0f, 0xfc, 0x00, 0xff, 0x0f, 0xfc, 0x00, 0xff, 0x0f, 0xfc,
  106.    0x00, 0xff, 0x0f, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc};
  108. #define caution_width 26
  109. #define caution_height 38
  110. static char caution_bits[] = {
  111.    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0xc0, 0x00, 0xfc,
  112.    0x00, 0xe0, 0x01, 0xfc, 0x00, 0xee, 0x19, 0xfc, 0x00, 0xef, 0x3d, 0xfc,
  113.    0x00, 0xef, 0x3d, 0xfc, 0x00, 0xef, 0x3d, 0xfc, 0x00, 0xef, 0x3d, 0xfc,
  114.    0x70, 0xef, 0x3d, 0xfc, 0x78, 0xef, 0x3d, 0xfc, 0x78, 0xef, 0x3d, 0xfc,
  115.    0x78, 0xef, 0x3d, 0xfc, 0x78, 0xef, 0x3d, 0xfc, 0x78, 0xef, 0xdd, 0xfc,
  116.    0x78, 0xef, 0xed, 0xfc, 0x78, 0xff, 0xef, 0xfc, 0xf8, 0xff, 0xf7, 0xfc,
  117.    0xf8, 0xff, 0xf7, 0xfc, 0xf8, 0xff, 0xf7, 0xfc, 0xf8, 0xff, 0xf7, 0xfc,
  118.    0xf8, 0xff, 0xf9, 0xfc, 0xf8, 0x7f, 0xfe, 0xfc, 0xf8, 0xbf, 0xff, 0xfc,
  119.    0xf8, 0xbf, 0xff, 0xfc, 0xf8, 0xdf, 0xff, 0xfc, 0xf8, 0xdf, 0xff, 0xfc,
  120.    0xf8, 0xdf, 0xff, 0xfc, 0xf0, 0xff, 0x7f, 0xfc, 0xe0, 0xff, 0x3f, 0xfc,
  121.    0x80, 0xff, 0x0f, 0xfc, 0x80, 0xff, 0x07, 0xfc, 0x80, 0xff, 0x07, 0xfc,
  122.    0x80, 0xff, 0x07, 0xfc, 0x80, 0xff, 0x07, 0xfc, 0x80, 0xff, 0x07, 0xfc,
  123.    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0xfc};
  125. #define warning_width 26
  126. #define warning_height 38
  127. static char warning_bits[] = {
  128.  0x00,0x00,0x00,0xfc,0x00,0x00,0x00,0xfc,0x00,0xc0,0x00,0xfc,0x00,0xe0,0x01,
  129.  0xfc,0x00,0xee,0x19,0xfc,0x00,0xef,0x3d,0xfc,0x00,0xef,0x3d,0xfc,0x00,0xef,
  130.  0x3d,0xfc,0x00,0xef,0x3d,0xfc,0x70,0xef,0x3d,0xfc,0x78,0xef,0x3d,0xfc,0x78,
  131.  0x2f,0x30,0xfc,0x78,0x0f,0x38,0xfc,0x78,0x0f,0x3c,0xfc,0x78,0x07,0xde,0xfc,
  132.  0x78,0x07,0xef,0xfc,0xf8,0x03,0xef,0xfc,0xf8,0x01,0xf6,0xfc,0xf8,0x0f,0xf7,
  133.  0xfc,0xf8,0x8f,0xf7,0xfc,0xf8,0xe7,0xf7,0xfc,0xf8,0xf3,0xf9,0xfc,0xf8,0x79,
  134.  0xfe,0xfc,0xf8,0xbe,0xff,0xfc,0xf8,0xbf,0xff,0xfc,0xf8,0xdf,0xff,0xfc,0xf8,
  135.  0xdf,0xff,0xfc,0xf8,0xdf,0xff,0xfc,0xf0,0xff,0x7f,0xfc,0xe0,0xff,0x3f,0xfc,
  136.  0x80,0xff,0x0f,0xfc,0x80,0xff,0x07,0xfc,0x80,0xff,0x07,0xfc,0x80,0xff,0x07,
  137.  0xfc,0x80,0xff,0x07,0xfc,0x80,0xff,0x07,0xfc,0x00,0x00,0x00,0xfc,0x00,0x00,
  138.  0x00,0xfc};
  140. Image *DefaultImage()
  141. {
  142.     if (default_image)
  143. return default_image;
  145.     default_pixmap = XCreatePixmapFromBitmapData(display, win, www_bits,
  146.                       www_width, www_height, textColor, transparent, depth);
  148.     default_image = (Image *)malloc(sizeof(Image));
  149.     default_image->pixmap =  XCreatePixmapFromBitmapData(display, win, www_bits,
  150.       www_width, www_height, textColor, transparent, depth);
  151.     default_image->width = www_width;
  152.     default_image->height = www_height;
  154.     return default_image;
  155. }
  157. int Brightness2Voltage(int brightness)
  158. {
  159.     double voltage;
  160.     static double log_a = 0; /* howcome added double */
  162.     if (brightness == 0)
  163.         return 0;
  165.     if (log_a == 0)
  166.         log_a = (Gamma - 1.0) * log((double)65535);      /* cast added by howcome 21/9/94 */
  168.     voltage = (log_a + log((double)brightness))/Gamma;   /* cast added by howcome 21/9/94 */
  170.     return (int)(0.5 + exp(voltage));
  171. }
  173. int Voltage2Brightness(int voltage)
  174. {
  175.     double brightness;
  176.     static double log_a;
  178.     if (voltage == 0)
  179.         return 0;
  181.     if (log_a == 0)
  182.         log_a = (Gamma - 1.0) * log((double)255);   /* cast added by howcome 21/9/94 */
  184.     brightness = Gamma * log((double)voltage) - log_a;    /* cast added by howcome 21/9/94 */
  186.     return (int)(0.5 + exp(brightness));
  187. }
  188. /* don't add this to images list to avoid trouble when freeing document images */
  190. Image *MakeIcon(unsigned int depth, char *name, int width, int height, char *bits)
  191. {
  192.     GC drawGC;
  193.     Pixmap pixmap;
  194.     XImage *ximage;
  195.     Image *image;
  196.     unsigned char *data, *p, *s;
  197.     int size, i, j, k;
  198.     unsigned int byte = 0;
  200.     size = width * height;
  202.     if (size == 0)
  203.         return NULL;
  205.     image = (Image *)malloc(sizeof(Image));
  206.     image->url = name;
  207.     image->npixels = 0;
  208.     image->pixels = 0;
  209.     image->next = NULL;
  210.     image->width = width;
  211.     image->height = height;
  213.     s = (unsigned char*)bits;
  215.     if (depth == 8)
  216.     {
  217.         p = data = (unsigned char *)malloc(size);
  219.         for (i = 0; i < height; ++i)
  220.             for (j = 0, k= 8; j < width; ++j)
  221.             {
  222.                 if (++k > 8)  /* need to read next 8 pixel values */
  223.                 {
  224.                     byte = *s++;
  225.                     k = 1;
  226.                 }
  228.                 if (byte & 0x01)
  229.                     *p++ = textColor;
  230.                 else
  231.                     p = Transparent(p, j, i);
  233.                 byte = byte >> 1;
  234.             }
  235.     }
  236.     else  if (depth == 16)
  237.     {
  238.         p = data = (unsigned char *)malloc(size * 2);
  240.         for (i = 0; i < height; ++i)
  241.             for (j = 0, k= 8; j < width; ++j)
  242.             {
  243.                 if (++k > 8)  /* need to read next 8 pixel values */
  244.                 {
  245.                     byte = *s++;
  246.                     k = 1;
  247.                 }
  249.                 if (byte & 1)
  250.                 {
  251.     *p++ = (textColor >>  8) & 0xFF;
  252.     *p++ = textColor & 0xFF;
  253. }
  254.                 else
  255.                     p = Transparent(p, j, i);
  257.                 byte = byte >> 1;
  258.             }
  259.     }
  260.     else  if (depth == 24)
  261.     {
  262.         p = data = (unsigned char *)malloc(size * 4);
  264.         for (i = 0; i < height; ++i)
  265.             for (j = 0, k= 8; j < width; ++j)
  266.             {
  267.                 if (++k > 8)  /* need to read next 8 pixel values */
  268.                 {
  269.                     byte = *s++;
  270.                     k = 1;
  271.                 }
  273.                 if (byte & 1)
  274.                 {
  275.                     *p++ = '';
  276.                     *p++ = (textColor >> 16) & 0xFF;
  277.                     *p++ = (textColor >>  8) & 0xFF;
  278.                     *p++ = textColor & 0xFF;
  279.                 }
  280.                 else
  281.                     p = Transparent(p, j, i);
  283.                 byte = byte >> 1;
  284.             }
  285.     }
  286.     else if (depth == 4 || depth == 2 || depth == 1)
  287.     {
  288. int             ppb, bpl, shift = 0;
  289. int newbyte;
  291. ppb = 8/depth; /* pixels per byte */
  292. bpl = width/ppb + (width%ppb ? 1 : 0); /* bytes per line */
  294.         p = data = (unsigned char *)malloc(bpl * height);
  295. newbyte = 1;
  297.         for (i = 0; i < height; ++i) {
  298.             for (j = 0, k= 8; j < width; ++j)
  299.             {
  300.         if (newbyte) {
  301.     *p = 0;
  302.             newbyte = 0;
  303.         }
  305.                 if (++k > 8)  /* need to read next 8 pixel values */
  306.                 {
  307.                     byte = *s++;
  308.                     k = 1;
  309.                 }
  311.                 if (byte & 0x01) {
  312.     shift = (((7 - (j % 8)) % ppb) * depth);
  313.     *p |= textColor << shift;
  314.     if (shift == 0) {
  315. p++;
  316. newbyte = 1;
  317.     }
  318. }
  319.                 else {
  320.     shift = (((7 - (j % 8)) % ppb) * depth);
  321.     *p |= transparent << shift;
  322.     if (shift == 0) {
  323. p++;
  324. newbyte = 1;
  325.     }
  326. }
  327.                 byte = byte >> 1;
  328.             }
  329.     
  330.     if (shift) {
  331. p++;   /* make sure we start on a new byte for the next line */
  332. newbyte = 1;
  333.     }
  334. }
  335.     }
  336.     else
  337.     {
  338. fprintf(stderr,"Icons for display depth %d unsupportedn", depth);
  339.         return NULL;
  340.     }
  342.     if ((ximage = XCreateImage(display, DefaultVisual(display, screen),
  343.              depth, ZPixmap, 0, (char *)data,
  344.              width, height, (depth == 24 ? 32 :(depth == 16 ? 16 : 8)), 0)) == 0)
  345.     {
  346.         Warn("Failed to create XImage: %s", image->url);
  347.         Free(data);
  348. Free(image);
  349.         return DefaultImage();
  350.     }
  352.     /* howcome 22/2/95: do we need to set these?? */
  354.     ximage->byte_order = MSBFirst;
  355.                        
  356.     ximage->bitmap_bit_order = BitmapBitOrder(display);
  358.     if ((pixmap = XCreatePixmap(display, win, width, height, depth)) == 0)
  359.     {
  360.         Warn("Failed to create Pixmap: %s", image->url);
  361.         XDestroyImage(ximage); /* also free's image data */
  362. Free(image);
  363.         return DefaultImage();
  364.     }
  366.     drawGC = XCreateGC(display, pixmap, 0, 0);
  367.     XSetFunction(display, drawGC, GXcopy);
  368.     XPutImage(display, pixmap, drawGC, ximage, 0, 0, 0, 0, width, height);
  369.     XFreeGC(display, drawGC);
  370.     XDestroyImage(ximage);  /* also free's image data */
  372.     /* janet 27/07/95: image not always freed! */
  373.     Free(image); 
  374.       
  375.     image = (Image *)malloc(sizeof(Image));
  376.     image->url = name;
  377.     image->npixels = 0;
  378.     image->pixels = 0;
  379.     image->next = NULL;
  380.     image->width = width;
  381.     image->height = height;
  382.     image->pixmap = pixmap;
  383.     return image;    
  384. }
  386. void MakeIcons(unsigned int depth)
  387. {
  388.     note_image = MakeIcon(depth, "note", note_width, note_height, note_bits);
  389.     caution_image = MakeIcon(depth, "caution", caution_width, caution_height, caution_bits);
  390.     warning_image = MakeIcon(depth, "warning", warning_width, warning_height, warning_bits);
  391. }
  393. unsigned char *gamma_table=NULL;
  396. static unsigned int
  397. range (unsigned int val, unsigned int max)
  398. {
  399.   return (val > max) ? max : val;
  400. }
  402. void
  403. build_gamma_table()
  404. {
  405.   if (!gamma_table) {
  406.     int i;
  407.     double file_gamma = 1.0/2.2;
  408.     double g = 1.0 / (file_gamma * Gamma);
  409.   
  410.     gamma_table = (unsigned char *) malloc(256 * sizeof(char));
  411.     for (i = 0; i < 256; i++)
  412. gamma_table[i] = (unsigned char)range((pow((double)i / 255.0, g) * 255.0), 255);
  413.   }
  414. }
  417. void
  418. free_gamma_table()
  419. {
  420.   if(gamma_table){
  421.     free(gamma_table);
  422.     gamma_table=NULL;
  423.   }
  424. }
  426. int AllocGreyScale(void)
  427. {
  428.     unsigned long g;
  429.     XColor color;
  431.     greymap[0] = BlackPixel(display, screen);
  432.     greymap[15] = WhitePixel(display, screen);
  434. /*    mycmap[128 & 0] = BlackPixel(display, screen);
  435.     mycmap[128 & 15] = WhitePixel(display, screen);
  436.     */
  437.     for (g = !OwnColorMap; g < 16+OwnColorMap; ++g)
  438.     {
  439.         color.red = color.green = color.blue = (g * 65535)/15;
  441.      /* map brightness values into voltages for Gamma correction */
  443.         color.red = Brightness2Voltage(color.red);
  444.         color.green = Brightness2Voltage(color.green);
  445.         color.blue = Brightness2Voltage(color.blue);
  447.         if (XAllocColor(display, colormap, &color) == 0)
  448.         {
  449.             fprintf(stderr, "Can't allocate standard grey paletten");
  451.             while (g > 1)
  452.                 XFreeColors(display, colormap, &(greymap[--g]), 1, 0);
  454.             return 0;
  455.         }
  456.         greymap[g] = color.pixel;
  457. /* mycmap[128 & g] = color.pixel;*/
  458.     }
  460.     return 1;
  461. }
  464. int AllocStandardColors(void)
  465. {
  466.     unsigned long i;
  467.     XColor colors[128];  /* howcome 5/10/94 */
  468.     int status[128];  /* howcome 5/10/94 */
  469.     XColor color;
  470.     int color_ok=1;
  472.     stdcmap[0] = BlackPixel(display, screen);
  473.     stdcmap[127] = WhitePixel(display, screen);
  475.     mycmap[0] = BlackPixel(display, screen);
  476.     mycmap[127] = WhitePixel(display, screen);
  478.     for (i = 0; i < 128; ++i)
  479.     {
  480. #if 0
  481. double gammaC = 0.7;
  482.         color.red = /*(i & 0x3) * 65535/3 ; */ pow((((double)(i & 0x3))/3.0), gammaC)*65535;
  483.         color.green = /*((i >> 2) & 0x7) * 65535/7 ;*/ pow((((double)((i >> 2) & 0x7))/7.0), gammaC)*65535;    
  484.         color.blue = /*((i >> 5) & 0x3) * 65535/3 ;*/ pow((((double)((i >> 5) & 0x3))/3.0), gammaC)*65535;
  485. #endif
  486. color.red = (i & 0x3) * 65535/3;
  487.         color.green = ((i >> 2) & 0x7) * 65535/7;
  488.         color.blue = ((i >> 5) & 0x3) * 65535/3;
  490. if (COLOR_TRACE)
  491.     fprintf(stderr,"AllocStandardColors exact %d %d %dn", (color.red >> 8), (color.green >> 8), (color.blue >> 8));
  493. /* howcome 5/10/94: added support for XAllocColors which will
  494.            speed things up. */
  496. /* map brightness values into voltages for Gamma correction */
  498. colors[i].red = Brightness2Voltage(color.red);
  499.         colors[i].green = Brightness2Voltage(color.green);
  500.         colors[i].blue = Brightness2Voltage(color.blue);
  501. #if 0
  502. colors[i].red = color.red;
  503.         colors[i].green = color.green;
  504.         colors[i].blue = color.blue; 
  505. #endif
  506. if (COLOR_TRACE)
  507.     fprintf(stderr,"AllocStandardColors %d %d %dn", (colors[i].red >> 8), (colors[i].green >> 8), (colors[i].blue >> 8));
  508.     }
  510.     /* howcome 5/10/94: here comes the one and only call to XAllocColors */
  512.     if (!OwnColorMap)
  513.     {
  514. if (XAllocColors(display, colormap, colors, i, status)) {
  515.     for (i = 1; i < 127; i++ ) {
  516. stdcmap[i] = colors[i].pixel;
  517. mycmap[i] = colors[i].pixel;
  518.     }
  519. } else {
  520.     int j;
  521.     for(j = 1; j < i ; j++)
  522. if (status[j])
  523.     XFreeColors( display, colormap, &colors[j].pixel, 1, 0L );
  524.     OwnColorMap = 1; /* --Spif 25-Oct-95 -cm flag now works */
  525.     color_ok=0;
  526. }
  527.     };
  528.   
  529.     /* howcome 10/8/05: added support for own colormap */
  531.     if (OwnColorMap) {
  532. int j;
  533. if(!color_ok) {
  534.     fprintf(stderr,"Can't alloc colors, creating new colormap..n");
  535.     for(i=1; i < 15 ; i++)
  536. XFreeColors(display, colormap, &(greymap[i]), 1, 0);
  537. };
  538. colormap = XCreateColormap(display, RootWindow(display, screen),
  539.    visual, AllocNone);
  540. AllocGreyScale();
  541. for(j=0;j<128;j++)
  542. {
  543.     if (XAllocColor(display, colormap, &colors[j]) == 0)
  544.     {
  545. int g;
  546. fprintf(stderr, "FATAL ERROR:Can't allocate my own palette!!n");
  547. g=j;
  548. while (g > 1)
  549.     XFreeColors(display, colormap, &(stdcmap[--g]), 1, 0);
  550. return 0;
  551.     };
  552.     stdcmap[j] = colors[j].pixel;
  553.     mycmap[j] = colors[j].pixel;
  554. }
  556. return 1; /* assume success, what could go wrong? */
  558.     }
  560.     return 1;
  561. }
  563. int SupportTrueColor(void)
  564. {
  565.     long visual_info_mask;
  566.     int number_visuals, i, flag;
  567.     XVisualInfo *visual_array, visual_info_template;
  569.     visual_info_template.screen = DefaultScreen(display);
  570.     visual_info_mask = VisualClassMask | VisualScreenMask;
  572.     visual_info_template.class = TrueColor;
  573.     visual_array = XGetVisualInfo(display, visual_info_mask,
  574.                         &visual_info_template,
  575.                         &number_visuals);
  577.     for (i = flag = 0; i < number_visuals; ++i)
  578.     {
  579. if (visual_array[i].depth == 16)
  580. {
  581.     long int maskval;
  582.     int j=0, k;
  584.     maskval = (*visual).blue_mask;
  585.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  586.     maskval = (*visual).blue_mask;
  587.     BPixelMask = 0;
  588.     for(k=0; k<16; k++)
  589.     {
  590. if(maskval & 1)
  591. {
  592.     if(!BPixelMask)
  593. BPixelMask = 1;
  594.     else
  595. BPixelMask += BPixelMask + 1;
  596. };
  597. maskval = maskval >> 1;
  598.     }
  599.     j=0;
  600.     maskval = (*visual).green_mask;
  601.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  602.     GPixelShift = j;
  603.     GPixelMask = 0;
  604.     for(k=0; k<16; k++)
  605.     {
  606. if(maskval & 1)
  607. {
  608.     if(!GPixelMask)
  609. GPixelMask = 1;
  610.     else
  611. GPixelMask += GPixelMask + 1;
  612. };
  613. maskval = maskval >> 1;
  614.     }
  615.     j=0;
  616.     maskval = (*visual).red_mask;
  617.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  618.     RPixelShift = j;
  619.     RPixelMask = 0;
  620.     for(k=0; k<16; k++)
  621.     {
  622. if(maskval & 1)
  623. {
  624.     if(!RPixelMask)
  625. RPixelMask = 1;
  626.     else
  627. RPixelMask += RPixelMask + 1;
  628. };
  629. maskval = maskval >> 1;
  630.     };
  631.             flag = 1;
  632. }
  633. if (visual_array[i].depth == 24)
  634.         {
  635.     long int maskval;
  636.     int j=0;
  637.     
  638.     maskval = (*visual).blue_mask;
  639.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  640.     BPixelShift = j;
  641.     j=0;
  642.     maskval = (*visual).green_mask;
  643.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  644.     GPixelShift = j;
  645.     j=0;
  646.     maskval = (*visual).red_mask;
  647.     while ((maskval & 1) == 0) { j++; maskval = maskval >> 1; }
  648.     RPixelShift = j;
  649.             flag = 1;
  650.             break;
  651. }
  652.     }
  654.     XFree((void *)visual_array);
  655.     return flag;
  656. }
  658. int InitImaging(int ColorStyle)
  659. {
  660.     imaging = MONO;
  661.     
  662.     build_gamma_table();
  663.     
  664.     greymap[0] = BlackPixel(display, screen);
  665.     greymap[15] = WhitePixel(display, screen);
  667.     if (ColorStyle == MONO)
  668.     {
  669.         imaging = ColorStyle;
  670.         return imaging;
  671.     }
  673.     if (ColorStyle == COLOR888 && SupportTrueColor())
  674.     {
  675.         imaging = ColorStyle;
  676.         return imaging;
  677.     }
  679.     if(OwnColorMap)
  680. if (AllocStandardColors())
  681. {
  682.     imaging = COLOR232;
  683.     return imaging;
  684. };
  685.     
  686.     if (AllocGreyScale())
  687.     {
  688.         imaging = GREY4;
  690.         if (ColorStyle == GREY4)
  691.             return imaging;
  693.         if (AllocStandardColors())
  694.             imaging = COLOR232;
  695.     } else 
  696. if(OwnColorMap)
  697.     if (AllocStandardColors())
  698. imaging = COLOR232;
  699.     return imaging;
  700. }
  702. void ReportVisuals(void)
  703. {
  704.     long visual_info_mask;
  705.     int number_visuals, i;
  706.     XVisualInfo *visual_array, visual_info_template;
  708.     visual_info_template.screen = DefaultScreen(display);
  710.     visual_info_mask = VisualClassMask | VisualScreenMask;
  712.     printf("TrueColor:n");
  714.     visual_info_template.class = TrueColor;
  715.     visual_array = XGetVisualInfo(display, visual_info_mask,
  716.                         &visual_info_template,
  717.                         &number_visuals);
  719.     for (i = 0; i < number_visuals; ++i)
  720.     {
  721.         printf("  visual Id 0x%xn", visual_array[i].visualid);
  722.         printf("  depth = %d, bits per rgb = %d, size = %dn", visual_array[i].depth,
  723.                     visual_array[i].bits_per_rgb, visual_array[i].colormap_size);
  724.         printf("   rgb masks %lx, %lx, %lxn", visual_array[i].red_mask,
  725.                     visual_array[i].green_mask, visual_array[i].blue_mask);
  726.     }
  728.     XFree((void *)visual_array);
  730.     printf("DirectColor:n");
  732.     visual_info_template.class = DirectColor;
  733.     visual_array = XGetVisualInfo(display, visual_info_mask,
  734.                         &visual_info_template,
  735.                         &number_visuals);
  737.     for (i = 0; i < number_visuals; ++i)
  738.     {
  739.         printf("  visual Id 0x%xn", visual_array[i].visualid);
  740.         printf("  depth = %d, bits per rgb = %d, size = %dn", visual_array[i].depth,
  741.                     visual_array[i].bits_per_rgb, visual_array[i].colormap_size);
  742.         printf("   rgb masks %lx, %lx, %lxn", visual_array[i].red_mask,
  743.                     visual_array[i].green_mask, visual_array[i].blue_mask);
  744.     }
  746.     XFree((void *)visual_array);
  748.     printf("PseudoColor:n");
  750.     visual_info_template.class = PseudoColor;
  751.     visual_array = XGetVisualInfo(display, visual_info_mask,
  752.                         &visual_info_template,
  753.                         &number_visuals);
  755.     for (i = 0; i < number_visuals; ++i)
  756.     {
  757.         printf("  visual Id 0x%xn", visual_array[i].visualid);
  758.         printf("  depth = %d, bits per rgb = %d, size = %dn", visual_array[i].depth,
  759.                     visual_array[i].bits_per_rgb, visual_array[i].colormap_size);
  760.         printf("   rgb masks %lx, %lx, %lxn", visual_array[i].red_mask,
  761.                     visual_array[i].green_mask, visual_array[i].blue_mask);
  762.     }
  764.     XFree((void *)visual_array);
  765. }
  767. void ReportStandardColorMaps(Atom which_map)
  768. {
  769.     XStandardColormap *std_colormaps;
  770.     int i, number_colormaps;
  771.     char *atom_name;
  773.     if (XGetRGBColormaps(display, RootWindow(display, screen),
  774.             &std_colormaps, &number_colormaps, which_map) != 0)
  775.     {
  776.         atom_name = XGetAtomName(display, which_map);
  777.         printf("nPrinting %d standard colormaps for %sn",
  778.                 number_colormaps, atom_name);
  779.         XFree(atom_name);
  781.         for  (i = 0; i < number_colormaps; ++i)
  782.         {
  783.             printf("tColormap: 0x%xn", std_colormaps[i].colormap);
  784.             printf("tMax cells (rgb): %d, %d, %dn",
  785.                 std_colormaps[i].red_max,
  786.                 std_colormaps[i].green_max,
  787.                 std_colormaps[i].blue_max);
  788.             printf("tMultipliers: %d, %d, %dn",
  789.                 std_colormaps[i].red_mult,
  790.                 std_colormaps[i].green_mult,
  791.                 std_colormaps[i].blue_mult);
  792.             printf("tBase pixel: %dn", std_colormaps[i].base_pixel);
  793.             printf("tVisual Id 0x%x, Kill Id 0x%xn",
  794.                 std_colormaps[i].visualid,
  795.                 std_colormaps[i].killid);
  796.         }
  798.         XFree((void *)std_colormaps);
  799.     }
  800. }
  802. XColor paperrgb[3];
  804. /* Init paperrgb */
  805. void InitPaperRGB ()
  806. {
  807.   int i;
  808.   
  809.   for (i=0; i<3; i++) {
  810.     int r=0, g=0, b=0;
  811.     switch(i) {
  812.       case 0:
  813. r=230; g=218; b=194;
  814. break;
  815.       case 1:
  816. r=220; g=209; b=186;
  817. break;
  818.       case 2:
  819. r=210; g=199; b=177;
  820. break;
  821.     }
  822.   
  823.     paperrgb[i].red=gamma_table[r];
  824.     paperrgb[i].green=gamma_table[g];
  825.     paperrgb[i].blue=gamma_table[b];
  826.   }
  827. }   
  830. /* Barely used colormap */
  831. XColor papercols[256];
  834. /* create a textured background as paper */
  835. unsigned char *CreateBackground(unsigned int width, unsigned int height, unsigned int depth)
  836. {
  837.     unsigned char *data, *p;
  838.     int size, i, j;
  839.     unsigned long cs[3]; /* howcome 21/9/94 */
  840.     unsigned long int ulp;
  841.     
  842.     if (depth == 8)
  843.     {
  844.       /* howcome 4/10/94: changed last arg to GetColor */
  845.       
  846.       int i;
  847.       for (i=0; i<3; i++) {
  848. int r, g, b;
  849. r=paperrgb[i].red;
  850. g=paperrgb[i].green;
  851. b=paperrgb[i].blue;
  852. if (!GetColor(r, g, b, &cs[i]))
  853.   return NULL;
  854. paperrgb[i].pixel=cs[i];
  855. papercols[cs[i]].red=r;
  856. papercols[cs[i]].green=g;
  857. papercols[cs[i]].blue=b;
  858.       }
  860.       size = width * height;
  861.     }
  862.     else if (depth == 24)
  863.         size = width * height * 4;
  864.     else if (depth == 16)
  865. size = width * height *2;
  866.     else
  867.         return NULL;
  869.     p = data = (unsigned char *)malloc(size);
  871.     if (data == NULL)
  872.         return NULL;
  874.     srand(0x6000);
  876.     if (depth == 8)
  877.     {
  878.         for (i = 0; i < height; ++i)
  879.             for (j = 0; j < width; ++j)
  880.             {
  881.                 /* howcome 21/9/94: rand returns different ranges on different platforms, therefore: */
  882.             
  883.       *p++ = paperrgb[rand() % 3].pixel;
  884.             }
  885.     }
  886.     else if (depth == 24)
  887.     {
  888.         for (i = 0; i < height; ++i)
  889.             for (j = 0; j < width; ++j)
  890.     {
  891. int col,r,g,b;
  892.                 
  893. col=rand() % 3;
  895. r=paperrgb[col].red;
  896. g=paperrgb[col].green;
  897. b=paperrgb[col].blue;
  899. GetColor(r, g, b, &ulp);
  900.                 
  901. *p++ = '';
  902. *p++ = (ulp >> 16) & 0xff; 
  903. *p++ = (ulp >> 8) & 0xff; 
  904. *p++ = ulp & 0xff; 
  905. #if 0
  906. *p++ = '';
  907. *p++ = paperrgb[col].red;
  908. *p++ = paperrgb[col].green;
  909. *p++ = paperrgb[col].blue;
  910. #endif
  911.             }
  912.     } else if (depth == 16) 
  913.     {
  914.  for (i = 0; i < height; ++i)
  915.             for (j = 0; j < width; ++j)
  916.     {
  917. int col,r,g,b;
  918.                 
  919. col=rand() % 3;
  920. r=paperrgb[col].red;
  921. g=paperrgb[col].green;
  922. b=paperrgb[col].blue;
  924. GetColor(r, g, b, &ulp);
  925.                 
  926. *p++ = ((char*)&ulp)[1]; 
  927. *p++ = ((char*)&ulp)[0]; 
  928.     }
  929.     }
  930.     return data;
  931. }
  933. #if 0  /* used to allow for nested comments */
  934. /* XPM */
  935. /********************************************************/
  936. /**   (c) Copyright Hewlett-Packard Company, 1992.     **/
  937. /********************************************************/
  938. static char ** arizona.l.px  = {
  939. /* width height ncolors cpp [x_hot y_hot] */
  940. "28 38 13 1",
  941. /* colors */
  942. "   s iconColor2    m white c white",
  943. ".  s iconGray2     m white c #c8c8c8c8c8c8",
  944. "X  s iconColor1    m black c black",
  945. "o  s iconGray6     m black c #646464646464",
  946. "O  s iconGray3     m white c #afafafafafaf",
  947. "+  s iconColor3    m black c red",
  948. "@  s iconColor8    m white c magenta",
  949. "#  s iconGray4     m white c #969696969696",
  950. "$  s iconGray5     m black c #7d7d7d7d7d7d",
  951. "%  s iconColor6    m white c yellow",
  952. "&  s iconGray1     m white c #e1e1e1e1e1e1",
  953. "*  s iconColor4    m black c green",
  954. "=  s bottomShadowColor     m black c #646464646464",
  955. /* pixels */
  956. "                            ",
  957. " ..........................X",
  958. " ..............oo..........X",
  959. " .........OOOoo+@@oooOOOOOOX",
  960. " .....OOOoooo@####@+ooooo..X",
  961. " ..ooo#oo+@###$$$$#####OOO.X",
  962. " ..OOOOOO###$$....$$#@+ooo.X",
  963. " .......+@#$.%%%%%%.$###OOOX",
  964. " ..o.ooo..$.%%%%%%%%%$#@+ooX",
  965. and so on, ending with:
  966. " XXXXXXXXXXXXXXXXXXXXXXXXXXX"};
  967. #endif
  969. #define NEXTCHAR(s) (*s ? *s++ : '')
  971. static char *FindCh(char *s, char ch)
  972. {
  973.     char c;
  975.     for (;;)
  976.     {
  977.         c = NEXTCHAR(s);
  979.         if (c == ch || c == '')
  980.             return s;
  981.     }
  982. }
  984. /* *c to first char and return last word */
  986. static char *ReadColor(char *s, char **name, int *ch)
  987. {
  988.     char *p;
  989.     int c;
  990.     static char line[256];
  992.     s = FindCh(s, '"');
  993.     *ch = NEXTCHAR(s);
  994.     p = line;
  996.     while ((c = NEXTCHAR(s)) != '"' && c != '' && p < line+255)
  997.         *p++ = c;
  999.     *p = '';
  1000.     p = strrchr(line, ' ');
  1002.     if (p)
  1003.         ++p;
  1005.     *name = p;
  1006.     return s;
  1007. }
  1009. unsigned char *Transparent(unsigned char *p, int x, int y)
  1010. {
  1011.     unsigned int i;
  1012.     unsigned char *s;
  1014.     if (tileData)
  1015.     {
  1016.         x = x % tileWidth;
  1017.         y = y % tileHeight;
  1018.         i = y * tileWidth + x;
  1020. if (depth == 24)
  1021.         {
  1022.             s = tileData + 4 * i;
  1023.     
  1024.             *p++ = *s++;
  1025.             *p++ = *s++;
  1026.             *p++ = *s++;
  1027.             *p++ = *s++;
  1028.     
  1029.             return p;
  1030.         }
  1032. if (depth == 16)
  1033. {
  1034.     s = tileData + 2 * i;
  1035.     
  1036.     *p++ = *s++;
  1037.     *p++ = *s++;
  1038.     
  1039.     return p;
  1040. };
  1042. *p++ = gamma_table[tileData[i]];
  1043. return p;
  1044.     }
  1046.     if (depth == 24)
  1047.     {
  1048.         *p++ = '';
  1049.         *p++ = (transparent  >> 16) & 0xFF;
  1050.         *p++ = (transparent  >> 8) & 0xFF;
  1051. *p++ = transparent & 0xFF;
  1052.         return p;
  1053.     }
  1055.     if (depth == 16) 
  1056.     {
  1057. *p++ = (transparent  >> 8) & 0xFF;
  1058. *p++ = transparent & 0xFF;
  1059.         return p;
  1060.     };
  1062.     *p++ = transparent;
  1063.     return p;
  1064. }
  1066. /* load data from an XPM file and allocate colors */
  1068. char *LoadXpmImage(Image *image, Block *bp, unsigned int depth)
  1069. {
  1070.     int c, i, j, cr, cg, cb, r, g, b, ncolors, size, map[256];
  1071.     unsigned int width, height;
  1072.     /*    unsigned long pixel, *pixdata; */ /* janet 21/07/95: not used */
  1073.     unsigned char *data = NULL, *p;
  1074.     unsigned long ccolor;
  1075.     char *name, *s;
  1076.     Color *colors, color;
  1077.     XColor xcolor;
  1079.     s = bp->buffer + bp->next;
  1081.     s = FindCh(s, '"');
  1082.     sscanf(s, "%d %d %d", &width, &height, &ncolors);
  1083.     s = FindCh(s, 'n');
  1085.     size = width * height;
  1086.     image->width = width;
  1087.     image->height = height;
  1089.     if (size == 0 || ncolors == 0)
  1090.         return NULL;
  1093.     if (depth != 8 && depth != 24 && depth != 4 && depth != 2 && depth != 1)
  1094.     {
  1095.         printf("Display depth %d unsupportedn", depth);
  1096.         return NULL;
  1097.     }
  1099.     image->npixels = 0;
  1100.     image->pixels = 0; /*(unsigned long *)malloc(ncolors * sizeof(unsigned long)); */
  1102.     colors = (Color *)malloc(ncolors * sizeof(Color));
  1104.     for (i = 0; i < 256; ++i)
  1105.         map[i] = -1;
  1107.     for (i = 0; i < ncolors; ++i)
  1108.     {
  1109.         s = ReadColor(s, &name, &c);
  1111.         if (XParseColor(display, colormap, name, &xcolor) == 0)
  1112.         {
  1113.             map[c] = -1;
  1114.             continue;
  1115.         }
  1117.         map[c] = i;
  1118.         r = xcolor.red >> 8;
  1119.         g = xcolor.green >> 8;
  1120.         b = xcolor.blue >> 8;
  1122.      /* apply Gamma correction to map voltages to brightness values */
  1124.         if (imaging != COLOR888)
  1125.         {
  1126.     /*
  1127.     r = gamma_table[r];
  1128.             g = gamma_table[g];
  1129.             b = gamma_table[b];*/
  1130.     r = Voltage2Brightness(r);
  1131.     g = Voltage2Brightness(g);
  1132.     b = Voltage2Brightness(b);
  1133.         }
  1135.         colors[i].red = r;
  1136.         colors[i].green = g;
  1137.         colors[i].blue = b;
  1138.         colors[i].grey = (3*r + 6*g + b)/10;
  1139.     }
  1142.     if (depth == 8)
  1143.     {
  1144.         p = data = malloc(size);
  1146.         for (i = 0; i < height; ++i)
  1147.         {
  1148.             s = FindCh(s, '"');
  1150.             for (j = 0; j < width; ++j)
  1151.             {
  1152.                 c = *s++;
  1153.                 c = map[c];
  1155.                 if (c < 0)
  1156.                 {
  1157.                     p = Transparent(p, j, i);
  1158.                     continue;
  1159.                 }
  1161.                 color = colors[c];
  1162.                 c = ((i % 16) << 4) + (j % 16);
  1164.                 if (imaging == COLOR232)
  1165.                 {
  1166.                     cr = color.red;
  1167.                     cg = color.green;
  1168.                     cb = color.blue;
  1170.                     if (cr == cg  && cg == cb)
  1171.                     {
  1172.                         cg  = color.grey;
  1173.                         g = cg & 0xF0;
  1175.                         if (cg - g > Magic16[c])
  1176.                             g += 16;
  1178.                         g = min(g, 0xF0);
  1179.                         *p++ = greymap[g >> 4];
  1180.                     }
  1181.                     else
  1182.                     {
  1183.                         r = cr & 0xC0;
  1184.                         g = cg & 0xE0;
  1185.                         b = cb & 0xC0;
  1187.                         if (cr - r > Magic64[c])
  1188.                             r += 64;
  1190.                         if (cg - g > Magic32[c])
  1191.                             g += 32;
  1193.                         if (cb - b > Magic64[c])
  1194.                             b += 64;
  1196.                         r = min(r, 255) & 0xC0;
  1197.                         g = min(g, 255) & 0xE0;
  1198.                         b = min(b, 255) & 0xC0;
  1200.                         *p++ = stdcmap[(r >> 6) | (g >> 3) | (b >> 1)];
  1201.                     }
  1202.                 }
  1203.                 else if (imaging == GREY4)
  1204.                 {
  1205.                     cg  = color.grey;
  1206.                     g = cg & 0xF0;
  1208.                     if (cg - g > Magic16[c])
  1209.                         g += 16;
  1211.                     g = min(g, 0xF0);
  1212.                     *p++ = greymap[g >> 4];
  1213.                 }
  1214.                 else /* MONO */
  1215.                 {
  1216.                     if (color.grey < Magic256[c])
  1217.                         *p++ = greymap[0];
  1218.                     else
  1219.                         *p++ = greymap[15];
  1220.                 }
  1221.             }
  1223.             s = FindCh(s, 'n');
  1224.         }
  1225.     }
  1226.     else if (depth == 24)
  1227.     {
  1228.         p = data = malloc(size * 4);
  1230.         for (i = 0; i < height; ++i)
  1231.         {
  1232.             s = FindCh(s, '"');
  1234.             for (j = 0; j < width; ++j)
  1235.             {
  1236.                 if ((c = map[*s++]) < 0)
  1237.                 {
  1238.                     p = Transparent(p, j, i);
  1239.                     continue;
  1240.                 };
  1242.                 color = colors[c];
  1243.                 *p++ = '';
  1244.                 *p++ = color.red;
  1245.                 *p++ = color.green;
  1246.                 *p++ = color.blue;
  1247.             }
  1249.             s = FindCh(s, 'n');
  1250.         }
  1251.     } 
  1252.     else if (depth == 16)
  1253.     {
  1254. p = data = malloc(size * 2);
  1256.         for (i = 0; i < height; ++i)
  1257.         {
  1258.             s = FindCh(s, '"');
  1259.     
  1260.             for (j = 0; j < width; ++j)
  1261.             {
  1262.                 if ((c = map[*s++]) < 0)
  1263.                 {
  1264.                     p = Transparent(p, j, i);
  1265.                     continue;
  1266.                 };
  1268.                 color = colors[c];
  1269. GetColor(color.red, color.green, color.blue, &ccolor);
  1270.                 *p++ = (ccolor >> 8 )& 0xff;
  1271.                 *p++ = (ccolor & 0xff);
  1272.     }
  1273.     s = FindCh(s, 'n');
  1274.         }
  1275.     }
  1276.     else if (depth == 1 || depth == 2 || depth == 4)  /* howcome added support for these */
  1277.     {
  1278. int             ppb, bpl, shift = 0;
  1279. int newbyte;
  1281. ppb = 8/depth; /* pixels per byte */
  1282. bpl = width/ppb + (width%ppb ? 1 : 0); /* bytes per line */
  1284.         p = data = (unsigned char *)malloc(bpl * height);
  1285. newbyte = 1;
  1287.         for (i = 0; i < height; ++i)
  1288. {
  1289.             s = FindCh(s, '"');
  1291.             for (j = 0; j < width; ++j)
  1292.             {
  1293. if (newbyte) {
  1294.     *p = 0;
  1295.     newbyte = 0;
  1296. }
  1298. c = *s++;
  1299.                 c = map[c];
  1301.                 if (c < 0)
  1302.                 {
  1303.     shift = (((7 - (j % 8)) % ppb) * depth);
  1304.     *p |= transparent << shift;
  1305.     if (shift == 0) {
  1306. p++;
  1307. *p = 0;
  1308.     }
  1309.                     continue;
  1310.                 }
  1312.                 color = colors[c];
  1313.                 c = ((i % 16) << 4) + (j % 16);
  1315.                 if (imaging == COLOR232)
  1316.                 {
  1317.                     cr = color.red;
  1318.                     cg = color.green;
  1319.                     cb = color.blue;
  1321.                     if (cr == cg  && cg == cb)
  1322.                     {
  1323.                         cg  = color.grey;
  1324.                         g = cg & 0xF0;
  1326.                         if (cg - g > Magic16[c])
  1327.                             g += 16;
  1329.                         g = min(g, 0xF0);
  1331. shift = (((7 - (j % 8)) % ppb) * depth);
  1332. *p |= greymap[g >> 4] << shift;
  1333. if (shift == 0) {
  1334.     p++;
  1335.     newbyte = 1;
  1336. }
  1338.                     }
  1339.                     else
  1340.     {
  1341.                         r = cr & 0xC0;
  1342.                         g = cg & 0xE0;
  1343.                         b = cb & 0xC0;
  1345.                         if (cr - r > Magic64[c])
  1346.                             r += 64;
  1348.                         if (cg - g > Magic32[c])
  1349.                             g += 32;
  1351.                         if (cb - b > Magic64[c])
  1352.                             b += 64;
  1354.                         r = min(r, 255) & 0xC0;
  1355.                         g = min(g, 255) & 0xE0;
  1356.                         b = min(b, 255) & 0xC0;
  1358. shift = (((7 - (j % 8)) % ppb) * depth);
  1359. *p |= stdcmap[(r >> 6) | (g >> 3) | (b >> 1)] << shift;
  1360. if (shift == 0) {
  1361.     p++;
  1362.     newbyte = 1;
  1363. }
  1364.                     }
  1365.                 }
  1366.                 else if (imaging == GREY4)
  1367.                 {
  1368.                     cg  = color.grey;
  1369.                     g = cg & 0xF0;
  1371.                     if (cg - g > Magic16[c])
  1372.                         g += 16;
  1374.                     g = min(g, 0xF0);
  1376.     shift = (((7 - (j % 8)) % ppb) * depth);
  1377.     *p |= greymap[g >> 4] << shift;
  1378.     if (shift == 0) {
  1379. p++;
  1380. newbyte = 1;
  1381.     }
  1382.                 }
  1383.                 else /* MONO */
  1384.                 {
  1385.                     if (color.grey < Magic256[c]) {
  1386. shift = (((7 - (j % 8)) % ppb) * depth);
  1387. *p |= greymap[0] << shift;
  1388. if (shift == 0) {
  1389.     p++;
  1390.     newbyte = 1;
  1391. }
  1392.     }
  1393.                     else {
  1394. shift = (((7 - (j % 8)) % ppb) * depth);
  1395. *p |= greymap[15] << shift;
  1396. if (shift == 0) {
  1397.     p++;
  1398.     newbyte = 1;
  1399. }
  1400.     }
  1401. }
  1402.     }
  1404.     s = FindCh(s, 'n');
  1405.     
  1406.     if (shift) {
  1407.         p++;   /* make sure we start on a new byte for the next line */
  1408.         newbyte = 1;
  1409.     }
  1410. }
  1411.     }
  1413.     Free(colors);
  1414.     return (char *)data;
  1415. }
  1417. /* 
  1418.     Load data from an XBM file
  1420. #define back_width 20
  1421. #define back_height 23
  1422. static char back_bits[] = {
  1423.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x0f,
  1424.    0x00, 0x80, 0x0f, 0x00, 0x80, 0x0f, 0x00, 0x80, 0x0f, 0x00, 0x80, 0x0f,
  1425.    0x00, 0x80, 0x0f, 0x60, 0x80, 0x0f, 0x70, 0x80, 0x0f, 0x78, 0x00, 0x00,
  1426.    0xfc, 0xff, 0x0f, 0xfe, 0xff, 0x07, 0xff, 0xff, 0x03, 0xfe, 0xff, 0x01,
  1427.    0xfc, 0xff, 0x00, 0x78, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x00, 0x00,
  1428.    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  1430. So find line start with #define and read last number as width.
  1431. Repeat to get height. Should really look at names to avoid problems
  1432. if order is swapped, but probably won't be necessary.
  1434. Number of bytes of data is:     ((height * width) + 7)/8
  1436. Then skip to '{' char and then start reading data:
  1438.     whitespace or ',' followed by hex number
  1439. */
  1441. char *LoadXbmImage(Image *image, Block *bp, unsigned int depth)
  1442. {
  1443.     char *s;
  1444.     int c, i, j, k, size;
  1445.     unsigned int width, height, byte;
  1446.     unsigned char *data, *p;
  1448.     s = (char *)bp->buffer + bp->next;
  1450.     s = FindCh(s, '#');         /* find #define */
  1451.     s = FindCh(s, ' ');         /* find 1st space char */
  1452.     s = FindCh(s, ' ');         /* find 2nd space char */
  1453.     sscanf(s, "%d", &width);    /* and read width */
  1454.     s = FindCh(s, '#');         /* find next #define */
  1455.     s = FindCh(s, ' ');         /* find 1st space char */
  1456.     s = FindCh(s, ' ');         /* find 2nd space char */
  1457.     sscanf(s, "%d", &height);   /* and read width */
  1458.     s = FindCh(s, '{');         /* find opening brace for data */
  1460.     size = width * height;
  1461.     image->width = width;
  1462.     image->height = height;
  1464.     if (size == 0)
  1465.         return NULL;
  1467.     image->npixels = 0;
  1468.     image->pixels = 0;
  1470.     if (depth == 8)
  1471.     {
  1472.         p = data = (unsigned char *)malloc(size);
  1474.         for (i = 0; i < height; ++i)
  1475.             for (j = 0, k= 8; j < width; ++j)
  1476.             {
  1477.                 if (++k > 8)  /* need to read next 8 pixel values */
  1478.                 {
  1479.                     s = FindCh(s, '0');
  1480.                     sscanf(s+1, "%x", &byte); /* howcome 5/11/94: '-1' changed to '+1' since some don't like 0x */
  1481.                     while ((c = NEXTCHAR(s)) != ',' && c != '}');
  1482.                     k = 1;
  1483.                 }
  1485.                 if (byte & 0x01)
  1486.                     *p++ = textColor;
  1487.                 else
  1488.                     p = Transparent(p, j, i);
  1490.                 byte = byte >> 1;
  1491.             }
  1492.     }
  1493.     else if (depth == 24)
  1494.     {
  1495.         p = data = (unsigned char *)malloc(size * 4);
  1496.         
  1498.         for (i = 0; i < height; ++i)
  1499.             for (j = 0, k= 8; j < width; ++j)
  1500.             {
  1501.                 if (++k > 8)  /* need to read next 8 pixel values */
  1502.                 {
  1503.                     s = FindCh(s, '0');
  1504.                     sscanf(s-1, "%x", &byte);
  1505.                     while ((c = NEXTCHAR(s)) != ',' && c != '}');
  1506.                     k = 1;
  1507.                 }
  1509.                 if (byte & 1)
  1510.                 {
  1511.                     *p++ = '';
  1512.                     *p++ = (textColor >> 16) & 0xFF;
  1513.                     *p++ = (textColor >>  8) & 0xFF;
  1514.                     *p++ = textColor & 0xFF;
  1515.                 }
  1516.                 else
  1517.                     p = Transparent(p, j, i);
  1519.                 byte = byte >> 1;
  1520.             }
  1521.     }
  1522.     else if (depth == 16)
  1523.     {
  1524.         p = data = (unsigned char *)malloc(size * 2);
  1525.         
  1527.         for (i = 0; i < height; ++i)
  1528.             for (j = 0, k= 8; j < width; ++j)
  1529.             {
  1530.                 if (++k > 8)  /* need to read next 8 pixel values */
  1531.                 {
  1532.                     s = FindCh(s, '0');
  1533.                     sscanf(s-1, "%x", &byte);
  1534.                     while ((c = NEXTCHAR(s)) != ',' && c != '}');
  1535.                     k = 1;
  1536.                 }
  1538.                 if (byte & 1)
  1539.                 {
  1540.     *p++ = (textColor >>  8) & 0xFF;
  1541.                     *p++ = textColor & 0xFF;
  1542.                 }
  1543.                 else
  1544.                     p = Transparent(p, j, i);
  1546.                 byte = byte >> 1;
  1547.             }
  1548.     }
  1549.     else if (depth == 1 || depth == 2 || depth == 4)  /* howcome added support for these */
  1550.     {
  1551. int             ppb, bpl, shift;
  1552. int newbyte;
  1554. ppb = 8/depth; /* pixels per byte */
  1555. bpl = width/ppb + (width%ppb ? 1 : 0); /* bytes per line */
  1557.         p = data = (unsigned char *)malloc(bpl * height);
  1558. newbyte = 1;
  1560.         for (i = 0; i < height; ++i) {
  1561.             for (j = 0, k= 8; j < width; ++j)
  1562.             {
  1563. if (newbyte) {
  1564.       *p = 0;
  1565.               newbyte = 0;
  1566.           }
  1568.                 if (++k > 8)  /* need to read next 8 pixel values */
  1569.                 {
  1570.                     s = FindCh(s, '0');
  1571.                     sscanf(s+1, "%x", &byte); /* howcome 5/11/94: '-1' changed to '+1' since some don't like 0x */
  1572.                     while ((c = NEXTCHAR(s)) != ',' && c != '}');
  1573.                     k = 1;
  1574.                 }
  1576.                 if (byte & 0x01) {
  1577.     shift = (((7 - (j % 8)) % ppb) * depth);
  1578.     *p |= textColor << shift;
  1579. }
  1580.                 else {
  1581.     shift = (((7 - (j % 8)) % ppb) * depth);
  1582.     *p |= transparent << shift;
  1583. }
  1585. if (shift == 0) {
  1586.     p++;
  1587.     newbyte = 1;
  1588. }
  1590.                 byte = byte >> 1;
  1591.             }
  1593.     if (shift) {
  1594. p++;
  1595. newbyte = 1;
  1596.     }
  1597. }
  1598.     }
  1599.     else
  1600.     {
  1601.         Warn("image/x-xbitmap unsupported for depth %d", depth);
  1602.         return NULL;
  1603.     }
  1605.     return (char *)data;
  1606. }
  1609. Image *ProcessLoadedImage(Doc *doc)
  1610. {
  1611.     char *data;
  1612.     Image *image;
  1613.     Block block;
  1614.     unsigned int width, height;
  1615.     XImage *ximage;
  1616.     Pixmap pixmap;
  1617.     GC drawGC;
  1618.     HTAtom *a = NULL;
  1620.     if (doc && doc->anchor)
  1621. a = HTAnchor_format(doc->anchor->parent);
  1623.     image = (Image *)malloc(sizeof(Image));
  1624.     image->npixels = 0;
  1626.     block.next = 0;  /*NewDoc.hdrlen; */
  1627.     block.size = doc->loaded_length; /* NewDoc.length; */
  1628.     block.buffer = doc->content_buffer;
  1629.     
  1630.     if (!doc->content_buffer) { /* probably externally viewed image */
  1631.         doc->state = DOC_EXTERNAL;
  1632. return NULL;
  1633. /* return DefaultImage(image); */
  1634.     }
  1636.     Announce("Processing image %s...", doc->url);
  1637.     
  1638.     if (a == gif_atom)
  1639. {
  1640.     if ((data = (char *)LoadGifImage(image, &block, depth)) == NULL)
  1641. {
  1642.     Warn("Failed to load GIF image: %s", doc->url);
  1643.     Free(block.buffer);
  1644. /*     return DefaultImage(image); */
  1645.     doc->state = DOC_REJECTED;
  1646.     return NULL;
  1647. }
  1648. }
  1650.     else if (a == xpm_atom)
  1651. {
  1652.     if ((data = LoadXpmImage(image, &block, depth)) == NULL)
  1653. {
  1654.     Warn("Failed to load XPM image: %s", doc->url);
  1655.     Free(block.buffer);
  1656.     doc->state = DOC_REJECTED;
  1657. /*     return DefaultImage(image); */
  1658.     return NULL;
  1659. }
  1660. }
  1662.     else if (a == xbm_atom)
  1663. {
  1664.     if ((data = LoadXbmImage(image, &block, depth)) == NULL)
  1665. {
  1666.     Warn("Failed to load XBM image: %s", doc->url);
  1667.     Free(block.buffer);
  1668.     doc->state = DOC_REJECTED;
  1669. /*     return DefaultImage(image); */
  1670.     return NULL;
  1671. }
  1672. }
  1674. #ifdef JPEG
  1675.       else if (a == jpeg_atom)
  1676. {
  1677.     if ((data = LoadJPEGImage(image, &block, depth)) == NULL)
  1678. {
  1679.     Warn("Failed to load JPEG image: %s", doc->url);
  1680.     Free(block.buffer);
  1681.     doc->state = DOC_REJECTED;
  1682.     return NULL;
  1683. }
  1684. }
  1685. #endif /* JPEG */
  1688. #ifdef PNG
  1689.       else if (a == png_atom || a == png_exp_atom)
  1690. {
  1691.     if ((data = LoadPNGImage(image, &block, depth)) == NULL)
  1692. {
  1693.     Warn("Failed to load PNG image: %s", doc->url);
  1694.     Free(block.buffer);
  1695.     doc->state = DOC_REJECTED;
  1696.     return NULL;
  1697. }
  1698. }
  1699. #endif /* PNG */
  1701.       else
  1702. {
  1703.     Warn("Failed to load unknown image format: %s", doc->url);
  1704.     Free(block.buffer);
  1705.     doc->state = DOC_REJECTED;
  1706. /*     return DefaultImage(image); */
  1707.     return NULL;
  1708. }
  1709.     
  1710.     Free(block.buffer);
  1711.     doc->state = DOC_PROCESSED;
  1712.     doc->content_buffer = NULL; /* howcome 4/12/94: no need to keep the gif source around */
  1713.     width = image->width;
  1714.     height = image->height;
  1715.     
  1716.     if ((ximage = XCreateImage(display, DefaultVisual(display, screen),
  1717.        depth, ZPixmap, 0, data, width, height,
  1718.        (depth == 24 ? 32 :(depth == 16 ? 16 : 8)), 0)) == 0)
  1719. {
  1720.     Warn("Failed to create XImage: %s", doc->url);
  1721.     doc->state = DOC_REJECTED;
  1722.     Free(data);
  1723. /*      return DefaultImage(image);*/
  1724.     return NULL;
  1725. }
  1727.     /* howcome 22/2/95: do we need to set these?? */
  1729.     ximage->byte_order = MSBFirst;
  1730.     ximage->bitmap_bit_order = BitmapBitOrder(display);
  1731.        
  1732.     if ((pixmap = XCreatePixmap(display, win, width, height, depth)) == 0)
  1733. {
  1734.     Warn("Failed to create Pixmap: %s", doc->url);
  1735.     XDestroyImage(ximage); /* also free's image data */
  1736.     doc->state = DOC_REJECTED;
  1737. /*     return DefaultImage(image); */
  1738.     return NULL;
  1739. }
  1740.     
  1741.     drawGC = XCreateGC(display, pixmap, 0, 0);
  1742.     XSetFunction(display, drawGC, GXcopy);
  1743.     XPutImage(display, pixmap, drawGC, ximage, 0, 0, 0, 0, width, height);
  1744.     XFreeGC(display, drawGC);
  1745.     XDestroyImage(ximage);  /* also free's image data */
  1746.   
  1747.     image->pixmap = pixmap;
  1748.     image->width = width;
  1749.     image->height = height;
  1750.     doc->image = image;
  1751.     return doc->image;
  1752. }
  1755. Image *GetImage(char *href, int hreflen, BOOL reload)
  1756. {
  1757.     Doc *doc = NULL;
  1759.     /* check for null name */
  1761.     if ((doc = GetInline(href, hreflen, reload))) {
  1762. if (doc->image)
  1763.     return (doc->image);
  1764. else
  1765.     return (ProcessLoadedImage(doc));
  1766.     }
  1767.     
  1768.     return NULL;
  1769. }
  1774. void FreeImages(int cloned)
  1775. {
  1776.     Image *im;
  1778.     while (images)
  1779.     {
  1780.         /* deallocate colors */
  1782.         if (!cloned && images->npixels > 0)
  1783.             XFreeColors(display, colormap, images->pixels, images->npixels, 0);
  1785.         /* free pixmap and image structure */
  1787.         if (!cloned && images->pixmap != default_pixmap)
  1788.             XFreePixmap(display, images->pixmap);
  1790.         im = images;
  1791.         images = im->next;
  1792.         Free(im->url);
  1794.         if (im->npixels > 0)
  1795.             Free(im->pixels);
  1797.         Free(im);
  1798.     }
  1799. }