scribblearea.h

/*
 
Pencil2D - Traditional Animation Software
Copyright (C) 2005-2007 Patrick Corrieri & Pascal Naidon
Copyright (C) 2012-2020 Matthew Chiawen Chang
 
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; version 2 of the License.
 
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.
 
*/
 
 
#ifndef SCRIBBLEAREA_H
#define SCRIBBLEAREA_H
 
#include <cstdint>
#include <ctime>
#include <deque>
#include <memory>
 
#include <QColor>
#include <QPoint>
#include <QWidget>
#include <QPixmapCache>
 
#include "movemode.h"
#include "log.h"
#include "pencildef.h"
#include "bitmapimage.h"
#include "canvaspainter.h"
#include "overlaypainter.h"
#include "preferencemanager.h"
#include "strokemanager.h"
#include "selectionpainter.h"
#include "camerapainter.h"
 
class Layer;
class Editor;
class BaseTool;
class PointerEvent;
class BitmapImage;
class VectorImage;
 
 
class ScribbleArea : public QWidget
{
    Q_OBJECT
 
    friend class MoveTool;
    friend class EditTool;
    friend class SmudgeTool;
    friend class BucketTool;
 
public:
    ScribbleArea(QWidget* parent);
    ~ScribbleArea() override;
 
    bool init();
    void setEditor(Editor* e) { mEditor = e; }
    StrokeManager* getStrokeManager() const { return mStrokeManager.get(); }
    Editor* editor() const { return mEditor; }
 
    void deleteSelection();
    void displaySelectionProperties();
 
    void applyTransformedSelection();
    void cancelTransformedSelection();
 
    bool isLayerPaintable() const;
 
    QVector<QPoint> calcSelectionCenterPoints();
 
    void setEffect(SETTING e, bool isOn);
 
    LayerVisibility getLayerVisibility() const { return mLayerVisibility; }
    qreal getCurveSmoothing() const { return mCurveSmoothingLevel; }
    bool usePressure() const { return mUsePressure; }
    bool makeInvisible() const { return mMakeInvisible; }
 
    QRect getCameraRect();
    QPointF getCentralPoint();
 
    void updateCurrentFrame();
    void updateFrame(int frame);
 
    void onScrubbed(int frameNumber);
 
    void onFramesModified();
 
    void onPlayStateChanged();
 
    void onViewChanged();
 
    void onFrameModified(int frameNumber);
 
    void onLayerChanged();
 
    void onSelectionChanged();
 
    void onOnionSkinTypeChanged();
 
    void onObjectLoaded();
 
    void onToolPropertyUpdated(ToolType, ToolPropertyType);
 
    void onToolChanged(ToolType);
 
    void setModified(int layerNumber, int frameNumber);
    void setModified(const Layer* layer, int frameNumber);
 
    void flipSelection(bool flipVertical);
 
    BaseTool* currentTool() const;
    BaseTool* getTool(ToolType eToolMode);
    void setCurrentTool(ToolType eToolMode);
 
    void floodFillError(int errorType);
 
    bool isMouseInUse() const { return mMouseInUse; }
    bool isTabletInUse() const { return mTabletInUse; }
    bool isPointerInUse() const { return mMouseInUse || mTabletInUse; }
 
    void keyEvent(QKeyEvent* event);
    void keyEventForSelection(QKeyEvent* event);
 
signals:
    void multiLayerOnionSkinChanged(bool);
    void refreshPreview();
    void selectionUpdated();
 
public slots:
    void clearImage();
    void setCurveSmoothing(int);
    void toggleThinLines();
    void toggleOutlines();
    void increaseLayerVisibilityIndex();
    void decreaseLayerVisibilityIndex();
    void setLayerVisibility(LayerVisibility visibility);
 
    void updateToolCursor();
    void paletteColorChanged(QColor);
 
    void showLayerNotVisibleWarning();
 
protected:
    bool event(QEvent *event) override;
    void tabletEvent(QTabletEvent*) override;
    void wheelEvent(QWheelEvent*) override;
    void mousePressEvent(QMouseEvent*) override;
    void mouseMoveEvent(QMouseEvent*) override;
    void mouseReleaseEvent(QMouseEvent*) override;
    void mouseDoubleClickEvent(QMouseEvent*) override;
    void keyPressEvent(QKeyEvent*) override;
    void keyReleaseEvent(QKeyEvent*) override;
    void paintEvent(QPaintEvent*) override;
    void resizeEvent(QResizeEvent*) override;
 
public:
    void drawPolyline(QPainterPath path, QPen pen, bool useAA);
    void drawLine(QPointF P1, QPointF P2, QPen pen, QPainter::CompositionMode cm);
    void drawPath(QPainterPath path, QPen pen, QBrush brush, QPainter::CompositionMode cm);
    void drawPen(QPointF thePoint, qreal brushWidth, QColor fillColor, bool useAA = true);
    void drawPencil(QPointF thePoint, qreal brushWidth, qreal fixedBrushFeather, QColor fillColor, qreal opacity);
    void drawBrush(QPointF thePoint, qreal brushWidth, qreal offset, QColor fillColor, qreal opacity, bool usingFeather = true, bool useAA = false);
    void blurBrush(BitmapImage *bmiSource_, QPointF srcPoint_, QPointF thePoint_, qreal brushWidth_, qreal offset_, qreal opacity_);
    void liquifyBrush(BitmapImage *bmiSource_, QPointF srcPoint_, QPointF thePoint_, qreal brushWidth_, qreal offset_, qreal opacity_);
 
