kis_paint_device.h

/*
 *  copyright (c) 2002 patrick julien <freak@codepimps.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., 675 mass ave, cambridge, ma 02139, usa.
 */
#ifndef KIS_PAINT_DEVICE_IMPL_H_
#define KIS_PAINT_DEVICE_IMPL_H_
 
#include <tqcolor.h>
#include <tqobject.h>
#include <tqpixmap.h>
#include <tqptrlist.h>
#include <tqrect.h>
#include <tqvaluelist.h>
#include <tqstring.h>
 
#include "kis_types.h"
#include "kdebug.h"
#include "kis_global.h"
#include "kis_image.h"
#include "kis_colorspace.h"
#include "kis_canvas_controller.h"
#include "kis_color.h"
#include <koffice_export.h>
 
class DCOPObject;
 
class TQImage;
class TQSize;
class TQPoint;
class TQWMatrix;
class TQTimer;
 
class KNamedCommand;
 
class KoStore;
 
class KisExifInfo;
class KisHLineIteratorPixel;
class KisImage;
class KisRectIteratorPixel;
class KisVLineIteratorPixel;
class KisRandomAccessorPixel;
class KisRandomSubAccessorPixel;
class KisUndoAdapter;
class KisFilter;
class KisDataManager;
typedef TDESharedPtr<KisDataManager> KisDataManagerSP;
 
class KisMemento;
typedef TDESharedPtr<KisMemento> KisMementoSP;
 

