Add TargetModel class

Author: adazem009

src/CMakeLists.txt

@@ -24,6 +24,8 @@ qt_add_qml_module(scratchcpp-render
 	projectloader.h
     projectscene.cpp
     projectscene.h
+    targetmodel.cpp
+    targetmodel.h
 	stagemodel.cpp
 	stagemodel.h
 	spritemodel.cpp

src/spritemodel.cpp

@@ -6,52 +6,21 @@
 #include <scratchcpp/textbubble.h>
 
 #include "spritemodel.h"
-#include "renderedtarget.h"
-#include "ipenlayer.h"
-#include "graphicseffect.h"
+#include "penlayer.h"
 
-namespace scratchcpprender
-{
+using namespace scratchcpprender;
 
 SpriteModel::SpriteModel(QObject *parent) :
-    QObject(parent)
+    TargetModel(parent)
 {
 }
 
 void SpriteModel::init(libscratchcpp::Sprite *sprite)
 {
     m_sprite = sprite;
 
-    if (m_sprite) {
-        libscratchcpp::TextBubble *bubble = m_sprite->bubble();
-
-        bubble->typeChanged().connect([this](libscratchcpp::TextBubble::Type type) {
-            if (type == libscratchcpp::TextBubble::Type::Say) {
-                if (m_bubbleType == TextBubbleShape::Type::Say)
-                    return;
-
-                m_bubbleType = TextBubbleShape::Type::Say;
-            } else {
-                if (m_bubbleType == TextBubbleShape::Type::Think)
-                    return;
-
-                m_bubbleType = TextBubbleShape::Type::Think;
-            }
-
-            emit bubbleTypeChanged();
-        });
-
-        bubble->textChanged().connect([this](const std::string &text) {
-            QString newText = QString::fromStdString(text);
-
-            if (m_bubbleText != newText) {
-                m_bubbleText = newText;
-                emit bubbleTextChanged();
-            }
-        });
-
-        bubble->layerOrderChanged().connect([this](int) { emit bubbleLayerChanged(); });
-    }
+    if (m_sprite)
+        setupTextBubble(m_sprite->bubble());
 }
 
 void SpriteModel::deinitClone()
@@ -66,184 +35,119 @@ void SpriteModel::onCloned(libscratchcpp::Sprite *clone)
 
     SpriteModel *cloneModel = new SpriteModel(m_cloneRoot);
     cloneModel->m_cloneRoot = m_cloneRoot;
-    cloneModel->m_penLayer = m_penLayer;
-    cloneModel->m_penState = m_penState;
+    cloneModel->setPenLayer(penLayer());
+    cloneModel->penState() = penState();
     clone->setInterface(cloneModel);
     emit cloned(cloneModel);
 }
 
 void SpriteModel::onCostumeChanged(libscratchcpp::Costume *costume)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateCostume(costume);
+    updateCostume(costume);
 }
 
 void SpriteModel::onVisibleChanged(bool visible)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateVisibility(visible);
+    updateVisibility(visible);
 }
 
 void SpriteModel::onXChanged(double x)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateX(x);
+    updateX(x);
 }
 
 void SpriteModel::onYChanged(double y)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateY(y);
+    updateY(y);
 }
 
 void SpriteModel::onMoved(double oldX, double oldY, double newX, double newY)
 {
-    if (m_penState.penDown && m_penLayer) {
-        m_penLayer->drawLine(m_penState.penAttributes, oldX, oldY, newX, newY);
-        libscratchcpp::IEngine *engine = m_sprite->engine();
-
-        if (engine)
-            engine->requestRedraw();
-    }
+    TargetModel::onMoved(oldX, oldY, newX, newY);
 }
 
 void SpriteModel::onSizeChanged(double size)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateSize(size);
+    updateSize(size);
 }
 
 void SpriteModel::onDirectionChanged(double direction)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateDirection(direction);
+    updateDirection(direction);
 }
 
 void SpriteModel::onRotationStyleChanged(libscratchcpp::Sprite::RotationStyle rotationStyle)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateRotationStyle(rotationStyle);
