kis_brush.h

/*
 *  Copyright (c) 1999 Matthias Elter  <me@kde.org>
 *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
 *  Copyright (c) 2004 Boudewijn Rempt <boud@valdyas.org>
 *
 *  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 program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#ifndef KIS_BRUSH_
#define KIS_BRUSH_
 
#include <tqcstring.h>
#include <tqstring.h>
#include <tqsize.h>
#include <tqimage.h>
#include <tqvaluevector.h>
 
#include <tdeio/job.h>
 
#include "kis_resource.h"
#include "kis_types.h"
#include "kis_point.h"
#include "kis_alpha_mask.h"
#include "koffice_export.h"
#include "kis_boundary.h"
#include "kis_paintop.h"
 
class TQPoint;
class TQPixmap;
class KisBoundary;
class KisColorSpace;
class TQIODevice;
 
enum enumBrushType {
    INVALID,
    MASK,
    IMAGE,
    PIPE_MASK,
    PIPE_IMAGE,
    AIRBRUSH
};
 
class KRITACORE_EXPORT KisBrush : public KisResource {
    typedef KisResource super;
    TQ_OBJECT
  
 
public:
    KisBrush(const TQString& filename);
    KisBrush(const TQString& filename,
         const TQByteArray & data,
         TQ_UINT32 & dataPos);
    KisBrush(KisPaintDevice* image, int x, int y, int w, int h);
    KisBrush(const TQImage& image, const TQString& name = TQString(""));
 
    virtual ~KisBrush();
 
    virtual bool load();
    virtual bool save();
    virtual TQImage img();
    virtual bool saveToDevice(TQIODevice* dev) const;

    virtual KisAlphaMaskSP mask(const KisPaintInformation& info,
                                double subPixelX = 0, double subPixelY = 0) const;
    // XXX: return non-tiled simple buffer
    virtual KisPaintDeviceSP image(KisColorSpace * colorSpace, const KisPaintInformation& info,
                             double subPixelX = 0, double subPixelY = 0) const;
 
    void setHotSpot(KisPoint);
    KisPoint hotSpot(const KisPaintInformation& info = KisPaintInformation()) const;
 
    void setSpacing(double s) { m_spacing = s; }
    double spacing() const { return m_spacing; }
    double xSpacing(double pressure = PRESSURE_DEFAULT) const;
    double ySpacing(double pressure = PRESSURE_DEFAULT) const;
 
    // Dimensions in pixels of the mask/image at a given pressure.
    TQ_INT32 maskWidth(const KisPaintInformation& info) const;
    TQ_INT32 maskHeight(const KisPaintInformation& info) const;
 
    virtual void setUseColorAsMask(bool useColorAsMask) { m_useColorAsMask = useColorAsMask; }
    virtual bool useColorAsMask() const { return m_useColorAsMask; }
    virtual bool hasColor() const;
 
    virtual void makeMaskImage();
    TQ_INT32 width() const;
    TQ_INT32 height() const;
 
    virtual enumBrushType brushType() const;
 
    //TQImage outline(double pressure = PRESSURE_DEFAULT);
    virtual KisBoundary boundary();

    virtual bool canPaintFor(const KisPaintInformation& /*info*/) { return true; }
 
    virtual KisBrush* clone() const;
 
protected:
    void setWidth(TQ_INT32 w);
    void setHeight(TQ_INT32 h);
    void setImage(const TQImage& img);
    void setBrushType(enumBrushType type) { m_brushType = type; };
    static double scaleForPressure(double pressure);
 
private:
    class ScaledBrush {
    public:
        ScaledBrush();
        ScaledBrush(KisAlphaMaskSP scaledMask, const TQImage& scaledImage, double scale, double xScale, double yScale);
 
        double scale() const { return m_scale; }
        double xScale() const { return m_xScale; }
        double yScale() const { return m_yScale; }
        KisAlphaMaskSP mask() const { return m_mask; }
        TQImage image() const { return m_image; }
 
    private:
        KisAlphaMaskSP m_mask;
        TQImage m_image;
        double m_scale;
        double m_xScale;
        double m_yScale;
    };
 
 
    bool init();
    bool initFromPaintDev(KisPaintDevice* image, int x, int y, int w, int h);
    void createScaledBrushes() const;
 
    KisAlphaMaskSP scaleMask(const ScaledBrush *srcBrush, double scale, double subPixelX, double subPixelY) const;
    TQImage scaleImage(const ScaledBrush *srcBrush, double scale, double subPixelX, double subPixelY) const;
 
    static TQImage scaleImage(const TQImage& srcImage, int width, int height);
    static TQImage interpolate(const TQImage& image1, const TQImage& image2, double t);
 
    static KisAlphaMaskSP scaleSinglePixelMask(double scale, TQ_UINT8 maskValue, double subPixelX, double subPixelY);
    static TQImage scaleSinglePixelImage(double scale, TQRgb pixel, double subPixelX, double subPixelY);
 
    // Find the scaled brush(es) nearest to the given scale.
    void findScaledBrushes(double scale, const ScaledBrush **aboveBrush, const ScaledBrush **belowBrush) const;
 
    // Initialize our boundary
    void generateBoundary();
 
    TQByteArray m_data;
    bool m_ownData;
    KisPoint m_hotSpot;
    double m_spacing;
    bool m_useColorAsMask;
    bool m_hasColor;
    TQImage m_img;
    mutable TQValueVector<ScaledBrush> m_scaledBrushes;
 
    TQ_INT32 m_width;
    TQ_INT32 m_height;
 
    TQ_UINT32 m_header_size;  /*  header_size = sizeof (BrushHeader) + brush name  */
    TQ_UINT32 m_version;      /*  brush file version #  */
    TQ_UINT32 m_bytes;        /*  depth of brush in bytes */
    TQ_UINT32 m_magic_number; /*  GIMP brush magic number  */
 
    enumBrushType m_brushType;
 
    KisBoundary* m_boundary;
 
};
#endif // KIS_BRUSH_