Fix linux compilation.

src/rendering/mesh/AbstractMesh.cpp

@@ -5,6 +5,11 @@ void AbstractMesh::addConstantNodeVectorAttribute(const std::string& tag, const
 
 }
 
+AbstractMesh::~AbstractMesh()
+{
+
+}
+
 std::vector<std::vector<double> > AbstractMesh::getNodeVectorAttributes(const std::string& tag)
 {
     std::vector<std::vector<double> > attribs(mNodes.size());

src/rendering/mesh/AbstractMesh.h

@@ -20,7 +20,7 @@ public:
         QUAD
     };
 
-    virtual ~AbstractMesh() = default;
+    virtual ~AbstractMesh();
 
     void addVectorAttribute(const std::string& tag, const std::vector<double>& values);
 

src/rendering/visual_elements/basic_shapes/CircleNode.cpp

@@ -14,6 +14,11 @@ CircleNode::CircleNode(const Transform& transform, double radius)
     mMinorRadius = mRadius;
 }
 
+CircleNode::~CircleNode()
+{
+
+}
+
 CircleNode::Type CircleNode::getType()
 {
     return Type::Circle;

src/rendering/visual_elements/basic_shapes/CircleNode.h

@@ -10,6 +10,8 @@ class CircleNode : public GeometryNode
 public:
     CircleNode(const Transform& transform, double radius);
 
+    virtual ~CircleNode();
+
     Type getType() override;
     double getRadius() const;
 

src/rendering/visual_elements/nodes/GridNode.cpp

@@ -9,6 +9,11 @@ GridNode::GridNode(const Transform& transform)
 
 }
 
+GridNode::~GridNode()
+{
+
+}
+
 void GridNode::setNumX(std::size_t numX)
 {
     if (mNumberX != numX)

src/rendering/visual_elements/nodes/GridNode.h

@@ -10,6 +10,8 @@ class GridNode : public MaterialNode
 public:
     GridNode(const Transform& transform);
 
+    virtual ~GridNode();
+
     void setNumX(std::size_t numX);
 
     void setNumY(std::size_t numY);

src/rendering/visual_elements/nodes/MaterialNode.cpp

@@ -8,6 +8,11 @@ MaterialNode::MaterialNode(const Transform& transform)
 
 }
 
