From 02c87cde3c55517388b6dc1c79b0f498f7f411cd Mon Sep 17 00:00:00 2001
From: korenkonder <admin@mysterious-home.net>
Date: Tue, 27 Jun 2023 03:49:44 +0300
Subject: [PATCH] dw_gui is fully functional now (except dw::Menu)

---
 src/CRE/rob/rob.cpp                   |  18 +-
 src/ReDIVA/config.hpp                 |   1 +
 src/ReDIVA/data_test/glitter_test.cpp | 439 ++++++++++++++++----------
 src/ReDIVA/data_test/glitter_test.hpp |  57 +++-
 src/ReDIVA/data_test/motion_test.cpp  | 156 +++++++--
 src/ReDIVA/data_test/motion_test.hpp  |   2 +
 src/ReDIVA/data_test/stage_test.cpp   |  46 +--
 src/ReDIVA/data_test/stage_test.hpp   |   2 +-
 src/ReDIVA/dw.cpp                     | 143 +++++----
 src/ReDIVA/dw.hpp                     |   5 +-
 src/ReDIVA/input.cpp                  |   7 +-
 src/ReDIVA/input_state.cpp            |  84 ++---
 src/ReDIVA/input_state.hpp            |   2 +-
 src/ReDIVA/pv_game/pv_game.cpp        |   2 +-
 14 files changed, 633 insertions(+), 331 deletions(-)

