mirrors/nxdumptool
1
0
Fork 0
mirror of https://github.com/DarkMatterCore/nxdumptool.git synced 2024-12-23 00:52:10 +00:00
Code Issues Releases Activity

Added templated ErrorLayerView class.

Browse source
This commit is contained in:
Pablo Curiel 2021-06-20 03:49:33 -04:00
parent da2b7daae2
commit e621b0473f
5 changed files with 155 additions and 89 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/error_frame.hpp
View file

@ -40,7 +40,7 @@ namespace nxdt::views
void layout(NVGcontext* vg, brls::Style* style, brls::FontStash* stash) override;
public:
ErrorFrame(std::string msg);
ErrorFrame(std::string msg = "");
~ErrorFrame(void);
void SetMessage(std::string msg);

129
include/error_layer_view.hpp Normal file
View file

@ -0,0 +1,129 @@
/*
* error_layer_view.hpp
*
* Copyright (c) 2020-2021, DarkMatterCore <pabloacurielz@gmail.com>.
*
* This file is part of nxdumptool (https://github.com/DarkMatterCore/nxdumptool).
*
* nxdumptool is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* nxdumptool is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#ifndef __ERROR_LAYER_VIEW_HPP__
#define __ERROR_LAYER_VIEW_HPP__
#include "error_frame.hpp"
namespace nxdt::views
{
/* Extended class to switch between ErrorFrame and List views whenever an event is triggered. */
template<typename TaskType, typename EventType>
class ErrorLayerView: public brls::LayerView
{
private:
TaskType *task = nullptr;
std::vector<typename EventType::Subscription> task_subs;
ErrorFrame *error_frame = nullptr;
brls::List *list = nullptr;
std::vector<brls::View*> list_views;
int layer_view_index = 0;
protected:
void SwitchLayerView(bool use_error_frame);
void SetErrorFrameMessage(std::string msg = "");
void AddListView(brls::View* view);
void RegisterListener(typename EventType::Callback cb);
public:
ErrorLayerView(TaskType *task);
~ErrorLayerView(void);
};
template<typename TaskType, typename EventType>
ErrorLayerView<TaskType, EventType>::ErrorLayerView(TaskType *task) : brls::LayerView(), task(task)
{
/* Error frame. */
this->error_frame = new ErrorFrame();
this->addLayer(this->error_frame);
/* List. */
this->list = new brls::List();
this->list->setSpacing(this->list->getSpacing() / 2);
this->list->setMarginBottom(20);
this->addLayer(this->list);
}
template<typename TaskType, typename EventType>
ErrorLayerView<TaskType, EventType>::~ErrorLayerView(void)
{
/* Unregister task listeners. */
for(typename EventType::Subscription task_sub : this->task_subs) this->task->UnregisterListener(task_sub);
/* Clear task subscriptions vector. */
if (this->task_subs.size()) this->task_subs.clear();
/* Clear list views vector. */
if (this->list_views.size()) this->list_views.clear();
}
template<typename TaskType, typename EventType>
void ErrorLayerView<TaskType, EventType>::SwitchLayerView(bool use_error_frame)
{
if ((use_error_frame && this->layer_view_index == 0) || (!use_error_frame && this->layer_view_index == 1)) return;
int index = (this->layer_view_index ^ 1);
brls::View *current_focus = brls::Application::getCurrentFocus();
/* Focus the sidebar if we're currently focusing an element from our List. */
for(brls::View* list_view : this->list_views)
{
if (current_focus == list_view)
{
brls::Application::onGamepadButtonPressed(GLFW_GAMEPAD_BUTTON_DPAD_LEFT, false);
break;
}
}
/* Change layer view. */
this->changeLayer(index);
this->invalidate(true);
this->layer_view_index = index;
}
template<typename TaskType, typename EventType>
void ErrorLayerView<TaskType, EventType>::SetErrorFrameMessage(std::string msg)
{
this->error_frame->SetMessage(msg);
}
template<typename TaskType, typename EventType>
void ErrorLayerView<TaskType, EventType>::AddListView(brls::View* view)
{
this->list->addView(view);
this->list_views.push_back(view);
}
template<typename TaskType, typename EventType>
void ErrorLayerView<TaskType, EventType>::RegisterListener(typename EventType::Callback cb)
{
typename EventType::Subscription task_sub = this->task->RegisterListener(cb);
this->task_subs.push_back(task_sub);
}
}
#endif /* __ERROR_LAYER_VIEW_HPP__ */

21
include/gamecard_tab.hpp
View file

