Many CGuiWidget imps

Runtime/GuiSys/CGuiWidget.cpp

@@ -25,13 +25,14 @@ CGuiWidget::CGuiWidget(const CGuiWidgetParms& parms)
 : x7c_selfId(parms.x6_selfId), x7e_parentId(parms.x8_parentId),
   xbc_color(parms.x10_color), xc0_color2(parms.x10_color),
   xc4_drawFlags(parms.x14_drawFlags), xc8_frame(parms.x0_frame),
-  xf6_24_pg(parms.xd_g), xf6_25_pd(parms.xa_d), xf6_26_isActive(parms.xb_defaultActive),
-  xf6_27_(true), xf6_28_(false), xf6_29_pf(parms.xc_f), xf6_30_(false),
+  xf6_24_pg(parms.xd_g), xf6_25_isVisible(parms.xa_defaultVisible),
+  xf6_26_isActive(parms.xb_defaultActive),
+  xf6_27_(true), xf6_28_eventLock(false), xf6_29_pf(parms.xc_f), xf6_30_(false),
   xf6_31_(true), xf7_24_(false), xf7_25_(true)
 {
     if (parms.x4_a)
         EnsureHasAnimController();
-    RecalcWidgetColor(ETraversalMode::NonRecursive);
+    RecalcWidgetColor(ETraversalMode::Single);
 }
 
 CGuiWidget::CGuiWidgetParms
@@ -43,15 +44,15 @@ CGuiWidget::ReadWidgetHeader(CGuiFrame* frame, CInputStream& in, bool flag)
     s16 parentId = frame->GetWidgetIdDB().AddWidget(parent);
 
     bool a = in.readBool();
-    bool d = in.readBool();
-    bool e = in.readBool();
+    bool defaultVis = in.readBool();
+    bool defaultActive = in.readBool();
     bool f = in.readBool();
     zeus::CColor color;
     color.readRGBABig(in);
     EGuiModelDrawFlags df = EGuiModelDrawFlags(in.readUint32Big());
 
-    return CGuiWidget::CGuiWidgetParms(frame, a, selfId, parentId, d, e, f,
-                                       color, df, true, flag);
+    return CGuiWidget::CGuiWidgetParms(frame, a, selfId, parentId, defaultVis, defaultActive,
+                                       f, color, df, true, flag);
 }
 
 CGuiWidget* CGuiWidget::Create(CGuiFrame* frame, CInputStream& in, bool flag)
@@ -107,6 +108,128 @@ void CGuiWidget::ParseAnimations(CInputStream& in, const CGuiWidgetParms& parms)
     assert(count == 0);
 }
 
