Rename UICDM and UICIMP to QT3DS

Task-number: QT3DS-18
Change-Id: I3800cd72b449b033b0b42cf2dd9e9eccc4eb7f8f
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>

1 files changed, 305 insertions, 0 deletions

diff --git a/src/Authoring/QT3DSDM/Systems/Qt3DSDMSignalStructImpl.h b/src/Authoring/QT3DSDM/Systems/Qt3DSDMSignalStructImpl.h
new file mode 100644
index 00000000..8d22b8cd
--- /dev/null
+++ b/src/Authoring/QT3DSDM/Systems/Qt3DSDMSignalStructImpl.h
@@ -0,0 +1,305 @@
+/****************************************************************************
+**
+** Copyright (C) 1993-2009 NVIDIA Corporation.
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt 3D Studio.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#pragma once
+#ifndef UICDMSIGNALSTRUCTIMPLH
+#define UICDMSIGNALSTRUCTIMPLH
+#include "Qt3DSDMSignalStructs.h"
+
+namespace UICDM {
+
+struct SSignalDataStruct0
+{
+    typedef SSignalDataStruct0 TThisType;
+    typedef std::function<void()> TFunType;
+    static void Send(ISignalSystem &system, void *sender, const char *sigName)
+    {
+        system.Signal(sender, sigName, NULL, 0);
+    }
+
+    static void Unpack(void *inSender, const char *inName, const char *inData, size_t inDataSize,
+                       TFunType inHandler)
+    {
+        if (inDataSize == 0)
+            inHandler();
+        else {
+            QT3DS_ASSERT(false);
+        }
+    }
+
+    static TGenericSignalHandlerFunc CreateHandler(std::function<void()> inHandler)
+    {
+        return std::bind(&TThisType::Unpack, std::placeholders::_1, std::placeholders::_2,
+                         std::placeholders::_3, std::placeholders::_4, inHandler);
+    }
+
+    static std::shared_ptr<ISignalConnection> AddListener(ISignalSystem &inSystem, void *inSender,
+                                                            const char *inName, TFunType inHandler)
+    {
+        return inSystem.AddListener(inSender, inName, CreateHandler(inHandler));
+    }
+};
+
+#define UICDM_SIGNALS_DEFINE_SPECIFIC_SIGNAL_STRUCT0(name)                                         \
+    std::shared_ptr<ISignalConnection> Sig##name::AddListener(                                   \
+        ISignalSystem &inSystem, void *inSender, std::function<void()> inHandler)                \
+    {                                                                                              \
+        typedef SSignalDataStruct0 TBase;                                                          \
+        return TBase::AddListener(inSystem, inSender, #name, inHandler);                           \
+    }                                                                                              \
+    void Sig##name::Send(ISignalSystem &system, void *sender)                                      \
+    {                                                                                              \
+        typedef SSignalDataStruct0 TBase;                                                          \
+        TBase::Send(system, sender, #name);                                                        \
+    }
+
+template <typename TData1>
+struct SSignalDataStruct1
+{
+    typedef SSignalDataStruct1<TData1> TThisType;
+    TData1 m_Data1;
+    typedef std::function<void(TData1)> TFunType;
+    SSignalDataStruct1(TData1 d1)
+        : m_Data1(d1)
+    {
+    }
+    static void Send(ISignalSystem &system, void *sender, const char *sigName, const TData1 &d1)
+    {
+        TThisType theData(d1);
+        system.Signal(sender, sigName, reinterpret_cast<const char *>(&theData), sizeof(TThisType));
+    }
+
+    static void Unpack(void *inSender, const char *inName, const char *inData, size_t inDataSize,
+                       TFunType inHandler)
+    {
+        if (inDataSize == sizeof(TThisType)) {
+            const TThisType *theData = reinterpret_cast<const TThisType *>(inData);
+            inHandler(theData->m_Data1);
+        } else {
+            QT3DS_ASSERT(false);
+        }
+    }
+
+    static TGenericSignalHandlerFunc CreateHandler(TFunType inHandler)
+    {
+        return std::bind(&TThisType::Unpack, std::placeholders::_1, std::placeholders::_2,
+                         std::placeholders::_3, std::placeholders::_4, inHandler);
+    }
+
+    static std::shared_ptr<ISignalConnection> AddListener(ISignalSystem &inSystem, void *inSender,
+                                                            const char *inName, TFunType inHandler)
+    {
+        return inSystem.AddListener(inSender, inName, CreateHandler(inHandler));
+    }
+};
+
+#define UICDM_SIGNALS_DEFINE_SPECIFIC_SIGNAL_STRUCT1(name, d1)                                     \
+    std::shared_ptr<ISignalConnection> Sig##name::AddListener(                                   \
+        ISignalSystem &inSystem, void *inSender, std::function<void(d1)> inHandler)              \
+    {                                                                                              \
+        typedef SSignalDataStruct1<d1> TBase;                                                      \
+        return TBase::AddListener(inSystem, inSender, #name, inHandler);                           \
+    }                                                                                              \
+    void Sig##name::Send(ISignalSystem &system, void *sender, const d1 &arg)                       \
+    {                                                                                              \
+        typedef SSignalDataStruct1<d1> TBase;                                                      \
+        TBase::Send(system, sender, #name, arg);                                                   \
+    }
+
+template <typename TData1, typename TData2>
+struct SSignalDataStruct2
+{
+    typedef SSignalDataStruct2<TData1, TData2> TThisType;
+    typedef std::function<void(TData1, TData2)> TFunType;
+    TData1 m_Data1;
+    TData2 m_Data2;
+    SSignalDataStruct2(TData1 d1, TData2 d2)
+        : m_Data1(d1)
+        , m_Data2(d2)
+    {
+    }
+    static void Send(ISignalSystem &system, void *sender, const char *sigName, const TData1 &d1,
+                     const TData2 &d2)
+    {
+        TThisType theData(d1, d2);
+        system.Signal(sender, sigName, reinterpret_cast<const char *>(&theData), sizeof(TThisType));
+    }
+
+    static void Unpack(void *inSender, const char *inName, const char *inData, size_t inDataSize,
+                       TFunType inHandler)
+    {
+        if (inDataSize == sizeof(TThisType)) {
+            const TThisType *theData = reinterpret_cast<const TThisType *>(inData);
+            inHandler(theData->m_Data1, theData->m_Data2);
+        } else {
+            QT3DS_ASSERT(false);
+        }
+    }
+
+    static TGenericSignalHandlerFunc CreateHandler(TFunType inHandler)
+    {
+        return std::bind(&TThisType::Unpack, std::placeholders::_1, std::placeholders::_2,
+                         std::placeholders::_3, std::placeholders::_4, inHandler);
+    }
+
+    static std::shared_ptr<ISignalConnection> AddListener(ISignalSystem &inSystem, void *inSender,
+                                                            const char *inName, TFunType inHandler)
+    {
+        return inSystem.AddListener(inSender, inName, CreateHandler(inHandler));
+    }
+};
+
+#define UICDM_SIGNALS_DEFINE_SPECIFIC_SIGNAL_STRUCT2(name, d1, d2)                                 \
+    std::shared_ptr<ISignalConnection> Sig##name::AddListener(                                   \
+        ISignalSystem &inSystem, void *inSender, std::function<void(d1, d2)> inHandler)          \
+    {                                                                                              \
+        return SSignalDataStruct2<d1, d2>::AddListener(inSystem, inSender, #name, inHandler);      \
+    }                                                                                              \
+    void Sig##name::Send(ISignalSystem &system, void *sender, const d1 &arg1, const d2 &arg2)      \
+    {                                                                                              \
+        SSignalDataStruct2<d1, d2>::Send(system, sender, #name, arg1, arg2);                       \
+    }
+
+template <typename TData1, typename TData2, typename TData3>
+struct SSignalDataStruct3
+{
+    typedef SSignalDataStruct3<TData1, TData2, TData3> TThisType;
+    typedef std::function<void(TData1, TData2, TData3)> TFunType;
+    TData1 m_Data1;
+    TData2 m_Data2;
+    TData3 m_Data3;
+    SSignalDataStruct3(const TData1 &d1, const TData2 &d2, const TData3 &d3)
+        : m_Data1(d1)
+        , m_Data2(d2)
+        , m_Data3(d3)
+    {
+    }
+    static void Send(ISignalSystem &system, void *sender, const char *sigName, const TData1 &d1,
+                     const TData2 &d2, const TData3 &d3)
+    {
+        TThisType theData(d1, d2, d3);
+        system.Signal(sender, sigName, reinterpret_cast<const char *>(&theData), sizeof(TThisType));
+    }
+
+    static void Unpack(void *inSender, const char *inName, const char *inData, size_t inDataSize,
+                       TFunType inHandler)
+    {
+        if (inDataSize == sizeof(TThisType)) {
+            const TThisType *theData = reinterpret_cast<const TThisType *>(inData);
+            inHandler(theData->m_Data1, theData->m_Data2, theData->m_Data2);
+        } else {
+            QT3DS_ASSERT(false);
+        }
+    }
+
+    static TGenericSignalHandlerFunc CreateHandler(TFunType inHandler)
+    {
+        return std::bind(&TThisType::Unpack, std::placeholders::_1, std::placeholders::_2,
+                         std::placeholders::_3, std::placeholders::_4, inHandler);
+    }
+
+    static std::shared_ptr<ISignalConnection> AddListener(ISignalSystem &inSystem, void *inSender,
+                                                            const char *inName, TFunType inHandler)
+    {
+        return inSystem.AddListener(inSender, inName, CreateHandler(inHandler));
+    }
+};
+
+#define UICDM_SIGNALS_DEFINE_SPECIFIC_SIGNAL_STRUCT3(name, d1, d2, d3)                             \
+    std::shared_ptr<ISignalConnection> Sig##name::AddListener(                                   \
+        ISignalSystem &inSystem, void *inSender, std::function<void(d1, d2, d3)> inHandler)      \
+    {                                                                                              \
+        return SSignalDataStruct3<d1, d2, d3>::AddListener(inSystem, inSender, #name, inHandler);  \
+    }                                                                                              \
+    void Sig##name::Send(ISignalSystem &system, void *sender, const d1 &arg1, const d2 &arg2,      \
+                         const d3 &arg3)                                                           \
+    {                                                                                              \
+        SSignalDataStruct3<d1, d2, d3>::Send(system, sender, #name, arg1, arg2, arg3);             \
+    }
+
+template <typename TData1, typename TData2, typename TData3, typename TData4>
+struct SSignalDataStruct4
+{
+    typedef SSignalDataStruct4<TData1, TData2, TData3, TData4> TThisType;
+    typedef std::function<void(TData1, TData2, TData3, TData4)> TFunType;
+    TData1 m_Data1;
+    TData2 m_Data2;
+    TData3 m_Data3;
+    TData4 m_Data4;
+    SSignalDataStruct4(const TData1 &d1, const TData2 &d2, const TData3 &d3, const TData4 &d4)
+        : m_Data1(d1)
+        , m_Data2(d2)
+        , m_Data3(d3)
+        , m_Data4(d4)
+    {
+    }
+    static void Send(ISignalSystem &system, void *sender, const char *sigName, const TData1 &d1,
+                     const TData2 &d2, const TData3 &d3, const TData4 &d4)
+    {
+        TThisType theData(d1, d2, d3, d4);
+        system.Signal(sender, sigName, reinterpret_cast<const char *>(&theData), sizeof(TThisType));
+    }
+
+    static void Unpack(void *inSender, const char *inName, const char *inData, size_t inDataSize,
+                       TFunType inHandler)
+    {
+        if (inDataSize == sizeof(TThisType)) {
+            const TThisType *theData = reinterpret_cast<const TThisType *>(inData);
+            inHandler(theData->m_Data1, theData->m_Data2, theData->m_Data2, theData->m_Data4);
+        } else {
+            QT3DS_ASSERT(false);
+        }
+    }
+
+    static TGenericSignalHandlerFunc CreateHandler(TFunType inHandler)
+    {
+        return std::bind(&TThisType::Unpack, std::placeholders::_1, std::placeholders::_2,
+                         std::placeholders::_3, std::placeholders::_4, inHandler);
+    }
+
+    static std::shared_ptr<ISignalConnection> AddListener(ISignalSystem &inSystem, void *inSender,
+                                                            const char *inName, TFunType inHandler)
+    {
+        return inSystem.AddListener(inSender, inName, CreateHandler(inHandler));
+    }
+};
+
+#define UICDM_SIGNALS_DEFINE_SPECIFIC_SIGNAL_STRUCT4(name, d1, d2, d3, d4)                         \
+    std::shared_ptr<ISignalConnection> Sig##name::AddListener(                                   \
+        ISignalSystem &inSystem, void *inSender, std::function<void(d1, d2, d3, d4)> inHandler)  \
+    {                                                                                              \
+        return SSignalDataStruct4<d1, d2, d3, d4>::AddListener(inSystem, inSender, #name,          \
+                                                               inHandler);                         \
+    }                                                                                              \
+    void Sig##name::Send(ISignalSystem &system, void *sender, const d1 &arg1, const d2 &arg2,      \
+                         const d3 &arg3, const d4 &arg4)                                           \
+    {                                                                                              \
+        SSignalDataStruct4<d1, d2, d3, d4>::Send(system, sender, #name, arg1, arg2, arg3, arg4);   \
+    }
+}
+#endif