+MaterialNode::~MaterialNode()
+{
+
+}
+
 const Color& MaterialNode::getFillColor() const
 {
     return mFillColor;

src/rendering/visual_elements/nodes/MaterialNode.h

@@ -8,6 +8,7 @@ class MaterialNode : public AbstractVisualNode
 {
 public:
     MaterialNode(const Transform& transform);
+    virtual ~MaterialNode();
 
     const Color& getFillColor() const;
     const Color& getStrokeColor() const;

src/rendering/visual_elements/nodes/MeshNode.cpp

@@ -9,6 +9,28 @@ MeshNode::MeshNode(const Transform& transform)
 
 }
 
+MeshNode::~MeshNode()
+{
+
+}
+
+SceneItem* MeshNode::getSceneItem(std::size_t idx) const
+{
+    return mModel.get();
+}
+
+std::size_t MeshNode::getNumSceneItems() const
+{
+    if (mWorkingMesh)
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
 void MeshNode::setWidth(double width)
 {
     if (mWidth != width)
@@ -33,23 +55,6 @@ void MeshNode::setMesh(AbstractMesh* mesh)
     mMeshIsDirty = true;
 }
 
-SceneItem* MeshNode::getSceneItem(std::size_t idx) const
-{
-    return mModel.get();
-}
-
-std::size_t MeshNode::getNumSceneItems() const
-{
-    if (mWorkingMesh)
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
 void MeshNode::update(SceneInfo* sceneInfo)
 {
     if (!mModel || mMeshIsDirty)

src/rendering/visual_elements/nodes/MeshNode.h

@@ -9,6 +9,8 @@ class MeshNode : public MaterialNode
 {
 public:
     MeshNode(const Transform& transform);
+    virtual ~MeshNode();
+
     void setMesh(AbstractMesh* mesh);
 
     SceneItem* getSceneItem(std::size_t idx) const override;

src/rendering/visual_elements/scene/SceneItem.cpp

@@ -5,6 +5,11 @@ SceneItem::SceneItem()
 
 }
 
+SceneItem::~SceneItem()
+{
+
+}
+
 const Color& SceneItem::getFillColor() const
 {
     return mFillColor;
@@ -20,6 +25,11 @@ const Transform& SceneItem::getTransform() const
     return mTransform;
 }
 
+const std::string& SceneItem::getName() const
+{
+    return mName;
+}
+
 double SceneItem::getOutlineThickness() const
 {
     return mOutlineThickness;
@@ -78,3 +88,8 @@ void SceneItem::updateTransform(const Transform& transform)
         mTransform = transform;
     }
 }
+
+void SceneItem::setName(const std::string& name)
+{
+    mName = name;
+}

src/rendering/visual_elements/scene/SceneItem.h

@@ -18,7 +18,7 @@ public:
 
     SceneItem();
 
-    virtual ~SceneItem() = default;
+    virtual ~SceneItem();
 
     const Color& getFillColor() const;
 
@@ -30,6 +30,8 @@ public:
 
     double getOutlineThickness() const;
 
+    const std::string& getName() const;
+
     bool hasFillColor() const;
 
     bool hasOutlineColor() const;
@@ -44,18 +46,10 @@ public:
 
     void setFillColor(const Color& color);
 
+    void setName(const std::string& name);
+
     void updateTransform(const Transform& transform);
 
-    void setName(const std::string& name)
-    {
-        mName = name;
-    }
-
-    const std::string& getName() const
-    {
-        return mName;
-    }
-
 protected:
     Transform mTransform;
 

src/rendering/visual_elements/scene/SceneModel.cpp

@@ -10,6 +10,11 @@ SceneModel::SceneModel(std::unique_ptr<AbstractMesh> mesh)
 
 }
 
+SceneModel::~SceneModel()
+{
+
+}
+
 SceneModel::SceneModel(std::unique_ptr<AbstractGeometricItem> geometry)
     : SceneItem(),
       mGeometry(std::move(geometry))

src/rendering/visual_elements/scene/SceneModel.h

@@ -15,6 +15,8 @@ class SceneModel : public SceneItem
 {
 public:
     SceneModel() = default;
+    virtual ~SceneModel();
+
     explicit SceneModel(std::unique_ptr<AbstractMesh> mesh);
     explicit SceneModel(std::unique_ptr<AbstractGeometricItem> geometry);
 

src/ui/ui_elements/widgets/BoxGeometry.cpp

@@ -1,10 +1,15 @@
 #include "BoxGeometry.h"
 
 BoxGeometry::BoxGeometry()
-	: mLocation(DiscretePoint(0, 0)),
-		mSize({ 100, 0, 0, 100, 0, 0 }),
-		mPadding(),
-		mMargin()
+    : mLocation(DiscretePoint(0, 0)),
+        mSize({ 100, 0, 0, 100, 0, 0 }),
+        mPadding(),
+        mMargin()
+{
+
+}
+
+BoxGeometry::~BoxGeometry()
 {
 
 }
@@ -12,40 +17,40 @@ BoxGeometry::BoxGeometry()
 
 BoundedSize BoxGeometry::getSize() const
 {
-	return mSize;
+    return mSize;
 }
 
 const DiscretePoint& BoxGeometry::getLocation() const
 {
-	return mLocation;
+    return mLocation;
 }
 
 void BoxGeometry::setSize(const BoundedSize& size)
 {
-	if (size != mSize)
-	{
-		mSize = size;
-		mTransformDirty = true;
-	}
+    if (size != mSize)
+    {
+        mSize = size;
+        mTransformDirty = true;
+    }
 }
 
 void BoxGeometry::setMargin(unsigned margin)
 {
-	setMargin({ margin, margin, margin, margin });
+    setMargin({ margin, margin, margin, margin });
 }
 
 void BoxGeometry::setMargin(const BoundaryOffset& margin)
 {
-	if (margin != mMargin)
-	{
-		mMargin = margin;
-		mTransformDirty = true;
-	}
+    if (margin != mMargin)
+    {
+        mMargin = margin;
+        mTransformDirty = true;
+    }
 }
 
 void BoxGeometry::setPadding(unsigned padding)
 {
-	setPadding({ padding, padding, padding, padding });
+    setPadding({ padding, padding, padding, padding });
 }
 
 void BoxGeometry::setPadding(const BoundaryOffset& padding)

src/ui/ui_elements/widgets/BoxGeometry.h

@@ -51,7 +51,7 @@ class BoxGeometry
 public:
     BoxGeometry();
 
-    virtual ~BoxGeometry() = default;
+    virtual ~BoxGeometry();
 
     bool contains(const DiscretePoint& loc) const;
 
@@ -88,4 +88,4 @@ protected:
     BoundaryOffset mMargin;
 
     bool mTransformDirty{ true };
-};
+};

src/ui/windows/ui_interfaces/x11/XcbEventInterface.cpp

@@ -13,7 +13,7 @@ std::unique_ptr<XcbEventInterface> XcbEventInterface::Create()
     return std::make_unique<XcbEventInterface>();
 }
 
