bitmap.h

Go to the documentation of this file.

#ifndef BITMAP_CLASS
#define BITMAP_CLASS

/*****************************************************************************\
*                                                                             *
*  Name   : bitmap                                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Provides access to the windowing system's bitmap objects and allows      *
*  them to be manipulated.                                                    *
*                                                                             *
*******************************************************************************
* 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 "winexdll.h"

#include <basis/portable.h>

// forward.
class palette;

class WINDOWS_EXTENSIONS_CLASS_STYLE bitmap
{
public:
  bitmap();
    // constructs an empty, invalid bitmap.
  bitmap(const istring &filename);
    // constructs a bitmap from a file.
  bitmap(application_instance instance, const char *resource);
    // loads a bitmap from a "resource" id within the "instance".  the
    // "resource" can either be a textual name or a resource id created with
    // MAKEINTRESOURCE.
  bitmap(HGLOBAL global);
    // loads a bitmap from a "global" object.  this object must remain valid
    // for the life of the bitmap object.
  ~bitmap();

  bool valid() const { return _valid; }
    // reports whether construction succeeded or not.

  int image_size() const;
    // returns the size of the image in bytes.
  int width() const;
    // returns the pixel width of the image?
  int height() const;
    // returns the pixel height of the image?
  int colors() const;
    // returns the number of colors in the color table.  this is zero if
    // the image has better than eight bit color, since those types of bitmaps
    // have no color table.

  byte *get_bits() const;
    // returns the raw storage for the bitmap.  this could be stored in
    // top down or bottom up order.
//how to tell?

  BITMAPINFOHEADER *get_header() const;
  BITMAPINFO *get_info() const;
  RGBQUAD *get_color_table() const;
    // returns a pointer to the color table structure for the bitmap, if it
    // has one.  NIL is returned if the bitmap has no table (because it has
    // more than 8 bits of color).

  void reset();
    // gets rid of any data held and resets the object to an unconstructed
    // state.

  bool paint(HDC context, const RECT &update_rectangle,
          const RECT &bitmap_portion) const;
    // the bitmap is painted to the screen using the device "context".  the
    // area to paint within the context is stored in "update_rectangle".
    // the segment that should be painted from the bitmap is defined by the
    // "bitmap_portion" rectangle.

  palette &get_palette() const { return *_palette; }
    // gets the palettized color table for this bitmap.

  bool load_from_file(const istring &fileName);
    // returns true if the "filename" can be loaded into the bitmap object.
  bool load_from_global(HGLOBAL glob);
    // returns true if a bitmap could be extracted from "glob".
  bool load_from_resource(application_instance instance, const char *resource);
    // returns true if the bitmap could be pulled out of the "instance"
    // using the "resource" id.

private:
  bool _valid;  // true if this object has constructed properly.
  BITMAPFILEHEADER _file_header;  // a copy of the file header from disk.
  BITMAPINFO *_info;  // super-structure containing header and color table.
  BITMAPINFOHEADER *_header;  // header describing bitmap.
  RGBQUAD *_color_table;  // colors used in the bitmap.
  byte *_the_bits;  // storage of image bits.
  int _colors;  // number of colors used in the color table.
  HGLOBAL _optional_global;
    // tracks a global memory object if used to create a bitmap.
  palette *_palette;  // created once we know the colors for the bitmap.

  // forbidden.
  bitmap(const bitmap &to_copy);
  bitmap &operator =(const bitmap &to_copy);

  bool retrieve_palette(palette &to_fill) const;
    // stores the color table of this bitmap into a palette "to_fill".

  void make_pointers_valid(bool read_only);
    // given a valid pointer value in "_info", the other class members will
    // be created from the information there.  if "read_only" is true, no
    // fixups will be attempted on the header data.
};

#endif

---