home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / xicon05.zip / xbmread.c < prev    next >
C/C++ Source or Header  |  1993-05-06  |  9KB  |  350 lines
  1. /* This file is xbmread.c (part of XIcon)
  2.  *
  3.  * Copyright (C) 1993 by Norman Walsh
  4.  *
  5.  *   This program is free software; you can redistribute it and/or modify
  6.  *   it under the terms of the GNU General Public License as published by
  7.  *   the Free Software Foundation; either version 2 of the License, or
  8.  *   (at your option) any later version.
  9.  *
  10.  *   This program is distributed in the hope that it will be useful,
  11.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *   GNU General Public License for more details.
  14.  *
  15.  *   You should have received a copy of the GNU General Public License
  16.  *   along with this program; if not, write to the Free Software
  17.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  ************************************************************************/
  19.  
  20. #include <stdio.h>
  21. #include "xbmread.h"
  22. #include "iconio.h"
  23. #include "icondata.h"
  24. #include "iconvars.h"
  25. #include "generic.h"
  26. #include "bitmap.h"
  27. #include "palette.h"
  28. #include "xbmdata.h"
  29.  
  30. int XBMrevbits;
  31. int XBMforg;
  32. int XBMback;
  33.  
  34. extern int ReadXBM(FILE *, ULONG *, ULONG *, BYTE **);
  35.  
  36. BYTE revbits(BYTE b)
  37. {
  38.   BYTE inmask, outmask;
  39.   BYTE outchar;
  40.  
  41.   outchar = 0;
  42.   for (inmask = 0x80, outmask = 0x01;
  43.        inmask > 0;
  44.        inmask >>= 1, outmask <<= 1)
  45.     if ((b & inmask) == inmask)
  46.       outchar |= outmask;
  47.  
  48.   return outchar;
  49. }
  50.  
  51. void read_xbm_file()
  52. {
  53.   BYTE *XBMbits_map = NULL, *XBMmask_map = NULL, *XBMch;
  54.   ULONG XBMwidth, XBMheight, XBM_mask_width, XBM_mask_height;
  55.   bitmap_info XBMbits, XBMmask;
  56.   generic_info *g;
  57.   int row, col, count, rc;
  58.   BYTE ch;
  59.   int mBit1, mBit2, rXBMforg, rXBMback, bitColor;
  60.  
  61.   generic_count = 1;
  62.   generic = (generic_info *) malloc(sizeof(generic_info));
  63.  
  64.   init_generic(0);
  65.   g = generic;
  66.  
  67.   fseek(input, 0, SEEK_SET);
  68.   rc = ReadXBM(input, &XBMwidth, &XBMheight, &XBMbits_map);
  69.  
  70.   if (rc != 0)
  71.     {
  72.       fprintf(stderr, "Error reading XBM file\n");
  73.       exit(1);
  74.     }
  75.  
  76.   XBMbits.width = XBMwidth;
  77.   XBMbits.height = XBMheight;
  78.   XBMbits.bits_per_pixel = 1;
  79.   XBMbits.bytewidth = (XBMwidth+7) / 8;
  80.   XBMbits.size = XBMbits.bytewidth * XBMheight;
  81.   XBMbits.num_colors = 2;
  82.   XBMbits.palette = bw_palette;
  83.   XBMbits.map = XBMbits_map;
  84.  
  85.   if (XBMrevbits)
  86.     {
  87.       XBMch = XBMbits.map;
  88.       for (count = 0; count < XBMbits.size; count++, XBMch++)
  89.     *XBMch = revbits(*XBMch);
  90.     }
  91.  
  92.   g->clr_map = init_empty_map(XBMwidth, XBMheight, 4);
  93.   g->clr_map.palette = pc_palette;
  94.   g->and_map = init_empty_map(XBMwidth, XBMheight, 1);
  95.   g->and_map.palette = bw_palette;
  96.   g->xor_map = init_empty_map(XBMwidth, XBMheight, 1);
  97.   g->xor_map.palette = bw_palette;
  98.  
  99.   if (maskfile)
  100.     {
  101.       fseek(maskfile, 0, SEEK_SET);
  102.       rc = ReadXBM(maskfile, &XBM_mask_width, &XBM_mask_height, &XBMmask_map);
  103.  
  104.       if (rc != 0)
  105.     {
  106.       fprintf(stderr, "Error reading XBM mask file, mask ignored.\n");
  107.       XBMmask_map = NULL;
  108.     }
  109.       else
  110.     if (XBM_mask_width != XBMwidth || XBM_mask_height != XBMheight)
  111.       {
  112.         fprintf(stderr, "XBM image and mask are different sizes, mask ignored.\n");
  113.         XBMmask_map = NULL;
  114.       }
  115.     }
  116.  
  117.   XBMmask = XBMbits;
  118.   if (XBMmask_map)
  119.     {
  120.       XBMmask.map = XBMmask_map;
  121.       /* We want the bits the other way around, 1 for transparent... */
  122.       XBMch = XBMmask.map;
  123.       for (count = 0; count < XBMmask.size; count++, XBMch++)
  124.     {
  125.       if (XBMrevbits)
  126.         *XBMch = revbits(*XBMch);
  127.       *XBMch = (*XBMch ^ 0xFF);
  128.     }
  129.     }
  130.   else
  131.     { 
  132.       XBMmask = init_empty_map (XBMwidth, XBMheight, 1);
  133.     }
  134.       
  135.   /* Now "XBMbits" holds the image, 1=on, 0=off.
  136.          "XBMmask" holds the mask, 1=transparent, 0=setbit.
  137.    */
  138.  
  139.   if (0 && dump_input)
  140.     {
  141.       printf("XBMbits:\n");
  142.       for (row = 1; row <= XBMheight; row++)
  143.     {
  144.       for (col = 1; col <= XBMwidth; col++)
  145.         if (get_bit(XBMbits, row, col))
  146.           printf("1");
  147.         else
  148.           printf("0");
  149.       printf("\n");
  150.     }
  151.  
  152.       printf("XBMmask:\n");
  153.       for (row = 1; row <= XBMheight; row++)
  154.     {
  155.       for (col = 1; col <= XBMwidth; col++)
  156.         if (get_bit(XBMmask, row, col))
  157.           printf("1");
  158.         else
  159.           printf("0");
  160.       printf("\n");
  161.     }
  162.     }
  163.  
  164.   if (XBMforg < 0)
  165.     rXBMforg = 0;
  166.   else
  167.     rXBMforg = XBMforg;
  168.  
  169.   if (XBMback < 0)
  170.     rXBMback = 0;
  171.   else
  172.     rXBMback = XBMback;
  173.  
  174.   mBit1 = 2;
  175.   mBit2 = 2;
  176.   if (XBMback == XBM_TRANSPARENT)
  177.     mBit1 = 0;
  178.   if (XBMforg == XBM_TRANSPARENT)
  179.     mBit2 = 1;
  180.  
  181.   for (row = 1; row <= XBMheight; row++)
  182.     for (col = 1; col <= XBMwidth; col++)
  183.       {
  184.     bitColor = get_bit (XBMbits, row, col);
  185.     if ((bitColor == mBit1  || bitColor == mBit2)
  186.         && get_bit (XBMmask, row, col) == 0)
  187.       set_bit(XBMmask, row, col, 1);
  188.       }
  189.  
  190.   mBit1 = 2;
  191.   mBit2 = 2;
  192.   if (XBMback == XBM_REVERSEVID)
  193.     mBit1 = 0;
  194.   if (XBMforg == XBM_REVERSEVID)
  195.     mBit2 = 1;
  196.  
  197.   for (row = 1; row <= XBMheight; row++)
  198.     for (col = 1; col <= XBMwidth; col++)
  199.       {
  200.     bitColor = get_bit (XBMbits, row, col);
  201.     if ((bitColor == mBit1  || bitColor == mBit2)
  202.         && get_bit (XBMmask, row, col) == 0)
  203.       {
  204.         set_bit(XBMmask, row, col, 1);
  205.         set_bit(g->xor_map, row, col, 1);
  206.       }
  207.       }
  208.  
  209.   g->and_map.map = XBMmask.map;
  210.   
  211.   for (row = 1; row <= XBMheight; row++)
  212.     for (col = 1; col <= XBMwidth; col++)
  213.       {
  214.     if (get_bit(XBMmask, row, col) == 0)
  215.       if (get_bit(XBMbits, row, col))
  216.         set_bit(generic[0].clr_map, row, col, rXBMforg);
  217.       else
  218.         set_bit(generic[0].clr_map, row, col, rXBMback);
  219.     else
  220.       set_bit(generic[0].clr_map, row, col, 0xFF);
  221.       }
  222.  
  223. #if 0
  224.   /* One combination is special.  If the desired color is 0, the xor
  225.      mask should be 1, and the and and clr masks should be 0. */
  226.  
  227.   mBit1 = 2;
  228.   mBit2 = 2;
  229.   if (XBMback == 0)
  230.     mBit1 = 0;
  231.   if (XBMforg == 0)
  232.     mBit2 = 1;
  233.   
  234.   for (row = 1; row <= XBMheight; row++)
  235.     for (col = 1; col <= XBMwidth; col++)
  236.       {
  237.     bitColor = get_bit(XBMbits, row, col);
  238.     if ((bitColor == mBit1 || bitColor == mBit2)
  239.         && get_bit (XBMmask, row, col) == 0)
  240.       {
  241.         set_bit(generic[0].and_map, row, col, 0);
  242.         set_bit(generic[0].xor_map, row, col, 1);
  243.         set_bit(generic[0].clr_map, row, col, 0);
  244.       }
  245.       }
  246. #endif /* 0 */
  247.  
  248.   if (dump_input)
  249.     {
  250.       bitmap_info foo;
  251.  
  252.       printf("CLR mask:\n");
  253.       for (row = 1; row <= XBMheight; row++)
  254.     {
  255.       for (col = 1; col <= XBMwidth; col++)
  256.         printf("%x", get_bit(generic[0].clr_map, row, col));
  257.       printf("\n");
  258.     }
  259.  
  260.       printf("AND mask:\n");
  261.       for (row = 1; row <= XBMheight; row++)
  262.     {
  263.       for (col = 1; col <= XBMwidth; col++)
  264.         if (get_bit(generic[0].and_map, row, col))
  265.           printf("1");
  266.         else
  267.           printf("0");
  268.       printf("\n");
  269.     }
  270.  
  271.       printf("XOR mask:\n");
  272.       for (row = 1; row <= XBMheight; row++)
  273.     {
  274.       for (col = 1; col <= XBMwidth; col++)
  275.         if (get_bit(generic[0].xor_map, row, col))
  276.           printf("1");
  277.         else
  278.           printf("0");
  279.       printf("\n");
  280.     }
  281.  
  282.       foo = init_empty_map (XBMwidth, XBMheight, 4);
  283.       XBMch = foo.map;
  284.       for (count = 0; count < generic[0].clr_map.size; count++, XBMch++)
  285.     *XBMch = 0xBB;
  286.  
  287. /*
  288.       printf("RESULT (raw):\n");
  289.       for (row = 1; row <= XBMheight; row++)
  290.     {
  291.       for (col = 1; col <= XBMwidth; col++)
  292.         printf("%x", get_bit(foo, row, col));
  293.       printf("\n");
  294.     }
  295. */
  296.  
  297.       for (row = 1; row <= XBMheight; row++)
  298.     for (col = 1; col <= XBMwidth; col++)
  299.       {
  300.         if (!get_bit(generic[0].and_map, row, col))
  301.           set_bit(foo, row, col, 0);
  302.       }
  303.  
  304. /*
  305.       printf("RESULT (after AND):\n");
  306.       for (row = 1; row <= XBMheight; row++)
  307.     {
  308.       for (col = 1; col <= XBMwidth; col++)
  309.         printf("%x", get_bit(foo, row, col));
  310.       printf("\n");
  311.     }
  312. */
  313.  
  314.       for (row = 1; row <= XBMheight; row++)
  315.     for (col = 1; col <= XBMwidth; col++)
  316.       {
  317.         bitColor = get_bit(foo, row, col);
  318.         if (get_bit (generic[0].xor_map, row, col))
  319.           set_bit(foo, row, col, (bitColor ^ 0xF));
  320.       }
  321.  
  322. /*
  323.       printf("RESULT (after XOR):\n");
  324.       for (row = 1; row <= XBMheight; row++)
  325.     {
  326.       for (col = 1; col <= XBMwidth; col++)
  327.         printf("%x", get_bit(foo, row, col));
  328.       printf("\n");
  329.     }
  330. */
  331.  
  332.       for (row = 1; row <= XBMheight; row++)
  333.     for (col = 1; col <= XBMwidth; col++)
  334.       {
  335.         bitColor = get_bit(foo, row, col);
  336.         set_bit (foo, row, col, bitColor ^ 
  337.              get_bit(generic[0].clr_map, row, col));
  338.         
  339.       }
  340.  
  341.       printf("RESULT (on a field of 0xbb):\n");
  342.       for (row = 1; row <= XBMheight; row++)
  343.     {
  344.       for (col = 1; col <= XBMwidth; col++)
  345.         printf("%x", get_bit(foo, row, col));
  346.       printf("\n");
  347.     }
  348.     }
  349. }
  350.