swkbd_cpp.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/filesystem.h>
#include <nn/result.h>
#include <padscore/kpad.h>
#include <string.h>
#include <vpad/input.h>
 
#ifdef __cplusplus
 
namespace nn
{
 
namespace swkbd
{
 
enum class ControllerType
{
   WiiRemote0 = 0,
   WiiRemote1 = 1,
   WiiRemote2 = 2,
   WiiRemote3 = 3,
   DrcGamepad = 4,
};
 
enum class LanguageType
{
   Japanese           = 0,
   English            = 1,
   French             = 2,
   German             = 3,
   Italian            = 4,
   Spanish            = 5,
   SimplifiedChinese  = 6,
   Korean             = 7,
   Dutch              = 8,
   Portuguese         = 9,
   Russian            = 10,
   TraditionalChinese = 11,
   Invalid            = 12,
};
 
enum class RegionType
{
   Japan  = 0,
   USA    = 1,
   Europe = 2,
   China  = 3,
   Korea  = 4,
   Taiwan = 5,
};
 
enum class State
{
   Hidden  = 0,
   FadeIn  = 1,
   Visible = 2,
   FadeOut = 3,
};
 
enum class InputFormType
{
   InputForm0 = 0,
   Default    = 1,
};
 
enum class KeyboardLayout
{
   JPN_JP_QWERTY      = 0,
   USA_EN_QWERTY      = 1,
   USA_FR_QWERTY      = 2,
   USA_ES_QWERTY      = 3,
   USA_PT_QWERTY      = 4,
   EUR_EN_QWERTY      = 5,
   EUR_FR_AZERTY      = 6,
   EUR_DE_QWERTZ      = 7,
   EUR_IT_QWERTY      = 8,
   EUR_ES_QWERTY      = 9,
   EUR_NL_QWERTY      = 10,
   EUR_PT_QWERTY      = 11,
   EUR_RU_JCUKEN      = 12,
   JPN_JP_Kana        = 13,
   JPN_JP_Phone       = 14,
   JPN_JP_Handwriting = 15,
   JPN_JP_Symbols     = 16,
   USA_Special        = 17,
   EUR_Special        = 17,
   USA_Symbols        = 18,
   EUR_Symbols        = 18,
   LanguageDefault    = 19,
};
 
enum class KeyboardMode
{
   Full   = 0,
   Numpad = 1,
   Utf8   = 2,
   NNID   = 3,
};
 
enum class PasswordMode
{
   Clear = 0,
   Hide  = 1,
   Fade  = 2,
};
 
struct ConfigArg
{
   ConfigArg()
   {
      memset(this, 0, sizeof(*this));
      languageType   = LanguageType::English;
      controllerType = ControllerType::DrcGamepad;
      keyboardMode   = KeyboardMode::Full;
      accessFlags    = 0x7FFFF;
      keyboardLayout = KeyboardLayout::LanguageDefault;
      keyboardTab    = -1;
      unk_0x9C       = 1;
      unk_0xA4       = -1;
   }
 
