kis_image.h

/*
 *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
 *                2006 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_IMAGE_H_
#define KIS_IMAGE_H_
 
#include <tqobject.h>
#include <tqstring.h>
#include <tqvaluevector.h>
#include <tqmutex.h>
 
#include <config.h>
 
#include <ksharedptr.h>
#include <kurl.h>
 
#include "KoUnit.h"
 
#include "kis_composite_op.h"
#include "kis_global.h"
#include "kis_types.h"
#include "kis_annotation.h"
#include "kis_paint_device.h"
 
#include <koffice_export.h>
 
 
class DCOPObject;
class KCommand;
 
class KoCommandHistory;
 
class KisColorSpace;
class KisNameServer;
class KisUndoAdapter;
class KisPainter;
class KCommand;
class KisColor;
class KisFilterStrategy;
class KisImageIface;
class KisProfile;
class KisProgressDisplayInterface;
class KisPaintLayer;
class KisPerspectiveGrid;
 
class KRITACORE_EXPORT KisImage : public TQObject, public TDEShared {
    TQ_OBJECT
  
 
public:
    KisImage(KisUndoAdapter * adapter, TQ_INT32 width, TQ_INT32 height, KisColorSpace * colorSpace, const TQString& name);
    KisImage(const KisImage& rhs);
    virtual ~KisImage();
    virtual DCOPObject *dcopObject();
 
public:
    typedef enum enumPaintFlags {
        PAINT_IMAGE_ONLY = 0,
        PAINT_BACKGROUND = 1,
        PAINT_SELECTION = 2,
        PAINT_MASKINACTIVELAYERS = 4,
        PAINT_EMBEDDED_RECT = 8 // If the current layer is an embedded part draw a rect around it
    } PaintFlags;

    virtual void renderToPainter(TQ_INT32 x1,
                    TQ_INT32 y1,
                    TQ_INT32 x2,
                    TQ_INT32 y2,
                    TQPainter &painter,
                    KisProfile *profile,
                    PaintFlags paintFlags,
                    float exposure = 0.0f);
    virtual TQImage convertToTQImage(TQ_INT32 x1,
                                    TQ_INT32 y1,
                                    TQ_INT32 x2,
                                    TQ_INT32 y2,
                                    KisProfile * profile,
                                    float exposure = 0.0f);
 
    virtual TQImage convertToTQImage(const TQRect& r, const TQSize& fullImageSize, KisProfile *profile, PaintFlags paintFlags, float exposure = 0.0f);
 
    KisBackgroundSP background() const;
    KisSubstrateSP substrate() const;
    
 
public:

    void lock();

    void unlock();

    bool locked() const;
 
    KisColor backgroundColor() const;
    void setBackgroundColor(const KisColor & color);
 
    TQString name() const;
    void setName(const TQString& name);
 
    TQString description() const;
    void setDescription(const TQString& description);
 
    TQString nextLayerName() const;
    void rollBackLayerName();
    
    KisPerspectiveGrid* perspectiveGrid();
    void createPerspectiveGrid(TQPoint topLeft, TQPoint topRight, TQPoint bottomRight, TQPoint bottomLeft);
    void resize(TQ_INT32 w, TQ_INT32 h, TQ_INT32 x = 0, TQ_INT32 y = 0,  bool cropLayers = false);

    void resize(const TQRect& rc, bool cropLayers = false);
 
    void scale(double sx, double sy, KisProgressDisplayInterface *m_progress, KisFilterStrategy *filterStrategy);
    void rotate(double radians, KisProgressDisplayInterface *m_progress);
    void shear(double angleX, double angleY, KisProgressDisplayInterface *m_progress);

    void convertTo(KisColorSpace * dstColorSpace, TQ_INT32 renderingIntent = INTENT_PERCEPTUAL);
 
    // Get the profile associated with this image
    KisProfile *  getProfile() const;

 
    void setProfile(const KisProfile * profile);

    void setUndoAdapter(KisUndoAdapter * undoAdapter);

    KisUndoAdapter *undoAdapter() const;

    bool undo() const;
    void setModified();
 
    KisColorSpace * colorSpace() const;
 
    // Resolution of the image == XXX: per inch?
    double xRes();
    double yRes();
    void setResolution(double xres, double yres);
 
    TQ_INT32 width() const;
    TQ_INT32 height() const;
 
    bool empty() const;

    KisPaintDeviceSP mergedImage();
 
    /*
    * Returns the colour of the merged image at pixel (x, y).
    */
    KisColor mergedPixel(TQ_INT32 x, TQ_INT32 y);

    KisLayerSP newLayer(const TQString& name, TQ_UINT8 opacity,
                            const KisCompositeOp& compositeOp = KisCompositeOp(), KisColorSpace * colorstrategy = 0);

    KisPaintDeviceSP activeDevice();
 
    void setLayerProperties(KisLayerSP layer, TQ_UINT8 opacity, const KisCompositeOp& compositeOp, const TQString& name);
 
    KisGroupLayerSP rootLayer() const;
    KisLayerSP activeLayer() const;

    KisPaintDeviceSP projection();
    
    KisLayerSP activate(KisLayerSP layer);
    KisLayerSP findLayer(const TQString& name) const;
    KisLayerSP findLayer(int id) const;

    bool moveLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);

    bool addLayer(KisLayerSP layer, KisGroupLayerSP parent);
    
    bool addLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);

    bool removeLayer(KisLayerSP layer);

    bool raiseLayer(KisLayerSP layer);

    bool lowerLayer(KisLayerSP layer);

    bool toTop(KisLayerSP layer);

    bool toBottom(KisLayerSP layer);
 
    TQ_INT32 nlayers() const;
    TQ_INT32 nHiddenLayers() const;
 
    KCommand *raiseLayerCommand(KisLayerSP layer);
    KCommand *lowerLayerCommand(KisLayerSP layer);
    KCommand *topLayerCommand(KisLayerSP layer);
    KCommand *bottomLayerCommand(KisLayerSP layer);

    void flatten();

    void mergeLayer(KisLayerSP l);
 
    TQRect bounds() const;

    void notifyLayersChanged();
 
    void notifyPropertyChanged(KisLayerSP layer);
 
    void notifyImageLoaded();
 
    void notifyLayerUpdated(KisLayerSP layer, TQRect rc);
 
    void setColorSpace(KisColorSpace * colorSpace);
    void setRootLayer(KisGroupLayerSP rootLayer);
 
    //KisGuideMgr *guides() const;

    void addAnnotation(KisAnnotationSP annotation);

    KisAnnotationSP annotation(TQString type);

    void removeAnnotation(TQString type);

    vKisAnnotationSP_it beginAnnotations();

    vKisAnnotationSP_it endAnnotations();
 