+    updateRotationStyle(rotationStyle);
 }
 
 void SpriteModel::onLayerOrderChanged(int layerOrder)
 {
-    if (m_renderedTarget)
-        m_renderedTarget->updateLayerOrder(layerOrder);
+    updateLayerOrder(layerOrder);
 }
 
 void SpriteModel::onGraphicsEffectChanged(libscratchcpp::IGraphicsEffect *effect, double value)
 {
-    GraphicsEffect *graphicsEffect = dynamic_cast<GraphicsEffect *>(effect);
-
-    if (graphicsEffect && m_renderedTarget)
-        m_renderedTarget->setGraphicEffect(graphicsEffect->effect(), value);
+    setGraphicEffect(effect, value);
 }
 
 void SpriteModel::onGraphicsEffectsCleared()
 {
-    if (m_renderedTarget)
-        m_renderedTarget->clearGraphicEffects();
+    clearGraphicEffects();
 }
 
 int SpriteModel::costumeWidth() const
 {
-    return m_renderedTarget->costumeWidth();
+    return TargetModel::costumeWidth();
 }
 
 int SpriteModel::costumeHeight() const
 {
-    return m_renderedTarget->costumeHeight();
+    return TargetModel::costumeHeight();
 }
 
 libscratchcpp::Rect SpriteModel::boundingRect() const
 {
-    return m_renderedTarget->getBounds();
+    libscratchcpp::Rect ret;
+    getBoundingRect(ret);
+    return ret;
 }
 
 libscratchcpp::Rect SpriteModel::fastBoundingRect() const
 {
-    return m_renderedTarget->getFastBounds();
+    libscratchcpp::Rect ret;
+    getFastBoundingRect(ret);
+    return ret;
 }
 
 bool SpriteModel::touchingClones(const std::vector<libscratchcpp::Sprite *> &clones) const
 {
-    return m_renderedTarget->touchingClones(clones);
+    return TargetModel::touchingClones(clones);
 }
 
 bool SpriteModel::touchingPoint(double x, double y) const
 {
-    return m_renderedTarget->containsScratchPoint(x, y);
+    return TargetModel::touchingPoint(x, y);
 }
 
 bool SpriteModel::touchingColor(libscratchcpp::Rgb color) const
 {
-    return m_renderedTarget->touchingColor(color);
+    return TargetModel::touchingColor(color);
 }
 
 bool SpriteModel::touchingColor(libscratchcpp::Rgb color, libscratchcpp::Rgb mask) const
 {
-    return m_renderedTarget->touchingColor(color, mask);
+    return TargetModel::touchingColor(color, mask);
 }
 
 libscratchcpp::Sprite *SpriteModel::sprite() const
 {
     return m_sprite;
 }
 
-IRenderedTarget *SpriteModel::renderedTarget() const
-{
-    return m_renderedTarget;
-}
-
-void SpriteModel::setRenderedTarget(IRenderedTarget *newRenderedTarget)
-{
-    if (m_renderedTarget == newRenderedTarget)
-        return;
-
-    m_renderedTarget = newRenderedTarget;
-    emit renderedTargetChanged();
-}
-
-IPenLayer *SpriteModel::penLayer() const
-{
-    return m_penLayer;
-}
-
-void SpriteModel::setPenLayer(IPenLayer *newPenLayer)
-{
-    if (m_penLayer == newPenLayer)
-        return;
-
-    m_penLayer = newPenLayer;
-    emit penLayerChanged();
-}
-
-PenState &SpriteModel::penState()
-{
-    return m_penState;
-}
-
-PenAttributes &SpriteModel::penAttributes()
-{
-    return m_penState.penAttributes;
-}
-
-bool SpriteModel::penDown() const
-{
-    return m_penState.penDown;
-}
-
-void SpriteModel::setPenDown(bool newPenDown)
+int SpriteModel::bubbleLayer() const
 {
-    m_penState.penDown = newPenDown;
-
-    if (m_penState.penDown && m_penLayer && m_sprite) {
-        m_penLayer->drawPoint(m_penState.penAttributes, m_sprite->x(), m_sprite->y());
-        libscratchcpp::IEngine *engine = m_sprite->engine();
-
-        if (engine)
-            engine->requestRedraw();
-    }
+    return m_sprite ? m_sprite->bubble()->layerOrder() : 0;
 }
 
 SpriteModel *SpriteModel::cloneRoot() const
@@ -254,19 +158,26 @@ SpriteModel *SpriteModel::cloneRoot() const
         return m_cloneRoot;
 }
 