diff --git a/src/CRE/rob/rob.cpp b/src/CRE/rob/rob.cpp
index 7927b9ea..88d7ac79 100644
--- a/src/CRE/rob/rob.cpp
+++ b/src/CRE/rob/rob.cpp
@@ -2544,22 +2544,22 @@ static void rob_chara_data_adjust_ctrl(rob_chara* rob_chr,
         mat4_mult_vec3(&mat, &adjust->curr_external_force, &adjust->curr_external_force);
     }
     else if (adjust->type == 2) {
-        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, 9)->ex_data_mat;
+        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, MOT_BONE_KL_MUNE_B_WJ)->ex_data_mat;
         if (mat)
             mat4_mult_vec3(mat, &adjust->curr_external_force, &adjust->curr_external_force);
     }
     else if (adjust->type == 3) {
-        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, 10)->ex_data_mat;
+        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, MOT_BONE_KL_KUBI)->ex_data_mat;
         if (mat)
             mat4_mult_vec3(mat, &adjust->curr_external_force, &adjust->curr_external_force);
     }
     else if (adjust->type == 4) {
-        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, 15)->ex_data_mat;
+        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, MOT_BONE_FACE_ROOT)->ex_data_mat;
         if (mat)
             mat4_mult_vec3(mat, &adjust->curr_external_force, &adjust->curr_external_force);
     }
     else if (adjust->type == 5) {
-        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, 177)->ex_data_mat;
+        mat4* mat = rob_chara_bone_data_get_node(rob_chr->bone_data, MOT_BONE_KL_KOSI_ETC_WJ)->ex_data_mat;
         if (mat) {
             adjust->curr_external_force.z = -adjust->curr_external_force.z;
             mat4_mult_vec3(mat, &adjust->curr_external_force, &adjust->curr_external_force);
@@ -3498,7 +3498,8 @@ void rob_chara::reset_data(rob_chara_pv_data* pv_data,
         BONE_DATABASE_SKELETON_COMMON, chara_init_data->skeleton_type, bone_data);
     data.reset();
     data_prev.reset();
-    item_equip->get_parent_bone_nodes(rob_chara_bone_data_get_node(this->bone_data, 0), bone_data);
+    item_equip->get_parent_bone_nodes(rob_chara_bone_data_get_node(
+        this->bone_data, MOT_BONE_N_HARA_CP), bone_data);
     type = pv_data->type;
     rob_chara_data* rob_chr_data = &data;
     rob_chr_data->miku_rot.rot_y_int16 = pv_data->rot_y_int16;
@@ -8240,7 +8241,7 @@ static void rob_disp_rob_chara_init(rob_chara* rob_chr,
 
     rob_chara_item_equip* rob_itm_equip = rob_chr->item_equip;
     const chara_init_data* chr_init_data = rob_chr->chara_init_data;
-    bone_node* v3 = rob_chara_bone_data_get_node(rob_chr->bone_data, 0);
+    bone_node* v3 = rob_chara_bone_data_get_node(rob_chr->bone_data, MOT_BONE_N_HARA_CP);
     rob_itm_equip->reset_init_data(v3);
     rob_itm_equip->set_item_equip_range(rob_chr->module_index == 501);
     rob_itm_equip->load_object_info({}, ITEM_BODY, false, bone_data, data, obj_db);
@@ -11484,7 +11485,8 @@ void rob_chara_array_free_chara_id(int32_t chara_id) {
 
 void rob_chara_array_reset_bone_data_item_equip(int32_t chara_id) {
     rob_chara_item_equip* rob_itm_equip = rob_chara_array[chara_id].item_equip;
-    rob_itm_equip->reset_init_data(rob_chara_bone_data_get_node(rob_chara_array[chara_id].bone_data, 0));
+    rob_itm_equip->reset_init_data(rob_chara_bone_data_get_node(
+        rob_chara_array[chara_id].bone_data, MOT_BONE_N_HARA_CP));
     rob_itm_equip->set_shadow_type(chara_id);
     rob_itm_equip->field_A0 = 0x05;
 }
@@ -16618,7 +16620,7 @@ bool OpdMakeWorker::Ctrl() {
         }
 
         rob_chr->item_equip->reset_init_data(rob_chara_bone_data_get_node(
-            rob_chara_array[chara_id].bone_data, 0));
+            rob_chara_array[chara_id].bone_data, MOT_BONE_N_HARA_CP));
         rob_chr->item_equip->set_shadow_type(chara_id);
         rob_chr->item_equip->field_A0 = 0x05;
         state = 2;
diff --git a/src/ReDIVA/config.hpp b/src/ReDIVA/config.hpp
index b6553bca..39085e10 100644
--- a/src/ReDIVA/config.hpp
+++ b/src/ReDIVA/config.hpp
@@ -7,6 +7,7 @@
 #define BAKE_PNG (0)
 #define BAKE_VIDEO (0)
 #define BAKE_PV826 (0)
+#define DW_TRANSLATE (0)
 #define PV_DEBUG (1)
 
 #define DATA_EDIT (0)
diff --git a/src/ReDIVA/data_test/glitter_test.cpp b/src/ReDIVA/data_test/glitter_test.cpp
index 15407da9..0f5f7f18 100644
--- a/src/ReDIVA/data_test/glitter_test.cpp
+++ b/src/ReDIVA/data_test/glitter_test.cpp
@@ -10,7 +10,8 @@
 #include "../../CRE/render_context.hpp"
 #include "../../CRE/stage.hpp"
 #include "../imgui_helper.hpp"
-#include "../input.hpp"
+#include "../input_state.hpp"
+#include "../print_work.hpp"
 #include "stage_test.hpp"
 
 TaskDataTestGlitterParticle* task_data_test_glitter_particle;
@@ -22,9 +23,8 @@ extern bool input_reset;
 extern bool input_locked;
 extern bool draw_grid_3d;
 
-TaskDataTestGlitterParticle::TaskDataTestGlitterParticle() : hash(), scene_counter(), frame(),
-auto_and_repeat(), reload(), pv_mode(), show_grid(), rebuild_geff(), geff_index(),
-file_index(), load_file(), input_play(), input_stop(), delta_frame(), stage_test() {
+TaskDataTestGlitterParticle::TaskDataTestGlitterParticle() : hash(), dw(),
+frame(), auto_and_repeat(), reload(), pv_mode(), show_grid(), rebuild_geff() {
 
 }
 
@@ -35,56 +35,40 @@ TaskDataTestGlitterParticle::~TaskDataTestGlitterParticle() {
 bool TaskDataTestGlitterParticle::Init() {
     LARGE_INTEGER time;
     QueryPerformanceCounter(&time);
-    Glitter::glt_particle_manager->counter = (uint32_t)(time.LowPart * 0x0CAD3078ULL);
+    Glitter::glt_particle_manager->counter = (uint32_t)(time.LowPart * hash_murmurhash_empty);
 
-    data_list[DATA_AFT].get_directory_files("rom/particle/", files);
-    for (std::vector<data_struct_file>::iterator i = files.begin(); i != files.end();)
-        if (str_utils_check_ends_with(i->name.c_str(), ".farc")) {
-            char* temp = str_utils_get_without_extension(i->name.c_str());
-            if (temp) {
-                i->name.assign(temp);
-                free(temp);
-            }
-            else
-                i->name.clear();
-            i++;
-        }
-        else
-            i = files.erase(i);
+    clear_color = 0xFF606060;
 
     Glitter::glt_particle_manager->emission = 1.0f;
     Glitter::glt_particle_manager->draw_all = false;
     Glitter::glt_particle_manager->draw_all_mesh = false;
-    dtm_stg_load(0);
-
-    clear_color = 0xFF606060;
 
     camera* cam = rctx_ptr->camera;
     cam->reset();
-    cam->set_view_point({ 0.0f, 0.88f, 4.3f });
+    cam->set_view_point({ 0.0f, 1.0f, 3.45f });
     cam->set_interest({ 0.0f, 1.0f, 0.0f });
 
     hash = hash_fnv1a64m_empty;
     scene_counter = 0;
-    frame = 0.0f;
+    dw = new DataTestGlitterParticleDw(this);
+    dw->sub_1402F38B0();
+    frame = 0;
     auto_and_repeat = false;
     reload = false;
     pv_mode = false;
     show_grid = false;
     rebuild_geff = false;
-    file_index = -1;
     return true;
 }
 
 bool TaskDataTestGlitterParticle::Ctrl() {
-    if (load_file && file_index < files.size())
-        LoadFile(files[file_index].name.c_str());
-    load_file = false;
-
-    if (input_play)
-        reload = true;
-    else if (input_stop)
-        Glitter::glt_particle_manager->FreeSceneEffect(scene_counter);
+    InputState* input_state = input_state_get(0);
+    if (input_state) {
+        if (input_state->CheckTapped(43))
+            SetReload();
+        else if (input_state->CheckTapped(42))
+            SceneFree();
+    }
 
     if (!Glitter::glt_particle_manager->CheckNoFileReaders(hash)) {
         reload = false;
@@ -92,36 +76,51 @@ bool TaskDataTestGlitterParticle::Ctrl() {
     }
 
     if (rebuild_geff) {
-        int32_t effects_count = (int32_t)Glitter::glt_particle_manager->GetEffectsCount(this->hash);
-        geff.clear();
-        geff.push_back("ALL");
-        for (int32_t i = 0; i < effects_count; i++)
-            geff.push_back(Glitter::glt_particle_manager->GetEffectName(hash, i));
+        if (dw) {
+            if (dw->geff->list)
+                dw->geff->list->ClearItems();
+
+            int32_t effects_count = (int)Glitter::glt_particle_manager->GetEffectsCount(hash);
+            dw->geff->AddItem("ALL");
+
+            std::vector<uint64_t> effect_hashes(effects_count);
+            for (int32_t i = 0; i < effects_count; i++) {
+                const char* effect_name = Glitter::glt_particle_manager->GetEffectName(hash, i);
+                dw->geff->AddItem(effect_name);
+                effect_hashes[i] = Glitter::glt_particle_manager->CalculateHash(effect_name);
+            }
+
+            dw->geff->SetItemIndex(0);
+        }
+
         rebuild_geff = false;
     }
 
-    if (Glitter::glt_particle_manager->SceneHasNotEnded(scene_counter) && !Glitter::glt_particle_manager->GetPause())
+    if (Glitter::glt_particle_manager->SceneHasNotEnded(scene_counter)
+        && !Glitter::glt_particle_manager->GetPause())
         frame += sys_frame_rate.GetDeltaFrame();
 
     if (reload || auto_and_repeat && !Glitter::glt_particle_manager->SceneHasNotEnded(scene_counter)) {
         Glitter::glt_particle_manager->FreeSceneEffect(scene_counter);
         uint64_t effect_hash = hash_fnv1a64m_empty;
 
-        if (geff_index)
-            effect_hash = Glitter::glt_particle_manager->CalculateHash(geff[geff_index].c_str());
+        if (dw) {
+            dw::ListBox* geff = dw->geff;
+            if (geff->list && geff->list->selected_item)
+                effect_hash = Glitter::glt_particle_manager->CalculateHash(
+                    geff->GetItemStr(geff->list->selected_item).c_str());
+        }
 
         if (!pv_mode)
-            scene_counter = Glitter::glt_particle_manager->Load(hash, effect_hash, 0);
+            scene_counter = Glitter::glt_particle_manager->Load(hash, effect_hash, false);
         else if (effect_hash == hash_fnv1a64m_empty)
             scene_counter = Glitter::glt_particle_manager->LoadScene(hash, hash_fnv1a64m_empty);
         else
             scene_counter = Glitter::glt_particle_manager->LoadScene(hash_fnv1a64m_empty, effect_hash);
+
         frame = 0.0f;
         reload = false;
     }
-
-    input_play = false;
-    input_stop = false;
     return false;
 }
 
@@ -130,6 +129,11 @@ bool TaskDataTestGlitterParticle::Dest() {
     Glitter::glt_particle_manager->FreeScenes();
     Glitter::glt_particle_manager->FreeEffects();
     Glitter::glt_particle_manager->SetPause(false);
+
+    if (dw) {
+        dw->Hide();
+        dw = 0;
+    }
     return true;
 }
 
@@ -144,138 +148,249 @@ void TaskDataTestGlitterParticle::Disp() {
         etc.data.grid.hs = 50;
         rctx_ptr->disp_manager.entry_obj_etc(&mat4_identity, &etc);
     }
+
+    int32_t life_time = 0;
+    float_t frame = Glitter::glt_particle_manager->GetSceneFrameLifeTime(scene_counter, &life_time);
+
+    PrintWork print_work;
+    font_info font(16);
+    print_work.SetFont(&font);
+    print_work.line_origin_loc = { 0.0f, 624.0f };
+    print_work.text_current_loc = { 0.0f, 624.0f };
+    print_work.printf_align_left("%.0f - %.0f/%.0f\n", this->frame, frame, (float_t)life_time);
+
+    size_t disp;
+    size_t ctrl;
+
+    disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_QUAD);
+    ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_QUAD);
+    print_work.printf_align_left(" Quad: ctrl%d, disp%d\n", disp, ctrl);
+
+    disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_LOCUS);
+    ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_LOCUS);
+    print_work.printf_align_left("Locus: ctrl%d, disp%d\n", disp, ctrl);
+
+    disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_LINE);
+    ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_LINE);
+    print_work.printf_align_left(" Line: ctrl%d, disp%d\n", disp, ctrl);
+
+    // Added
+    disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_MESH);
+    ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_MESH);
+    print_work.printf_align_left(" Mesh: ctrl%d, disp%d\n", disp, ctrl);
+
 }
 