   LanguageType languageType;
   ControllerType controllerType;
   KeyboardMode keyboardMode;
   uint32_t accessFlags; // Bitmasked!
   KeyboardLayout keyboardLayout;
   int32_t keyboardTab;
   bool unk_0x18;
   const char16_t *okString;
   char16_t numpadCharLeft;
   char16_t numpadCharRight;
   bool showWordSuggestions;
   WUT_PADDING_BYTES(3);
   uint8_t unk_0x28;
   uint8_t unk_0x29;
   uint8_t unk_0x2A;
   bool disableNewLine;
   WUT_UNKNOWN_BYTES(0x9C - 0x2C);
   uint32_t unk_0x9C;
   bool drawSysWiiPointer;
   int32_t unk_0xA4;
};
WUT_CHECK_OFFSET(ConfigArg, 0x00, languageType);
WUT_CHECK_OFFSET(ConfigArg, 0x04, controllerType);
WUT_CHECK_OFFSET(ConfigArg, 0x08, keyboardMode);
WUT_CHECK_OFFSET(ConfigArg, 0x0C, accessFlags);
WUT_CHECK_OFFSET(ConfigArg, 0x10, keyboardLayout);
WUT_CHECK_OFFSET(ConfigArg, 0x14, keyboardTab);
WUT_CHECK_OFFSET(ConfigArg, 0x18, unk_0x18);
WUT_CHECK_OFFSET(ConfigArg, 0x1C, okString);
WUT_CHECK_OFFSET(ConfigArg, 0x20, numpadCharLeft);
WUT_CHECK_OFFSET(ConfigArg, 0x22, numpadCharRight);
WUT_CHECK_OFFSET(ConfigArg, 0x24, showWordSuggestions);
WUT_CHECK_OFFSET(ConfigArg, 0x28, unk_0x28);
WUT_CHECK_OFFSET(ConfigArg, 0x29, unk_0x29);
WUT_CHECK_OFFSET(ConfigArg, 0x2A, unk_0x2A);
WUT_CHECK_OFFSET(ConfigArg, 0x2B, disableNewLine);
WUT_CHECK_OFFSET(ConfigArg, 0x9C, unk_0x9C);
WUT_CHECK_OFFSET(ConfigArg, 0xA0, drawSysWiiPointer);
WUT_CHECK_OFFSET(ConfigArg, 0xA4, unk_0xA4);
WUT_CHECK_SIZE(ConfigArg, 0xA8);
 
struct ReceiverArg
{
   uint32_t unk_0x00 = 0;
   uint32_t unk_0x04 = 0;
   uint32_t unk_0x08 = 0;
   int32_t unk_0x0C  = -1;
   uint32_t unk_0x10 = 0;
   int32_t unk_0x14  = -1;
};
WUT_CHECK_OFFSET(ReceiverArg, 0x00, unk_0x00);
WUT_CHECK_OFFSET(ReceiverArg, 0x04, unk_0x04);
WUT_CHECK_OFFSET(ReceiverArg, 0x08, unk_0x08);
WUT_CHECK_OFFSET(ReceiverArg, 0x0C, unk_0x0C);
WUT_CHECK_OFFSET(ReceiverArg, 0x10, unk_0x10);
WUT_CHECK_OFFSET(ReceiverArg, 0x14, unk_0x14);
WUT_CHECK_SIZE(ReceiverArg, 0x18);
 
struct KeyboardArg
{
   ConfigArg configArg;
   ReceiverArg receiverArg;
};
WUT_CHECK_SIZE(KeyboardArg, 0xC0);
 
struct InputFormArg
{
   InputFormType type                   = InputFormType::Default;
   int32_t unk_0x04                     = -1;
   const char16_t *initialText          = nullptr;
   const char16_t *hintText             = nullptr;
   int32_t maxTextLength                = -1;
   nn::swkbd::PasswordMode passwordMode = nn::swkbd::PasswordMode::Clear;
   uint32_t unk_0x18                    = 0;
   bool drawInput0Cursor                = false;
   bool higlightInitialText             = false;
   bool showCopyPasteButtons            = false;
   WUT_PADDING_BYTES(1);
};
WUT_CHECK_OFFSET(InputFormArg, 0x00, type);
WUT_CHECK_OFFSET(InputFormArg, 0x04, unk_0x04);
WUT_CHECK_OFFSET(InputFormArg, 0x08, initialText);
WUT_CHECK_OFFSET(InputFormArg, 0x0C, hintText);
WUT_CHECK_OFFSET(InputFormArg, 0x10, maxTextLength);
WUT_CHECK_OFFSET(InputFormArg, 0x14, passwordMode);
WUT_CHECK_OFFSET(InputFormArg, 0x18, unk_0x18);
WUT_CHECK_OFFSET(InputFormArg, 0x1C, drawInput0Cursor);
WUT_CHECK_OFFSET(InputFormArg, 0x1D, higlightInitialText);
WUT_CHECK_OFFSET(InputFormArg, 0x1E, showCopyPasteButtons);
WUT_CHECK_SIZE(InputFormArg, 0x20);
 
struct AppearArg
{
   KeyboardArg keyboardArg;
   InputFormArg inputFormArg;
};
WUT_CHECK_SIZE(AppearArg, 0xE0);
 
struct CreateArg
{
   void *workMemory      = nullptr;
   RegionType regionType = RegionType::Europe;
   uint32_t unk_0x08     = 0;
   FSClient *fsClient    = nullptr;
};
WUT_CHECK_OFFSET(CreateArg, 0x00, workMemory);
WUT_CHECK_OFFSET(CreateArg, 0x04, regionType);
WUT_CHECK_OFFSET(CreateArg, 0x08, unk_0x08);
WUT_CHECK_OFFSET(CreateArg, 0x0C, fsClient);
WUT_CHECK_SIZE(CreateArg, 0x10);
 
struct ControllerInfo
{
   VPADStatus *vpad    = nullptr;
   KPADStatus *kpad[4] = {nullptr, nullptr, nullptr, nullptr};
};
WUT_CHECK_OFFSET(ControllerInfo, 0x00, vpad);
WUT_CHECK_OFFSET(ControllerInfo, 0x04, kpad);
WUT_CHECK_SIZE(ControllerInfo, 0x14);
 
struct DrawStringInfo
{
   DrawStringInfo()
   {
      memset(this, 0, sizeof(*this));
   }
 