-const TextBubbleShape::Type &SpriteModel::bubbleType() const
+void SpriteModel::loadCostume()
 {
-    return m_bubbleType;
+    if (m_sprite)
+        updateCostume(m_sprite->currentCostume().get());
 }
 
-const QString &SpriteModel::bubbleText() const
+void SpriteModel::drawPenPoint(IPenLayer *penLayer, const PenAttributes &penAttributes)
 {
-    return m_bubbleText;
+    penLayer->drawPoint(penAttributes, m_sprite->x(), m_sprite->y());
+    libscratchcpp::IEngine *engine = m_sprite->engine();
+
+    if (engine)
+        engine->requestRedraw();
 }
 
-int SpriteModel::bubbleLayer() const
+void SpriteModel::drawPenLine(IPenLayer *penLayer, const PenAttributes &penAttributes, double x0, double y0, double x1, double y1)
 {
-    return m_sprite ? m_sprite->bubble()->layerOrder() : 0;
-}
+    penLayer->drawLine(penAttributes, x0, y0, x1, y1);
+    libscratchcpp::IEngine *engine = m_sprite->engine();
 
-} // namespace scratchcpprender
+    if (engine)
+        engine->requestRedraw();
+}

src/spritemodel.h

@@ -2,33 +2,19 @@
 
 #pragma once
 
-#include <QObject>
-#include <QQmlEngine>
 #include <scratchcpp/ispritehandler.h>
 
-#include "penstate.h"
-#include "textbubbleshape.h"
-
-Q_MOC_INCLUDE("renderedtarget.h");
-Q_MOC_INCLUDE("ipenlayer.h");
+#include "targetmodel.h"
 
 namespace scratchcpprender
 {
 
-class IRenderedTarget;
-class IPenLayer;
-
 class SpriteModel
-    : public QObject
+    : public TargetModel
     , public libscratchcpp::ISpriteHandler
 {
         Q_OBJECT
         QML_ELEMENT
-        Q_PROPERTY(IRenderedTarget *renderedTarget READ renderedTarget WRITE setRenderedTarget NOTIFY renderedTargetChanged)
-        Q_PROPERTY(IPenLayer *penLayer READ penLayer WRITE setPenLayer NOTIFY penLayerChanged)
-        Q_PROPERTY(TextBubbleShape::Type bubbleType READ bubbleType NOTIFY bubbleTypeChanged)
-        Q_PROPERTY(QString bubbleText READ bubbleText NOTIFY bubbleTextChanged)
-        Q_PROPERTY(int bubbleLayer READ bubbleLayer NOTIFY bubbleLayerChanged)
 
     public:
         SpriteModel(QObject *parent = nullptr);
@@ -65,43 +51,23 @@ class SpriteModel
 
         libscratchcpp::Sprite *sprite() const;
 
-        IRenderedTarget *renderedTarget() const;
-        void setRenderedTarget(IRenderedTarget *newRenderedTarget);
-
-        IPenLayer *penLayer() const;
-        void setPenLayer(IPenLayer *newPenLayer);
-
-        PenState &penState();
-        PenAttributes &penAttributes();
-
-        bool penDown() const;
-        void setPenDown(bool newPenDown);
+        int bubbleLayer() const override;
 
         SpriteModel *cloneRoot() const;
 
-        const TextBubbleShape::Type &bubbleType() const;
-
-        const QString &bubbleText() const;
-
-        int bubbleLayer() const;
+        Q_INVOKABLE void loadCostume() override;
 
     signals:
-        void renderedTargetChanged();
-        void penLayerChanged();
-        void bubbleTypeChanged();
-        void bubbleTextChanged();
         void cloned(SpriteModel *cloneModel);
         void cloneDeleted(SpriteModel *clone);
-        void bubbleLayerChanged();
+
+    protected:
+        void drawPenPoint(IPenLayer *penLayer, const PenAttributes &penAttributes) override;
+        void drawPenLine(IPenLayer *penLayer, const PenAttributes &penAttributes, double x0, double y0, double x1, double y1) override;
 
     private:
         libscratchcpp::Sprite *m_sprite = nullptr;
-        IRenderedTarget *m_renderedTarget = nullptr;
-        IPenLayer *m_penLayer = nullptr;
-        PenState m_penState;
         SpriteModel *m_cloneRoot = nullptr;
-        TextBubbleShape::Type m_bubbleType = TextBubbleShape::Type::Say;
-        QString m_bubbleText;
 };
 
 } // namespace scratchcpprender