class KRITACORE_EXPORT KisPaintDevice
    : public TQObject
    , public TDEShared
{
 
        TQ_OBJECT
  
 
public:

    KisPaintDevice(KisColorSpace * colorSpace, const char * name = 0);

    KisPaintDevice(KisLayer *parentLayer, KisColorSpace * colorSpace, const char * name = 0);
 
    KisPaintDevice(const KisPaintDevice& rhs);
    virtual ~KisPaintDevice();
    virtual DCOPObject *dcopObject();
 
    void lock(bool lock) { m_lock = lock; }
 
public:

    virtual bool write(KoStore *store);

    virtual bool read(KoStore *store);
 
public:

    virtual void move(TQ_INT32 x, TQ_INT32 y);

    virtual void move(const TQPoint& pt);

    virtual KNamedCommand * moveCommand(TQ_INT32 x, TQ_INT32 y);

    bool contains(TQ_INT32 x, TQ_INT32 y) const;

    bool contains(const TQPoint& pt) const;

    virtual void extent(TQ_INT32 &x, TQ_INT32 &y, TQ_INT32 &w, TQ_INT32 &h) const;
    virtual TQRect extent() const;

    bool extentIsValid() const;

    void setExtentIsValid(bool isValid);

    virtual void exactBounds(TQ_INT32 &x, TQ_INT32 &y, TQ_INT32 &w, TQ_INT32 &h) const;
    virtual TQRect exactBounds() const;
    virtual TQRect exactBoundsOldMethod() const;
    virtual TQRect exactBoundsImprovedOldMethod() const;

    void crop(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);

    void crop(TQRect r);

    virtual void clear();

    void fill(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h, const TQ_UINT8 *fillPixel);

    virtual void readBytes(TQ_UINT8 * data, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);

    virtual void writeBytes(const TQ_UINT8 * data, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);

    TQ_INT32 numContiguousColumns(TQ_INT32 x, TQ_INT32 minY, TQ_INT32 maxY);

    TQ_INT32 numContiguousRows(TQ_INT32 y, TQ_INT32 minX, TQ_INT32 maxX);

    TQ_INT32 rowStride(TQ_INT32 x, TQ_INT32 y);

    TDE_DEPRECATED const TQ_UINT8* pixel(TQ_INT32 x, TQ_INT32 y);

    TDE_DEPRECATED TQ_UINT8* writablePixel(TQ_INT32 x, TQ_INT32 y);

    virtual void convertTo(KisColorSpace * dstColorSpace, TQ_INT32 renderingIntent = INTENT_PERCEPTUAL);

    virtual void setProfile(KisProfile * profile);
    
    virtual void convertFromTQImage(const TQImage& img, const TQString &srcProfileName, TQ_INT32 offsetX = 0, TQ_INT32 offsetY = 0);

    virtual TQImage convertToTQImage(KisProfile *  dstProfile, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h, float exposure = 0.0f);

    virtual TQImage convertToTQImage(KisProfile *  dstProfile, float exposure = 0.0f);

 
    KisPaintDeviceSP createThumbnailDevice(TQ_INT32 w, TQ_INT32 h);
            
    virtual TQImage createThumbnail(TQ_INT32 maxw, TQ_INT32 maxh);
 

    bool pixel(TQ_INT32 x, TQ_INT32 y, TQColor *c, TQ_UINT8 *opacity);
 

    bool pixel(TQ_INT32 x, TQ_INT32 y, KisColor * kc);

    KisColor colorAt(TQ_INT32 x, TQ_INT32 y);

    bool setPixel(TQ_INT32 x, TQ_INT32 y, const TQColor& c, TQ_UINT8 opacity);
 
    bool setPixel(TQ_INT32 x, TQ_INT32 y, const KisColor& kc);
 
    KisColorSpace * colorSpace() const;
 
    KisDataManagerSP dataManager() const;

    void setData(KisDataManagerSP data, KisColorSpace * colorSpace);

    TQ_INT32 getX() const;

    TQ_INT32 getY() const;

    void setX(TQ_INT32 x);

    void setY(TQ_INT32 y);
 

    virtual TQ_INT32 pixelSize() const;

    virtual TQ_INT32 nChannels() const;

    KisImage *image() const;

    KisLayer *parentLayer() const;

    void setParentLayer(KisLayer *parentLayer);

    virtual void setDirty(const TQRect & rc);

    virtual void setDirty();
    
    
    void mirrorX();
    void mirrorY();
 
    KisMementoSP getMemento();
    void rollback(KisMementoSP memento);
    void rollforward(KisMementoSP memento);

    KisRectIteratorPixel createRectIterator(TQ_INT32 left, TQ_INT32 top, TQ_INT32 w, TQ_INT32 h, bool writable);

    KisHLineIteratorPixel createHLineIterator(TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, bool writable);

    KisVLineIteratorPixel createVLineIterator(TQ_INT32 x, TQ_INT32 y, TQ_INT32 h, bool writable);

    KisRandomAccessorPixel createRandomAccessor(TQ_INT32 x, TQ_INT32 y, bool writable);
    
    KisRandomSubAccessorPixel createRandomSubAccessor();
    
    KisSelectionSP selection();

    void addSelection(KisSelectionSP selection);

    void subtractSelection(KisSelectionSP selection);

    bool hasSelection();

    bool selectionDeselected();

    void deselect();

    void reselect();
        
    void clearSelection();

    void applySelectionMask(KisSelectionSP mask);

    KisSelectionSP setSelection(KisSelectionSP selection);

    void emitSelectionChanged();

    void emitSelectionChanged(const TQRect& r);
 
    
    KisUndoAdapter *undoAdapter() const;

    KisExifInfo* exifInfo();
    bool hasExifInfo() { return m_exifInfo != 0; }
signals:
    void positionChanged(KisPaintDeviceSP device);
    void ioProgress(TQ_INT8 percentage);
    void profileChanged(KisProfile *  profile);
 
private slots:
 
    void runBackgroundFilters();
    
private:
    KisPaintDevice& operator=(const KisPaintDevice&);
 
protected:
    KisDataManagerSP m_datamanager;
    
private:
    /* The KisLayer that contains this paint device, or 0 if this is not 
     * part of a layer.
     */
    KisLayer *m_parentLayer;
 
    bool m_extentIsValid;
 
    TQ_INT32 m_x;
    TQ_INT32 m_y;
    KisColorSpace * m_colorSpace;
    // Cached for quick access
    TQ_INT32 m_pixelSize;
    TQ_INT32 m_nChannels;
 
    // Whether the selection is active
    bool m_hasSelection;
    bool m_selectionDeselected;
    
    // Contains the actual selection. For now, there can be only
    // one selection per layer. XXX: is this a limitation?
    KisSelectionSP m_selection;
    
    DCOPObject * m_dcop;
 
    KisExifInfo* m_exifInfo;
 
    TQValueList<KisFilter*> m_longRunningFilters;
    TQTimer * m_longRunningFilterTimer;
 
    bool m_lock;
};
 
inline TQ_INT32 KisPaintDevice::pixelSize() const
{
    Q_ASSERT(m_pixelSize > 0);
    return m_pixelSize;
}
 
inline TQ_INT32 KisPaintDevice::nChannels() const
{
    Q_ASSERT(m_nChannels > 0);
    return m_nChannels;
;
}
 
inline KisColorSpace * KisPaintDevice::colorSpace() const
{
    Q_ASSERT(m_colorSpace != 0);
        return m_colorSpace;
}
 
 
inline TQ_INT32 KisPaintDevice::getX() const
{
    return m_x;
}
 
inline TQ_INT32 KisPaintDevice::getY() const
{
    return m_y;
}
 
#endif // KIS_PAINT_DEVICE_IMPL_H_