   WUT_UNKNOWN_BYTES(0x1C);
};
WUT_CHECK_SIZE(DrawStringInfo, 0x1C);
 
struct KeyboardCondition
{
   uint32_t unk_0x00 = 0;
   uint32_t unk_0x04 = 0;
};
WUT_CHECK_OFFSET(KeyboardCondition, 0x00, unk_0x00);
WUT_CHECK_OFFSET(KeyboardCondition, 0x04, unk_0x04);
WUT_CHECK_SIZE(KeyboardCondition, 0x8);
 
struct IEventReceiver;
struct IControllerEventObj;
struct ISoundObj;
 
bool
AppearInputForm(const AppearArg &args);
 
bool
AppearKeyboard(const KeyboardArg &args);
 
void
CalcSubThreadFont();
 
void
CalcSubThreadPredict();
 
void
Calc(const ControllerInfo &controllerInfo);
 
void
ConfirmUnfixAll();
 
bool
Create(const CreateArg &args);
 
void
Destroy();
 
bool
DisappearInputForm();
 
bool
DisappearKeyboard();
 
void
DrawDRC();
 
void
DrawTV();
 
void
GetDrawStringInfo(DrawStringInfo *drawStringInfo);
 
const char16_t *
GetInputFormString();
 
void
GetKeyboardCondition(KeyboardCondition *keyboardCondition);
 
State
GetStateInputForm();
 
State
GetStateKeyboard();
 
uint32_t
GetWorkMemorySize(uint32_t unk);
 
void
InactivateSelectCursor();
 
bool
InitLearnDic(void *dictionary);
 
bool
IsCoveredWithSubWindow();
 
bool
IsDecideCancelButton(bool *outIsSelected);
 
bool
IsDecideOkButton(bool *outIsSelected);
 
bool
IsKeyboardTarget(IEventReceiver *eventReceiver);
 
bool
IsNeedCalcSubThreadFont();
 
bool
IsNeedCalcSubThreadPredict();
 
bool
IsSelectCursorActive();
 
void
MuteAllSound(bool muted);
 
void
SetControllerRemo(ControllerType type);
 
void
SetCursorPos(int pos);
 
void
SetEnableOkButton(bool enable);
 
void
SetInputFormString(const char16_t *str);
 
void
SetReceiver(const ReceiverArg &receiver);
 
void
SetSelectFrom(int);
 
void
SetUserControllerEventObj(IControllerEventObj *controllerEventObj);
 
void
SetUserSoundObj(ISoundObj *soundObj);
 
} // namespace swkbd
} // namespace nn
 
#endif // ifdef __cplusplus