unatima.hpp

/* ==================================================== ======== ======= *
*
*  unatima.hpp : native images and pixmaps
*  Ubit Project
*  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
*  (C) 1999-2006 EricLecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
*
* ***********************************************************************
* COPYRIGHT NOTICE :
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE
* IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* 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.
* SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
* ***********************************************************************
* ==================================================== [(c)Elc] ======= *
* ==================================================== ======== ======= */

#ifndef _unatima_hpp_
#define _unatima_hpp_
//pragma ident  "@(#)unatima.hpp        ubit:05.05.00"
#include <ubit/unatgraph.hpp>
namespace ubit {

/* ==================================================== ===== ======= */
class UNatIma {
public:
  static const char* const GIF;
  static const char* const JPG;
  static const char* const XPM;
  static const char* const XPM_DATA;

  static int xpmFileReader(UNatDisp*, const char* fpath, UNatIma*&);
  static int xpmDataReader(UNatDisp*, const char* xpm_data, UNatIma*&);
  static int gifFileReader(UNatDisp*, const char* fpath, UNatIma*&);
  static int jpegFileReader(UNatDisp*, const char* fpath,UNatIma*&, int max_w, int max_h);

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  UNatIma(UNatDisp*, USysIma ima, USysIma imashape);
//ifdef HAVE_GL
  UNatIma(UNatDisp*, unsigned char* glpixels, int width, int height);
//endif
  
  ~UNatIma();

  bool isRealized() const;
  int getAlpha()  const {return alpha;}
  int getDepth()  const {return depth;}
  int getWidth()  const {return width;}
  int getHeight() const {return height;}
  USysIma getXImage()  {return xima;}
  USysIma getXImageShape() {return ximashape;}
  
  USysPixel getPixel(int x, int y) {
#ifdef WITH_GDK
    return gdk_image_get_pixel(xima, x, y);
#else
    return XGetPixel(xima, x, y);
#endif
  }

  void setPixel(USysPixel p, int x, int y) {
#ifdef WITH_GDK
    gdk_image_put_pixel(xima, p, x, y);
#else
    XPutPixel(xima, p, x, y);
#endif
  }
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  static int readImage(UNatDisp*, const char* filename, const char* filetype, 
                       UNatIma*& natima);
  static int readImage(UNatDisp*, const char* filename, const char* filetype,
                       UNatIma*& natima, int max_width, int max_height);
  static UNatIma* createImage(UNatDisp*, int width, int height);
  
  UNatIma* createScaledImage(float xscale, float yscale);
  UNatIma* createScaledImage(UNatDisp* to_nd, float xscale, float yscale);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  static USysIma createEmptyXImage(UNatDisp*, int width, int height, int depth);
  static USysIma createScaledXImage(UNatDisp* to_nd, UNatDisp* from_nd,
                                     USysIma from_ima, float xscale, float yscale);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  static bool blendXImages(UNatDisp*, USysIma i1, USysIma i2, float alpha);
  static bool blendXImage(UNatDisp*, USysIma i1, USysPixel p2, float alpha);
  static USysPixel* allocXColors(UNatDisp*, USysColor* colors, int col_count); 

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // implementation

#ifndef NO_DOC
protected:
  friend class UGraph;
  friend class UIma;
  friend class UPix;
  friend class UNatPix;

  UNatDisp* natdisp;
  // !att: width,height = taille LOGIQUE de l'image, pas de la texture
  // qui est toujours une puissance de 2 !
  int width, height;
  mutable unsigned char alpha;  // 0, 1 or 8 bits
  unsigned char depth;
  float scale;
  USysIma xima, ximashape;       // image data for X11
  mutable unsigned char* glpix;  // image data for OpenGL
#ifdef HAVE_GL
  mutable GLuint gltex;          // texture Identifiant
  void createGLTexFromPixels() const;
  void createGLTexFromXImages() const;
#endif
#endif
};

/* ==================================================== ===== ======= */
class UNatPix {
  friend class UGraph;
  friend class UPix;
  UNatDisp *natdisp;
  USysPix xpix, xpixshape;
  int width, height;
  int depth;
  float scale; 

public:
  // xpixshape == None ==> opaque image
  // xpixshape != None ==> transparent background
  UNatPix(UNatDisp*, USysPix pix, USysPix shape, int width, int height, int depth);

  // creates the pixmaps from the images
  // ximashape == null ==> opaque image
  // ximashape != null ==> transparent background
  UNatPix(UNatDisp*, USysIma xima, USysIma ximashape);
  UNatPix(UNatDisp*, UNatIma*);
  ~UNatPix();

  void set(USysIma xima, USysIma ximashape);

  int getWidth()    const {return width;}
  int getHeight()   const {return height;}
  bool isRealized() const {return xpix != USysNull;}
  bool isShaped()   const {return xpixshape != USysNull;}
  const USysPix getXPixmap()      const {return xpix;}
  const USysPix getXPixmapShape() const {return xpixshape;}
};

}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---