kis_painter.h

/*
 *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
 *  Copyright (c) 2004 Clarence Dang <dang@kde.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_PAINTER_H_
#define KIS_PAINTER_H_
 
#include <kcommand.h>
 
#include "kis_color.h"
#include "kis_global.h"
#include "kis_types.h"
#include "kis_paint_device.h"
#include "kis_point.h"
#include "kis_filter.h"
#include "kis_progress_subject.h"
#include "kis_paintop.h"
#include "kis_color.h"
 
#include <koffice_export.h>
 
class TQRect;
class KisTransaction;
class KisBrush;
class KisPattern;

class KRITACORE_EXPORT KisPainter : public KisProgressSubject {
    typedef KisProgressSubject super;
 
public:
    KisPainter();
    KisPainter(KisPaintDeviceSP device);
    virtual ~KisPainter();
 
private:
    // Implement KisProgressSubject
    virtual void cancel() { m_cancelRequested = true; }
 
public:
    void begin(KisPaintDeviceSP device);

    KCommand *end();

    void beginTransaction(const TQString& customName = TQString());

    KCommand *endTransaction();

    void beginTransaction( KisTransaction* command);

    KisTransaction  * transaction() { return m_transaction; }
 

    KisPaintDeviceSP device() const { return m_device; }
 
 
    // -----------------------------------------------------------------
    //  Native paint methods that are undo/redo-able,
    // use the color strategies and the composite operations.

    void bitBlt(TQ_INT32 dx, TQ_INT32 dy,
                const KisCompositeOp& op,
                KisPaintDeviceSP src,
                TQ_INT32 sx, TQ_INT32 sy,
                TQ_INT32 sw, TQ_INT32 sh)
    {
        bitBlt(dx, dy, op, src, OPACITY_OPAQUE, sx, sy, sw, sh);
    }

    void bitBlt(TQ_INT32 dx, TQ_INT32 dy,
                const KisCompositeOp& op,
                KisPaintDeviceSP src,
                TQ_UINT8 opacity,
                TQ_INT32 sx, TQ_INT32 sy,
                TQ_INT32 sw, TQ_INT32 sh);

    void bltMask(TQ_INT32 dx, TQ_INT32 dy,
                      const KisCompositeOp &op,
                      KisPaintDeviceSP src,
                      KisPaintDeviceSP selMask,
                      TQ_UINT8 opacity,
                      TQ_INT32 sx, TQ_INT32 sy,
                      TQ_INT32 sw, TQ_INT32 sh);

    void bltSelection(TQ_INT32 dx, TQ_INT32 dy,
                      const KisCompositeOp &op,
                      KisPaintDeviceSP src,
                      KisSelectionSP selMask,
                      TQ_UINT8 opacity,
                      TQ_INT32 sx, TQ_INT32 sy,
                      TQ_INT32 sw, TQ_INT32 sh);
 

    void bltSelection(TQ_INT32 dx, TQ_INT32 dy,
                      const KisCompositeOp &op,
                      KisPaintDeviceSP src,
                      TQ_UINT8 opacity,
                      TQ_INT32 sx, TQ_INT32 sy,
                      TQ_INT32 sw, TQ_INT32 sh);
 

    TQRect dirtyRect();

    TQRect addDirtyRect(TQRect r) { m_dirtyRect |= r; return m_dirtyRect; }
 
 

    void paintPolyline(const TQValueVector <KisPoint> &points,
                       int index = 0, int numPoints = -1);

    double paintLine(const KisPoint &pos1,
             const double pressure1,
             const double xTilt1,
             const double yTilt1,
             const KisPoint &pos2,
             const double pressure2,
             const double xTilt2,
             const double yTilt2,
             const double savedDist = -1);

    double paintBezierCurve(const KisPoint &pos1,
                const double pressure1,
                const double xTilt1,
                const double yTilt1,
                const KisPoint &control1,
                const KisPoint &control2,
                const KisPoint &pos2,
                const double pressure2,
                const double xTilt2,
                const double yTilt2,
                const double savedDist = -1);

    void getBezierCurvePoints(const KisPoint &pos1,
                  const KisPoint &control1,
                  const KisPoint &control2,
                  const KisPoint &pos2,
                  vKisPoint& points);
 

    void paintRect(const KisPoint &startPoint,
               const KisPoint &endPoint,
               const double pressure,
               const double xTilt,
               const double yTilt);
 

    void paintEllipse(const KisPoint &startPoint,
                      const KisPoint &endPoint,
                      const double pressure,
                      const double /*xTilt*/,
                      const double /*yTilt*/);

    void paintPolygon(const vKisPoint& points);

    void paintAt(const KisPoint &pos,
             const double pressure,
             const double /*xTilt*/,
             const double /*yTilt*/);
 
 
    // ------------------------------------------------------------------------
    // Set the parameters for the higher level graphics primitives.

    void setVaryBrushSpacingWithPressureWhenDrawingALine( bool varyBrushSpacingWithPressureWhenDrawingALine )
        { m_varyBrushSpacingWithPressureWhenDrawingALine = varyBrushSpacingWithPressureWhenDrawingALine; }
    bool varyBrushSpacingWithPressureWhenDrawingALine() {  return m_varyBrushSpacingWithPressureWhenDrawingALine;  }

    void setBrush(KisBrush* brush) { m_brush = brush; }
    KisBrush * brush() const { return m_brush; }

    void setPattern(KisPattern * pattern) { m_pattern = pattern; }
    KisPattern * pattern() const { return m_pattern; }

    void setPaintColor(const KisColor& color) { m_paintColor = color;}

    KisColor paintColor() const { return m_paintColor; }

    void setBackgroundColor(const KisColor& color) {m_backgroundColor = color; }
    KisColor backgroundColor() const { return m_backgroundColor; }

    void setFillColor(const KisColor& color) { m_fillColor = color; }
    KisColor fillColor() const { return m_fillColor; }
 

    enum FillStyle {
        FillStyleNone,
        FillStyleForegroundColor,
        FillStyleBackgroundColor,
        FillStylePattern,
        FillStyleGradient,
        FillStyleStrokes
    };

    void setFillStyle(FillStyle fillStyle) { m_fillStyle = fillStyle; }
    FillStyle fillStyle() const { return m_fillStyle; }

    enum StrokeStyle {
        StrokeStyleNone,
        StrokeStyleBrush
    };

    void setStrokeStyle(StrokeStyle strokeStyle) { m_strokeStyle = strokeStyle; }
    StrokeStyle strokeStyle() const { return m_strokeStyle; }

    void setOpacity(TQ_UINT8 opacity) { m_opacity = opacity; }
    TQ_UINT8 opacity() const { return m_opacity; }

    void setCompositeOp(const KisCompositeOp& op) { m_compositeOp = op; }
    KisCompositeOp compositeOp() const { return m_compositeOp; }

    void setFilter(KisFilterSP filter) { m_filter = filter; }
    KisFilterSP filter() { return m_filter; }

    // TODO: this is an hack ! it must be fix, the following functions have nothing to do here
    void setDuplicateOffset(const KisPoint& offset) { m_duplicateOffset = offset; }
    KisPoint duplicateOffset(){ return m_duplicateOffset; }
 
    inline void setDuplicateHealing(bool v) { m_duplicateHealing = v; }
    inline bool duplicateHealing() { return m_duplicateHealing; }
 
    inline void setDuplicateHealingRadius(int r) { m_duplicateHealingRadius = r; }
    inline int duplicateHealingRadius() { return m_duplicateHealingRadius; }
 
    inline void setDuplicatePerspectiveCorrection(bool v) { m_duplicatePerspectiveCorrection = v; }
    inline bool duplicatePerspectiveCorrection() { return m_duplicatePerspectiveCorrection; }
 
    void setDuplicateStart(const KisPoint start) { m_duplicateStart = start;}
    KisPoint duplicateStart() { return m_duplicateStart;}

    void setPressure(double pressure) { m_pressure = pressure; }
    double pressure() { return m_pressure; }

    void setPaintOp(KisPaintOp * paintOp) { delete m_paintOp; m_paintOp = paintOp; }
    KisPaintOp * paintOp() const { return m_paintOp; }

    void setDab(KisPaintDeviceSP dab) { m_dab = dab; }
    KisPaintDeviceSP dab() const { return m_dab; }

    bool cancelRequested() const { return m_cancelRequested; }
 