signals:
 
    void sigActiveSelectionChanged(KisImageSP image);
    void sigSelectionChanged(KisImageSP image);
    void sigSelectionChanged(KisImageSP image, const TQRect& rect);

    void sigLayerActivated(KisLayerSP layer);

    void sigLayerAdded(KisLayerSP layer);

    void sigLayerRemoved(KisLayerSP layer, KisGroupLayerSP wasParent, KisLayerSP wasAboveThis);

    void sigLayerMoved(KisLayerSP layer, KisGroupLayerSP previousParent, KisLayerSP wasAboveThis);

    void sigLayerPropertiesChanged(KisLayerSP layer);

    void sigLayersChanged(KisGroupLayerSP rootLayer);

    void sigImageUpdated(TQRect rc);

    void sigLayerUpdated(KisLayerSP layer, TQRect rc);

    void sigImageModified();
 
    void sigSizeChanged(TQ_INT32 w, TQ_INT32 h);
    void sigProfileChanged(KisProfile *  profile);
    void sigColorSpaceChanged(KisColorSpace*  cs);
 

    void sigMaskInfoChanged();
public slots:
    void slotSelectionChanged();
    void slotSelectionChanged(const TQRect& r);
 
 
private:
    KisImage& operator=(const KisImage& rhs);
    void init(KisUndoAdapter * adapter, TQ_INT32 width, TQ_INT32 height,  KisColorSpace * colorSpace, const TQString& name);
    void emitSizeChanged();
 
private:
 
    KURL m_uri;
    TQString m_name;
    TQString m_description;
 
    TQ_INT32 m_width;
    TQ_INT32 m_height;
 
    double m_xres;
    double m_yres;
 
    KoUnit::Unit m_unit;
 
    KisColorSpace * m_colorSpace;
 
    bool m_dirty;
    TQRect m_dirtyRect;
 
    KisBackgroundSP m_bkg;
 
    KisGroupLayerSP m_rootLayer; // The layers are contained in here
    KisLayerSP m_activeLayer;
 
    KisNameServer *m_nserver;
    KisUndoAdapter *m_adapter;
    //KisGuideMgr m_guides;
 
    DCOPObject *m_dcop;
 
    vKisAnnotationSP m_annotations;
 
    class KisImagePrivate;
    KisImagePrivate * m_private;
    
};
 
#endif // KIS_IMAGE_H_