QSDK 1.1 Documentation

image.h

Go to the documentation of this file.

/*-
 * Copyright (c) 1999-2003 Qube Software, Ltd.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of the source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Any redistribution solely in binary form must conspicuously
 *    reproduce the following disclaimer in documentation provided with the
 *    binary redistribution.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'', WITHOUT ANY WARRANTIES, EXPRESS
 * OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  LICENSOR SHALL
 * NOT BE LIABLE FOR ANY LOSS OR DAMAGES RESULTING FROM THE USE OF THIS
 * SOFTWARE, EITHER ALONE OR IN COMBINATION WITH ANY OTHER SOFTWARE.
 *
 *      $Qube: Q/image/sdk/image.h,v 1.38.2.1 2003/09/24 14:20:09 jamief Exp $
 */

#ifndef __image_h__
#define __image_h__

#define QImage_version  10002000

#ifndef IMAGE_BEGIN
#define IMAGE_BEGIN     namespace Image {
#define IMAGE_END       }
#endif

#include <Q/linkage.h>

namespace Net {
    struct ReadStream;
    struct WriteStream;
};

IMAGE_BEGIN

struct Pixmap;

struct PixelIterator
{
    enum Type {
        Single,

        Double
    };

    virtual                     ~PixelIterator() {}

    virtual Maths::Color4b      get() const = 0;

    virtual void                put(const Maths::Color4b&) = 0;

    virtual size_t              read(Maths::Color4b* buf, size_t n) = 0;

    virtual size_t              write(const Maths::Color4b* buf, size_t n) = 0;

    virtual bool                next() = 0;

    virtual bool                valid() = 0;

    virtual void                set(unsigned int x, unsigned int y) = 0;
};

struct Format : public Utils::Object
{
    enum Type {
        Unknown,        // This is used for formats implemented elsewhere .
        RGB565,
        RGBA5551,
        RGBA4444,
        RGB888,
        RGBA8888,
        BGR565,
        BGRA5551,
        BGRA4444,
        BGR888,
        BGRA8888,
        GREY8,
        IDX8,
        IDX4
    };

    typedef Utils::Ref<Format> REF;

    static EXPORT_QIMAGE Format* create(Type);

    virtual                     ~Format() {}

    virtual size_t              bitsPerPixel() const = 0;

    virtual bool                hasAlpha() const = 0;

    virtual Type                type() const = 0;

    virtual Maths::Color4b      get(unsigned int x,
                                    unsigned int y,
                                    const Pixmap*) const = 0;

    virtual void*               getScanlineAddress(unsigned int y,
                                                   Pixmap*) const = 0;

    virtual void                put(unsigned int x,
                                    unsigned int y,
                                    const Maths::Color4b& pixel,
                                    Pixmap*) const = 0;

    virtual PixelIterator*      createIterator(Pixmap*,
                                               PixelIterator::Type) const = 0;
};

struct IndexedColorFormat : public Format
{
    typedef Utils::Ref<IndexedColorFormat> REF;

    static EXPORT_QIMAGE IndexedColorFormat* create(Type);

    // Palette controls
    virtual size_t              entries() const = 0;

    virtual void                setEntry(unsigned int idx,
                                         const Maths::Color4b& value) = 0;

    virtual Maths::Color4b      getEntry(unsigned int idx) const = 0;

    virtual unsigned int        getIndex(unsigned int x,
                                         unsigned int y,
                                         const Pixmap* p) const = 0;

    virtual void                putIndex(unsigned int x,
                                         unsigned int y,
                                         unsigned int idx,
                                         const Pixmap*) const = 0;
};

struct EXPORT_QIMAGE Pixmap : public Utils::Object
{
    typedef Utils::Ref<Pixmap> REF;

                        Pixmap(unsigned int width,
                               unsigned int height,
                               Format* format);

                        Pixmap(unsigned int width,
                               unsigned int height,
                               unsigned int stride,
                               void* data,
                               Format* format);

                        ~Pixmap();

    unsigned int        width() const { return width_; }

    unsigned int        height() const { return height_; }

    unsigned int        stride() const { return stride_; }

    unsigned int        depth() const { return format_->bitsPerPixel(); }

    Format*             format() const { return format_; }

    void*               data() const { return bits_; }

    void                copyTo(Pixmap* dest) const;

    void                copyFrom(Pixmap* source, const Maths::Vec2ui& off);

private:
    void                init();

    unsigned short      width_;
    unsigned short      height_;
    unsigned int        stride_;        // bytes per line
    Format::REF         format_;        // what kind of image
    void*               bits_;          // image data
    bool                ownsData_;      // Did we allocate bits_ ?
};

struct Source : public Utils::Object
{
    typedef Utils::Ref<Source> REF;

    virtual             ~Source() {}

    virtual unsigned int width() = 0;

    virtual unsigned int height() = 0;

    virtual Format*     format() = 0;

    virtual bool        unpack(Pixmap*, unsigned int scanlines = 0) = 0;

    virtual bool        isValid() = 0;

    static EXPORT_QIMAGE
    Source*     create(const char* filename);

    static EXPORT_QIMAGE
    Source*     create(Net::ReadStream*);

};

struct Destination : public Utils::Object
{
    typedef Utils::Ref<Destination> REF;

    virtual             ~Destination() {}

    virtual void        pack() = 0;

    static EXPORT_QIMAGE
    Destination*        create(const char* filename, Image::Pixmap*);

    static EXPORT_QIMAGE
    Destination*        create(Net::WriteStream*, Image::Pixmap*);
};


IMAGE_END

#endif // __image_h__

// Local Variables:
// mode: c++
// End:

		Qube Software Limited © 2000-2004