protected:
    void init();
    KisPainter(const KisPainter&);
    KisPainter& operator=(const KisPainter&);

    static double pointToLineDistance(const KisPoint& p, const KisPoint& l0, const KisPoint& l1);

    void fillPolygon(const vKisPoint& points, FillStyle fillStyle);
 
protected:
    KisPaintDeviceSP m_device;
    KisTransaction  *m_transaction;
 
    TQRect m_dirtyRect;
 
    KisColor m_paintColor;
    KisColor m_backgroundColor;
    KisColor m_fillColor;
    FillStyle m_fillStyle;
    StrokeStyle m_strokeStyle;
    KisBrush *m_brush;
    KisPattern *m_pattern;
    KisPoint m_duplicateOffset;
    KisPoint m_duplicateStart;
    bool m_duplicateHealing;
    int m_duplicateHealingRadius;
    bool m_duplicatePerspectiveCorrection;
    TQ_UINT8 m_opacity;
    KisCompositeOp m_compositeOp;
    KisFilterSP m_filter;
    KisPaintOp * m_paintOp;
    double m_pressure;
    bool m_cancelRequested;
    TQ_INT32 m_pixelSize;
    KisColorSpace * m_colorSpace;
    KisProfile *  m_profile;
    KisPaintDeviceSP m_dab;
    bool m_varyBrushSpacingWithPressureWhenDrawingALine;
 
};
 
 
#endif // KIS_PAINTER_H_