bitmap.cpp

Go to the documentation of this file.

#ifndef BITMAP_IMPLEMENTATION_FILE
#define BITMAP_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : bitmap                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1997-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "bitmap.h"
#include "palette.h"

#include <basis/array.h>
#include <basis/convert_utf.h>
#include <basis/function.h>
#include <basis/istring.h>
#include <basis/portable.h>
#include <opsystem/byte_filer.h>

#include <memory.h>

#define WIDTH(rectang) absolute_value((rectang).right - (rectang).left)
#define HEIGHT(rectang) absolute_value((rectang).bottom - (rectang).top)

//hmmm: isolate windows specific portions into a bitmap implementation.

bitmap::bitmap()
: _valid(false), _file_header(), _info(NIL), _header(NIL), _color_table(NIL),
  _the_bits(NIL), _colors(0), _optional_global(NIL), _palette(new palette())
{}

bitmap::bitmap(const istring &filename)
: _valid(false), _file_header(), _info(NIL), _header(NIL), _color_table(NIL),
  _the_bits(NIL), _colors(0), _optional_global(NIL), _palette(new palette())
{ load_from_file(filename); }

bitmap::bitmap(application_instance instance, const char *resource)
: _valid(false), _file_header(), _info(NIL), _header(NIL), _color_table(NIL),
  _the_bits(NIL), _colors(0), _optional_global(NIL), _palette(new palette())
{ load_from_resource(instance, resource); }

bitmap::bitmap(HGLOBAL global)
: _valid(false), _file_header(), _info(NIL), _header(NIL), _color_table(NIL),
  _the_bits(NIL), _colors(0), _optional_global(NIL), _palette(new palette())
{ load_from_global(global); }

bitmap::~bitmap()
{
  reset();
  delete _palette;
  _palette = NIL;
}

void bitmap::reset()
{
  _valid = false;
  if (_optional_global) {
    // if we constructed from a global object, we just whack that.
    UnlockResource(_optional_global);
    FreeResource(_optional_global);
    _optional_global = NIL;
  } else {
    // we really created our own memory and stuff, so whack that.
    delete [] _info;
  }
  _palette->reset();
  _info = NIL;
  _header = NIL;
  _color_table = NIL;
  _the_bits = NIL;
  _colors = 0;
}

bool bitmap::load_from_resource(application_instance instance,
    const char *resource)
{
  reset();  // clean out our stuff so we can load.
  // first, locate the resource within this instance.
  HRSRC hrsrc = FindResource(instance, to_unicode_temp(resource), RT_BITMAP);
  if (!hrsrc) return false;  // not valid.
  // then, load the resource into a global memory object.
  HGLOBAL glob = LoadResource(instance, hrsrc);
  // now, construct the rest of our stuff from the global memory.
  return load_from_global(glob);
}

bool bitmap::load_from_global(HGLOBAL glob)
{
  reset();  // clean out our stuff so we can load.
  _optional_global = glob;
  // stuff our pointer from the global.
  _info = (LPBITMAPINFO)LockResource(_optional_global);
  make_pointers_valid(true);
  return true;
}

bool bitmap::load_from_file(const istring &filename)
{
  reset();  // clean out our stuff so we can load.
  // open a binary mode file to read the bitmap.
  byte_filer bitfile(filename, "rb");
  if (!bitfile.good()) { bitfile.close(); return false; }
  int file_len = int(bitfile.length());
    // retrieve the file length before we start messing with the file.

  // pull the file header off first.
  int read = bitfile.read((byte *)&_file_header, sizeof(_file_header));
  if (read != sizeof(_file_header)) {
    // fail because the size read didn't fill our header.
    reset(); bitfile.close(); return false;
  }

  // make sure we're not reading a non-bitmap type of file.
  if (_file_header.bfType != 0x4d42) {
    // fail since this seems to not be a bitmap.
    reset(); bitfile.close(); return false;
  }

  // read in the info header for consumption.
  BITMAPINFOHEADER temp_header;
  read = bitfile.read((byte *)&temp_header, sizeof(temp_header));
  if (read != sizeof(temp_header)) {
    // fail because the size read didn't fill our header.
    reset(); bitfile.close(); return false;
  }

  // ensure that we have the right type of BMP file; if it's for presentation
  // manager, we'll want to convert it someday.
  if (temp_header.biSize != sizeof(BITMAPINFOHEADER)) {
    if (temp_header.biSize != sizeof(BITMAPCOREHEADER)) {
      // fail because the size doesn't match OS2 BMPs either.
      reset(); bitfile.close(); return false;
    }
reset(); bitfile.close(); return false;
//hmmm: this would employ handy conversion code.
  }

  // find out how many colors are in the color table.
  _header = &temp_header;  // temporary to grab colors.
  int colors_used = colors();
  _header = NIL;  // reset it back.
  
  if (!colors_used) {
//hmmm: handle no color table somehow.
reset(); bitfile.close(); return false;
  }

  // reset the header info for our own version of the color table.
  temp_header.biClrUsed = 256;
  temp_header.biBitCount = 8;

  int just_bits_size = _file_header.bfSize - _file_header.bfOffBits;
  int full_size = sizeof(temp_header) + 256 * sizeof(RGBQUAD) + just_bits_size;
    // we base our full size on the size of the bitmap header plus the color
    // table size (we always use 256 colors for simplicity currently) plus the
    // size of the bits (as reported by the file header).

  byte *DIB_chunk = new byte[full_size];  // allocate storage.
  memset(DIB_chunk, 0, full_size);  // clear out contents.
  memcpy(DIB_chunk, (byte *)&temp_header, sizeof(temp_header));
    // store the header.

  int stored_color_table_size = colors_used * sizeof(RGBQUAD);
  read = bitfile.read(DIB_chunk + sizeof(temp_header),
      stored_color_table_size);
    // read in just the color table that the file actually possesses.
  if (read != stored_color_table_size) {
    // fail because we couldn't read the color table.
    reset(); bitfile.close(); return false;
  }
  
  // make sure we have enough total bytes in the file for what we've decided
  // will be read overall.  if we don't, then we need to bail out.
  if (file_len < int(sizeof(_file_header) + sizeof(temp_header))
      + stored_color_table_size + just_bits_size) {
    // fail because we know the file is too small.
    reset(); bitfile.close(); return false;
  }

//is this re-seek needed?
  bitfile.seek(_file_header.bfOffBits, byte_filer::FROM_START);

  int chunk_offset = sizeof(temp_header) + 256 * sizeof(RGBQUAD);
  int bytes_read = bitfile.read(DIB_chunk + chunk_offset, just_bits_size);
  bitfile.close();
  if (bytes_read != just_bits_size) {
    // fail because the file wasn't the right size.
    reset(); return false;
  }

  // make our pointers valid by aiming them into our bit storage.
  _info = (BITMAPINFO *)DIB_chunk;

  make_pointers_valid(false);

  return true;
}