-std::unique_ptr<KeyboardEvent> XcbEventInterface::ConvertKeyPress(xcb_key_press_event_t* event, Keyboard* keyboard) const
+std::unique_ptr<KeyboardEvent> XcbEventInterface::convertKeyPress(xcb_key_press_event_t* event, Keyboard* keyboard) const
 {
     auto ui_event = KeyboardEvent::Create();
     ui_event->setAction(KeyboardEvent::Action::Pressed);
@@ -29,7 +29,7 @@ std::unique_ptr<KeyboardEvent> XcbEventInterface::ConvertKeyPress(xcb_key_press_
     return ui_event;
 }
 
-std::unique_ptr<KeyboardEvent> XcbEventInterface::ConvertKeyRelease(xcb_key_press_event_t* event, Keyboard* keyboard) const
+std::unique_ptr<KeyboardEvent> XcbEventInterface::convertKeyRelease(xcb_key_press_event_t* event, Keyboard* keyboard) const
 {
     auto ui_event = KeyboardEvent::Create();
     ui_event->setAction(KeyboardEvent::Action::Released);
@@ -45,31 +45,31 @@ std::unique_ptr<KeyboardEvent> XcbEventInterface::ConvertKeyRelease(xcb_key_pres
     return ui_event;
 }
 
-std::unique_ptr<MouseEvent> XcbEventInterface::ConvertButtonPress(xcb_button_press_event_t* event) const
+std::unique_ptr<MouseEvent> XcbEventInterface::convertButtonPress(xcb_button_press_event_t* event) const
 {
     auto ui_event = MouseEvent::Create();
     auto x = static_cast<unsigned>(event->event_x);
     auto y = static_cast<unsigned>(event->event_y);
-    ui_event->SetClientLocation(DiscretePoint(x, y));
+    ui_event->setClientLocation(DiscretePoint(x, y));
 
     auto screen_x = static_cast<unsigned>(event->root_x);
     auto screen_y = static_cast<unsigned>(event->root_y);
-    ui_event->SetScreenLocation(DiscretePoint(x, y));
-    ui_event->SetAction(MouseEvent::Action::Pressed);
+    ui_event->setScreenLocation(DiscretePoint(x, y));
+    ui_event->setAction(MouseEvent::Action::Pressed);
     return ui_event;
 }
 
-std::unique_ptr<MouseEvent> XcbEventInterface::ConvertButtonRelease(xcb_button_press_event_t* event) const
+std::unique_ptr<MouseEvent> XcbEventInterface::convertButtonRelease(xcb_button_press_event_t* event) const
 {
     auto ui_event = MouseEvent::Create();
     auto x = static_cast<unsigned>(event->event_x);
     auto y = static_cast<unsigned>(event->event_y);
-    ui_event->SetClientLocation(DiscretePoint(x, y));
+    ui_event->setClientLocation(DiscretePoint(x, y));
 
     auto screen_x = static_cast<unsigned>(event->root_x);
     auto screen_y = static_cast<unsigned>(event->root_y);
-    ui_event->SetScreenLocation(DiscretePoint(x, y));
+    ui_event->setScreenLocation(DiscretePoint(x, y));
 
-    ui_event->SetAction(MouseEvent::Action::Released);
+    ui_event->setAction(MouseEvent::Action::Released);
     return ui_event;
 }

src/ui/windows/ui_interfaces/x11/XcbEventInterface.h

@@ -13,16 +13,15 @@ struct xcb_button_press_event_t;
 class XcbEventInterface
 {
 public:
-
     static std::unique_ptr<XcbEventInterface> Create();
 
-    std::unique_ptr<KeyboardEvent> ConvertKeyPress(xcb_key_press_event_t* event, Keyboard* keyboard) const;
+    std::unique_ptr<KeyboardEvent> convertKeyPress(xcb_key_press_event_t* event, Keyboard* keyboard) const;
 
-    std::unique_ptr<KeyboardEvent> ConvertKeyRelease(xcb_key_press_event_t* event, Keyboard* keyboard) const;
+    std::unique_ptr<KeyboardEvent> convertKeyRelease(xcb_key_press_event_t* event, Keyboard* keyboard) const;
 
-    std::unique_ptr<MouseEvent> ConvertButtonPress(xcb_button_press_event_t* event) const;
+    std::unique_ptr<MouseEvent> convertButtonPress(xcb_button_press_event_t* event) const;
 
-    std::unique_ptr<MouseEvent> ConvertButtonRelease(xcb_button_press_event_t* event) const;
+    std::unique_ptr<MouseEvent> convertButtonRelease(xcb_button_press_event_t* event) const;
 };
 
 using XcbEventInterfacePtr = std::unique_ptr<XcbEventInterface>;

src/ui/windows/ui_interfaces/x11/XcbInterface.cpp

@@ -182,7 +182,7 @@ void XcbInterface::addWindow(mt::Window* window)
 
 void XcbInterface::onPaint()
 {
-    mDesktopManager->onUiEvent(PaintEvent::Create());
+    mDesktopManager->onUiEvent(PaintEvent::Create(mDesktopManager->getThemeManager(), mDesktopManager->getFontsManager()));
 
     auto mainWindow = mDesktopManager->getWindowManager()->getMainWindow();
     auto defaultScreen = mDesktopManager->getDefaultScreen();
@@ -215,25 +215,25 @@ void XcbInterface::loop()
             }
             case XCB_KEY_PRESS: {
                 auto kp = reinterpret_cast<xcb_key_press_event_t*>(event);
-                auto ui_event = mEventInterface->ConvertKeyPress(kp, mDesktopManager->getKeyboard());
+                auto ui_event = mEventInterface->convertKeyPress(kp, mDesktopManager->getKeyboard());
                 mDesktopManager->onUiEvent(std::move(ui_event));
                 break;
             }
             case XCB_KEY_RELEASE: {
                 auto kr = reinterpret_cast<xcb_key_release_event_t*>(event);
-                auto ui_event = mEventInterface->ConvertKeyRelease(kr, mDesktopManager->getKeyboard());
+                auto ui_event = mEventInterface->convertKeyRelease(kr, mDesktopManager->getKeyboard());
                 mDesktopManager->onUiEvent(std::move(ui_event));
                 break;
             }
             case XCB_BUTTON_PRESS: {
                 auto press = reinterpret_cast<xcb_button_press_event_t*>(event);
-                auto ui_event = mEventInterface->ConvertButtonPress(press);
+                auto ui_event = mEventInterface->convertButtonPress(press);
                 mDesktopManager->onUiEvent(std::move(ui_event));
                 break;
             }
             case XCB_BUTTON_RELEASE: {
                 auto release = reinterpret_cast<xcb_button_release_event_t*>(event);
-                auto ui_event = mEventInterface->ConvertButtonRelease(release);
+                auto ui_event = mEventInterface->convertButtonRelease(release);
                 mDesktopManager->onUiEvent(std::move(ui_event));
                 break;
             }

src/ui/windows/ui_interfaces/x11/XcbInterface.h

@@ -38,20 +38,23 @@ public:
     void showWindow(mt::Window* window) override;
 
 private:
-    void initialize() override;
-    void onPaint();
-    void onExposeEvent(xcb_expose_event_t* event);
-
-    void initializeHardwareRendering() override;
     void createGraphicsContext();
 
     void connect();
-    void updateScreen();
+
+    uint32_t getEventMask();
+
+    void initialize() override;
+    void initializeHardwareRendering() override;
+
+    void onPaint();
+    void onExposeEvent(xcb_expose_event_t* event);
+
     void mapWindow(mt::Window* window);
 
     void shutDown() override;
-    uint32_t getEventMask();
 
+    void updateScreen();
 private:
     xcb_connection_t* mConnection{nullptr};
     _XDisplay* mX11Display{nullptr};