kis_layer.h

/*
 *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
 *  Copyright (c) 2005 Casper Boemann <cbr@boemann.dk>
 *
 *  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_LAYER_H_
#define KIS_LAYER_H_
 
#include <tqobject.h>
#include "kis_types.h"
#include "kis_layer_visitor.h"
#include "kis_composite_op.h"
#include <koffice_export.h>
 
class KNamedCommand;
class TQPainter;
class KisUndoAdapter;
class KisGroupLayer;

class KRITACORE_EXPORT KisLayer : public TQObject, public TDEShared
{
    TQ_OBJECT
  
 
public:
    KisLayer(KisImage *img, const TQString &name, TQ_UINT8 opacity);
    KisLayer(const KisLayer& rhs);
    virtual ~KisLayer();
 
    
    virtual void setClean(const TQRect & rect);
    
    virtual bool dirty();

    virtual bool dirty(const TQRect & rc);
 
 
    virtual TQRect dirtyRect() const;
    
    
    virtual void setDirty(bool propagate = true);

    virtual void setDirty(const TQRect & rect, bool propagate = true);
    
    virtual KisLayerSP clone() const = 0;

    int id() const { return m_id; }
 
    /* Returns the index of the layer in its parent's list of child layers. Indices
     * increase from 0, which is the topmost layer in the list, to the bottommost.
     */
    virtual int index() const;

    virtual void setIndex(int index);

    virtual KisGroupLayerSP parent() const;

    virtual KisLayerSP prevSibling() const;

    virtual KisLayerSP nextSibling() const;

    KisLayerSP siblingAbove() const { return prevSibling(); }

    KisLayerSP siblingBelow() const { return nextSibling(); }

    virtual uint childCount() const { return 0; }

    virtual KisLayerSP firstChild() const { return 0; }

    virtual KisLayerSP lastChild() const { return 0; }

    virtual KisLayerSP findLayer(const TQString& name) const;

    virtual KisLayerSP findLayer(int id) const;
 
    enum { Visible = 1, Hidden = 2, Locked = 4, Unlocked = 8 };

    virtual int numLayers(int type = 0) const;
 
public:
    virtual void activate() {};

    virtual void deactivate() {};
 
public:
    virtual TQ_INT32 x() const = 0;
    virtual void setX(TQ_INT32) = 0;
 
    virtual TQ_INT32 y() const = 0;
    virtual void setY(TQ_INT32) = 0;
 
    virtual KNamedCommand *moveCommand(TQPoint oldPosition, TQPoint newPosition);

    virtual TQRect extent() const = 0;
    virtual TQRect exactBounds() const = 0;
 
    virtual const bool visible() const;
    virtual void setVisible(bool v);
    KNamedCommand *setVisibleCommand(bool visiblel);
 
    TQ_UINT8 opacity() const;
    void setOpacity(TQ_UINT8 val);
    KNamedCommand *setOpacityCommand(TQ_UINT8 val);
    KNamedCommand *setOpacityCommand(TQ_UINT8 prevOpacity, TQ_UINT8 newOpacity);
 
    bool locked() const;
    void setLocked(bool l);
    KNamedCommand *setLockedCommand(bool locked);
 
    void notifyPropertyChanged();
 
    bool temporary() const;
    void setTemporary(bool t);
 
    virtual TQString name() const;
    virtual void setName(const TQString& name);
 
    KisCompositeOp compositeOp() { return m_compositeOp; }
    void setCompositeOp(const KisCompositeOp& compositeOp);
    KNamedCommand *setCompositeOpCommand(const KisCompositeOp& compositeOp);
 
    KisImage *image() const { return m_image; }
    virtual void setImage(KisImage *image) { m_image = image; }
 
    KisUndoAdapter *undoAdapter() const;

    virtual void paintSelection(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);
    virtual void paintSelection(TQImage &img, const TQRect& scaledImageRect, const TQSize& scaledImageSize, const TQSize& imageSize);

    virtual void paintMaskInactiveLayers(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);

    virtual TQImage createThumbnail(TQ_INT32 w, TQ_INT32 h);

    virtual bool accept(KisLayerVisitor &) = 0;
 
private:
    friend class KisGroupLayer;
 
    bool matchesFlags(int flags) const;
 
    int m_id;
    int m_index;
    TQ_UINT8 m_opacity;
    bool m_locked;
    bool m_visible;
    bool m_temporary;
 
    // XXX: keep a list of dirty rects instead of always aggegrating them
    TQRect m_dirtyRect;
    TQString m_name;
    KisGroupLayerSP m_parent;
    KisImage *m_image;
 
    // Operation used to composite this layer with the layers _under_ this layer
    KisCompositeOp m_compositeOp;
};
 
// For classes that support indirect painting
class KRITACORE_EXPORT KisLayerSupportsIndirectPainting {
    // To simulate the indirect painting
    KisPaintDeviceSP m_temporaryTarget;
    KisCompositeOp m_compositeOp;
    TQ_UINT8 m_compositeOpacity;
public:
    // Indirect painting
    void setTemporaryTarget(KisPaintDeviceSP t);
    void setTemporaryCompositeOp(const KisCompositeOp& c);
    void setTemporaryOpacity(TQ_UINT8 o);
    KisPaintDeviceSP temporaryTarget();
    KisCompositeOp temporaryCompositeOp() const;
    TQ_UINT8 temporaryOpacity() const;
 
    // Or I could make KisLayer a virtual base of KisLayerSupportsIndirectPainting and so, but
    // I'm sure virtual diamond inheritance isn't as appreciated as this
    virtual KisLayer* layer() = 0;
};
 
#endif // KIS_LAYER_H_