@ -25,7 +25,7 @@
#define __GAMECARD_TAB_HPP__
#include "tasks.hpp"
#include "error_frame.hpp"
#include "error_layer_view.hpp"
namespace nxdt::views
{
@ -40,20 +40,16 @@ namespace nxdt::views
GameCardTable(void);
};
/* Extended class to switch between ErrorFrame and List views whenever the gamecard status event is triggered. */
class GameCardTab: public brls::LayerView
/* Instantiate the template for our class. */
typedef ErrorLayerView<nxdt::tasks::GameCardTask, nxdt::tasks::GameCardStatusEvent> GameCardErrorLayerView;
class GameCardTab: public GameCardErrorLayerView
{
typedef bool (*GameCardSizeFunc)(u64 *size);
private:
nxdt::tasks::GameCardTask *gc_status_task = nullptr;
nxdt::tasks::GameCardStatusEvent::Subscription gc_status_task_sub;
GameCardStatus gc_status = GameCardStatus_NotInserted;
ErrorFrame *error_frame = nullptr;
brls::List *list = nullptr;
GameCardTable *properties_table = nullptr;
brls::TableRow *capacity = nullptr;
brls::TableRow *total_size = nullptr;
@ -70,17 +66,10 @@ namespace nxdt::views
brls::ListItem *dump_initial_data = nullptr;
brls::ListItem *dump_hfs_partitions = nullptr;
std::vector<brls::View*> views;
int view_index = -1;
void addLayerWrapper(brls::View* view);
void changeLayerWrapper(brls::View* view);
std::string GetFormattedSizeString(GameCardSizeFunc func);
public:
GameCardTab(nxdt::tasks::GameCardTask *gc_status_task);
~GameCardTab(void);
};
}

2
include/root_view.hpp
View file

@ -39,7 +39,7 @@ namespace nxdt::views
nxdt::tasks::UmsTask *ums_task = nullptr;
nxdt::tasks::UsbHostTask *usb_host_task = nullptr;
brls::VoidEvent::Subscription status_info_task_sub;
nxdt::tasks::VoidEvent::Subscription status_info_task_sub;
brls::Label *applet_mode_lbl = nullptr;
brls::Label *time_lbl = nullptr;

90
source/gamecard_tab.cpp
View file