    void paintBitmapBuffer();
    void paintCanvasCursor(QPainter& painter);
    void clearBitmapBuffer();
    void setGaussianGradient(QGradient &gradient, QColor color, qreal opacity, qreal offset);
 
    void pointerPressEvent(PointerEvent*);
    void pointerMoveEvent(PointerEvent*);
    void pointerReleaseEvent(PointerEvent*);
 
    void updateCanvasCursor();
 
    void handleDrawingOnEmptyFrame();
 
    BitmapImage mBufferImg; // used to draw strokes for both bitmap and vector
 
    QPixmap mCursorImg;
    QPixmap mTransCursImg;
 
private:
 
    void invalidatePainterCaches();
 
    void invalidateCacheForFrame(int frameNumber);
 
    void invalidateAllCache();
 
    void invalidateCacheForDirtyFrames();
 
    void invalidateOnionSkinsCacheAround(int frame);
 
    void prepOverlays(int frame);
    void prepCameraPainter(int frame);
    void prepCanvas(int frame, QRect rect);
    void drawCanvas(int frame, QRect rect);
    void settingUpdated(SETTING setting);
    void paintSelectionVisuals(QPainter &painter);
 
    BitmapImage* currentBitmapImage(Layer* layer) const;
    VectorImage* currentVectorImage(Layer* layer) const;
 
    MoveMode mMoveMode = MoveMode::NONE;
 
    std::unique_ptr<StrokeManager> mStrokeManager;
 
    Editor* mEditor = nullptr;
 
 
    bool mIsSimplified = false;
    bool mShowThinLines = false;
    bool mQuickSizing = true;
    LayerVisibility mLayerVisibility = LayerVisibility::ALL;
    bool mUsePressure   = true;
    bool mMakeInvisible = false;
    bool mToolCursors = true;
    qreal mCurveSmoothingLevel = 0.0;
    bool mMultiLayerOnionSkin = false; // future use. If required, just add a checkbox to updated it.
    QColor mOnionColor;
    int mDeltaFactor = 1;
 
private:
 
    /* Under certain circumstances a mouse press event will fire after a tablet release event.
       This causes unexpected behaviours for some of the tools, eg. the bucket.
       The problem only seems to occur on windows and only when tapping.
       prior to this fix the event queue would look like this:
       eg: TabletPress -> TabletRelease -> MousePress
       The following will filter mouse events created after a tablet release event.
    */
    void tabletReleaseEventFired();
    bool mKeyboardInUse = false;
    bool mMouseInUse = false;
    bool mMouseRightButtonInUse = false;
    bool mTabletInUse = false;
    qreal mDevicePixelRatio = 1.;
 
    // Double click handling for tablet input
    void handleDoubleClick();
    bool mIsFirstClick = true;
    int mDoubleClickMillis = 0;
    // Microsoft suggests that a double click action should be no more than 500 ms
    const int DOUBLE_CLICK_THRESHOLD = 500;
    QTimer* mDoubleClickTimer = nullptr;
    int mTabletReleaseMillisAgo;
    const int MOUSE_FILTER_THRESHOLD = 200;
 
    QTimer* mMouseFilterTimer = nullptr;
 
    QPoint mCursorCenterPos;
    QPointF mTransformedCursorPos;
 
    PreferenceManager* mPrefs = nullptr;
 
    QPixmap mCanvas;
    CanvasPainter mCanvasPainter;
    OverlayPainter mOverlayPainter;
    SelectionPainter mSelectionPainter;
    CameraPainter mCameraPainter;
 
    QPolygonF mOriginalPolygonF = QPolygonF();
 
    // Pixmap Cache keys
    QMap<unsigned int, QPixmapCache::Key> mPixmapCacheKeys;
 
    // debug
    QLoggingCategory mLog{ "ScribbleArea" };
};
 
#endif