void bitmap::make_pointers_valid(bool read_only)
{
  if (!_info) return;  // someone's going crazy here.

  _header = (BITMAPINFOHEADER *)_info;
//hmmm: compute the color table as NIL if this is not 8 bit or less.
  _color_table = (RGBQUAD *)((byte *)_info + _header->biSize);

//if (_header->biSize != sizeof(BITMAPINFOHEADER))
//LOG("something is wrong with the object's biSize.");

  // retrieve the number of colors from our DIB.
  _colors = colors();

  if (!read_only) {
    // compute what the image size should be and fill in the DIB.
    _header->biSizeImage = image_size();
    // set the DIB's used color count to ensure it's correct.
    _header->biClrUsed = _colors;
  }

  // compute the pointer into the bit storage for the bitmaps.
//hmmm: table size is zero for bigger bitmaps.
  int color_table_size = _colors * sizeof(RGBQUAD);
  _the_bits = (byte *) ((byte *)_info + _header->biSize + color_table_size);

  _valid = true;

  // get our color table entries into the palette we hold onto.  this must
  // come after the validity flag is true or nothing will happen.
  retrieve_palette(*_palette);
}

int bitmap::image_size() const
{
  if (!_header->biSizeImage) {
    // we set the image size if it is currently uninitialized.
    int width_in_bytes = width();
    int size_of_image = width_in_bytes * height();
    return size_of_image;
  } else {
    // assume the current size is correct.
    return _header->biSizeImage;
  }
}

int bitmap::width() const { return _header->biWidth; }
        
int bitmap::height() const { return _header->biHeight; }
        
int bitmap::colors() const
{
  if (!_header) return 0;
  if (_header->biClrUsed) return _header->biClrUsed;
    // if the member is set, assume it's correct.
  if (_header->biBitCount <= 8) return 1 << _header->biBitCount;
  // more than eight bits used for colors means no color table.
  return 0;
}
    
BITMAPINFOHEADER *bitmap::get_header() const { return _header; }

BITMAPINFO *bitmap::get_info() const { return _info; }

RGBQUAD *bitmap::get_color_table() const { return _color_table; }

byte *bitmap::get_bits() const { return _the_bits; }

bool bitmap::paint(HDC context, const RECT &update_rectangle,
    const RECT &bitmap_portion) const
{
  if (!valid()) return false;

  HPALETTE old_palette = NIL;
  if (_palette->win_palette()) {
    // select the bitmap's palette into the device context.
    old_palette = SelectPalette(context, _palette->win_palette(), false);
      // and make sure we track the old palette for later.
  }

  // we use a stretching mode that works well with colors.
  SetStretchBltMode(context, COLORONCOLOR);

  // we need to realize the palette to get the DC to use it.
  RealizePalette(context);

  BOOL to_return;
  if ( (WIDTH(update_rectangle) == WIDTH(bitmap_portion)) &&
       (HEIGHT(update_rectangle) == HEIGHT(bitmap_portion))) {
    // we can just blast the bits out if the dimensions are identical.
    to_return = ::SetDIBitsToDevice(context, update_rectangle.left,
        update_rectangle.top, WIDTH(update_rectangle),
        HEIGHT(update_rectangle), bitmap_portion.left,
        (int)height() - bitmap_portion.top - HEIGHT(bitmap_portion),
        0, (WORD)height(), _the_bits, _info, DIB_RGB_COLORS);
  } else {
    // otherwise, we need to stretch the bitmap portion to the rectangle.
    to_return = ::StretchDIBits(context, update_rectangle.left,
        update_rectangle.top, WIDTH(update_rectangle),
        HEIGHT(update_rectangle), bitmap_portion.left, bitmap_portion.top,
        WIDTH(bitmap_portion), HEIGHT(bitmap_portion), _the_bits, _info,
        DIB_RGB_COLORS, SRCCOPY);              
  }

  // put the old palette back into the device context.
  if (_palette->win_palette() && old_palette) {
    ::SelectPalette(context, old_palette, true);
  }

  return to_return;
}

bool bitmap::retrieve_palette(palette &to_fill) const
{
  if (!valid()) return false;
  to_fill = palette(colors(), get_color_table());
  return to_fill.valid();
}


#endif //BITMAP_IMPLEMENTATION_FILE

---