@ -55,19 +55,13 @@ namespace nxdt::views
if (this->hasParent()) this->getParent()->onChildFocusGained(this);
}
GameCardTab::GameCardTab(nxdt::tasks::GameCardTask *gc_status_task) : brls::LayerView(), gc_status_task(gc_status_task)
GameCardTab::GameCardTab(nxdt::tasks::GameCardTask *gc_status_task) : GameCardErrorLayerView(gc_status_task)
{
/* Error frame. */
this->error_frame = new ErrorFrame("gamecard_tab/error_frame/not_inserted"_i18n);
this->addLayerWrapper(this->error_frame);
/* List. */
this->list = new brls::List();
this->list->setSpacing(this->list->getSpacing() / 2);
this->list->setMarginBottom(20);
this->SetErrorFrameMessage("gamecard_tab/error_frame/not_inserted"_i18n);
/* Gamecard properties table. */
this->list->addView(new brls::Header("gamecard_tab/list/properties_table/header"_i18n));
this->AddListView(new brls::Header("gamecard_tab/list/properties_table/header"_i18n));
this->properties_table = new GameCardTable();
this->capacity = this->properties_table->addRow(brls::TableRowType::BODY, "gamecard_tab/list/properties_table/capacity"_i18n);
@ -77,51 +71,49 @@ namespace nxdt::views
this->lafw_version = this->properties_table->addRow(brls::TableRowType::BODY, "gamecard_tab/list/properties_table/lafw_version"_i18n);
this->sdk_version = this->properties_table->addRow(brls::TableRowType::BODY, "gamecard_tab/list/properties_table/sdk_version"_i18n);
this->compatibility_type = this->properties_table->addRow(brls::TableRowType::BODY, "gamecard_tab/list/properties_table/compatibility_type"_i18n);
this->list->addView(this->properties_table);
this->AddListView(this->properties_table);
/* ListItem elements. */
this->list->addView(new brls::Header("gamecard_tab/list/dump_options"_i18n));
this->AddListView(new brls::Header("gamecard_tab/list/dump_options"_i18n));
this->dump_card_image = new brls::ListItem("gamecard_tab/list/dump_card_image/label"_i18n, "gamecard_tab/list/dump_card_image/description"_i18n);
this->list->addView(this->dump_card_image);
this->AddListView(this->dump_card_image);
this->dump_certificate = new brls::ListItem("gamecard_tab/list/dump_certificate/label"_i18n, "gamecard_tab/list/dump_certificate/description"_i18n);
this->list->addView(this->dump_certificate);
this->AddListView(this->dump_certificate);
this->dump_header = new brls::ListItem("gamecard_tab/list/dump_header/label"_i18n, "gamecard_tab/list/dump_header/description"_i18n);
this->list->addView(this->dump_header);
this->AddListView(this->dump_header);
this->dump_decrypted_cardinfo = new brls::ListItem("gamecard_tab/list/dump_decrypted_cardinfo/label"_i18n, "gamecard_tab/list/dump_decrypted_cardinfo/description"_i18n);
this->list->addView(this->dump_decrypted_cardinfo);
this->AddListView(this->dump_decrypted_cardinfo);
this->dump_initial_data = new brls::ListItem("gamecard_tab/list/dump_initial_data/label"_i18n, "gamecard_tab/list/dump_initial_data/description"_i18n);
this->list->addView(this->dump_initial_data);
this->AddListView(this->dump_initial_data);
this->dump_hfs_partitions = new brls::ListItem("gamecard_tab/list/dump_hfs_partitions/label"_i18n, "gamecard_tab/list/dump_hfs_partitions/description"_i18n);
this->list->addView(this->dump_hfs_partitions);
this->addLayerWrapper(this->list);
this->AddListView(this->dump_hfs_partitions);
/* Subscribe to gamecard status event. */
this->gc_status_task_sub = this->gc_status_task->RegisterListener([this](GameCardStatus gc_status) {
if (gc_status < GameCardStatus_InsertedAndInfoLoaded) this->changeLayerWrapper(this->error_frame);
this->RegisterListener([this](GameCardStatus gc_status) {
if (gc_status < GameCardStatus_InsertedAndInfoLoaded) this->SwitchLayerView(true);
switch(gc_status)
{
case GameCardStatus_NotInserted:
this->error_frame->SetMessage("gamecard_tab/error_frame/not_inserted"_i18n);
this->SetErrorFrameMessage("gamecard_tab/error_frame/not_inserted"_i18n);
break;
case GameCardStatus_Processing:
this->error_frame->SetMessage("gamecard_tab/error_frame/processing"_i18n);
this->SetErrorFrameMessage("gamecard_tab/error_frame/processing"_i18n);
break;
case GameCardStatus_NoGameCardPatchEnabled:
this->error_frame->SetMessage("gamecard_tab/error_frame/nogc_enabled"_i18n);
this->SetErrorFrameMessage("gamecard_tab/error_frame/nogc_enabled"_i18n);
break;
case GameCardStatus_LotusAsicFirmwareUpdateRequired:
this->error_frame->SetMessage("gamecard_tab/error_frame/lafw_update_required"_i18n);
this->SetErrorFrameMessage("gamecard_tab/error_frame/lafw_update_required"_i18n);
break;
case GameCardStatus_InsertedAndInfoNotLoaded:
this->error_frame->SetMessage(i18n::getStr("gamecard_tab/error_frame/info_not_loaded"_i18n, GITHUB_NEW_ISSUE_URL));
this->SetErrorFrameMessage(i18n::getStr("gamecard_tab/error_frame/info_not_loaded"_i18n, GITHUB_NEW_ISSUE_URL));
break;
case GameCardStatus_InsertedAndInfoLoaded:
{
@ -147,7 +139,7 @@ namespace nxdt::views
compatibility_type >= GameCardCompatibilityType_Count ? "generic/unknown"_i18n : GameCardCompatibilityTypeStrings[compatibility_type], \
compatibility_type));
this->changeLayerWrapper(this->list);
this->SwitchLayerView(false);
break;
}
@ -159,50 +151,6 @@ namespace nxdt::views
});
}
GameCardTab::~GameCardTab(void)
{
/* Unregister gamecard task listener. */
this->gc_status_task->UnregisterListener(this->gc_status_task_sub);
/* Clear views vector. */
if (this->views.size()) this->views.clear();
}
void GameCardTab::addLayerWrapper(brls::View* view)
{
this->views.push_back(view);
this->addLayer(view);
if (this->view_index == -1) this->view_index = 0;
}
void GameCardTab::changeLayerWrapper(brls::View* view)
{
int index = -1;
brls::View *current_focus = brls::Application::getCurrentFocus();
for(size_t i = 0; i < this->views.size(); i++)
{
if (this->views[i] == view)
{
index = (int)i;
break;
}
}
if (index == -1) return;
/* Focus the sidebar if we're currently focusing an element from our List. */
if (current_focus && (current_focus == this->properties_table || current_focus == this->dump_card_image || current_focus == this->dump_certificate || current_focus == this->dump_header || \
current_focus == this->dump_decrypted_cardinfo || current_focus == this->dump_initial_data || current_focus == this->dump_hfs_partitions))
{
brls::Application::onGamepadButtonPressed(GLFW_GAMEPAD_BUTTON_DPAD_LEFT, false);
}
this->changeLayer(index);
this->invalidate(true);
this->view_index = index;
}
std::string GameCardTab::GetFormattedSizeString(GameCardSizeFunc func)
{
u64 size = 0;