- Your Widget Set For OpenGL

---

uimageio.hpp

/***************************************************************************
    LibUFO - UI For OpenGL
    copyright         : (C) 2001-2005 by Johannes Schmidt
    email             : schmidtjf at users.sourceforge.net
                             -------------------

    file              : include/ufo/image/uimageio.hpp
    begin             : Fri Oct 5 2001
    $Id: uimageio.hpp,v 1.11 2005/05/21 15:17:23 schmidtjf Exp $
 ***************************************************************************/

/***************************************************************************
 *  This library is free software; you can redistribute it and/or          *
 * modify it under the terms of the GNU Lesser General Public              *
 * License as published by the Free Software Foundation; either            *
 * version 2.1 of the License, or (at your option) any later version.      *
 *                                                                         *
 * This library is distributed in the hope that it will be useful,         *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU       *
 * Lesser General Public License for more details.                         *
 *                                                                         *
 * You should have received a copy of the GNU Lesser General Public        *
 * License along with this library; if not, write to the Free Software     *
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
 ***************************************************************************/

#ifndef UIMAGEIO_HPP
#define UIMAGEIO_HPP

#include "../uobject.hpp"

#include "../util/udimension.hpp"

#include <vector>
#include <map>

#include <fstream>

namespace ufo {


class UFO_EXPORT UImageIO : public UObject {
    UFO_DECLARE_DYNAMIC_CLASS(UImageIO)
public: // Public types

    typedef std::istream IStream;
    typedef std::ostream OStream;

    typedef unsigned char * (*LoadFuncPointer)(
        UImageIO * imageIOA, // image io which should contain the image
        IStream & streamA, // the stream to load from
        std::string * commentA, // a comment
        int * widthA, // the width in pixels
        int * heightA, // the height in pixels
        int * componentsA // the amount of color components (1..4)
    );

    typedef bool (*SaveFuncPointer) (
        UImageIO * imageIO, // image io which contains the image
        OStream & streamA // the stream to save to
    );
    enum FilterRule {
        NoFilterRule = 0,
        AlphaLayer = 1, // add an alpha layer
        ColorTypeRGB = 2,
        ColorTypeRGBA = ColorTypeRGB | AlphaLayer,
        ColorTypeGray = 4,
        ColorTypeGrayAlpha = ColorTypeGray | AlphaLayer,
        FlipX = 8,
        FlipY = 16
    };

    /*
    enum ColorType {
        Alpha,
        Red,
        Green,
        Blue,
        Luminance,
        LuminanceAlpha,
        RGB,
        BGR,
        RGBA,
        BGRA
    };*/

public: // c'tors
    UImageIO();
    UImageIO(const std::string & fileNameA);
    UImageIO(IStream & streamA, const std::string & extensionA);
    UImageIO(unsigned char * dataA, int widthA, int heightA, int componentsA);
    UImageIO(int widthA, int heightA, int componentsA);
    virtual ~UImageIO();


public: // general accessors
    unsigned char * getPixels();

    int getWidth();
    int getHeight();
    const UDimension & getSize();

    std::string getComment();

    int getImageComponents();

public: // Image loading methods

    bool load(const std::string & fileNameA);

    bool loadFromArchive(const std::string & fileNameA);

    bool load(UImageIO::IStream & streamA, const std::string & extensionA);
    //bool load(std::basic_istream<unsigned char> & streamA,
    //  std::string extensionA);


public: // Image saving methods

    bool save(const std::string & fileNameA);
    bool save(UImageIO::OStream & streamA, const std::string & extensionA);

public: // filter rules
    //void setFilterRule(UImageIO::FilterRule filterRule);
    //UImageIO::FilterRule getFilterRule();


    //void apply();

public: // Public static methods
    static std::vector<std::string> getAvailableLoadingExtensions();
    static UImageIO::LoadFuncPointer registerLoader(
            UImageIO::LoadFuncPointer loaderA,
            const std::string & extensionA);
    static void unregisterLoader(UImageIO::LoadFuncPointer saverA,
            const std::string & extensionA);


    static std::vector<std::string> getAvailableSavingExtensions();
    static UImageIO::SaveFuncPointer registerSaver(UImageIO::SaveFuncPointer saverA,
            const std::string & extensionA);
    static void unregisterSaver(UImageIO::SaveFuncPointer saverA,
            const std::string & extensionA);

    static void init();

protected:  // Overrides UObject
    virtual std::ostream & paramString(std::ostream & os) const;

public:  // Public attributes

    static const int ALPHA_LAYER;

    static const int COLOR_TYPE_RGB;
    static const int COLOR_TYPE_RGB_ALPHA;

    static const int COLOR_TYPE_GRAY;

    static const int COLOR_TYPE_GRAY_ALPHA;

    static const int FLIP_X;
    static const int FLIP_Y;

private:  // Private attributes
    std::string m_comment;
    unsigned char * m_data;
    UDimension m_size;
    int m_components;
    //FilterRule m_filterRule;

    typedef std::map<std::string, LoadFuncPointer> LoadMap_t;
    typedef std::map<std::string, SaveFuncPointer> SaveMap_t;
    static LoadMap_t m_loadFuncs;
    static SaveMap_t m_saveFuncs;
};

} // namespace ufo

#endif // UIMAGEIO_HPP

---