-void TaskDataTestGlitterParticle::Window() {
-    ImGuiIO& io = ImGui::GetIO();
-    ImGuiStyle& style = ImGui::GetStyle();
-    ImFont* font = ImGui::GetFont();
+void TaskDataTestGlitterParticle::SceneFree( ){
+    Glitter::glt_particle_manager->FreeSceneEffect(scene_counter);
+}
 
-    float_t w = 280.0f;
-    float_t h = 278.0f;
+void TaskDataTestGlitterParticle::SetPause(bool value) {
+    Glitter::glt_particle_manager->SetPause(value);
+}
 
-    ImGui::SetNextWindowPos({ 0, 0 }, ImGuiCond_Appearing);
-    ImGui::SetNextWindowSize({ w, h }, ImGuiCond_Always);
-
-    ImGuiWindowFlags window_flags = 0;
-    window_flags |= ImGuiWindowFlags_NoResize;
-
-    window_focus = false;
-    if (!ImGui::Begin("Glitter Test##Data Test", 0, window_flags)) {
-        ImGui::End();
-        return;
-    }
-
-    if (ImGui::ColumnComboBoxConfigFile("File", files.data(),
-        files.size(), &file_index, 0, false, &window_focus)) {
-        load_file = true;
-        input_stop = true;
-    }
-
-    if (ImGui::ButtonEnterKeyPressed("Reset Camera (R)"))
-        input_reset = true;
-
-    w = ImGui::GetContentRegionAvailWidth();
-    if (ImGui::ButtonEnterKeyPressed("Play (F)", { w, 0.0f }) || ImGui::IsKeyPressed(ImGuiKey_F))
-        input_play = true;
-
-    w = ImGui::GetContentRegionAvailWidth();
-    if (ImGui::ButtonEnterKeyPressed("Stop (V)", { w, 0.0f }) || ImGui::IsKeyPressed(ImGuiKey_V))
-        input_stop = true;
-
-    bool pause = Glitter::glt_particle_manager->GetPause();
-    ImGui::CheckboxEnterKeyPressed("Pause (G)", &pause);
-    if (ImGui::IsKeyPressed(ImGuiKey_G))
-        pause ^= true;
-    Glitter::glt_particle_manager->SetPause(pause);
-
-    ImGui::CheckboxEnterKeyPressed("Auto (T)", &auto_and_repeat);
-    if (ImGui::IsKeyPressed(ImGuiKey_T))
-        auto_and_repeat ^= true;
-
-    ImGui::CheckboxEnterKeyPressed("PV Mode (P)", &pv_mode);
-    if (ImGui::IsKeyPressed(ImGuiKey_P))
-        pv_mode ^= true;
-
-    ImGui::Separator();
-
-    ImGui::ColumnSliderFloatButton("Emission",
-        &Glitter::glt_particle_manager->emission, 0.01f, 1.0f, 2.0f, 0.1f, "%.2f", 0);
-
-    ImGui::Separator();
-
-    ImGui::CheckboxEnterKeyPressed("Show Grid", &draw_grid_3d);
-
-    w = ImGui::GetContentRegionAvailWidth();
-    if (ImGui::ButtonEnterKeyPressed("Stage", { w, 0.0f }))
-        stage_test = true;
-
-    window_focus |= ImGui::IsWindowFocused();
-    ImGui::End();
-
-    float_t win_x = min_def((float_t)width, 240.0f);
-    float_t win_y = min_def((float_t)height, 96.0f);
-
-    float_t x = 0.0f;
-    float_t y = (float_t)height - win_y;
-    w = win_x;
-    h = win_y;
-
-    ImGui::SetNextWindowPos({ x, y }, ImGuiCond_Always);
-    ImGui::SetNextWindowSize({ w, h }, ImGuiCond_Always);
-
-    window_flags = 0;
-    window_flags |= ImGuiWindowFlags_NoTitleBar;
-    window_flags |= ImGuiWindowFlags_NoResize;
-    window_flags |= ImGuiWindowFlags_NoScrollbar;
-    window_flags |= ImGuiWindowFlags_NoCollapse;
-    window_flags |= ImGuiWindowFlags_NoMouseInputs;
-    window_flags |= ImGuiWindowFlags_NoNavInputs;
-    window_flags |= ImGuiWindowFlags_NoNavFocus;
-
-    ImGui::PushStyleColor(ImGuiCol_Border, 0);
-    ImGui::PushStyleColor(ImGuiCol_WindowBg, 0);
-    if (ImGui::Begin("Glitter Test Sub##Data Test", 0, window_flags)) {
-        size_t ctrl;
-        size_t disp;
-        float_t frame;
-        int32_t life_time;
-
-        life_time = 0;
-        frame = Glitter::glt_particle_manager->GetSceneFrameLifeTime(scene_counter, &life_time);
-        ImGui::Text("%.0f - %.0f/%d", this->frame, frame, life_time);
-
-        ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_QUAD);
-        disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_QUAD);
-        ImGui::Text(" Quad: ctrl%lld, disp%lld", ctrl, disp);
-
-        ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_LOCUS);
-        disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_LOCUS);
-        ImGui::Text("Locus: ctrl%lld, disp%lld", ctrl, disp);
-
-        ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_LINE);
-        disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_LINE);
-        ImGui::Text(" Line: ctrl%lld, disp%lld", ctrl, disp);
-
-        ctrl = Glitter::glt_particle_manager->GetCtrlCount(Glitter::PARTICLE_MESH);
-        disp = Glitter::glt_particle_manager->GetDispCount(Glitter::PARTICLE_MESH);
-        ImGui::Text(" Mesh: ctrl%lld, disp%lld", ctrl, disp);
-    }
-    ImGui::PopStyleColor(2);
-    ImGui::End();
+void TaskDataTestGlitterParticle::SetReload() {
+    reload = true;
 }
 
 void TaskDataTestGlitterParticle::LoadFile(const char* file) {
     data_struct* aft_data = &data_list[DATA_AFT];
+    object_database* aft_obj_db = &aft_data->data_ft.obj_db;
 
     Glitter::glt_particle_manager->FreeSceneEffect(scene_counter);
     Glitter::glt_particle_manager->UnloadEffectGroup(hash);
-    hash = Glitter::glt_particle_manager->LoadFile(Glitter::FT, aft_data, file, 0, -1.0f, true);
+    hash = Glitter::glt_particle_manager->LoadFile(Glitter::FT, aft_data, file, 0, -1.0f, true, aft_obj_db);
     rebuild_geff = true;
 }
 