+std::vector<TResId> CGuiWidget::GetTextureAssets() const
+{
+    return {};
+}
+
+std::vector<TResId> CGuiWidget::GetModelAssets() const
+{
+    return {};
+}
+
+std::vector<TResId> CGuiWidget::GetFontAssets() const
+{
+    return {};
+}
+
+void CGuiWidget::Initialize() {}
+void CGuiWidget::Touch() const {}
+
+bool CGuiWidget::GetIsVisible() const
+{
+    return xf6_25_isVisible;
+}
+
+bool CGuiWidget::GetIsActive() const
+{
+    return xf6_26_isActive;
+}
+
+CGuiTextSupport* CGuiWidget::TextSupport()
+{
+    return nullptr;
+}
+
+CGuiTextSupport* CGuiWidget::GetTextSupport() const
+{
+    return nullptr;
+}
+
+void CGuiWidget::ModifyRGBA(CGuiWidget* widget)
+{
+    xb8_ += widget->xb8_;
+    xb4_ = xb8_ + xc0_color2;
+}
+
+void CGuiWidget::RecalculateAllRGBA()
+{
+    CGuiWidget* parent = static_cast<CGuiWidget*>(GetParent());
+    if (parent)
+        ModifyRGBA(parent);
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->RecalculateAllRGBA();
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->RecalculateAllRGBA();
+}
+
+void CGuiWidget::InitializeRGBAFactor()
+{
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->InitializeRGBAFactor();
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->InitializeRGBAFactor();
+}
+
+bool CGuiWidget::GetIsFinishedLoadingWidgetSpecific() const
+{
+    return true;
+}
+
+std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* CGuiWidget::FindTriggerList(int id)
+{
+    auto search = xcc_triggerMap.find(id);
+    if (search == xcc_triggerMap.cend())
+        return nullptr;
+    return search->second.get();
+}
+
+void CGuiWidget::AddTrigger(std::unique_ptr<CGuiLogicalEventTrigger>&& trigger)
+{
+    int tid = trigger->GetTriggerId();
+    std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* list = FindTriggerList(tid);
+    if (!list)
+    {
+        auto it =
+        xcc_triggerMap.emplace(std::make_pair(tid,
+            std::make_unique<std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>>()));
+        list = it.first->second.get();
+    }
+    list->push_back(std::move(trigger));
+}
+
+std::vector<std::unique_ptr<CGuiFunctionDef>>* CGuiWidget::FindFunctionDefList(int id)
+{
+    auto search = xe0_functionMap.find(id);
+    if (search == xe0_functionMap.cend())
+        return nullptr;
+    return search->second.get();
+}
+
+void CGuiWidget::AddFunctionDef(s32 id, std::unique_ptr<CGuiFunctionDef>&& def)
+{
+    std::vector<std::unique_ptr<CGuiFunctionDef>>* list = FindFunctionDefList(id);
+    if (!list)
+    {
+        auto it =
+        xe0_functionMap.emplace(std::make_pair(id,
+            std::make_unique<std::vector<std::unique_ptr<CGuiFunctionDef>>>()));
+        list = it.first->second.get();
+    }
+    list->push_back(std::move(def));
+}
+
+void CGuiWidget::SetIdlePosition(const zeus::CVector3f& pos, bool reapply)
+{
+    x80_transform.m_origin = pos;
+    if (reapply)
+        ReapplyXform();
+}
+
 void CGuiWidget::ReapplyXform()
 {
     RotateReset();
@@ -125,26 +248,29 @@ void CGuiWidget::EnsureHasAnimController()
     }
 }
 
-std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* CGuiWidget::FindTriggerList(int id)
+void CGuiWidget::BroadcastMessage(int id, CGuiControllerInfo* info)
 {
-    auto search = xcc_functionMap.find(id);
-    if (search == xcc_functionMap.cend())
-        return nullptr;
-    return &search->second;
+    CGuiFuncParm a((intptr_t(x7c_selfId)));
+    CGuiFuncParm b((intptr_t(id)));
+    CGuiFunctionDef def(0, false, a, b);
+    MAF_SendMessage(&def, info);
+
+    CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
+    if (ch)
+        ch->BroadcastMessage(id, info);
+
+    CGuiWidget* sib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (sib)
+        sib->BroadcastMessage(id, info);
 }
 
-void CGuiWidget::AddTrigger(std::unique_ptr<CGuiLogicalEventTrigger>&& trigger)
+void CGuiWidget::LockEvents(bool lock)
 {
-    int tid = trigger->GetTriggerId();
-    std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>* list = FindTriggerList(tid);
-    if (!list)
-    {
-        auto it =
-        xcc_functionMap.emplace(std::make_pair(tid,
-            std::vector<std::unique_ptr<CGuiLogicalEventTrigger>>()));
-        list = &it.first->second;
-    }
-    list->push_back(std::move(trigger));
+    xf6_28_eventLock = lock;
+    if (lock)
+        DoUnregisterEventHandler();
+    else
+        DoRegisterEventHandler();
 }
 
 void CGuiWidget::UnregisterEventHandler()
