home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 March / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / InitImage.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-17  |  6.7 KB  |  208 lines
  1. // $Id: InitImage.C,v 1.3 1998/06/17 09:03:52 zeller Exp $ -*- C++ -*-
  2. // Create an XImage from bitmap data
  3.  
  4. // Copyright (C) 1998 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. char InitImage_rcsid[] = 
  30.     "$Id: InitImage.C,v 1.3 1998/06/17 09:03:52 zeller Exp $";
  31.  
  32. #ifdef __GNUG__
  33. #pragma implementation
  34. #endif
  35.  
  36. #include "InitImage.h"
  37.  
  38. #include "config.h"
  39. #include "assert.h"
  40.  
  41. // These three are required for #including <X11/Xlibint.h>
  42. #include <string.h>        // bcopy()
  43. #include <sys/types.h>        // size_t
  44. #include <X11/Xlib.h>        // anything else
  45.  
  46. #include <X11/Xlibint.h>    // Xcalloc()
  47. #include <X11/Xutil.h>        // XGetPixel(), etc.
  48.  
  49. #if XlibSpecificationRelease < 6
  50.  
  51. // We're stuck with X11R5 or earlier, so we Provide a simple
  52. // XInitImage() replacement.  These GetPixel, PutPixel, and SubImage
  53. // functions only work for Bitmap data.
  54. // 
  55. // These functions were adapted from X11R6 `ImUtil.c', for which the
  56. // following copyright applies:
  57. //
  58. // Copyright (c) 1986 X Consortium
  59. // 
  60. // Permission is hereby granted, free of charge, to any person
  61. // obtaining a copy of this software and associated documentation
  62. // files (the "Software"), to deal in the Software without
  63. // restriction, including without limitation the rights to use, copy,
  64. // modify, merge, publish, distribute, sublicense, and/or sell copies
  65. // of the Software, and to permit persons to whom the Software is
  66. // furnished to do so, subject to the following conditions:
  67. // 
  68. // The above copyright notice and this permission notice shall be
  69. // included in all copies or substantial portions of the Software.
  70. // 
  71. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  72. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  73. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  74. // NONINFRINGEMENT.  IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR
  75. // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  76. // CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  77. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  78. // 
  79. // Except as contained in this notice, the name of the X Consortium
  80. // shall not be used in advertising or otherwise to promote the sale,
  81. // use or other dealings in this Software without prior written
  82. // authorization from the X Consortium.
  83.  
  84.  
  85. // The ROUNDUP macro rounds up a quantity to the specified boundary,
  86. // then truncates to bytes.
  87. #define ROUNDUP(nbytes, pad) ((((nbytes) + ((pad)-1)) / (pad)) * ((pad)>>3))
  88.  
  89. // Read a pixel from an 1-bit image data structure
  90. static unsigned long GetPixel (XImage *image, int x, int y)
  91. {
  92.     int xoff = x;
  93.     int yoff = y * image->bytes_per_line + (xoff >> 3);
  94.     xoff &= 7;
  95.     unsigned char bit = 1 << xoff;
  96.     return (image->data[yoff] & bit) ? 1 : 0;
  97. }
  98.  
  99. // Write a pixel into an 1-bit image data structure
  100. static int PutPixel (XImage *image, int x, int y, unsigned long pixel)
  101. {
  102.  
  103.     int xoff = x;
  104.     int yoff = y * image->bytes_per_line + (xoff >> 3);
  105.     xoff &= 7;
  106.     unsigned char bit = 1 << xoff;
  107.     if (pixel & 1)
  108.     image->data[yoff] |= bit;
  109.     else
  110.     image->data[yoff] &= ~bit;
  111.  
  112.     return 1;
  113. }
  114.  
  115. // Clone a new (sub)image from an existing one
  116. static XImage *SubImage (XImage *image, int x, int y, 
  117.              unsigned int width, unsigned int height)
  118. {
  119.     XImage *subimage = (XImage *) Xcalloc (1, sizeof (XImage));
  120.     if (subimage == 0)
  121.     return subimage;
  122.  
  123.     subimage->width            = width;
  124.     subimage->height           = height;
  125.     subimage->xoffset          = 0;
  126.     subimage->format           = image->format;
  127.     subimage->byte_order       = image->byte_order;
  128.     subimage->bitmap_unit      = image->bitmap_unit;
  129.     subimage->bitmap_bit_order = image->bitmap_bit_order;
  130.     subimage->bitmap_pad       = image->bitmap_pad;
  131.     subimage->bits_per_pixel   = image->bits_per_pixel;
  132.     subimage->depth            = image->depth;
  133.     subimage->bytes_per_line   = ROUNDUP(width, subimage->bitmap_pad);
  134.     subimage->obdata           = 0;
  135.  
  136.     InitImage(subimage);
  137.  
  138.     unsigned int dsize = subimage->bytes_per_line * height;
  139.  
  140.     char *data = (char *)Xcalloc (1, dsize);
  141.     if (data == 0)
  142.     {
  143.     Xfree((char *) subimage);
  144.     return 0;
  145.     }
  146.     subimage->data = data;
  147.  
  148.     if (int(height) > image->height - y)
  149.     height = image->height - y;
  150.     if (int(width) > image->width - x)
  151.     width = image->width - x;
  152.  
  153.     for (unsigned int row = y; row < (y + height); row++)
  154.     {
  155.     for (unsigned int col = x; col < (x + width); col++)
  156.     {
  157.         unsigned long pixel = XGetPixel(image, col, row);
  158.         XPutPixel(subimage, (col - x), (row - y), pixel);
  159.     }
  160.     }
  161.  
  162.     return subimage;
  163. }
  164.  
  165. #endif // XlibSpecificationRelease
  166.  
  167.  
  168.  
  169. void InitImage(XImage *image)
  170. {
  171. #if XlibSpecificationRelease >= 6
  172.     XInitImage(image);
  173. #else
  174.     assert(image->xoffset          == 0);
  175.     assert(image->format           == XYBitmap);
  176.     assert(image->byte_order       == MSBFirst);
  177.     assert(image->bitmap_unit      == 8);
  178.     assert(image->bitmap_bit_order == LSBFirst);
  179.     assert(image->bitmap_pad       == 8);
  180.     assert(image->depth            == 1);
  181.     assert(image->bytes_per_line   == (image->width + 7) / 8);
  182.  
  183.     image->f.get_pixel = GetPixel;
  184.     image->f.put_pixel = PutPixel;
  185.     image->f.sub_image = SubImage;
  186. #endif
  187. }
  188.  
  189. XImage *CreateImageFromBitmapData(unsigned char *bits, int width, int height)
  190. {
  191.     XImage *image = (XImage *)Xcalloc(1, sizeof(XImage));
  192.     image->width            = width;
  193.     image->height           = height;
  194.     image->xoffset          = 0;
  195.     image->format           = XYBitmap;
  196.     image->data             = (char *) bits;
  197.     image->byte_order       = MSBFirst;
  198.     image->bitmap_unit      = 8;
  199.     image->bitmap_bit_order = LSBFirst;
  200.     image->bitmap_pad       = 8;
  201.     image->depth            = 1;
  202.     image->bytes_per_line   = (width + 7) / 8;
  203.  
  204.     InitImage(image);
  205.  
  206.     return image;
  207. }
  208.