+DataTestGlitterParticleDw::DataTestGlitterParticleDw(TaskDataTestGlitterParticle* task) {
+    this->task = task;
+
+    SetText("Glitter");
+
+    (new dw::Label(this))->SetText("list");
+
+    list = new dw::ListBox(this);
+    list->SetMaxItems(30);
+    list->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::ListCallback));
+
+    (new dw::Label(this))->SetText("geff");
+
+    geff = new dw::ListBox(this);
+    geff->SetMaxItems(30);
+
+    pause = new dw::Button(this, dw::CHECKBOX);
+    pause->SetText("Pause");
+    pause->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::PauseCallback));
+
+    auto_and_repeat = new dw::Button(this, dw::CHECKBOX);
+    auto_and_repeat->SetText("Auto & Repeat");
+    auto_and_repeat->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::AutoAndRepeatCallback));
+
+    pv_mode = new dw::Button(this, dw::CHECKBOX);
+    pv_mode->SetText("PV Mode");
+    pv_mode->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::PvModeCallback));
+    
+    play = new dw::Button(this, dw::FLAG_8);
+    play->SetText("Play(E)");
+    play->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::PlayCallback));
+    
+    stop = new dw::Button(this, dw::FLAG_8);
+    stop->SetText("Stop(D)");
+    stop->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::StopCallback));
+
+    emission = dw::Slider::Create(this, (dw::Flags)(dw::FLAG_800 | dw::HORIZONTAL), "Emission", "%2.2f", 150.0f);
+    emission->SetParams(1.0f, 1.0f, 2.0f, 0.1f, 0.01f, 0.1f);
+    emission->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::EmissionCallback));
+
+    show_grid = new dw::Button(this, dw::CHECKBOX);
+    show_grid->SetText("Show Grid");
+    show_grid->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::ShowGridCallback));
+    
+    stage = new dw::Button(this, dw::FLAG_8);
+    stage->SetText("Stage");
+    stage->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::StageCallback));
+
+    chara = new dw::Button(this, dw::CHECKBOX);
+    chara->SetText("Chara");
+    chara->AddSelectionListener(new dw::SelectionListenerOnHook(
+        DataTestGlitterParticleDw::CharaCallback));
+
+    Init();
+
+    UpdateLayout();
+}
+
+DataTestGlitterParticleDw::~DataTestGlitterParticleDw() {
+
+}
+
+void DataTestGlitterParticleDw::Init() {
+    pause->SetValue(false);
+    auto_and_repeat->SetValue(false);
+    pv_mode->SetValue(false);
+    show_grid->SetValue(false);
+    chara->SetValue(false);
+    list->ClearItems();
+
+    std::vector<data_struct_file> files;
+    data_list[DATA_AFT].get_directory_files("rom/particle/", files);
+    for (data_struct_file& i : files) {
+        size_t pos = i.name.find(".farc");
+        if (pos == i.name.size() - 5)
+            list->AddItem(i.name.substr(0, pos));
+    }
+}
+
+void DataTestGlitterParticleDw::AutoAndRepeatCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->auto_and_repeat = button->value;
+    }
+}
+
+void DataTestGlitterParticleDw::CharaCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button)
+        if (dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell))
+            if (button->value) {
+                /*if (!app::TaskWork::CheckTaskReady(&data_test_chr))
+                    app::TaskWork::AddTask(&data_test_chr, "DATA_TEST_CHR");*/
+            }
+            else {
+                /*if (app::TaskWork::CheckTaskReady(&data_test_chr))
+                    data_test_chr.DelTask();*/
+            }
+}
+
+void DataTestGlitterParticleDw::EmissionCallback(dw::Widget* data) {
+    dw::Slider* slider = dynamic_cast<dw::Slider*>(data);
+    if (slider)
+        if (dynamic_cast<DataTestGlitterParticleDw*>(slider->parent_shell))
+            Glitter::glt_particle_manager->emission = slider->scroll_bar->value;
+}
+
+void DataTestGlitterParticleDw::ListCallback(dw::Widget* data) {
+    dw::ListBox* list_box = dynamic_cast<dw::ListBox*>(data);
+    if (list_box) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(list_box->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->LoadFile(list_box->GetItemStr(list_box->list->selected_item).c_str());
+    }
+}
+
+void DataTestGlitterParticleDw::PauseCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->SetPause(button->value);
+    }
+}
+
+void DataTestGlitterParticleDw::PlayCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->SetReload();
+    }
+}
+
+void DataTestGlitterParticleDw::PvModeCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->pv_mode = button->value;
+    }
+}
+
+void DataTestGlitterParticleDw::ShowGridCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw =
+            dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->show_grid = button->value;
+    }
+}
+
+void DataTestGlitterParticleDw::StageCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button)
+        if (dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell))
+            dtw_stg_load(0);
+}
+
+void DataTestGlitterParticleDw::StopCallback(dw::Widget* data) {
+    dw::Button* button = dynamic_cast<dw::Button*>(data);
+    if (button) {
+        DataTestGlitterParticleDw* glt_ptcl_dw = dynamic_cast<DataTestGlitterParticleDw*>(button->parent_shell);
+        if (glt_ptcl_dw)
+            glt_ptcl_dw->task->SceneFree();
+    }
+}
+
 void task_data_test_glitter_particle_init() {
-    task_data_test_glitter_particle = new TaskDataTestGlitterParticle;
+    if (!task_data_test_glitter_particle)
+        task_data_test_glitter_particle = new TaskDataTestGlitterParticle;
 }
 
 void task_data_test_glitter_particle_free() {
diff --git a/src/ReDIVA/data_test/glitter_test.hpp b/src/ReDIVA/data_test/glitter_test.hpp
index 1bfc1405..8a2f9742 100644
--- a/src/ReDIVA/data_test/glitter_test.hpp
+++ b/src/ReDIVA/data_test/glitter_test.hpp
@@ -10,12 +10,16 @@
 #include "../../KKdLib/default.hpp"
 #include "../../CRE/Glitter/glitter.hpp"
 #include "../../CRE/data.hpp"
-#include "../task_window.hpp"
+#include "../../CRE/task.hpp"
+#include "../dw.hpp"
 
-class TaskDataTestGlitterParticle : public app::TaskWindow {
+class DataTestGlitterParticleDw;
+
+class TaskDataTestGlitterParticle : public app::Task {
 public:
     uint64_t hash;
     Glitter::SceneCounter scene_counter;
+    DataTestGlitterParticleDw* dw;
     float_t frame;
     bool auto_and_repeat;
     bool reload;
@@ -23,19 +27,6 @@ public:
     bool show_grid;
     bool rebuild_geff;
 
-    std::vector<std::string> geff;
-    size_t geff_index;
-
-    std::vector<data_struct_file> files;
-    size_t file_index;
-    bool load_file;
-
-    bool input_play;
-    bool input_stop;
-    double_t delta_frame;
-
-    bool stage_test;
-
     TaskDataTestGlitterParticle();
     virtual ~TaskDataTestGlitterParticle() override;
 
@@ -43,9 +34,43 @@ public:
     virtual bool Ctrl() override;
     virtual bool Dest() override;
     virtual void Disp() override;
-    virtual void Window() override;
 
     void LoadFile(const char* file);
+    void SceneFree();
+    void SetPause(bool value);
+    void SetReload();
+};
+
+class DataTestGlitterParticleDw : public dw::Shell {
+public:
+    TaskDataTestGlitterParticle* task;
+    dw::ListBox* list;
+    dw::ListBox* geff;
+    dw::Button* pause;
+    dw::Button* auto_and_repeat;
+    dw::Button* pv_mode;
+    dw::Button* play;
+    dw::Button* stop;
+    dw::Slider* emission;
+    dw::Button* show_grid;
+    dw::Button* stage;
+    dw::Button* chara;
+
+    DataTestGlitterParticleDw(TaskDataTestGlitterParticle* task);
+    virtual ~DataTestGlitterParticleDw() override;
+
+    void Init();
+
+    static void AutoAndRepeatCallback(dw::Widget* data);
+    static void CharaCallback(dw::Widget* data);
+    static void EmissionCallback(dw::Widget* data);
+    static void ListCallback(dw::Widget* data);
+    static void PauseCallback(dw::Widget* data);
+    static void PlayCallback(dw::Widget* data);
+    static void PvModeCallback(dw::Widget* data);
+    static void ShowGridCallback(dw::Widget* data);
+    static void StageCallback(dw::Widget* data);
+    static void StopCallback(dw::Widget* data);
 };
 
 extern TaskDataTestGlitterParticle* task_data_test_glitter_particle;
diff --git a/src/ReDIVA/data_test/motion_test.cpp b/src/ReDIVA/data_test/motion_test.cpp
index 5a6fe980..0427f1bc 100644
--- a/src/ReDIVA/data_test/motion_test.cpp
+++ b/src/ReDIVA/data_test/motion_test.cpp
@@ -13,6 +13,7 @@
 #include "../../CRE/pv_db.hpp"
 #include "../../CRE/resolution_mode.hpp"
 #include "../../CRE/stage.hpp"
+#include "../config.hpp"
 #include "../input_state.hpp"
 #include "auth_3d_test.hpp"
 #include "equip_test.hpp"
@@ -81,6 +82,10 @@ DataTestMot::Data::Data() : chara_index(), curr_chara_index(), module_index(), c
 motion_set_index(), curr_motion_set_index(), motion_index(), curr_motion_index(), rot_y(),
 trans_x(), offset(), start_frame(), type(), reset_mot(), reset_cam(), reload_data(),
 sync_frame(), field_A8(), field_A9(), running(), field_AC(), field_B0(), sync_1p_frame() {
+    for (uint32_t& i : motion_set_index)
+        i = -1;
+    for (uint32_t& i : curr_motion_set_index)
+        i = -1;
     field_AA = true;
 }
 
@@ -117,7 +122,7 @@ bool DataTestMot::Ctrl() {
     data_struct* aft_data = &data_list[DATA_AFT];
     motion_database* aft_mot_db = &aft_data->data_ft.mot_db;
 
-    //data_test_mot_dw_array_get(0)->sub_14028D8B0();
+   data_test_mot_dw_array_get(0)->sub_14028D8B0();
 
     bool v3 = false;
     bool v2 = false;
@@ -282,26 +287,24 @@ bool DataTestMot::Ctrl() {
     if (data.reset_cam) {
         data.reset_cam = false;
 
-        camera* cam = rctx_ptr->camera;
-        cam->reset();
-
+        cam_struct cam;
         if (data.field_A9) {
-            cam->set_view_point({ 0.0f, 1.0f, 3.45f });
-            cam->set_interest({ 0.0f, 1.0f, 0.0f });
-            cam->set_view_point({ -3.79f, 0.71f, 1.0f });
-            cam->set_interest({ 0.0f, 0.96f, 0.0f });
-            cam->set_fov(32.8124985652134);
+            cam.view_point = { -3.79f, 0.71f, 1.0f };
+            cam.interest = { 0.0f, 0.96f, 0.0f };
+            cam.fov = 0.57268613576889f;
         }
         else {
-            cam->set_view_point({ 0.0f, 1.0f, 3.45f });
-            cam->set_interest({ 0.0f, 1.0f, 0.0f });
-            cam->set_fov(32.8124985652134);
+            cam.view_point = { 0.0f, 1.0f, 3.45f };
+            cam.interest = { 0.0f, 1.0f, 0.0f };
+            cam.fov = 0.563171327114105f;
         }
+        cam.set(rctx_ptr->camera);
     }
 
     if (data.field_A8) {
         data.field_A8 = false;
-        //rctx_ptr->camera->set_fov(data.field_A9 ? 32.2673416137695 : 32.8125);
+
+        //sub_1401F9510(data.field_A9 ? 32.2673416137695f : 32.8125f);
     }
 
     if (data.running && dtm_mot_array[0].CheckFirstFrame() && !frame_comp
@@ -458,6 +461,22 @@ void DataTestMotA3d::Basic() {
 
 const char* DataTestMotA3d::GetStateText() {
     switch (state) {
+#if DW_TRANSLATE
+    case 0:
+        return "A3D: Initializing...";
+    case 1:
+        return "A3D: Awaiting command...";
+    case 2:
+        return "A3D: Requesting data...";
+    case 3:
+        return "A3D: Loading PV Stage...";
+    case 4:
+        return "A3D: Loading A3D Category...";
+    case 5:
+        return "A3D: Loading A3D Handle...";
+    default:
+        return "A3D: Unknown mode";
+#else
     case 0:
         return "A3D: 初期化中...";
     case 1:
@@ -472,6 +491,7 @@ const char* DataTestMotA3d::GetStateText() {
         return "A3D: A3Dハンドル読込中...";
     default:
         return "A3D: 未知のモード";
+#endif
     }
 }
 
@@ -1798,7 +1818,7 @@ DataTestMotDw::DataTestMotDw(int32_t chara_id, DtmMot* dtm_mot) {
     start_ctrl_right->callback_data.v64 = this;
     start_ctrl_right->callback = DataTestMotDw::StartCtrlLeftRightCallback;
 
-    dw::Group* ab_loop_group = new dw::Group(this);
+    dw::Group* ab_loop_group = new dw::Group(frame_group);
     ab_loop_group->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
     ab_loop_group->SetText("AB LOOP");
     ab_loop_group->SetFont(dw::p_font_type_6x12);
@@ -1869,8 +1889,14 @@ DataTestMotDw::DataTestMotDw(int32_t chara_id, DtmMot* dtm_mot) {
 
     dtm_mot->SetPartialMot(false);
 
+#if DW_TRANSLATE
+    const char* save_only_start_frame_button_text = "Initialize only Start Frame Osage";
+#else
+    const char* save_only_start_frame_button_text = "Startフレームだけおさげ初期化";
+#endif
+
     dw::Button* save_only_start_frame_button = new dw::Button(this, dw::CHECKBOX);
-    save_only_start_frame_button->SetText("Initialize only Start Frame Osage");
+    save_only_start_frame_button->SetText(save_only_start_frame_button_text);
     save_only_start_frame_button->SetValue(false);
     save_only_start_frame_button->AddSelectionListener(&save_only_start_frame_button_proc);
     save_only_start_frame_button->callback_data.i32 = chara_id;
@@ -2057,6 +2083,52 @@ void DataTestMotDw::StartCtrlResetCallback(dw::Widget* data) {
     data_test_mot_data_get()->reset_mot = true;
 }
 
+void DataTestMotDw::sub_14028D8B0() {
+    InputState* input_state = input_state_get(0);
+
+    int32_t chara_list_dir = 0;
+    if (input_state->CheckTapped(70))
+        chara_list_dir--;
+    if (input_state->CheckTapped(71))
+        chara_list_dir++;
+
+    if (chara_list_dir) {
+        dw::List* list = chara_list_box_proc.list_box->list;
+        if (chara_list_dir >= 0) {
+            if (list->selected_item < list->items.size() - 1)
+                list->SetItemIndex(list->selected_item + 1);
+        }
+        else {
+            if (list->selected_item)
+                list->SetItemIndex(list->selected_item - 1);
+        }
+
+        dw::SelectionListener::CallbackData callback_data = chara_list_box_proc.list_box;
+        list->Callback(&callback_data);
+    }
+
+    int32_t set_list_dir = 0;
+    if (input_state->CheckTapped(72))
+        set_list_dir--;
+    if (input_state->CheckTapped(73))
+        set_list_dir++;
+
+    if (set_list_dir) {
+        dw::List* list = set_list_box_proc.list_box->list;
+        if (set_list_dir >= 0) {
+            if (list->selected_item < list->items.size() - 1)
+                list->SetItemIndex(list->selected_item + 1);
+        }
+        else {
+            if (list->selected_item)
+                list->SetItemIndex(list->selected_item - 1);
+        }
+
+        dw::SelectionListener::CallbackData callback_data = set_list_box_proc.list_box;
+        list->Callback(&callback_data);
+    }
+}
+
 DataTestMotA3dDw::PvListBoxProc::PvListBoxProc() {
 
 }
@@ -2164,11 +2236,17 @@ DataTestMotA3dDw::DataTestMotA3dDw() {
     a3d_label->SetText("A3d");
     a3d_label->SetFont(dw::p_font_type_6x12);
 
+#if DW_TRANSLATE
+    const char* please_select_a_pv = "Please select a PV";
+#else
+    const char* please_select_a_pv = "PVを選択して下さい";
+#endif
+
     a3d = new dw::ListBox(a3d_comp);
     a3d->SetMaxItems(20);
-    a3d->AddItem("PVを選択して下さい");
+    a3d->AddItem(please_select_a_pv);
 
-    a3d->Reset();
+    a3d->SetItemIndex(0);
     a3d->AddSelectionListener(&a3d_list_box_proc);
     a3d->SetFont(dw::p_font_type_6x12);
 
@@ -2201,6 +2279,7 @@ DataTestMotA3dDw::~DataTestMotA3dDw() {
 
 void DataTestMotA3dDw::Draw() {
     SetText(data_test_mot_a3d_get_state_text());
+    Shell::Draw();
 }
 
 void DataTestMotA3dDw::Hide() {
@@ -2305,11 +2384,52 @@ DataTestMotCtrlDw::~DataTestMotCtrlDw() {
 }
 
 void DataTestMotCtrlDw::Draw() {
+    data_struct* aft_data = &data_list[DATA_AFT];
+    motion_database* aft_mot_db = &aft_data->data_ft.mot_db;
 
+    DataTestMot::Data* test_mot_data = data_test_mot_data_get();
+    InputState* input_state = input_state_get(0);
+    if (input_state->CheckTapped(60))
+        test_mot_data->reset_mot = true;
+    else if (input_state->CheckTapped(50))
+        test_mot_data->reload_data = true;
+
+    if (input_state->CheckTapped(51))
+        switch (test_mot_data->type) {
+        case 0:
+        case 1:
+            test_mot_data->type = 2;
+            break;
+        case 2:
+        default: {
+            test_mot_data->type = 0;
+
+            if (dtm_mot_array[0].motion_set_id != -1) {
+                std::string motion_set_name(aft_mot_db->get_motion_set_name(dtm_mot_array[0].motion_set_id));
+
+                const char* v13[] = {
+                    "CMN",
+                    "EDT",
+                    "TEST_DESIGN",
+                };
+
+                for (const char* i : v13)
+                    if (motion_set_name.find(i) != -1) {
+                        test_mot_data->type = 1;
+                        break;
+                    }
+            }
+        } break;
+        }
+
+    if (type_list->list && type_list->list->selected_item != test_mot_data->type)
+        type_list->list->SetItemIndex(test_mot_data->type);
+
+    Shell::Draw();
 }
 
 void DataTestMotCtrlDw::Hide() {
-
+    Shell::SetDisp(false);
 }
 
 void DataTestMotCtrlDw::ReloadDataCallback(dw::Widget* data) {
diff --git a/src/ReDIVA/data_test/motion_test.hpp b/src/ReDIVA/data_test/motion_test.hpp
index 7babd9f4..90dacfed 100644
--- a/src/ReDIVA/data_test/motion_test.hpp
+++ b/src/ReDIVA/data_test/motion_test.hpp
@@ -430,6 +430,8 @@ public:
     static void BCallback(dw::Widget* data);
     static void StartCtrlLeftRightCallback(dw::Widget* data);
     static void StartCtrlResetCallback(dw::Widget* data);
+
+    void sub_14028D8B0();
 };
 
 class DataTestMotA3dDw : public dw::Shell {
diff --git a/src/ReDIVA/data_test/stage_test.cpp b/src/ReDIVA/data_test/stage_test.cpp
index b1c5aa9e..f52f8dc9 100644
--- a/src/ReDIVA/data_test/stage_test.cpp
+++ b/src/ReDIVA/data_test/stage_test.cpp
@@ -13,7 +13,7 @@
 #include "../../CRE/task_effect.hpp"
 #include "../imgui_helper.hpp"
 #include "../input.hpp"
-#include "../task_window.hpp"
+#include "../config.hpp"
 
 extern int32_t width;
 extern int32_t height;
@@ -74,12 +74,12 @@ DtwStg::DtwStg() : Shell(0) {
 
     std::vector<stage_data>& stg_data = aft_stage_data->stage_data;
 
-    dw::Widget::SetText(L"STAGE TEST");
+    dw::Widget::SetText("STAGE TEST");
 
     dw::Composite* pv_comp = new dw::Composite(this);
     pv_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
 
-    (new dw::Label(pv_comp))->SetText(L"PV:");
+    (new dw::Label(pv_comp))->SetText("PV:");
 
     pv_id = new dw::ListBox(pv_comp);
 
@@ -88,14 +88,14 @@ DtwStg::DtwStg() : Shell(0) {
     dw::Composite* ns_comp = new dw::Composite(this);
     ns_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
 
-    (new dw::Label(ns_comp))->SetText(L"NS:");
+    (new dw::Label(ns_comp))->SetText("NS:");
 
     ns = new dw::ListBox(ns_comp);
 
     dw::Composite* other_comp = new dw::Composite(this);
     other_comp->SetLayout(new dw::RowLayout(dw::HORIZONTAL));
 
-    (new dw::Label(other_comp))->SetText(L"Other:");
+    (new dw::Label(other_comp))->SetText("Other:");
 
     other = new dw::ListBox(other_comp);
 
@@ -140,24 +140,38 @@ DtwStg::DtwStg() : Shell(0) {
     stage->SetItemIndex(0);
     stage->AddSelectionListener(new dw::SelectionListenerOnHook(DtwStg::StageCallback));
 
+#if DW_TRANSLATE
+    const char*  stage_display_text = "Stage display";
+    const char*           ring_text = "[Ring]";
+    const char*         ground_text = "[Ground]";
+    const char*            sky_text = "[Sky]";
+    const char* effect_display_text = "Effects display";
+#else
+    const char* stage_display_text = "ステージ表示";
+    const char* ring_text = "【リング】";
+    const char* ground_text = "【地面】";
+    const char* sky_text = "【空】";
+    const char* effect_display_text = "エフェクト表示";
+#endif
+
     stage_display = new dw::Button(this, dw::CHECKBOX);
-    stage_display->SetText(L"Stage display");
+    stage_display->SetText(stage_display_text);
     stage_display->SetValue(true);
 
     ring = new dw::Button(this, dw::CHECKBOX);
-    ring->SetText(L"[Ring]");
+    ring->SetText(ring_text);
     ring->SetValue(true);
 
     ground = new dw::Button(this, dw::CHECKBOX);
-    ground->SetText(L"[Ground]");
+    ground->SetText(ground_text);
     ground->SetValue(true);
 
     sky = new dw::Button(this, dw::CHECKBOX);
-    sky->SetText(L"[Sky]");
+    sky->SetText(sky_text);
     sky->SetValue(true);
 
     effect_display = new dw::Button(this, dw::CHECKBOX);
-    effect_display->SetText(L"Effects display");
+    effect_display->SetText(effect_display_text);
     effect_display->SetValue(true);
 
     UpdateLayout();
@@ -221,11 +235,6 @@ bool dtm_stg_unload() {
 }
 
 void dtm_stg_free() {
-    if (dtw_stg) {
-        delete dtw_stg;
-        dtw_stg = 0;
-    }
-
     if (dtm_stg) {
         delete dtm_stg;
         dtm_stg = 0;
@@ -233,12 +242,9 @@ void dtm_stg_free() {
 }
 
 void dtw_stg_init() {
-    if (!dtw_stg) {
+    while (!dtw_stg)
         dtw_stg = new DtwStg;
-        dtw_stg->sub_1402F38B0();
-    }
-    else
-        dtw_stg->Disp();
+    dtw_stg->Disp();
 }
 
 void dtw_stg_load(bool hide) {
diff --git a/src/ReDIVA/data_test/stage_test.hpp b/src/ReDIVA/data_test/stage_test.hpp
index 0bd98a53..8411c88e 100644
--- a/src/ReDIVA/data_test/stage_test.hpp
+++ b/src/ReDIVA/data_test/stage_test.hpp
@@ -6,8 +6,8 @@
 #pragma once
 
 #include "../../KKdLib/default.hpp"
+#include "../../CRE/task.hpp"
 #include "../dw.hpp"
-#include "../task_window.hpp"
 
 struct stage_test_stage_pv {
     int32_t pv_id;
diff --git a/src/ReDIVA/dw.cpp b/src/ReDIVA/dw.cpp
index 92acf899..ba8a5a29 100644
--- a/src/ReDIVA/dw.cpp
+++ b/src/ReDIVA/dw.cpp
@@ -99,7 +99,7 @@ struct struc_751 {
     int8_t field_1C;
     int8_t field_1D;
     int64_t field_20;
-    int8_t field_28;
+    uint8_t field_28;
     int32_t key_input[2];
 
     struc_751();
@@ -144,14 +144,14 @@ namespace dw_gui_detail {
         Display(dw::init_data& init_data);
         virtual ~Display();
 
-        void AddShell(dw::Shell* value);
         void CheckShells();
         void Ctrl();
         void Draw();
         void FreeWidgets();
         dw::Shell* GetHoveredShell();
+        void MakeShellFirst(dw::Shell* value);
+        void MakeShellLast(dw::Shell* value);
         void RemoveShell(dw::Shell* value);
-        void PopShell(dw::Shell* value);
 
         void sub_1402E6300(dw::Widget* widget);
         void sub_1402E6440(dw::Widget* widget);
@@ -359,7 +359,7 @@ namespace dw {
 
     }
 
-    Widget::Widget(Widget* parent, Flags flags) : free(),
+    Widget::Widget(Widget* parent, Flags flags) : freed(),
         callback_data(), free_callback(), parent() {
         text.assign(L"NO_NAME");
         this->flags = flags;
@@ -409,7 +409,7 @@ namespace dw {
     }
 
     void Widget::Free() {
-        if (free)
+        if (freed)
             return;
 
         Reset();
@@ -417,7 +417,7 @@ namespace dw {
         if (free_callback)
             free_callback(this);
 
-        free = true;
+        freed = true;
 
         if (dw_gui_detail_display)
             dw_gui_detail_display->free_widgets.push_back(this);
@@ -973,7 +973,7 @@ namespace dw {
             if (!sub_140192D00())
                 return 0;
 
-            dw_gui_detail_display->AddShell(this);
+            dw_gui_detail_display->MakeShellFirst(this);
         }
 
         if ((uint16_t)dw_gui_detail_display->field_C0.field_18 >= 1 && (uint16_t)dw_gui_detail_display->field_C0.field_18 <= 8) {
@@ -1082,7 +1082,7 @@ namespace dw {
 
     void Shell::Disp() {
         SetDisp(true);
-        dw_gui_detail_display->AddShell(this);
+        dw_gui_detail_display->MakeShellFirst(this);
         dw_gui_detail_display->focused_shell = this;
         dw_gui_detail_display->set_focus = true;
     }
@@ -1097,7 +1097,7 @@ namespace dw {
 
         disp = value;
         if (disp) {
-            dw_gui_detail_display->AddShell(this);
+            dw_gui_detail_display->MakeShellFirst(this);
             dw_gui_detail_display->focused_shell = this;
             dw_gui_detail_display->set_focus = true;
             if (disp_callback)
@@ -1454,50 +1454,56 @@ namespace dw {
     void Group::Draw() {
         print->SetFont(&font);
 
-        rectangle v14 = GetRectangle();
+        rectangle rect = GetRectangle();
 
-        float_t v4 = (float_t)(int32_t)(font.GetFontGlyphHeight() * 0.5f);
-        v14.pos.y += v4;
-        v14.size.y += v4;
+        float_t half_glyph_height = (float_t)(int32_t)(font.GetFontGlyphHeight() * 0.5f);
+        rect.pos.y += half_glyph_height;
+        rect.size.y -= half_glyph_height;
 
         print->SetColor(colors_current.border_color);
-        print->sub_140301390(v14, 2.0f);
+        print->sub_140301390(rect, 2.0f);
 
-        v14.size += -1.0f;
+        rect.size += -1.0f;
         print->SetColor(color_black);
-        print->sub_140301390(v14, 1.0f);
+        print->sub_140301390(rect, 1.0f);
 
         if (GetText().size()) {
-            rectangle v7 = GetRectangle();
+            rectangle rect = GetRectangle();
 
-            rectangle v14;
-            v14.pos.x = v7.pos.x + 2.0f;
-            v14.pos.y = v7.pos.y;
-            v14.size.x = v7.size.x + 2.0f * -2.0f;
-            v14.size.y = font.GetFontGlyphHeight();
+            rect.pos.x += 2.0f;
+            rect.pos.y = rect.pos.y;
+            rect.size.x += 2.0f * -2.0f;
+            rect.size.y = font.GetFontGlyphHeight();
 
             vec2 text_size = print->GetTextSize(GetText());
-            v14.size.x = min_def(text_size.x, v14.size.x);
+            rect.size.x = min_def(text_size.x, rect.size.x);
 
             print->SetFillColor(colors_current.background);
-            print->FillRectangle(v14);
+            print->FillRectangle(rect);
 
             print->SetColor(colors_current.foreground);
-            print->SetClipData(v14);
-            print->PrintText(GetText(), v14.pos.x, v14.pos.y);
+            print->SetClipData(rect);
+            print->PrintText(GetText(), rect.pos.x, rect.pos.y);
         }
 
         Composite::Draw();
     }
 
+    vec2 Group::GetSize() {
+        vec2 size = Composite::GetSize();
+        size.x += 2.0f * 2.0f;
+        size.y += font.GetFontGlyphHeight() + 2.0f;
+        return size;
+    }
+
     rectangle Group::GetBoundingBox() {
         float_t glyph_height = font.GetFontGlyphHeight();
 
         rectangle rect = Scrollable::GetBoundingBox();
-        rect.pos.x = rect.pos.x + 2.0f;
-        rect.pos.y = rect.pos.y + glyph_height;
-        rect.size.x = rect.size.x - (2.0f * 2.0f);
-        rect.size.y = rect.size.y - (glyph_height + 2.0f);
+        rect.pos.x += 2.0f;
+        rect.pos.y += glyph_height;
+        rect.size.x -= 2.0f * 2.0f;
+        rect.size.y -= glyph_height + 2.0f;
         return rect;
     }
 
@@ -2008,6 +2014,12 @@ namespace dw {
         selection_listeners.push_back(value);
     }
 
+    void List::Callback(SelectionListener::CallbackData* data) {
+        if (data->widget)
+            for (SelectionListener*& i : selection_listeners)
+                i->Callback(data);
+    }
+
     bool List::CheckItemSelected(size_t index) {
         if (index >= items.size())
             return false;
@@ -2157,7 +2169,7 @@ namespace dw {
     }
 
     ListBox::~ListBox() {
-        delete list;
+
     }
 
     void ListBox::Draw() {
@@ -2798,7 +2810,7 @@ namespace dw {
     }
 
     Slider::~Slider() {
-        delete scroll_bar;
+
     }
 
     void Slider::Draw() {
@@ -3214,10 +3226,10 @@ void struc_751::sub_140300A10() {
     key_input[0] = 0;
     key_input[1] = 0;
 
-    bool key = input_state->GetKey();
+    uint8_t key = input_state->GetKey();
 
     field_28 = key;
-    key_input[0] = key ? 0x01 : 0x00;
+    key_input[0] = key;
 
     int32_t mouse_pos_x = input_state->sub_14018CCC0(8);
     int32_t mouse_pos_y = input_state->sub_14018CCC0(9);
@@ -3484,17 +3496,6 @@ dw_gui_detail::Display::~Display() {
 
 }
 
-void dw_gui_detail::Display::AddShell(dw::Shell* value) {
-    if (!value)
-        return;
-
-    for (dw::Shell* i : shells)
-        if (i == value)
-            return;
-
-    shells.push_back(value);
-}
-
 void dw_gui_detail::Display::CheckShells() {
     std::vector<dw::Shell*> vec;
 
@@ -3561,7 +3562,7 @@ dw::Shell* dw_gui_detail::Display::GetHoveredShell() {
     for (auto i = i_begin; i != i_end;) {
         i--;
 
-        if (!(*i)->free && (*i)->GetDisp()) {
+        if (!(*i)->freed && (*i)->GetDisp()) {
             rectangle rect = (*i)->GetRectangle();
             if (rect.pos.x <= mouse_callback_data.pos.x && mouse_callback_data.pos.x < rect.pos.x + rect.size.x
                 && rect.pos.y <= mouse_callback_data.pos.y && mouse_callback_data.pos.y < rect.pos.y + rect.size.y)
@@ -3572,6 +3573,38 @@ dw::Shell* dw_gui_detail::Display::GetHoveredShell() {
     return 0;
 }
 
+void dw_gui_detail::Display::MakeShellFirst(dw::Shell* value) {
+    if (!value)
+        return;
+
+    auto i = shells.begin();
+    auto i_end = shells.end();
+    while (i != i_end)
+        if (*i == value) {
+            shells.erase(i);
+            shells.push_back(value);
+            break;
+        }
+        else
+            i++;
+}
+
+void dw_gui_detail::Display::MakeShellLast(dw::Shell* value) {
+    if (!value)
+        return;
+
+    auto i = shells.begin();
+    auto i_end = shells.end();
+    while (i != i_end)
+        if (*i == value) {
+            shells.erase(i);
+            shells.insert(shells.begin(), value);
+            break;
+        }
+        else
+            i++;
+}
+
 void dw_gui_detail::Display::RemoveShell(dw::Shell* value) {
     auto i = shells.begin();
     auto i_end = shells.end();
@@ -3593,20 +3626,6 @@ void dw_gui_detail::Display::RemoveShell(dw::Shell* value) {
         move_resize_shell = 0;
 }
 
-void dw_gui_detail::Display::PopShell(dw::Shell* value) {
-    if (!value)
-        return;
-
-    auto i = shells.begin();
-    auto i_end = shells.end();
-    while (i != i_end)
-        if (*i == value) {
-            shells.erase(i);
-            shells.push_back(value);
-            break;
-        }
-}
-
 void dw_gui_detail::Display::sub_1402E6300(dw::Widget* widget) {
     rectangle rect = widget->GetRectangle();
 
@@ -3720,7 +3739,7 @@ int32_t dw_gui_detail::Display::sub_1402E5630() {
 
             if (v15a) {
                 if (selected_shell)
-                    PopShell(selected_shell);
+                    MakeShellLast(selected_shell);
 
                 switch (v15) {
                 case 0:
@@ -3862,6 +3881,6 @@ static void sub_1402EE3C0(rectangle rect, float_t border, int32_t type, color4u8
         v24.size.x = rect.size.x - border - border;
         v24.size.y = rect.size.y - border - border;
         dw::print->SetFillColor(*fill_color);
-        //dw::print->FillRectangle(v24);
+        dw::print->FillRectangle(v24);
     }
 }
diff --git a/src/ReDIVA/dw.hpp b/src/ReDIVA/dw.hpp
index 79365b0c..d6ee921c 100644
--- a/src/ReDIVA/dw.hpp
+++ b/src/ReDIVA/dw.hpp
@@ -153,7 +153,7 @@ namespace dw {
             MouseCallbackData();
         };
 
-        bool free;
+        bool freed;
 
         union {
             int8_t i8;
@@ -467,6 +467,8 @@ namespace dw {
 
         virtual void Draw() override;
 
+        virtual vec2 GetSize() override;
+
         virtual rectangle GetBoundingBox() override;
     };
 
@@ -524,6 +526,7 @@ namespace dw {
         void AddItem(const std::string& str);
         void AddItem(const std::wstring& str);
         void AddSelectionListener(SelectionListener* value);
+        void Callback(SelectionListener::CallbackData* data);
         bool CheckItemSelected(size_t index);
         void ClearItems();
         std::string GetItemStr(size_t index) const;
diff --git a/src/ReDIVA/input.cpp b/src/ReDIVA/input.cpp
index f77c2454..1049970d 100644
--- a/src/ReDIVA/input.cpp
+++ b/src/ReDIVA/input.cpp
@@ -30,6 +30,8 @@ extern HWND window_handle;
 extern ImGuiContext* imgui_context;
 extern lock_cs imgui_context_lock;
 
+extern bool disable_input_state_update;
+
 namespace Input {
     struct Key {
         int32_t key;
@@ -199,7 +201,10 @@ namespace Input {
         input_rotate_y = 0.0;
         input_roll = 0.0;
 
-        if (!window_handle || window_handle != GetForegroundWindow())
+        if (IsKeyTapped(GLFW_KEY_F3))
+            disable_input_state_update ^= true;
+
+        if (!window_handle || window_handle != GetForegroundWindow() || !disable_input_state_update)
             return;
 
         double_t freq = render_timer->get_freq();
diff --git a/src/ReDIVA/input_state.cpp b/src/ReDIVA/input_state.cpp
index 690177d8..306e4cbf 100644
--- a/src/ReDIVA/input_state.cpp
+++ b/src/ReDIVA/input_state.cpp
@@ -68,6 +68,8 @@ static bool sub_140190A30(struc_794* a1, int32_t index);
 
 InputState* input_state;
 
+bool disable_input_state_update = false;
+
 extern render_context* rctx_ptr;
 
 InputState::DoubleTap::DoubleTap() : hold_frame(), frame(), state() {
@@ -508,58 +510,60 @@ static bool sub_140190A30(struc_794* a1, int32_t index) {
         { 98, GLFW_MOUSE_BUTTON_RIGHT, },
     };
 
-    for (const key_map& i : key_map_array) {
-        bool tapped = false;
-        bool released = false;
-        bool down = false;
+    if (!disable_input_state_update) {
+        for (const key_map& i : key_map_array) {
+            bool tapped = false;
+            bool released = false;
+            bool down = false;
 
-        for (const int32_t& j : i.keys) {
-            if (j == -1)
-                break;
+            for (const int32_t& j : i.keys) {
+                if (j == -1)
+                    break;
 
-            if (!tapped)
-                if (Input::IsKeyTapped(j, -1))
-                    tapped = true;
+                if (!tapped)
+                    if (Input::IsKeyTapped(j, -1))
+                        tapped = true;
 
-            if (!released)
-                if (Input::IsKeyReleased(j, -1))
-                    released = true;
+                if (!released)
+                    if (Input::IsKeyReleased(j, -1))
+                        released = true;
 
-            if (!down)
-                if (Input::IsKeyDown(j, -1))
-                    down = true;
+                if (!down)
+                    if (Input::IsKeyDown(j, -1))
+                        down = true;
+            }
+
+            a1->tapped[i.index] = tapped;
+            a1->released[i.index] = released;
+            a1->down[i.index] = down;
         }
 
-        a1->tapped[i.index] = tapped;
-        a1->released[i.index] = released;
-        a1->down[i.index] = down;
-    }
+        for (const key_map& i : mouse_button_array) {
+            bool tapped = false;
+            bool released = false;
+            bool down = false;
 
-    for (const key_map& i : mouse_button_array) {
-        bool tapped = false;
-        bool released = false;
-        bool down = false;
+            for (const int32_t& j : i.keys) {
+                if (j == -1)
+                    break;
 
-        for (const int32_t& j : i.keys) {
-            if (j == -1)
-                break;
+                if (!tapped)
+                    if (Input::IsMouseButtonTapped(j))
+                        tapped = true;
 
-            if (!tapped)
-                if (Input::IsMouseButtonTapped(j))
-                    tapped = true;
+                if (!released)
+                    if (Input::IsMouseButtonReleased(j))
+                        released = true;
 
-            if (!released)
-                if (Input::IsMouseButtonReleased(j))
-                    released = true;
+                if (!down)
+                    if (Input::IsMouseButtonDown(j))
+                        down = true;
+            }
 
-            if (!down)
-                if (Input::IsMouseButtonDown(j))
-                    down = true;
+            a1->tapped[i.index] = tapped;
+            a1->released[i.index] = released;
+            a1->down[i.index] = down;
         }
-
-        a1->tapped[i.index] = tapped;
-        a1->released[i.index] = released;
-        a1->down[i.index] = down;
     }
 
     int32_t x_offset = rctx_ptr->post_process.screen_x_offset;
diff --git a/src/ReDIVA/input_state.hpp b/src/ReDIVA/input_state.hpp
index fed8dc82..e2ceffe4 100644
--- a/src/ReDIVA/input_state.hpp
+++ b/src/ReDIVA/input_state.hpp
@@ -59,7 +59,7 @@ struct InputState {
     bool updated;
     bool field_D1;
     bool field_D2;
-    bool key;
+    uint8_t key;
     DoubleTap DoubleTapData[INPUT_BUTTON_COUNT];
     HoldTap HoldTapData[INPUT_BUTTON_COUNT];
     IntervalTap IntervalTapData[INPUT_BUTTON_COUNT];
diff --git a/src/ReDIVA/pv_game/pv_game.cpp b/src/ReDIVA/pv_game/pv_game.cpp
index 02bcf51c..9ae2ff09 100644
--- a/src/ReDIVA/pv_game/pv_game.cpp
+++ b/src/ReDIVA/pv_game/pv_game.cpp
@@ -3416,7 +3416,7 @@ bool pv_game::load() {
             Glitter::glt_particle_manager->counter = 0;
             for (pv_effect_resource& i : data.effect_rs_list) {
                 uint64_t hash = Glitter::glt_particle_manager->LoadFile(Glitter::FT,
-                    aft_data, i.name.c_str(), 0, i.emission, true);
+                    aft_data, i.name.c_str(), 0, i.emission, true, aft_obj_db);
                 if (hash != hash_fnv1a64m_empty)
                     data.effect_rs_list_hashes.push_back(hash);
             }