@@ -165,7 +291,7 @@ void CGuiWidget::UnregisterEventHandler(ETraversalMode mode)
 {
     switch (mode)
     {
-    case ETraversalMode::Recursive:
+    case ETraversalMode::Children:
         if (!DoUnregisterEventHandler())
         {
             CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
@@ -173,7 +299,7 @@ void CGuiWidget::UnregisterEventHandler(ETraversalMode mode)
                 ch->UnregisterEventHandler();
         }
         break;
-    case ETraversalMode::NonRecursive:
+    case ETraversalMode::Single:
         DoUnregisterEventHandler();
         break;
     default:
@@ -184,8 +310,8 @@ void CGuiWidget::UnregisterEventHandler(ETraversalMode mode)
 
 bool CGuiWidget::DoUnregisterEventHandler()
 {
-    for (auto& item : xcc_functionMap)
-        for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : item.second)
+    for (auto& item : xcc_triggerMap)
+        for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : *item.second)
             xc8_frame->ClearMessageMap(trigger.get(), x7c_selfId);
     return false;
 }
@@ -208,7 +334,7 @@ void CGuiWidget::RegisterEventHandler(ETraversalMode mode)
 {
     switch (mode)
     {
-    case ETraversalMode::Recursive:
+    case ETraversalMode::Children:
         if (!DoRegisterEventHandler())
         {
             CGuiWidget* ch = static_cast<CGuiWidget*>(GetChildObject());
@@ -216,7 +342,7 @@ void CGuiWidget::RegisterEventHandler(ETraversalMode mode)
                 ch->RegisterEventHandler();
         }
         break;
-    case ETraversalMode::NonRecursive:
+    case ETraversalMode::Single:
         DoRegisterEventHandler();
         break;
     default:
@@ -227,15 +353,298 @@ void CGuiWidget::RegisterEventHandler(ETraversalMode mode)
 
 bool CGuiWidget::DoRegisterEventHandler()
 {
-    if (xf6_28_ || !GetIsActive())
+    if (xf6_28_eventLock || !GetIsActive())
         return false;
-    for (auto& item : xcc_functionMap)
-        for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : item.second)
+    for (auto& item : xcc_triggerMap)
+        for (std::unique_ptr<CGuiLogicalEventTrigger>& trigger : *item.second)
             xc8_frame->AddMessageMap(trigger.get(), x7c_selfId);
     return false;
 }
 
-void CGuiWidget::Initialize() {}
+CGuiWidget* CGuiWidget::RemoveChildWidget(CGuiWidget* widget, bool makeWorldLocal)
+{
+    return static_cast<CGuiWidget*>(RemoveChildObject(widget, makeWorldLocal));
+}
+
+void CGuiWidget::AddChildWidget(CGuiWidget* widget, bool makeWorldLocal, bool atEnd)
+{
+    AddChildObject(widget, makeWorldLocal, atEnd);
+}
+
+void CGuiWidget::AddAnim(EGuiAnimBehListID id, CGuiAnimBase* anim)
+{
+    if (!xb0_animController)
+    {
+        xb0_animController.reset(new CGuiAnimController(
+            CGuiWidgetParms(xc8_frame, false, -1, -1, false, false, false,
+                            zeus::CColor::skWhite, EGuiModelDrawFlags::Two, true, false), this));
+    }
+    xb0_animController->AddAnimation(anim, id);
+}
+
+void CGuiWidget::ResetAllAnimUpdateState()
+{
+    if (xb0_animController)
+        xb0_animController->ResetListUpdateState();
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->ResetAllAnimUpdateState();
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->ResetAllAnimUpdateState();
+}
+
+void CGuiWidget::SetVisibility(bool vis, ETraversalMode mode)
+{
+    switch (mode)
+    {
+    case ETraversalMode::Children:
+    {
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->SetVisibility(vis, ETraversalMode::ChildrenAndSiblings);
+        break;
+    }
+    case ETraversalMode::ChildrenAndSiblings:
+    {
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->SetVisibility(vis, ETraversalMode::ChildrenAndSiblings);
+        CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+        if (nextSib)
+            nextSib->SetVisibility(vis, ETraversalMode::ChildrenAndSiblings);
+        break;
+    }
+    default: break;
+    }
+    SetIsVisible(vis);
+}
+
+void CGuiWidget::SetAnimUpdateState(EGuiAnimBehListID id, bool state)
+{
+    if (xb0_animController)
+        xb0_animController->SetListUpdateState(id, state);
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->SetAnimUpdateState(id, state);
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->SetAnimUpdateState(id, state);
+}
+
+void CGuiWidget::SetAnimUpdateState(EGuiAnimBehListID id, bool state, ETraversalMode mode)
+{
+    switch (mode)
+    {
+    case ETraversalMode::Children:
+    {
+        if (xb0_animController)
+            xb0_animController->SetListUpdateState(id, state);
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->SetAnimUpdateState(id, state);
+        break;
+    }
+    case ETraversalMode::Single:
+    {
+        if (xb0_animController)
+            xb0_animController->SetListUpdateState(id, state);
+        break;
+    }
+    default:
+        SetAnimUpdateState(id, state);
+        break;
+    }
+}
+
+void CGuiWidget::GetBranchAnimLen(EGuiAnimBehListID id, float& len)
+{
+    if (xb0_animController)
+    {
+        float aLen = xb0_animController->GetAnimSetLength(id);
+        if (aLen > len)
+            len = aLen;
+    }
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->GetBranchAnimLen(id, len);
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->GetBranchAnimLen(id, len);
+}
+
+void CGuiWidget::GetBranchAnimLen(EGuiAnimBehListID id, float& len, ETraversalMode mode)
+{
+    switch (mode)
+    {
+    case ETraversalMode::Children:
+    {
+        if (xb0_animController)
+        {
+            float aLen = xb0_animController->GetAnimSetLength(id);
+            if (aLen > len)
+                len = aLen;
+        }
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->GetBranchAnimLen(id, len);
+        break;
+    }
+    case ETraversalMode::Single:
+    {
+        if (xb0_animController)
+        {
+            float aLen = xb0_animController->GetAnimSetLength(id);
+            if (aLen > len)
+                len = aLen;
+        }
+        break;
+    }
+    default:
+        GetBranchAnimLen(id, len);
+        break;
+    }
+}
+
+void CGuiWidget::IsAllAnimsDone(EGuiAnimBehListID id, bool& isDone)
+{
+    if (xb0_animController)
+    {
+        if (!isDone)
+            return;
+        xb0_animController->IsAnimsDone(id, isDone);
+    }
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->IsAllAnimsDone(id, isDone);
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->IsAllAnimsDone(id, isDone);
+}
+
+void CGuiWidget::IsAllAnimsDone(EGuiAnimBehListID id, bool& isDone, ETraversalMode mode)
+{
+    switch (mode)
+    {
+    case ETraversalMode::Children:
+    {
+        if (xb0_animController)
+        {
+            xb0_animController->IsAnimsDone(id, isDone);
+            if (!isDone)
+                return;
+        }
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->IsAllAnimsDone(id, isDone);
+        break;
+    }
+    case ETraversalMode::Single:
+    {
+        if (xb0_animController)
+            xb0_animController->IsAnimsDone(id, isDone);
+        break;
+    }
+    default:
+        IsAllAnimsDone(id, isDone);
+        break;
+    }
+}
+
+void CGuiWidget::InitializeAnimControllers(EGuiAnimBehListID id, float fval, bool flag,
+                                           EGuiAnimInitMode initMode)
+{
+    if (xb0_animController)
+        xb0_animController->InitTransform(this, id, fval, flag, initMode);
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+        child->InitializeAnimControllers(id, fval, flag, initMode);
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+        nextSib->InitializeAnimControllers(id, fval, flag, initMode);
+}
+
+void CGuiWidget::InitializeAnimControllers(EGuiAnimBehListID id, float fval, bool flag,
+                                           EGuiAnimInitMode initMode, ETraversalMode mode)
+{
+    switch (mode)
+    {
+    case ETraversalMode::Children:
+    {
+        if (xb0_animController)
+            xb0_animController->InitTransform(this, id, fval, flag, initMode);
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->InitializeAnimControllers(id, fval, flag, initMode);
+        break;
+    }
+    case ETraversalMode::Single:
+    {
+        if (xb0_animController)
+            xb0_animController->InitTransform(this, id, fval, flag, initMode);
+        break;
+    }
+    default:
+        InitializeAnimControllers(id, fval, flag, initMode);
+        break;
+    }
+}
+
+void CGuiWidget::RecalcWidgetColor(ETraversalMode mode)
+{
+    CGuiWidget* parent = static_cast<CGuiWidget*>(GetParent());
+    if (parent)
+        xc0_color2 = xbc_color * parent->xc0_color2;
+    else
+        xc0_color2 = xbc_color;
+    xb4_ = xb8_ + xc0_color2;
+
+    switch (mode)
+    {
+    case ETraversalMode::ChildrenAndSiblings:
+    {
+        CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+        if (nextSib)
+            nextSib->RecalcWidgetColor(ETraversalMode::ChildrenAndSiblings);
+    }
+    case ETraversalMode::Children:
+    {
+        CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+        if (child)
+            child->RecalcWidgetColor(ETraversalMode::ChildrenAndSiblings);
+    }
+    default: break;
+    }
+}
+
+CGuiWidget* CGuiWidget::FindWidget(s16 id)
+{
+    if (x7c_selfId == id)
+        return this;
+    CGuiWidget* child = static_cast<CGuiWidget*>(GetChildObject());
+    if (child)
+    {
+        CGuiWidget* found = child->FindWidget(id);
+        if (found)
+            return found;
+    }
+    CGuiWidget* nextSib = static_cast<CGuiWidget*>(GetNextSibling());
+    if (nextSib)
+    {
+        CGuiWidget* found = nextSib->FindWidget(id);
+        if (found)
+            return found;
+    }
+    return nullptr;
+}
+
+bool CGuiWidget::GetIsFinishedLoading() const
+{
+    bool widgetFinished = GetIsFinishedLoadingWidgetSpecific();
+    if (!xb0_animController)
+        return widgetFinished;
+    return widgetFinished && xb0_animController->GetIsFinishedLoading();
+}
 
 void CGuiWidget::InitializeRecursive()
 {
@@ -251,7 +660,7 @@ void CGuiWidget::InitializeRecursive()
 void CGuiWidget::SetColor(const zeus::CColor& color)
 {
     xbc_color = color;
-    RecalcWidgetColor(ETraversalMode::Recursive);
+    RecalcWidgetColor(ETraversalMode::Children);
 }
 
 void CGuiWidget::OnDeActivate() {}
@@ -259,6 +668,15 @@ void CGuiWidget::OnActivate(bool) {}
 void CGuiWidget::OnInvisible() {}
 void CGuiWidget::OnVisible() {}
 
+void CGuiWidget::SetIsVisible(bool vis)
+{
+    xf6_25_isVisible = vis;
+    if (vis)
+        OnVisible();
+    else
+        OnInvisible();
+}
+
 void CGuiWidget::SetIsActive(bool a, bool b)
 {
     if (a == xf6_26_isActive)
@@ -266,12 +684,12 @@ void CGuiWidget::SetIsActive(bool a, bool b)
     xf6_26_isActive = a;
     if (a)
     {
-        RegisterEventHandler(ETraversalMode::Recursive);
+        RegisterEventHandler(ETraversalMode::Children);
         OnActivate(b);
     }
     else
     {
-        RegisterEventHandler(ETraversalMode::Recursive);
+        RegisterEventHandler(ETraversalMode::Children);
         OnDeActivate();
     }
 }