inplace_transform_stroke_strategy.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2013 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#ifndef __INPLACE_TRANSFORM_STROKE_STRATEGY_H
#define __INPLACE_TRANSFORM_STROKE_STRATEGY_H
 
#include <QObject>
#include <KoUpdater.h>
#include <kis_stroke_strategy_undo_command_based.h>
#include <kis_types.h>
#include "tool_transform_args.h"
#include <kritatooltransform_export.h>
 
#include <transform_transaction_properties.h>
 
#include "KisAsynchronousStrokeUpdateHelper.h"
#include <commands_new/KisUpdateCommandEx.h>
 
class KisPostExecutionUndoAdapter;
class TransformTransactionProperties;
class KisUpdatesFacade;
class KisDecoratedNodeInterface;
 
 
class InplaceTransformStrokeStrategy : public QObject, public KisStrokeStrategyUndoCommandBased
{
    Q_OBJECT
public:
    class UpdateTransformData : public KisStrokeJobData {
    public:
        enum Destination {
            PAINT_DEVICE,
            SELECTION,
        };
 
    public:
        UpdateTransformData(ToolTransformArgs _args, Destination _dest)
            : KisStrokeJobData(SEQUENTIAL, NORMAL),
              args(_args),
              destination(_dest)
        {}
 
        KisStrokeJobData* createLodClone(int levelOfDetail) override {
            return new UpdateTransformData(*this, levelOfDetail);
        }
 
    private:
        UpdateTransformData(const UpdateTransformData &rhs, int levelOfDetail)
            : KisStrokeJobData(rhs),
              args(rhs.args),
              destination(rhs.destination)
        {
            Q_UNUSED(levelOfDetail);
        }
 
    public:
        ToolTransformArgs args;
        Destination destination;
    };
 
    class CalculateConvexHullData : public KisStrokeJobData {
    public:
        CalculateConvexHullData()
            : KisStrokeJobData(SEQUENTIAL, NORMAL) // Is this right?
        {}
    };
 
private:
 
    struct BarrierUpdateData : public KisAsynchronousStrokeUpdateHelper::UpdateData
    {
        BarrierUpdateData(bool forceUpdate);
        KisStrokeJobData* createLodClone(int levelOfDetail) override;
    private:
        BarrierUpdateData(const BarrierUpdateData &rhs, int levelOfDetail);
    };
 
public:
 
    enum CommandGroup {
        Clear = 0,
        ClearTemporary,
        Transform,
        TransformTemporary,
        TransformLod,
        TransformLodTemporary
    };
    Q_ENUM(CommandGroup);
 
public:
    InplaceTransformStrokeStrategy(ToolTransformArgs::TransformMode mode,
                                   const QString &filterId,
                                   bool forceReset,
                                   KisNodeList rootNodes,
                                   KisSelectionSP selection,
                                   KisPaintDeviceSP externalSource,
                                   KisStrokeUndoFacade *undoFacade,
                                   KisUpdatesFacade *updatesFacade, KisNodeSP imageRoot, bool forceLodMode);
 
    ~InplaceTransformStrokeStrategy() override;
 
    void initStrokeCallback() override;
    void finishStrokeCallback() override;
    void cancelStrokeCallback() override;
    void doStrokeCallback(KisStrokeJobData *data) override;
 
Q_SIGNALS:
    void sigTransactionGenerated(TransformTransactionProperties transaction, ToolTransformArgs args, void *cookie);
    void sigConvexHullCalculated(QPolygon convexHull, void *cookie);
 
protected:
    void postProcessToplevelCommand(KUndo2Command *command) override;
 
private:
    friend class InitializeTransformModeStrokeStrategy;
 
    InplaceTransformStrokeStrategy(const InplaceTransformStrokeStrategy &rhs, int levelOfDetail);
 
    void tryPostUpdateJob(bool forceUpdate);
    void doCanvasUpdate(bool forceUpdate);
    QPolygon calculateConvexHull();
 
    int calculatePreferredLevelOfDetail(const QRect &srcRect);
 
    void executeAndAddCommand(KUndo2Command *cmd, CommandGroup group, KisStrokeJobData::Sequentiality seq);
 
    void notifyAllCommandsDone();
    void undoAllCommands();
    void undoTransformCommands(int levelOfDetail);
 
    void fetchAllUpdateRequests(int levelOfDetail, KisBatchNodeUpdateSP updateData);
 
    void transformNode(KisNodeSP node, const ToolTransformArgs &config, int levelOfDetail);
    void createCacheAndClearNode(KisNodeSP node);
    void reapplyTransform(ToolTransformArgs args, QVector<KisStrokeJobData *> &mutatedJobs, int levelOfDetail, bool useHoldUI);
    void finalizeStrokeImpl(QVector<KisStrokeJobData *> &mutatedJobs, bool saveCommands);
 
    void finishAction(QVector<KisStrokeJobData *> &mutatedJobs);
    void cancelAction(QVector<KisStrokeJobData *> &mutatedJobs);
    void addDirtyRect(KisNodeSP node, const QRect &rect, int levelOfDetail);
 
    static void repopulateUI(QVector<KisStrokeJobData *> &mutatedJobs, KisUpdatesFacade *updatesFacade, const QRect &dirtyRect);
 
private:
    struct Private;
    const QScopedPointer<Private> m_d;
};
 
#endif /* __INPLACE_TRANSFORM_STROKE_STRATEGY_H */