image.h

Go to the documentation of this file.

#ifndef LWPP_IMAGE_H
#define LWPP_IMAGE_H
#include <lwpp/global.h>
#include <lwimage.h>
#include <lwpp/wrapper.h>
#include <lwpp/storeable.h>

#ifdef _DEBUG
#include <lwpp/debug.h>
#endif

namespace lwpp
{
  class ImageUtil : public PopUpCallback, protected GlobalBase<LWImageUtil>, public Storeable
  {
  private:
    LWPixmapID pixmap;
    bool doDestroy;
  public:
    ImageUtil(LWPixmapID _pixmap = 0) 
      : pixmap(_pixmap), doDestroy(false)
    {;}

    ImageUtil(int w, int h, LWImageType type) 
      : pixmap(0), doDestroy(true)
    {
      create(w, h, type);
    }
    ~ImageUtil()
    {
      if ((pixmap != 0) && doDestroy) globPtr->destroy(pixmap);
    }

    ImageUtil(const ImageUtil &iu)
    {
      pixmap = iu.pixmap;
      doDestroy = iu.doDestroy;
    }

    ImageUtil &operator=(const ImageUtil &iu)
    {
      if (&iu != this)
      {
        if ((pixmap != 0) && doDestroy) globPtr->destroy(pixmap);
        pixmap = iu.pixmap;
      }
      return *this;
    }

    static size_t GetStride(int type);
    size_t GetStride()
    {
      int w,h,type;
      getInfo(&w,&h,&type);
      return GetStride(type);
    }
    void setDestroy(bool destroy = true)
    {
      doDestroy = destroy;
    }
    bool isValid()
    {
      return pixmap != 0;
    }
    void create(int w, int h, LWImageType type) 
    {
      pixmap = globPtr->create(w, h, type);
    }

    void setPixel(int x, int y, void *pix)
    {
      globPtr->setPixel(pixmap, x, y, pix);
    }

    void getPixel(int x, int y, void *pix)
    {
      globPtr->getPixel(pixmap, x, y, pix);
    }

    void getInfo(int *w, int *h, int *type)
    {
      globPtr->getInfo(pixmap, w, h, type);
    }
    static void getInfo(LWPixmapID id, int *w, int *h, int *type)
    {
      globPtr->getInfo(id, w, h, type);
    }

    LWPixmapID  resample(int w, int h, int mode )
    {
      return globPtr->resample(pixmap, w, h, mode);
    }

    void setPixelTyped(int x, int y, int type, void *pix )
    {
      globPtr->setPixelTyped(pixmap, x, y, type, pix);
    }
    void getPixelTyped ( int x, int y, int type, void *pix )
    {
      globPtr->getPixelTyped(pixmap, x, y, type, pix);
    }
    int  getIndex8Map( LWPixelRGB24 *map )
    {
      return globPtr->getIndex8Map(pixmap, map);
    }
    int  getAttr ( LWImageParam tag, void* data )
    {
      return globPtr->getAttr(pixmap, tag, data);
    }
    int  getMakerNote ( LWMakerNote tag, void* data )
    {
      return globPtr->getMakerNote(pixmap, tag, data);
    }

    void save(int saver, const std::string name)
    {
      globPtr->save(pixmap, saver, name.c_str());
    }


    static int saverCount(void)
    {
      return globPtr->saverCount();
    }


    static const char *saverName(int n)
    {
      return globPtr->saverName(n);
    }
    
    std::string getSaverExtension(int n);

    int findSaver(std::string name);


  protected:
    virtual const char *popName(int n)
    {
      return saverName(n);
    }

    virtual size_t popCount(void) 
    {
      return saverCount();
    }
  };

  class Image : public PopUpCallback, public Storeable, protected GlobalBase<LWImageList>
  {
  private:
    LWImageID id;
  public:
    virtual const char *popName(int n);

    virtual size_t popCount(void); 

    Image(LWImageID _id = 0) : id(_id) {;}

    Image &operator= (const Image &from)
    {
      if (this != &from)
      {
        id = from.id;
      }
      return *this;
    }

    void SetID(LWImageID _id) {id = _id;}
    LWImageID getID() const {return id;}
    void GetPopUp(int i);
    int SetPopUp();

    bool isValid() {return id != 0;}
    void first(void) {id = globPtr->first();}
    void next(void) {id = globPtr->next(id);}
    void clear(void) {globPtr->clear(id);}
    void load(const char *filename) {id = globPtr->load(filename);}
    const char *name() const {return globPtr->name(id);}
    const char *filename(LWFrame frame = 0) const {return globPtr->filename(id, frame);}
    bool replace (const std::string &newFile)
    {
      return globPtr->replace(id, newFile.c_str()) != 0;
    }

    LWImageID getNumImage(int n);

    int getImageNum(LWImageID i);

    bool isColor (void) const
    {
      return (globPtr->isColor(id) != 0);
    }
    bool hasAlpha (void) const 
    {
      return (globPtr->hasAlpha(id) != 0);
    }
    
    void size (int &w, int &h) const 
    {
      globPtr->size(id, &w, &h);
    }
    int getWidth (void) const 
    {
      int w, h;
      globPtr->size(id, &w, &h);
      return w;
    }
    int getHeight (void) const 
    {
      int w, h;
      globPtr->size(id, &w, &h);
      return h;
    }
    
#ifdef WIN32
#ifdef RGB
#undef RGB
#endif
#endif

    void RGB (int x, int y, LWBufferValue val[3]) const 
    {
      globPtr->RGB(id, x, y, val);
    }
    void needAA ()
    {
      if (id) globPtr->needAA(id);
    }

    void  GetRGBSpot (double x, double y, double spotSize, bool blend, double rgb[3])
    {
      if (id) globPtr->RGBSpot(id, x, y, spotSize, blend ? 1 : 0, rgb);
    }

    double  GetAlphaSpot (double x, double y, double spotSize, bool blend)
    {
      if (id) return globPtr->alphaSpot(id, x, y, spotSize, blend ? 1 : 0);
      return 0.0;
    }

    double  GetLumaSpot (double x, double y, double spotSize, bool blend)
    {
      if (id) return globPtr->lumaSpot(id, x, y, spotSize, blend ? 1 : 0);
      return 0.0;
    }

    LWBufferValue alpha (int x, int y) const 
    {
      return globPtr->alpha(id, x, y);
    }
    
    LWBufferValue luma (int x, int y) const 
    {
      return globPtr->luma(id, x, y);
    }

    LWPixmapID evaluate (LWTime t)
    {
      return globPtr->evaluate(id, t);
    }

    virtual LWError Load(const LoadState &ls )
    {
      LWError err = 0;
      id = globPtr->sceneLoad(ls.getState());
      if (id == 0) err = "Could not load image";
      return err;
    }
    virtual LWError Save(const SaveState &ss )
    {
      LWError err = 0;
      globPtr->sceneSave(ss.getState(), id);
      return err;
    }
  };
  
  #define IMAGECHANGE_COMRING "lwppImageChange"
  
  // register a comRing for image changes
  /*
   * The Comring is called "lwppImageChange".
   * The eventCode is an image change eventCode.
   * The data payload is the imageID.
   */
  void RegisterImageChangeComRing();
  // unregister the Comring
  void UnregisterImageChangeComRing();
}
#endif // LWPP_IMAGE_H