Compare commits

..

1 Commits

Author SHA1 Message Date
coah
c8004b8a65 feat: link tiPredictLang unit
Declare the predictlang Sample class with its inline constructors so the
LayoutByNW4R thunks are emitted in the original order, and link the unit.
2026-09-28 04:49:15 +00:00
181 changed files with 8963 additions and 85095 deletions

View File

@@ -1,62 +0,0 @@
name: README progress
# runs on the self-hosted runner on cole's server so it doesn't use hosted minutes.
# only push/schedule/manual triggers, never pull_request, so fork PRs can't reach this machine.
on:
push:
branches: [main]
paths-ignore: [README.md]
schedule:
- cron: "*/30 * * * *"
workflow_dispatch:
concurrency:
group: readme-progress
cancel-in-progress: true
permissions:
contents: write
jobs:
progress:
runs-on: [self-hosted, wii-ipl-local]
timeout-minutes: 60
env:
ORIG_APP: /mnt/drive2/projects/wiichannels/wii-ipl/orig/43U/00000008.app
TOOL_CACHE: /mnt/drive2/projects/wiichannels/wii-ipl/build
NINJA: /home/cole/projects/tests/.venv/bin/ninja
steps:
- name: Checkout
uses: actions/checkout@v4
with:
ref: main
fetch-depth: 1
- name: Prepare
run: |
mkdir -p build orig/43U
cp "$ORIG_APP" orig/43U/00000008.app
[ -d build/compilers ] || cp -a "$TOOL_CACHE/compilers" build/
[ -d build/tools ] || cp -a "$TOOL_CACHE/tools" build/
- name: Build
run: |
python3 configure.py --version 43U
"$NINJA"
"$NINJA" build/43U/ok
- name: Report
run: build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
- name: Update README
run: python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
- name: Commit
run: |
if git diff --quiet README.md; then exit 0; fi
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add README.md
git commit -m "docs: update progress [skip ci]"
git pull --rebase origin main || { git rebase --abort; echo "main moved, next run will update"; exit 0; }
git push origin HEAD:main

View File

@@ -50,16 +50,6 @@ Supported versions:
Progress
========
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 84.90% | 75.26% | 56.76% | 86.70% |
units 748/1027 complete, functions 10978/12563 matched.
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
<!-- progress:end -->
| Version | Progress |
|-----------------------|------------------------------------------------------------------------------|
| [Wii Menu 4.3U][V43U] | [![FuncBadgeV43U]][V43U] [![DecompBadgeV43U]][V43U] [![LinkBadgeV43U]][V43U] |

View File

@@ -37,16 +37,11 @@ src/system/iplSystem.cpp:
.sdata start:0x81696060 end:0x81696080
src/system/iplController.cpp:
.text start:0x81335CCC end:0x81337318
.text start:0x81335CCC end:0x81337978
.rodata start:0x8160D2C0 end:0x8160D2D0
.data start:0x816346A8 end:0x81634910
.sdata2 start:0x81694440 end:0x81694478
.data start:0x816346A8 end:0x81634A28
.sdata2 start:0x81694440 end:0x81694490
.sdata start:0x81696080 end:0x81696088
src/system/iplControllerManager.cpp:
.text start:0x81337318 end:0x81337978
.data start:0x81634910 end:0x81634A28
.sdata2 start:0x81694478 end:0x81694490
.sbss start:0x81698680 end:0x81698690
src/system/iplChannelManager.cpp:

View File

@@ -7,7 +7,7 @@ mMac__Q33ipl6socket13SocketSetting = .bss:0x81089720; // type:object size:0x40
_database__7LibTVRC = .bss:0x81089760; // type:object size:0x20 data:4byte
_alarm__7LibTVRC = .bss:0x81089780; // type:object size:0x30
_tickWait__7LibTVRC = .bss:0x810897B0; // type:object size:0x10 data:4byte
mArg__Q33ipl7utility8Graphics = .bss:0x810897C0; // type:object size:0x84
mArg__Q33ipl7utility8Graphics = .bss:0x810897C0; // type:object size:0x88
unk__Q23ipl3snd = .bss:0x81089848; // type:object size:0xC
_seBlk__Q23ipl3snd = .bss:0x81089854; // type:object size:0xD8 data:4byte
sSystem__Q23ipl3snd = .bss:0x8108992C; // type:object size:0x63C data:4byte
@@ -123,7 +123,7 @@ CDB_SD_ROOT_PATH_LS = .bss:0x810C8A08; // type:object size:0x20
CDB_SD_VFF_FILE_NAME = .bss:0x810C8A28; // type:object size:0x48
lbl_810C8A80 = .bss:0x810C8A80; // type:object size:0x40 align:32
lbl_810C8AC0 = .bss:0x810C8AC0; // type:object size:0x40 align:32
s_mutex = .bss:0x810C8B00; // type:object size:0x18 scope:local
s_mutex = .bss:0x810C8B00; // type:object size:0x20 scope:local
s_cdbWiiId = .bss:0x810C8B20; // type:object size:0x40 scope:local
ncdMutex = .bss:0x810C8B60; // type:object size:0x20
ncdCommonResult = .bss:0x810C8B80; // type:object size:0x20 align:32 data:4byte
@@ -161,7 +161,7 @@ l_dev_init_info_table = .bss:0x810F55C0; // type:object size:0xD0 scope:local
l_tmpWName = .bss:0x810F5690; // type:object size:0x10 scope:local data:2byte
hashTable = .bss:0x810F56A0; // type:object size:0x22E scope:local data:byte
l_driveInfo = .bss:0x810F58D0; // type:object size:0x208 scope:local data:4byte
l_nandFunc = .bss:0x810F5AD8; // type:object size:0x1A0 scope:local
l_nandFunc = .bss:0x810F5AD8; // type:object size:0x1A8 scope:local
l_event = .bss:0x810F5C80; // type:object size:0x340 scope:local
l_sddrv_info = .bss:0x810F5FC0; // type:object size:0x80 scope:local
sZeroBuffer__Q44nw4r3snd6detail9AxManager = .bss:0x810F6040; // type:object size:0x100
@@ -4558,59 +4558,59 @@ __ct__Q33ipl5scene15SDChannelSelectFPQ23EGG4Heap = .text:0x813DAB08; // type:fun
__dt__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAE7C; // type:function size:0x5C
prepare__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAED8; // type:function size:0xA8
create__Q33ipl5scene15SDChannelSelectFv = .text:0x813DAF80; // type:function size:0x248
enqueueStartNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB1C8; // type:function size:0x44
enqueueFinishNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB20C; // type:function size:0x48
enqueueNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB254; // type:function size:0xB4
enqueueLoadNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB308; // type:function size:0x5C
enqueuePageNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB364; // type:function size:0x5C
enqueueResultNotice__Q33ipl5scene15SDChannelSelectFUl = .text:0x813DB3C0; // type:function size:0x5C
enqueueChannelNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB41C; // type:function size:0x5C
enqueueMoveNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB478; // type:function size:0x5C
enqueueStateNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB4D4; // type:function size:0x5C
enqueueErrorNotice__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DB530; // type:function size:0x5C
enqueueCommandNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB58C; // type:function size:0x60
enqueueDeleteNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB5EC; // type:function size:0x60
clearCommandQueue__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB64C; // type:function size:0x40
clearNoticeQueue__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB68C; // type:function size:0x40
processWorkerCommands__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB6CC; // type:function size:0x518
handleWorkerStartup__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBBE4; // type:function size:0xB0
handleNandTitleCount__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBC94; // type:function size:0xB8
handleNandTitleUsageComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBD4C; // type:function size:0x48
handleNandTitleUsage__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBD94; // type:function size:0xD8
compareTitleUsage__Q33ipl5scene15SDChannelSelectFPCvPCv = .text:0x813DBE6C; // type:function size:0x28
handleSDTitleList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBE94; // type:function size:0x124
compareTitleInfo__Q33ipl5scene15SDChannelSelectFPCvPCv = .text:0x813DBFB8; // type:function size:0x28
handleSDTitleListResult__Q33ipl5scene15SDChannelSelectFv = .text:0x813DBFE0; // type:function size:0x2AC
handleSDMountComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC28C; // type:function size:0x64
handleSDChannelUpdateComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC2F0; // type:function size:0x1B0
handleSDCardReady__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC4A0; // type:function size:0x5C
handleCardCommand__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC4FC; // type:function size:0x78
handleCopyComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC574; // type:function size:0x80
handleSDLocationUpdateComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC5F4; // type:function size:0x48
handleSDLocationReadComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC63C; // type:function size:0x48
handleMoveComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC684; // type:function size:0x90
handleBackupFitComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC714; // type:function size:0x48
handleNandSDCleanupComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC75C; // type:function size:0x48
handleSDDeleteComplete__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC7A4; // type:function size:0x48
updateChannelNotices__Q33ipl5scene15SDChannelSelectFii = .text:0x813DC7EC; // type:function size:0x14C
processWorkerState__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC938; // type:function size:0x18C
updateDialogAnimation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DCAC4; // type:function size:0x42C
setDialogMessage__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DCEF0; // type:function size:0x24
isCurrentTitleUsageEnough__Q33ipl5scene15SDChannelSelectCFPCl = .text:0x813DCF14; // type:function size:0xCC
getCurrentTitleUsage__Q33ipl5scene15SDChannelSelectCFPlPl = .text:0x813DCFE0; // type:function size:0xCC
collectTitlesByUsage__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD0AC; // type:function size:0x194
collectTitlesFromNandUsage__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD240; // type:function size:0x198
collectTitlesByChannelOrder__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD3D8; // type:function size:0x1F8
collectTitlesBySpecialChannels__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD5D0; // type:function size:0x5A4
collectTitlesForMode__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUli = .text:0x813DDB74; // type:function size:0x40
findAdjacentChannel__Q33ipl5scene15SDChannelSelectCFiPiPi = .text:0x813DDBB4; // type:function size:0xB4
setCurrentPageAndRefresh__Q33ipl5scene15SDChannelSelectFiiPQ33ipl5scene12SDChannelObj = .text:0x813DDC68; // type:function size:0x18
handleFourPageDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDC80; // type:function size:0x58
flushSaveDataAndMountSD__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDCD8; // type:function size:0x8C
handleThreePageDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDD64; // type:function size:0x58
finishCardDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDDBC; // type:function size:0x5C
finishDialogOperation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE18; // type:function size:0x2C
finishDialogTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE44; // type:function size:0x24
iplSDChannelSelect_813DB1C8 = .text:0x813DB1C8; // type:function size:0x44
iplSDChannelSelect_813DB20C = .text:0x813DB20C; // type:function size:0x48
iplSDChannelSelect_813DB254 = .text:0x813DB254; // type:function size:0xB4
iplSDChannelSelect_813DB308 = .text:0x813DB308; // type:function size:0x5C
iplSDChannelSelect_813DB364 = .text:0x813DB364; // type:function size:0x5C
iplSDChannelSelect_813DB3C0 = .text:0x813DB3C0; // type:function size:0x5C
iplSDChannelSelect_813DB41C = .text:0x813DB41C; // type:function size:0x5C
iplSDChannelSelect_813DB478 = .text:0x813DB478; // type:function size:0x5C
iplSDChannelSelect_813DB4D4 = .text:0x813DB4D4; // type:function size:0x5C
iplSDChannelSelect_813DB530 = .text:0x813DB530; // type:function size:0x5C
iplSDChannelSelect_813DB58C = .text:0x813DB58C; // type:function size:0x60
iplSDChannelSelect_813DB5EC = .text:0x813DB5EC; // type:function size:0x60
iplSDChannelSelect_813DB64C = .text:0x813DB64C; // type:function size:0x40
iplSDChannelSelect_813DB68C = .text:0x813DB68C; // type:function size:0x40
iplSDChannelSelect_813DB6CC = .text:0x813DB6CC; // type:function size:0x518
iplSDChannelSelect_813DBBE4 = .text:0x813DBBE4; // type:function size:0xB0
iplSDChannelSelect_813DBC94 = .text:0x813DBC94; // type:function size:0xB8
iplSDChannelSelect_813DBD4C = .text:0x813DBD4C; // type:function size:0x48
iplSDChannelSelect_813DBD94 = .text:0x813DBD94; // type:function size:0xD8
iplSDChannelSelect_813DBE6C = .text:0x813DBE6C; // type:function size:0x28
iplSDChannelSelect_813DBE94 = .text:0x813DBE94; // type:function size:0x124
iplSDChannelSelect_813DBFB8 = .text:0x813DBFB8; // type:function size:0x28
iplSDChannelSelect_813DBFE0 = .text:0x813DBFE0; // type:function size:0x2AC
iplSDChannelSelect_813DC28C = .text:0x813DC28C; // type:function size:0x64
iplSDChannelSelect_813DC2F0 = .text:0x813DC2F0; // type:function size:0x1B0
iplSDChannelSelect_813DC4A0 = .text:0x813DC4A0; // type:function size:0x5C
iplSDChannelSelect_813DC4FC = .text:0x813DC4FC; // type:function size:0x78
iplSDChannelSelect_813DC574 = .text:0x813DC574; // type:function size:0x80
iplSDChannelSelect_813DC5F4 = .text:0x813DC5F4; // type:function size:0x48
iplSDChannelSelect_813DC63C = .text:0x813DC63C; // type:function size:0x48
iplSDChannelSelect_813DC684 = .text:0x813DC684; // type:function size:0x90
iplSDChannelSelect_813DC714 = .text:0x813DC714; // type:function size:0x48
iplSDChannelSelect_813DC75C = .text:0x813DC75C; // type:function size:0x48
iplSDChannelSelect_813DC7A4 = .text:0x813DC7A4; // type:function size:0x48
iplSDChannelSelect_813DC7EC = .text:0x813DC7EC; // type:function size:0x14C
iplSDChannelSelect_813DC938 = .text:0x813DC938; // type:function size:0x18C
iplSDChannelSelect_813DCAC4 = .text:0x813DCAC4; // type:function size:0x42C
iplSDChannelSelect_813DCEF0 = .text:0x813DCEF0; // type:function size:0x24
iplSDChannelSelect_813DCF14 = .text:0x813DCF14; // type:function size:0xCC
iplSDChannelSelect_813DCFE0 = .text:0x813DCFE0; // type:function size:0xCC
iplSDChannelSelect_813DD0AC = .text:0x813DD0AC; // type:function size:0x194
iplSDChannelSelect_813DD240 = .text:0x813DD240; // type:function size:0x198
iplSDChannelSelect_813DD3D8 = .text:0x813DD3D8; // type:function size:0x1F8
iplSDChannelSelect_813DD5D0 = .text:0x813DD5D0; // type:function size:0x5A4
iplSDChannelSelect_813DDB74 = .text:0x813DDB74; // type:function size:0x40
iplSDChannelSelect_813DDBB4 = .text:0x813DDBB4; // type:function size:0xB4
iplSDChannelSelect_813DDC68 = .text:0x813DDC68; // type:function size:0x18
iplSDChannelSelect_813DDC80 = .text:0x813DDC80; // type:function size:0x58
iplSDChannelSelect_813DDCD8 = .text:0x813DDCD8; // type:function size:0x8C
iplSDChannelSelect_813DDD64 = .text:0x813DDD64; // type:function size:0x58
iplSDChannelSelect_813DDDBC = .text:0x813DDDBC; // type:function size:0x5C
iplSDChannelSelect_813DDE18 = .text:0x813DDE18; // type:function size:0x2C
iplSDChannelSelect_813DDE44 = .text:0x813DDE44; // type:function size:0x24
isResetProcessDone__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE68; // type:function size:0x28
calcCommon__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE90; // type:function size:0x1B0
calcFadein__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE040; // type:function size:0x30
@@ -4619,69 +4619,69 @@ initCalcFadeout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE24C; // type:fun
calcFadeout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE2EC; // type:function size:0x50
draw__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE33C; // type:function size:0x38C
destroy__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE6C8; // type:function size:0x334
createBaseLayout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE9FC; // type:function size:0x440
updateChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEE3C; // type:function size:0x5C
updateChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DEE98; // type:function size:0x78
calcChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEF10; // type:function size:0x58
drawChannelTransitionObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEF68; // type:function size:0x27C
isChannelReady__Q33ipl5scene15SDChannelSelectFPCQ33ipl5scene12SDChannelObj = .text:0x813DF1E4; // type:function size:0x14
drawChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF1F8; // type:function size:0xB0
processNormalInput__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF2A8; // type:function size:0x138
setPageActionFrame__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF3E0; // type:function size:0x1C
finishPageScroll__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF3FC; // type:function size:0x110
advancePageAnimation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF50C; // type:function size:0x4C
initializeNormalPage__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF558; // type:function size:0x178
refreshPageObjects__Q33ipl5scene15SDChannelSelectFiPQ33ipl5scene12SDChannelObji = .text:0x813DF6D0; // type:function size:0x164
createChannelList__Q33ipl5scene15SDChannelSelectFib = .text:0x813DF834; // type:function size:0x110
createChannelObject__Q33ipl5scene15SDChannelSelectFii = .text:0x813DF944; // type:function size:0x84
destroyUnusedChannelObjects__Q33ipl5scene15SDChannelSelectFiPQ33ipl5scene12SDChannelObj = .text:0x813DF9C8; // type:function size:0xF8
refreshChannelList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFAC0; // type:function size:0xFC
refreshAfterSDTitleList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFBBC; // type:function size:0xE4
destroyChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DFCA0; // type:function size:0x50
updateChannelObjectOrder__Q33ipl5scene15SDChannelSelectFi = .text:0x813DFCF0; // type:function size:0x74
moveChannelObjectsToDrawOrder__Q33ipl5scene15SDChannelSelectFii = .text:0x813DFD64; // type:function size:0x154
findChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813DFEB8; // type:function size:0x74
updateArrowVisibility__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFF2C; // type:function size:0x1C0
hasChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813E00EC; // type:function size:0x140
isChannelInCalc__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E022C; // type:function size:0x68
isPageCreated__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E0294; // type:function size:0x104
setStateAndPlaySelectSound__Q33ipl5scene15SDChannelSelectFi = .text:0x813E0398; // type:function size:0x18
setLayoutFrame__Q33ipl5scene15SDChannelSelectFi = .text:0x813E03B0; // type:function size:0xA0
selectChannel__Q33ipl5scene15SDChannelSelectFii = .text:0x813E0450; // type:function size:0xEC
tellStartingZoomAnm__Q33ipl5scene15SDChannelSelectFv = .text:0x813E053C; // type:function size:0x84
prepareRestarting__Q33ipl5scene15SDChannelSelectFi = .text:0x813E05C0; // type:function size:0x64
startPageTransition__Q33ipl5scene15SDChannelSelectFii = .text:0x813E0624; // type:function size:0xB4
getChannelBasePane__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E06D8; // type:function size:0xAC
getCenterChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E0784; // type:function size:0x30
getChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E07B4; // type:function size:0x30
getChannelPanePosition__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene15SDChannelSelecti = .text:0x813E07E4; // type:function size:0x64
setChannelScissor__Q33ipl5scene15SDChannelSelectCFPCQ33ipl5scene12SDChannelObj = .text:0x813E0848; // type:function size:0x3A4
initPageAnimations__Q33ipl5scene15SDChannelSelectFRCQ33ipl4math4VEC3i = .text:0x813E0BEC; // type:function size:0x294
calcPageAnimations__Q33ipl5scene15SDChannelSelectFv = .text:0x813E0E80; // type:function size:0x60
updatePageTransform__Q33ipl5scene15SDChannelSelectFv = .text:0x813E0EE0; // type:function size:0x26C
getCenterChannelIndex__Q33ipl5scene15SDChannelSelectCFPCc = .text:0x813E114C; // type:function size:0x78
createSceneLayouts__Q33ipl5scene15SDChannelSelectFv = .text:0x813E11C4; // type:function size:0x3A4
updateDragState__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1568; // type:function size:0x124
updateDragPageTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813E168C; // type:function size:0x2D0
finishDragWait__Q33ipl5scene15SDChannelSelectFv = .text:0x813E195C; // type:function size:0x6C
finishDragPageTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813E19C8; // type:function size:0x68
applyChannelMove__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1A30; // type:function size:0x208
finishChannelMove__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1C38; // type:function size:0x118
resetDragPreview__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1D50; // type:function size:0xFC
finishDragPageChange__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1E4C; // type:function size:0x19C
onEventDerived__Q33ipl5scene15SDChannelSelectFPCcUlPQ33ipl10controller9Interface = .text:0x813E1FE8; // type:function size:0x1A4
onButtonEvent__Q33ipl5scene15SDChannelSelectFPCcUlPCQ33ipl10controller9Interface = .text:0x813E218C; // type:function size:0x16C
startDrag__Q33ipl5scene15SDChannelSelectFPCQ33ipl10controller9Interfaceii = .text:0x813E22F8; // type:function size:0x1E0
finishDrag__Q33ipl5scene15SDChannelSelectFv = .text:0x813E24D8; // type:function size:0x204
isChannelMoveTarget__Q33ipl5scene15SDChannelSelectCFii = .text:0x813E26DC; // type:function size:0x74
moveDrag__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2750; // type:function size:0x164
onEvent__Q43ipl5scene32@unnamed@iplSDChannelSelect_cpp@27SDChannelSelectEventHandlerFUlUlPv = .text:0x813E28B4; // type:function size:0x2A0
onEventDerived__Q43ipl5scene32@unnamed@iplSDChannelSelect_cpp@33SDChannelSelectButtonEventHandlerFUlUlPCQ33ipl10controller9Interface = .text:0x813E2B54; // type:function size:0x240
iplSDChannelSelect_813DE9FC = .text:0x813DE9FC; // type:function size:0x440
iplSDChannelSelect_813DEE3C = .text:0x813DEE3C; // type:function size:0x5C
iplSDChannelSelect_813DEE98 = .text:0x813DEE98; // type:function size:0x78
iplSDChannelSelect_813DEF10 = .text:0x813DEF10; // type:function size:0x58
iplSDChannelSelect_813DEF68 = .text:0x813DEF68; // type:function size:0x27C
iplSDChannelSelect_813DF1E4 = .text:0x813DF1E4; // type:function size:0x14
iplSDChannelSelect_813DF1F8 = .text:0x813DF1F8; // type:function size:0xB0
iplSDChannelSelect_813DF2A8 = .text:0x813DF2A8; // type:function size:0x138
iplSDChannelSelect_813DF3E0 = .text:0x813DF3E0; // type:function size:0x1C
iplSDChannelSelect_813DF3FC = .text:0x813DF3FC; // type:function size:0x110
iplSDChannelSelect_813DF50C = .text:0x813DF50C; // type:function size:0x4C
iplSDChannelSelect_813DF558 = .text:0x813DF558; // type:function size:0x178
iplSDChannelSelect_813DF6D0 = .text:0x813DF6D0; // type:function size:0x164
iplSDChannelSelect_813DF834 = .text:0x813DF834; // type:function size:0x110
iplSDChannelSelect_813DF944 = .text:0x813DF944; // type:function size:0x84
iplSDChannelSelect_813DF9C8 = .text:0x813DF9C8; // type:function size:0xF8
iplSDChannelSelect_813DFAC0 = .text:0x813DFAC0; // type:function size:0xFC
iplSDChannelSelect_813DFBBC = .text:0x813DFBBC; // type:function size:0xE4
iplSDChannelSelect_813DFCA0 = .text:0x813DFCA0; // type:function size:0x50
iplSDChannelSelect_813DFCF0 = .text:0x813DFCF0; // type:function size:0x74
iplSDChannelSelect_813DFD64 = .text:0x813DFD64; // type:function size:0x154
iplSDChannelSelect_813DFEB8 = .text:0x813DFEB8; // type:function size:0x74
iplSDChannelSelect_813DFF2C = .text:0x813DFF2C; // type:function size:0x1C0
iplSDChannelSelect_813E00EC = .text:0x813E00EC; // type:function size:0x140
iplSDChannelSelect_813E022C = .text:0x813E022C; // type:function size:0x68
iplSDChannelSelect_813E0294 = .text:0x813E0294; // type:function size:0x104
iplSDChannelSelect_813E0398 = .text:0x813E0398; // type:function size:0x18
iplSDChannelSelect_813E03B0 = .text:0x813E03B0; // type:function size:0xA0
iplSDChannelSelect_813E0450 = .text:0x813E0450; // type:function size:0xEC
iplSDChannelSelect_813E053C = .text:0x813E053C; // type:function size:0x84
iplSDChannelSelect_813E05C0 = .text:0x813E05C0; // type:function size:0x64
iplSDChannelSelect_813E0624 = .text:0x813E0624; // type:function size:0xB4
iplSDChannelSelect_813E06D8 = .text:0x813E06D8; // type:function size:0xAC
iplSDChannelSelect_813E0784 = .text:0x813E0784; // type:function size:0x30
iplSDChannelSelect_813E07B4 = .text:0x813E07B4; // type:function size:0x30
iplSDChannelSelect_813E07E4 = .text:0x813E07E4; // type:function size:0x64
iplSDChannelSelect_813E0848 = .text:0x813E0848; // type:function size:0x3A4
iplSDChannelSelect_813E0BEC = .text:0x813E0BEC; // type:function size:0x294
iplSDChannelSelect_813E0E80 = .text:0x813E0E80; // type:function size:0x60
iplSDChannelSelect_813E0EE0 = .text:0x813E0EE0; // type:function size:0x26C
iplSDChannelSelect_813E114C = .text:0x813E114C; // type:function size:0x78
iplSDChannelSelect_813E11C4 = .text:0x813E11C4; // type:function size:0x3A4
iplSDChannelSelect_813E1568 = .text:0x813E1568; // type:function size:0x124
iplSDChannelSelect_813E168C = .text:0x813E168C; // type:function size:0x2D0
iplSDChannelSelect_813E195C = .text:0x813E195C; // type:function size:0x6C
iplSDChannelSelect_813E19C8 = .text:0x813E19C8; // type:function size:0x68
iplSDChannelSelect_813E1A30 = .text:0x813E1A30; // type:function size:0x208
iplSDChannelSelect_813E1C38 = .text:0x813E1C38; // type:function size:0x118
iplSDChannelSelect_813E1D50 = .text:0x813E1D50; // type:function size:0xFC
iplSDChannelSelect_813E1E4C = .text:0x813E1E4C; // type:function size:0x19C
iplSDChannelSelect_813E1FE8 = .text:0x813E1FE8; // type:function size:0x1A4
iplSDChannelSelect_813E218C = .text:0x813E218C; // type:function size:0x16C
iplSDChannelSelect_813E22F8 = .text:0x813E22F8; // type:function size:0x1E0
iplSDChannelSelect_813E24D8 = .text:0x813E24D8; // type:function size:0x204
iplSDChannelSelect_813E26DC = .text:0x813E26DC; // type:function size:0x74
iplSDChannelSelect_813E2750 = .text:0x813E2750; // type:function size:0x164
iplSDChannelSelect_813E28B4 = .text:0x813E28B4; // type:function size:0x2A0
iplSDChannelSelect_813E2B54 = .text:0x813E2B54; // type:function size:0x240
startResetting__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2D94; // type:function size:0x44
pop__Q33ipl5scene26SDChannelSelectNoticeQueueFv = .text:0x813E2DD8; // type:function size:0x4C
push__Q33ipl5scene27SDChannelSelectCommandQueueFRCQ33ipl5scene22SDChannelSelectCommand = .text:0x813E2E24; // type:function size:0x80
pop__Q33ipl5scene27SDChannelSelectCommandQueueFv = .text:0x813E2EA4; // type:function size:0x4C
copyFrom__Q33ipl5scene22SDChannelSelectCommandFRCQ33ipl5scene22SDChannelSelectCommand = .text:0x813E2EF0; // type:function size:0x34
iplSDChannelSelect_813E2DD8 = .text:0x813E2DD8; // type:function size:0x4C
iplSDChannelSelect_813E2E24 = .text:0x813E2E24; // type:function size:0x80
iplSDChannelSelect_813E2EA4 = .text:0x813E2EA4; // type:function size:0x4C
iplSDChannelSelect_813E2EF0 = .text:0x813E2EF0; // type:function size:0x34
@20@__dt__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2F24; // type:function size:0x8
__ct__Q33ipl5scene12SDChannelObjFPQ23EGG4Heapii = .text:0x813E2F2C; // type:function size:0x130
__dt__Q33ipl5scene12SDChannelObjFv = .text:0x813E305C; // type:function size:0xA8
@@ -4694,7 +4694,7 @@ iplSDChannelObj_813E322C = .text:0x813E322C; // type:function size:0x9C
iplSDChannelObj_813E32C8 = .text:0x813E32C8; // type:function size:0x3C
iplSDChannelObj_813E3304 = .text:0x813E3304; // type:function size:0x8
iplSDChannelObj_813E330C = .text:0x813E330C; // type:function size:0x14
getTranslate__Q33ipl5scene12SDChannelObjCFv = .text:0x813E3320; // type:function size:0x10
iplSDChannelObj_813E3320 = .text:0x813E3320; // type:function size:0x10
iplSDChannelObj_813E3330 = .text:0x813E3330; // type:function size:0x24
iplSDChannelObj_813E3354 = .text:0x813E3354; // type:function size:0x98
iplSDChannelObj_813E33EC = .text:0x813E33EC; // type:function size:0x94
@@ -4837,70 +4837,70 @@ onEvent__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPv = .text:0x813EB51C; // type
onEventDerived__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPCQ33ipl10controller9Interface = .text:0x813EB5E8; // type:function size:0x4
__ct__Q33ipl5scene8SDMemoryFv = .text:0x813EB5EC; // type:function size:0x48
__dt__Q33ipl5scene8SDMemoryFv = .text:0x813EB634; // type:function size:0x5C
create__Q33ipl5scene8SDMemoryFPQ23EGG4HeapPQ33ipl4nand10LayoutFilePQ33ipl5scene15SDChannelSelect = .text:0x813EB690; // type:function size:0x10A0
setTitleLists__Q33ipl5scene8SDMemoryFRCQ43ipl5scene8SDMemory10TitleRangeRCQ43ipl5scene8SDMemory10TitleRange = .text:0x813EC730; // type:function size:0xD4
setScrollLimit__Q33ipl5scene8SDMemoryFv = .text:0x813EC804; // type:function size:0x144
init__Q33ipl7utility8ScrollerFv = .text:0x813EC948; // type:function size:0x20
resetScrollArrows__Q33ipl5scene8SDMemoryFv = .text:0x813EC968; // type:function size:0x84
updateScrollArrows__Q33ipl5scene8SDMemoryFUlUlUlUl = .text:0x813EC9EC; // type:function size:0x9C
showDownArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECA88; // type:function size:0x74
showUpArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECAFC; // type:function size:0x74
hideDownArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECB70; // type:function size:0x78
hideUpArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECBE8; // type:function size:0x78
updateSideArrows__Q33ipl5scene8SDMemoryFv = .text:0x813ECC60; // type:function size:0x160
showLeftArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECDC0; // type:function size:0x60
showRightArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECE20; // type:function size:0x60
hideLeftArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECE80; // type:function size:0x64
hideRightArrow__Q33ipl5scene8SDMemoryFv = .text:0x813ECEE4; // type:function size:0x64
resetDialogPaneAnimations__Q33ipl5scene8SDMemoryFv = .text:0x813ECF48; // type:function size:0x13C
calc__Q33ipl5scene8SDMemoryFv = .text:0x813ED084; // type:function size:0x268
updateState__Q33ipl5scene8SDMemoryFv = .text:0x813ED2EC; // type:function size:0x4CC
onDialogState0__Q33ipl5scene8SDMemoryFv = .text:0x813ED7B8; // type:function size:0xA4
onDialogState2__Q33ipl5scene8SDMemoryFv = .text:0x813ED85C; // type:function size:0xC4
onDialogState3__Q33ipl5scene8SDMemoryFv = .text:0x813ED920; // type:function size:0x124
onDialogState4__Q33ipl5scene8SDMemoryFv = .text:0x813EDA44; // type:function size:0x110
onDialogState6__Q33ipl5scene8SDMemoryFv = .text:0x813EDB54; // type:function size:0x78
onDialogState7__Q33ipl5scene8SDMemoryFv = .text:0x813EDBCC; // type:function size:0xC0
onDialogState8__Q33ipl5scene8SDMemoryFv = .text:0x813EDC8C; // type:function size:0x278
onDialogState9__Q33ipl5scene8SDMemoryFv = .text:0x813EDF04; // type:function size:0xA4
onDialogState10__Q33ipl5scene8SDMemoryFv = .text:0x813EDFA8; // type:function size:0x130
onDialogState11__Q33ipl5scene8SDMemoryFv = .text:0x813EE0D8; // type:function size:0xE0
onDialogState12__Q33ipl5scene8SDMemoryFv = .text:0x813EE1B8; // type:function size:0x1A0
iplSDMemory_813EB690 = .text:0x813EB690; // type:function size:0x10A0
iplSDMemory_813EC730 = .text:0x813EC730; // type:function size:0xD4
iplSDMemory_813EC804 = .text:0x813EC804; // type:function size:0x144
iplSDMemory_813EC948 = .text:0x813EC948; // type:function size:0x20
iplSDMemory_813EC968 = .text:0x813EC968; // type:function size:0x84
iplSDMemory_813EC9EC = .text:0x813EC9EC; // type:function size:0x9C
iplSDMemory_813ECA88 = .text:0x813ECA88; // type:function size:0x74
iplSDMemory_813ECAFC = .text:0x813ECAFC; // type:function size:0x74
iplSDMemory_813ECB70 = .text:0x813ECB70; // type:function size:0x78
iplSDMemory_813ECBE8 = .text:0x813ECBE8; // type:function size:0x78
iplSDMemory_813ECC60 = .text:0x813ECC60; // type:function size:0x160
iplSDMemory_813ECDC0 = .text:0x813ECDC0; // type:function size:0x60
iplSDMemory_813ECE20 = .text:0x813ECE20; // type:function size:0x60
iplSDMemory_813ECE80 = .text:0x813ECE80; // type:function size:0x64
iplSDMemory_813ECEE4 = .text:0x813ECEE4; // type:function size:0x64
iplSDMemory_813ECF48 = .text:0x813ECF48; // type:function size:0x13C
iplSDMemory_813ED084 = .text:0x813ED084; // type:function size:0x268
iplSDMemory_813ED2EC = .text:0x813ED2EC; // type:function size:0x4CC
iplSDMemory_813ED7B8 = .text:0x813ED7B8; // type:function size:0xA4
iplSDMemory_813ED85C = .text:0x813ED85C; // type:function size:0xC4
iplSDMemory_813ED920 = .text:0x813ED920; // type:function size:0x124
iplSDMemory_813EDA44 = .text:0x813EDA44; // type:function size:0x110
iplSDMemory_813EDB54 = .text:0x813EDB54; // type:function size:0x78
iplSDMemory_813EDBCC = .text:0x813EDBCC; // type:function size:0xC0
iplSDMemory_813EDC8C = .text:0x813EDC8C; // type:function size:0x278
iplSDMemory_813EDF04 = .text:0x813EDF04; // type:function size:0xA4
iplSDMemory_813EDFA8 = .text:0x813EDFA8; // type:function size:0x130
iplSDMemory_813EE0D8 = .text:0x813EE0D8; // type:function size:0xE0
iplSDMemory_813EE1B8 = .text:0x813EE1B8; // type:function size:0x1A0
iplSDMemory_813EE358 = .text:0x813EE358; // type:function size:0x44
onDialogState13__Q33ipl5scene8SDMemoryFv = .text:0x813EE39C; // type:function size:0xEC
onDialogState14__Q33ipl5scene8SDMemoryFv = .text:0x813EE488; // type:function size:0x1C4
onDialogState15__Q33ipl5scene8SDMemoryFv = .text:0x813EE64C; // type:function size:0x12C
onDialogState16__Q33ipl5scene8SDMemoryFv = .text:0x813EE778; // type:function size:0xA0
onDialogState17__Q33ipl5scene8SDMemoryFv = .text:0x813EE818; // type:function size:0x128
onDialogState18__Q33ipl5scene8SDMemoryFv = .text:0x813EE940; // type:function size:0xE8
onDialogState19__Q33ipl5scene8SDMemoryFv = .text:0x813EEA28; // type:function size:0x84
onDialogState20__Q33ipl5scene8SDMemoryFv = .text:0x813EEAAC; // type:function size:0xE8
onDialogState21__Q33ipl5scene8SDMemoryFv = .text:0x813EEB94; // type:function size:0x148
onDialogState22__Q33ipl5scene8SDMemoryFv = .text:0x813EECDC; // type:function size:0x11C
onDialogState23__Q33ipl5scene8SDMemoryFv = .text:0x813EEDF8; // type:function size:0x78
onDialogState24__Q33ipl5scene8SDMemoryFv = .text:0x813EEE70; // type:function size:0xC0
draw__Q33ipl5scene8SDMemoryFv = .text:0x813EEF30; // type:function size:0x88
drawTransferTitles__Q33ipl5scene8SDMemoryFv = .text:0x813EEFB8; // type:function size:0x70C
writeFourFlagBytes__Q23ipl5sceneFPUcUcUcUcUc = .text:0x813EF6C4; // type:function size:0x14
setTitleRowColors__Q23ipl5sceneFPQ34nw4r3lyt7TextBoxRCQ34nw4r2ut5ColorRCQ34nw4r2ut5Color = .text:0x813EF6D8; // type:function size:0x48
iplSDMemory_813EE39C = .text:0x813EE39C; // type:function size:0xEC
iplSDMemory_813EE488 = .text:0x813EE488; // type:function size:0x1C4
iplSDMemory_813EE64C = .text:0x813EE64C; // type:function size:0x12C
iplSDMemory_813EE778 = .text:0x813EE778; // type:function size:0xA0
iplSDMemory_813EE818 = .text:0x813EE818; // type:function size:0x128
iplSDMemory_813EE940 = .text:0x813EE940; // type:function size:0xE8
iplSDMemory_813EEA28 = .text:0x813EEA28; // type:function size:0x84
iplSDMemory_813EEAAC = .text:0x813EEAAC; // type:function size:0xE8
iplSDMemory_813EEB94 = .text:0x813EEB94; // type:function size:0x148
iplSDMemory_813EECDC = .text:0x813EECDC; // type:function size:0x11C
iplSDMemory_813EEDF8 = .text:0x813EEDF8; // type:function size:0x78
iplSDMemory_813EEE70 = .text:0x813EEE70; // type:function size:0xC0
iplSDMemory_813EEF30 = .text:0x813EEF30; // type:function size:0x88
iplSDMemory_813EEFB8 = .text:0x813EEFB8; // type:function size:0x70C
iplSDMemory_813EF6C4 = .text:0x813EF6C4; // type:function size:0x14
iplSDMemory_813EF6D8 = .text:0x813EF6D8; // type:function size:0x48
GetBeginIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF720; // type:function size:0x8
GetEndIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF728; // type:function size:0x8
iplSDMemory_813EF728 = .text:0x813EF728; // type:function size:0x8
__ne__Q24nw4r2utFQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8IteratorQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8Iterator = .text:0x813EF730; // type:function size:0x18
getControlPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF748; // type:function size:0x74
activateControlPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EF7BC; // type:function size:0x128
deactivateControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF8E4; // type:function size:0xF0
cancelControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF9D4; // type:function size:0x120
onEvent__Q43ipl5scene8SDMemory23ControlPaneEventHandlerFUlUlPv = .text:0x813EFAF4; // type:function size:0xD8
getTitlePaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFBCC; // type:function size:0xC0
activateTitlePane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EFC8C; // type:function size:0x160
deactivateTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFDEC; // type:function size:0x128
selectTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFF14; // type:function size:0x24C
onEvent__Q43ipl5scene8SDMemory21TitlePaneEventHandlerFUlUlPv = .text:0x813F0160; // type:function size:0xD8
getDialogPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813F0238; // type:function size:0x74
activateDialogPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813F02AC; // type:function size:0x144
deactivateDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F03F0; // type:function size:0x10C
selectDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F04FC; // type:function size:0x1A0
onEvent__Q43ipl5scene8SDMemory22DialogPaneEventHandlerFUlUlPv = .text:0x813F069C; // type:function size:0xD8
iplSDMemory_813EF748 = .text:0x813EF748; // type:function size:0x74
iplSDMemory_813EF7BC = .text:0x813EF7BC; // type:function size:0x128
iplSDMemory_813EF8E4 = .text:0x813EF8E4; // type:function size:0xF0
iplSDMemory_813EF9D4 = .text:0x813EF9D4; // type:function size:0x120
iplSDMemory_813EFAF4 = .text:0x813EFAF4; // type:function size:0xD8
iplSDMemory_813EFBCC = .text:0x813EFBCC; // type:function size:0xC0
iplSDMemory_813EFC8C = .text:0x813EFC8C; // type:function size:0x160
iplSDMemory_813EFDEC = .text:0x813EFDEC; // type:function size:0x128
iplSDMemory_813EFF14 = .text:0x813EFF14; // type:function size:0x24C
iplSDMemory_813F0160 = .text:0x813F0160; // type:function size:0xD8
iplSDMemory_813F0238 = .text:0x813F0238; // type:function size:0x74
iplSDMemory_813F02AC = .text:0x813F02AC; // type:function size:0x144
iplSDMemory_813F03F0 = .text:0x813F03F0; // type:function size:0x10C
iplSDMemory_813F04FC = .text:0x813F04FC; // type:function size:0x1A0
iplSDMemory_813F069C = .text:0x813F069C; // type:function size:0xD8
__ct__Q33ipl5scene7SettingFPQ23EGG4Heapi = .text:0x813F0774; // type:function size:0xF8
isAnimating__Q33ipl5scene7SettingFv = .text:0x813F086C; // type:function size:0x3C
getFuncMsgQ__Q33ipl5scene7SettingFv = .text:0x813F08A8; // type:function size:0x68
@@ -13835,8 +13835,8 @@ scAnmTable__10homebutton = .rodata:0x8160F378; // type:object size:0x60 scope:lo
scGroupAnmTable__10homebutton = .rodata:0x8160F3D8; // type:object size:0x250 scope:local data:4byte
__DVDErrorMessage = .rodata:0x8160F628; // type:object size:0x28
lbl_8160F650 = .rodata:0x8160F650; // type:object size:0x16 data:2byte
specials$18760 = .rodata:0x8160F668; // type:object size:0xB data:byte
@19145 = .rodata:0x8160F673; // type:object size:0xC data:byte
lbl_8160F668 = .rodata:0x8160F668; // type:object size:0xB data:byte
lbl_8160F673 = .rodata:0x8160F673; // type:object size:0xC data:byte
lbl_8160F67F = .rodata:0x8160F67F; // type:object size:0xD data:byte
lbl_8160F690 = .rodata:0x8160F690; // type:object size:0x18 data:2byte
scAnmFrame__Q23ipl5scene = .rodata:0x8160F6A8; // type:object size:0x20 scope:local
@@ -15435,46 +15435,26 @@ __vt__Q33ipl5scene7Address = .data:0x81647B70; // type:object size:0x120
@11177 = .data:0x81647D9A; // type:object size:0xF scope:local data:string
__vt__Q33ipl5scene18AddressAddSelEvent = .data:0x81647DAC; // type:object size:0x18
__vt__Q33ipl5scene13AddressAddSel = .data:0x81647DC4; // type:object size:0x88
@16959 = .data:0x81647EE0; // type:object size:0xD data:string
@16960 = .data:0x81647EED; // type:object size:0xD data:string
@16961 = .data:0x81647EFA; // type:object size:0xD data:string
@16962 = .data:0x81647F07; // type:object size:0xE data:string
@16963 = .data:0x81647F15; // type:object size:0xC data:string
sButtonPaneNames = .data:0x81647F24; // type:object size:0x14
@16964 = .data:0x81647F38; // type:object size:0xE data:string
@23886 = .data:0x81647F46; // type:object size:0xC data:string
@24207 = .data:0x81647F52; // type:object size:0x12 data:string
@24208 = .data:0x81647F64; // type:object size:0x1C data:string
@24209 = .data:0x81647F80; // type:object size:0xF data:string
@24210 = .data:0x81647F8F; // type:object size:0x19 data:string
@24211 = .data:0x81647FA8; // type:object size:0xB data:string
@24212 = .data:0x81647FB3; // type:object size:0xB data:string
@24213 = .data:0x81647FBE; // type:object size:0xB data:string
@24214 = .data:0x81647FC9; // type:object size:0xC data:string
@24215 = .data:0x81647FD5; // type:object size:0xE data:string
@24216 = .data:0x81647FE3; // type:object size:0x1A data:string
@24217 = .data:0x81647FFD; // type:object size:0x1A data:string
@24218 = .data:0x81648017; // type:object size:0x1D data:string
@24219 = .data:0x81648034; // type:object size:0x1E data:string
@24220 = .data:0x81648052; // type:object size:0xC data:string
@24221 = .data:0x8164805E; // type:object size:0x22 data:string
@24222 = .data:0x81648080; // type:object size:0x9 data:string
@24223 = .data:0x81648089; // type:object size:0x23 data:string
@24224 = .data:0x816480AC; // type:object size:0x1C data:string
@24225 = .data:0x816480C8; // type:object size:0xD data:string
@24226 = .data:0x816480D5; // type:object size:0xD data:string
@24227 = .data:0x816480E2; // type:object size:0xD data:string
@24228 = .data:0x816480EF; // type:object size:0xE data:string
@24229 = .data:0x816480FD; // type:object size:0xE data:string
@24231 = .data:0x8164810B; // type:object size:0x1F5
@25188 = .data:0x81648300; // type:object size:0xC0 scope:local
@25187 = .data:0x816483C0; // type:object size:0xC0 scope:local
@25711 = .data:0x8164848D; // type:object size:0x16 data:string
@25835 = .data:0x816484A3; // type:object size:0xF data:string
@25838 = .data:0x816484B4; // type:object size:0x44 scope:local
@26007 = .data:0x81648508; // type:object size:0x58 scope:local
@26006 = .data:0x81648560; // type:object size:0x8C scope:local
@26030 = .data:0x816485EC; // type:object size:0xC data:wstring
lbl_81647EE0 = .data:0x81647EE0; // type:object size:0xD data:string
lbl_81647EED = .data:0x81647EED; // type:object size:0xD data:string
lbl_81647EFA = .data:0x81647EFA; // type:object size:0xD data:string
lbl_81647F07 = .data:0x81647F07; // type:object size:0xE data:string
lbl_81647F15 = .data:0x81647F15; // type:object size:0xC data:string
lbl_81647F24 = .data:0x81647F24; // type:object size:0x14
lbl_81647F38 = .data:0x81647F38; // type:object size:0xE data:string
lbl_81647F46 = .data:0x81647F46; // type:object size:0x83
lbl_81647FC9 = .data:0x81647FC9; // type:object size:0xC data:string
lbl_81647FD5 = .data:0x81647FD5; // type:object size:0x128
lbl_816480FD = .data:0x816480FD; // type:object size:0xE data:string
lbl_8164810B = .data:0x8164810B; // type:object size:0x1F5
jumptable_81648300 = .data:0x81648300; // type:object size:0xC0 scope:local
jumptable_816483C0 = .data:0x816483C0; // type:object size:0xC0 scope:local
lbl_8164848D = .data:0x8164848D; // type:object size:0x16 data:string
lbl_816484A3 = .data:0x816484A3; // type:object size:0xF data:string
jumptable_816484B4 = .data:0x816484B4; // type:object size:0x44 scope:local
jumptable_81648508 = .data:0x81648508; // type:object size:0x58 scope:local
jumptable_81648560 = .data:0x81648560; // type:object size:0x8C scope:local
lbl_816485EC = .data:0x816485EC; // type:object size:0xC data:wstring
__vt__Q33ipl5scene17AddressInputEvent = .data:0x816485F8; // type:object size:0x18
__vt__Q33ipl5scene16AddressEditEvent = .data:0x81648610; // type:object size:0x18
__vt__Q33ipl5scene11AddressEdit = .data:0x81648628; // type:object size:0x120
@@ -16752,73 +16732,73 @@ __vt__Q33ipl5scene14ParentalDialog = .data:0x81653ED8; // type:object size:0x68
@10007 = .data:0x81653FD8; // type:object size:0xE scope:local data:string
__vt__Q33ipl5scene6Reboot = .data:0x81653FE8; // type:object size:0x4C
__vt__Q33ipl5scene9RootScene = .data:0x81654038; // type:object size:0x4C
@16632 = .data:0x81654088; // type:object size:0x9 scope:local data:string
@16633 = .data:0x81654091; // type:object size:0x9 scope:local data:string
@16634 = .data:0x8165409A; // type:object size:0x9 scope:local data:string
@16635 = .data:0x816540A3; // type:object size:0x9 scope:local data:string
@16636 = .data:0x816540AC; // type:object size:0x9 scope:local data:string
@16637 = .data:0x816540B5; // type:object size:0x9 scope:local data:string
@16638 = .data:0x816540BE; // type:object size:0x9 scope:local data:string
@16639 = .data:0x816540C7; // type:object size:0x9 scope:local data:string
@16640 = .data:0x816540D0; // type:object size:0x9 scope:local data:string
@16641 = .data:0x816540D9; // type:object size:0x9 scope:local data:string
@16642 = .data:0x816540E2; // type:object size:0x9 scope:local data:string
@16643 = .data:0x816540EB; // type:object size:0x9 scope:local data:string
@16644 = .data:0x816540F4; // type:object size:0x9 scope:local data:string
@16645 = .data:0x816540FD; // type:object size:0x9 scope:local data:string
@16646 = .data:0x81654106; // type:object size:0x9 scope:local data:string
@16647 = .data:0x8165410F; // type:object size:0x9 scope:local data:string
@16648 = .data:0x81654118; // type:object size:0x9 scope:local data:string
@16649 = .data:0x81654121; // type:object size:0x9 scope:local data:string
@16650 = .data:0x8165412A; // type:object size:0x9 scope:local data:string
@16651 = .data:0x81654133; // type:object size:0x9 scope:local data:string
@16652 = .data:0x8165413C; // type:object size:0x9 scope:local data:string
@16653 = .data:0x81654145; // type:object size:0x9 scope:local data:string
@16654 = .data:0x8165414E; // type:object size:0x9 scope:local data:string
@16655 = .data:0x81654157; // type:object size:0x9 scope:local data:string
@16656 = .data:0x81654160; // type:object size:0x9 scope:local data:string
@16657 = .data:0x81654169; // type:object size:0x9 scope:local data:string
@16658 = .data:0x81654172; // type:object size:0x9 scope:local data:string
@16659 = .data:0x8165417B; // type:object size:0x9 scope:local data:string
@16660 = .data:0x81654184; // type:object size:0x9 scope:local data:string
@16661 = .data:0x8165418D; // type:object size:0x9 scope:local data:string
@16662 = .data:0x81654196; // type:object size:0x9 scope:local data:string
@16663 = .data:0x8165419F; // type:object size:0x9 scope:local data:string
@16664 = .data:0x816541A8; // type:object size:0x9 scope:local data:string
@16665 = .data:0x816541B1; // type:object size:0x9 scope:local data:string
@16666 = .data:0x816541BA; // type:object size:0x9 scope:local data:string
@16667 = .data:0x816541C3; // type:object size:0x9 scope:local data:string
@16668 = .data:0x816541CC; // type:object size:0x9 scope:local data:string
@16669 = .data:0x816541D5; // type:object size:0x9 scope:local data:string
@16670 = .data:0x816541DE; // type:object size:0x9 scope:local data:string
@16671 = .data:0x816541E7; // type:object size:0x9 scope:local data:string
@16672 = .data:0x816541F0; // type:object size:0x9 scope:local data:string
@16673 = .data:0x816541F9; // type:object size:0x9 scope:local data:string
lbl_81654088 = .data:0x81654088; // type:object size:0x9 data:string
lbl_81654091 = .data:0x81654091; // type:object size:0x9 data:string
lbl_8165409A = .data:0x8165409A; // type:object size:0x9 data:string
lbl_816540A3 = .data:0x816540A3; // type:object size:0x9 data:string
lbl_816540AC = .data:0x816540AC; // type:object size:0x9 data:string
lbl_816540B5 = .data:0x816540B5; // type:object size:0x9 data:string
lbl_816540BE = .data:0x816540BE; // type:object size:0x9 data:string
lbl_816540C7 = .data:0x816540C7; // type:object size:0x9 data:string
lbl_816540D0 = .data:0x816540D0; // type:object size:0x9 data:string
lbl_816540D9 = .data:0x816540D9; // type:object size:0x9 data:string
lbl_816540E2 = .data:0x816540E2; // type:object size:0x9 data:string
lbl_816540EB = .data:0x816540EB; // type:object size:0x9 data:string
lbl_816540F4 = .data:0x816540F4; // type:object size:0x9 data:string
lbl_816540FD = .data:0x816540FD; // type:object size:0x9 data:string
lbl_81654106 = .data:0x81654106; // type:object size:0x9 data:string
lbl_8165410F = .data:0x8165410F; // type:object size:0x9 data:string
lbl_81654118 = .data:0x81654118; // type:object size:0x9 data:string
lbl_81654121 = .data:0x81654121; // type:object size:0x9 data:string
lbl_8165412A = .data:0x8165412A; // type:object size:0x9 data:string
lbl_81654133 = .data:0x81654133; // type:object size:0x9 data:string
lbl_8165413C = .data:0x8165413C; // type:object size:0x9 data:string
lbl_81654145 = .data:0x81654145; // type:object size:0x9 data:string
lbl_8165414E = .data:0x8165414E; // type:object size:0x9 data:string
lbl_81654157 = .data:0x81654157; // type:object size:0x9 data:string
lbl_81654160 = .data:0x81654160; // type:object size:0x9 data:string
lbl_81654169 = .data:0x81654169; // type:object size:0x9 data:string
lbl_81654172 = .data:0x81654172; // type:object size:0x9 data:string
lbl_8165417B = .data:0x8165417B; // type:object size:0x9 data:string
lbl_81654184 = .data:0x81654184; // type:object size:0x9 data:string
lbl_8165418D = .data:0x8165418D; // type:object size:0x9 data:string
lbl_81654196 = .data:0x81654196; // type:object size:0x9 data:string
lbl_8165419F = .data:0x8165419F; // type:object size:0x9 data:string
lbl_816541A8 = .data:0x816541A8; // type:object size:0x9 data:string
lbl_816541B1 = .data:0x816541B1; // type:object size:0x9 data:string
lbl_816541BA = .data:0x816541BA; // type:object size:0x9 data:string
lbl_816541C3 = .data:0x816541C3; // type:object size:0x9 data:string
lbl_816541CC = .data:0x816541CC; // type:object size:0x9 data:string
lbl_816541D5 = .data:0x816541D5; // type:object size:0x9 data:string
lbl_816541DE = .data:0x816541DE; // type:object size:0x9 data:string
lbl_816541E7 = .data:0x816541E7; // type:object size:0x9 data:string
lbl_816541F0 = .data:0x816541F0; // type:object size:0x9 data:string
lbl_816541F9 = .data:0x816541F9; // type:object size:0x9 data:string
lbl_81654204 = .data:0x81654204; // type:object size:0xF0
@16674 = .data:0x816542F4; // type:object size:0xA scope:local data:string
@16675 = .data:0x816542FE; // type:object size:0xA scope:local data:string
@16676 = .data:0x81654308; // type:object size:0xA scope:local data:string
@16677 = .data:0x81654312; // type:object size:0xA scope:local data:string
lbl_816542F4 = .data:0x816542F4; // type:object size:0xA data:string
lbl_816542FE = .data:0x816542FE; // type:object size:0xA data:string
lbl_81654308 = .data:0x81654308; // type:object size:0xA data:string
lbl_81654312 = .data:0x81654312; // type:object size:0xA data:string
lbl_8165431C = .data:0x8165431C; // type:object size:0x20
@16679 = .data:0x8165433C; // type:object size:0xB scope:local data:string
@16680 = .data:0x81654347; // type:object size:0xB scope:local data:string
@16681 = .data:0x81654352; // type:object size:0xB scope:local data:string
@16682 = .data:0x8165435D; // type:object size:0xB scope:local data:string
lbl_8165433C = .data:0x8165433C; // type:object size:0xB data:string
lbl_81654347 = .data:0x81654347; // type:object size:0xB data:string
lbl_81654352 = .data:0x81654352; // type:object size:0xB data:string
lbl_8165435D = .data:0x8165435D; // type:object size:0xB data:string
lbl_81654368 = .data:0x81654368; // type:object size:0x20
lbl_81654388 = .data:0x81654388; // type:object size:0x14 data:4byte
sFourPageDialogPages__Q23ipl5scene = .data:0x8165439C; // type:object size:0x70
sThreePageDialogPages__Q23ipl5scene = .data:0x8165440C; // type:object size:0x54
@16689 = .data:0x81654460; // type:object size:0x9 scope:local data:string
@16690 = .data:0x81654469; // type:object size:0x9 scope:local data:string
lbl_8165439C = .data:0x8165439C; // type:object size:0x70
lbl_8165440C = .data:0x8165440C; // type:object size:0x54
lbl_81654460 = .data:0x81654460; // type:object size:0x9 data:string
lbl_81654469 = .data:0x81654469; // type:object size:0x9 data:string
lbl_81654472 = .data:0x81654472; // type:object size:0x16
@24438 = .data:0x81654488; // type:object size:0xE scope:local data:string
@24439 = .data:0x81654496; // type:object size:0x11 scope:local data:string
@24489 = .data:0x816544A7; // type:object size:0x19 scope:local data:string
@24490 = .data:0x816544C0; // type:object size:0x1B scope:local data:string
lbl_81654488 = .data:0x81654488; // type:object size:0xE data:string
lbl_81654496 = .data:0x81654496; // type:object size:0x11 data:string
lbl_816544A7 = .data:0x816544A7; // type:object size:0x19 data:string
lbl_816544C0 = .data:0x816544C0; // type:object size:0x1B data:string
jumptable_816544DC = .data:0x816544DC; // type:object size:0x38 scope:local
jumptable_81654514 = .data:0x81654514; // type:object size:0x40 scope:local
@24961 = .data:0x81654554; // type:object size:0xB scope:local data:string
@24962 = .data:0x8165455F; // type:object size:0xE scope:local data:string
lbl_81654554 = .data:0x81654554; // type:object size:0xB data:string
lbl_8165455F = .data:0x8165455F; // type:object size:0xE data:string
jumptable_81654570 = .data:0x81654570; // type:object size:0x3C scope:local
jumptable_816545AC = .data:0x816545AC; // type:object size:0x40 scope:local
jumptable_816545EC = .data:0x816545EC; // type:object size:0x40 scope:local
@@ -16826,16 +16806,16 @@ jumptable_8165462C = .data:0x8165462C; // type:object size:0x40 scope:local
jumptable_8165466C = .data:0x8165466C; // type:object size:0x28 scope:local
jumptable_81654694 = .data:0x81654694; // type:object size:0x78 scope:local
lbl_8165473B = .data:0x8165473B; // type:object size:0xD4
@26032 = .data:0x8165480F; // type:object size:0xE scope:local data:string
@26047 = .data:0x8165481D; // type:object size:0xB scope:local data:string
@26062 = .data:0x81654828; // type:object size:0x10 scope:local data:string
lbl_8165480F = .data:0x8165480F; // type:object size:0xE data:string
lbl_8165481D = .data:0x8165481D; // type:object size:0xB data:string
lbl_81654828 = .data:0x81654828; // type:object size:0x10 data:string
lbl_81654838 = .data:0x81654838; // type:object size:0x146
@26231 = .data:0x8165497E; // type:object size:0x16 scope:local data:string
@26266 = .data:0x81654994; // type:object size:0x10 scope:local data:string
@26311 = .data:0x816549A4; // type:object size:0xF scope:local data:string
@26312 = .data:0x816549B3; // type:object size:0x14 scope:local data:string
@26336 = .data:0x816549C7; // type:object size:0x10 scope:local data:string
@26559 = .data:0x816549D7; // type:object size:0xF scope:local data:string
lbl_8165497E = .data:0x8165497E; // type:object size:0x16 data:string
lbl_81654994 = .data:0x81654994; // type:object size:0x10 data:string
lbl_816549A4 = .data:0x816549A4; // type:object size:0xF data:string
lbl_816549B3 = .data:0x816549B3; // type:object size:0x14 data:string
lbl_816549C7 = .data:0x816549C7; // type:object size:0x10 data:string
lbl_816549D7 = .data:0x816549D7; // type:object size:0xF data:string
lbl_81654A08 = .data:0x81654A08; // type:object size:0x1C
lbl_81654A24 = .data:0x81654A24; // type:object size:0x18
lbl_81654A3C = .data:0x81654A3C; // type:object size:0xFC
@@ -21711,7 +21691,7 @@ lbl_816965C4 = .sdata:0x816965C4; // type:object size:0x6 data:string
lbl_816965CA = .sdata:0x816965CA; // type:object size:0x4
smButtonName__Q33ipl5scene13AddressAddSel = .sdata:0x816965D0; // type:object size:0x8
@10971 = .sdata:0x816965D8; // type:object size:0x4 scope:local data:string
sInputPaneName = .sdata:0x816965E0; // type:object size:0x4 data:4byte
lbl_816965E0 = .sdata:0x816965E0; // type:object size:0x4 data:4byte
lbl_816965E4 = .sdata:0x816965E4; // type:object size:0x4 data:string
lbl_816965E8 = .sdata:0x816965E8; // type:object size:0x2
lbl_816965EA = .sdata:0x816965EA; // type:object size:0x6 data:string
@@ -22014,20 +21994,20 @@ natType = .sdata:0x81696D30; // type:object size:0x4 scope:local data:4byte
@11124 = .sdata:0x81696D69; // type:object size:0x7 scope:local data:string
@11125 = .sdata:0x81696D70; // type:object size:0x7 scope:local data:string
@11250 = .sdata:0x81696D78; // type:object size:0x2 scope:local
@16631 = .sdata:0x81696D80; // type:object size:0x1 scope:local
@16684 = .sdata:0x81696D81; // type:object size:0x6 scope:local data:string
@16685 = .sdata:0x81696D87; // type:object size:0x6 scope:local data:string
@16686 = .sdata:0x81696D8D; // type:object size:0x6 scope:local data:string
@16687 = .sdata:0x81696D93; // type:object size:0x6 scope:local data:string
@16688 = .sdata:0x81696D99; // type:object size:0x6 scope:local data:string
@16692 = .sdata:0x81696D9F; // type:object size:0x7 scope:local data:string
lbl_81696D80 = .sdata:0x81696D80; // type:object size:0x1
lbl_81696D81 = .sdata:0x81696D81; // type:object size:0x6 data:string
lbl_81696D87 = .sdata:0x81696D87; // type:object size:0x6 data:string
lbl_81696D8D = .sdata:0x81696D8D; // type:object size:0x6 data:string
lbl_81696D93 = .sdata:0x81696D93; // type:object size:0x6 data:string
lbl_81696D99 = .sdata:0x81696D99; // type:object size:0x6 data:string
lbl_81696D9F = .sdata:0x81696D9F; // type:object size:0x7 data:string
lbl_81696DA8 = .sdata:0x81696DA8; // type:object size:0x4 data:4byte
lbl_81696DAC = .sdata:0x81696DAC; // type:object size:0x6 data:wstring
@25675 = .sdata:0x81696DB2; // type:object size:0x4 scope:local data:string
@25689 = .sdata:0x81696DB6; // type:object size:0x7 scope:local data:string
@25710 = .sdata:0x81696DBD; // type:object size:0x1 scope:local
@26199 = .sdata:0x81696DBE; // type:object size:0x4 scope:local data:string
@26201 = .sdata:0x81696DC2; // type:object size:0x5 scope:local data:string
lbl_81696DB2 = .sdata:0x81696DB2; // type:object size:0x4 data:string
lbl_81696DB6 = .sdata:0x81696DB6; // type:object size:0x7 data:string
lbl_81696DBD = .sdata:0x81696DBD; // type:object size:0x1
lbl_81696DBE = .sdata:0x81696DBE; // type:object size:0x4 data:string
lbl_81696DC2 = .sdata:0x81696DC2; // type:object size:0x5 data:string
lbl_81696DC7 = .sdata:0x81696DC7; // type:object size:0x8 data:string
lbl_81696DD0 = .sdata:0x81696DD0; // type:object size:0x4 data:4byte
lbl_81696DD4 = .sdata:0x81696DD4; // type:object size:0x4 data:4byte
@@ -23543,7 +23523,7 @@ s_fatalVFFlag = .sbss:0x81698D7C; // type:object size:0x4 scope:local data:4byte
CDBPrintDebugLevel = .sbss:0x81698D80; // type:object size:0x4 data:4byte
s_lastNANDError = .sbss:0x81698D84; // type:object size:0x4 scope:local data:4byte
s_lastVFError = .sbss:0x81698D88; // type:object size:0x4 scope:local data:4byte
CDBDatabaseWorkBuf = .sbss:0x81698D8C; // type:object size:0x4 data:4byte
lbl_81698D8C = .sbss:0x81698D8C; // type:object size:0x4 scope:local data:4byte
s_recordPool = .sbss:0x81698D90; // type:object size:0x4 scope:local data:4byte
s_databasePool = .sbss:0x81698D94; // type:object size:0x4 scope:local data:4byte
lbl_81698D98 = .sbss:0x81698D98; // type:object size:0x4 data:4byte

View File

@@ -624,8 +624,7 @@ config.libs = [
Object(Matching, "system/rvl_dec.c"),
Object(Matching, "system/RIPL_BoardRecord.c"),
Object(Matching, "system/iplSystem.cpp"),
Object(Matching, "system/iplController.cpp"),
Object(Matching, "system/iplControllerManager.cpp"),
Object(NonMatching, "system/iplController.cpp"),
Object(Matching, "system/iplChannelManager.cpp"),
Object(Matching, "system/iplChannelScriptManager.cpp"),
Object(Matching, "system/iplNand.cpp"),
@@ -654,7 +653,7 @@ config.libs = [
Object(Matching, "system/iplWarningHandler.cpp"),
Object(Matching, "system/iplSocketSetting.cpp"),
Object(Matching, "system/iplPostmanManager.cpp"),
Object(Matching, "system/iplSaveDataManager.cpp"),
Object(NonMatching, "system/iplSaveDataManager.cpp"),
Object(Matching, "system/iplChannelRsoThread.cpp"),
Object(Matching, "system/RsoSystem.cpp"),
Object(Matching, "system/iplCdbBackup.cpp"),
@@ -672,7 +671,7 @@ config.libs = [
Object(Matching, "utility/iplTVRCUtils.cpp"),
Object(Matching, "utility/iplTree.cpp"),
Object(Matching, "utility/iplFrameController.cpp"),
Object(Matching, "utility/iplGraphics.cpp"),
Object(Equivalent, "utility/iplGraphics.cpp"),
Object(Matching, "utility/iplCapture.cpp"),
Object(Matching, "utility/iplUtility.cpp"),
Object(Matching, "utility/iplThread.cpp"),
@@ -739,7 +738,7 @@ config.libs = [
),
IPLSection("board", [
Object(Equivalent, "scene/board/iplBoard.cpp"),
Object(Matching, "scene/board/iplBoardObject.cpp"),
Object(Equivalent, "scene/board/iplBoardObject.cpp"),
Object(Matching, "scene/board/iplBoardSD.cpp"),
Object(Matching, "scene/board/iplUrlProcessor.cpp"),
Object(Equivalent, "scene/board/iplFocusObject.cpp"),
@@ -815,7 +814,7 @@ config.libs = [
Object(NonMatching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
]
),
@@ -875,7 +874,7 @@ config.libs = [
Object(Matching, "scene/setting/iplAPScanThread.cpp"),
Object(NonMatching, "scene/setting/iplUSBAP.cpp"),
Object(NonMatching, "scene/setting/iplUSBAPThread.cpp"),
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(NonMatching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c"),
@@ -985,21 +984,21 @@ config.libs = [
Object(NonMatching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
Object(NonMatching, "clib/zi8alts.c"),
Object(NonMatching, "clib/zi8cgetc.c"),
Object(NonMatching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8copy.c"),
Object(NonMatching, "clib/zi8dawg.c"),
Object(Matching, "clib/zi8getc.c"),
Object(NonMatching, "clib/zi8getc.c"),
Object(NonMatching, "clib/zi8getc2.c"),
Object(Matching, "clib/zi8getSW.c"),
Object(Matching, "clib/zi8initd.c"),
Object(Matching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8getSW.c"),
Object(NonMatching, "clib/zi8initd.c"),
Object(NonMatching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8match.c"),
Object(Matching, "clib/zi8misc.c"),
Object(NonMatching, "clib/zi8misc.c"),
Object(NonMatching, "clib/zi8pud2.c"),
Object(Matching, "clib/Zi8punct.c"),
Object(Matching, "clib/zi8space.c"),
Object(NonMatching, "clib/Zi8punct.c"),
Object(NonMatching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
Object(Matching, "clib/zi8ver.c"),
Object(Matching, "clib/zi8ZHuwd.c"),
@@ -1026,8 +1025,8 @@ config.libs = [
Object(Matching, "cdb/CDBRecordFile.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(NonMatching, "cdb/CDBIntArray.c"),
Object(Matching, "cdb/CDBSystem.c"),
Object(Matching, "cdb/CDBAttr.c"),
Object(NonMatching, "cdb/CDBSystem.c"),
Object(Equivalent, "cdb/CDBAttr.c"),
Object(Matching, "cdb/CDBFBridge.c"),
Object(Matching, "cdb/CDBFBridgeVF.c"),
Object(Matching, "cdb/CDBFBridgeSD.c"),
@@ -1036,12 +1035,12 @@ config.libs = [
]
),
RevoEXLib("ncd", [
Object(Matching, "ncd/ncdsystem.c"),
Object(NonMatching, "ncd/ncdsystem.c"),
Object(NonMatching, "ncd/ncdsleep.c"),
]
),
RevoEXLib("net", [
Object(Matching, "net/nettime.c"),
Object(NonMatching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(NonMatching, "net/sha1.c"),
@@ -1053,19 +1052,19 @@ config.libs = [
]
),
RevoEXLib("nhttp", [
Object(Matching, "nhttp/NHTTP_bgnend.c"),
Object(Matching, "nhttp/NHTTP_control.c"),
Object(Matching, "nhttp/NHTTP_list.c"),
Object(Matching, "nhttp/NHTTP_os_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_bgnend.c"),
Object(NonMatching, "nhttp/NHTTP_control.c"),
Object(NonMatching, "nhttp/NHTTP_list.c"),
Object(NonMatching, "nhttp/NHTTP_os_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_recvbuf.c"),
Object(Matching, "nhttp/NHTTP_request.c"),
Object(Matching, "nhttp/NHTTP_response.c"),
Object(NonMatching, "nhttp/NHTTP_request.c"),
Object(NonMatching, "nhttp/NHTTP_response.c"),
Object(NonMatching, "nhttp/NHTTP_socket_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_stdlib_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_thread.c"),
Object(NonMatching, "nhttp/d_nhttp_private.c"),
Object(Matching, "nhttp/d_nhttp.c"),
Object(Matching, "nhttp/d_nhttp_common.c"),
Object(NonMatching, "nhttp/d_nhttp.c"),
Object(NonMatching, "nhttp/d_nhttp_common.c"),
]
),
RevoEXLib("nwc24", [
@@ -1089,7 +1088,7 @@ config.libs = [
Object(Matching, "nwc24/NWC24UserId.c"),
Object(Matching, "nwc24/NWC24Time.c"),
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(Equivalent, "nwc24/NWC24Download.c"),
Object(NonMatching, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(NonMatching, "nwc24/NWC24System.c"),
]
@@ -1164,7 +1163,7 @@ config.libs = [
Object(Matching, "vf/develop/d_hash.c"),
Object(Matching, "vf/develop/d_time.c"),
Object(Matching, "vf/develop/d_common.c"),
Object(Matching, "vf/develop/nand_drv.c"),
Object(NonMatching, "vf/develop/nand_drv.c"),
Object(Matching, "vf/develop/sd_drv.c"),
]
),
@@ -1707,7 +1706,7 @@ config.libs = [
Object(NonMatching, "fa/pf_volume.c"),
Object(NonMatching, "fa/pf_volume_apiadd.c"),
Object(NonMatching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_api_util.c"),
Object(NonMatching, "fa/pf_api_util.c"),
Object(NonMatching, "fa/pf_attach.c"),
Object(NonMatching, "fa/pf_buffering.c"),
Object(NonMatching, "fa/pf_cdelete.c"),
@@ -1774,7 +1773,7 @@ config.libs = [
Object(NonMatching, "fa/pf_unmount.c"),
Object(NonMatching, "fa/pf_unregctx.c"),
Object(NonMatching, "fa/pf_xdivide.c"),
Object(Matching, "fa/pf_w_api_util.c"),
Object(NonMatching, "fa/pf_w_api_util.c"),
Object(NonMatching, "fa/pf_w_cdelete.c"),
Object(NonMatching, "fa/pf_w_chdir.c"),
Object(NonMatching, "fa/pf_w_chdmod.c"),

View File

@@ -1,72 +0,0 @@
#ifndef IPL_MEMORY_CARD_LIB_H
#define IPL_MEMORY_CARD_LIB_H
#include <revolution/types.h>
namespace ipl {
namespace memorycard {
typedef struct FileInfo {
u16 fileNo; // 0x00
u16 size; // 0x02
u8 canCopy; // 0x04
u8 canMove; // 0x05
u16 unk_0x06; // 0x06
u32 key; // 0x08
} FileInfo; // 0x0C
typedef struct CardState {
vu8 unk_0x00; // 0x00
vu8 changed; // 0x01
vs16 state; // 0x02
vu16 unk_0x04; // 0x04
vu16 unk_0x06; // 0x06
vu32 key; // 0x08
vu16 unk_0x0C; // 0x0C
vu16 unk_0x0E; // 0x0E
vu16 freeBlocks; // 0x10
vu16 unk_0x12; // 0x12
} CardState; // 0x14
typedef struct IconState {
u8 bannerEnable; // 0x00
u8 unk_0x01; // 0x01
u8 unk_0x02; // 0x02
u8 bannerType; // 0x03
s8 anmDelta; // 0x04
u8 anmType; // 0x05
u8 unk_0x06; // 0x06
u8 unk_0x07; // 0x07
u8 iconFmt[8]; // 0x08
u16 anmFrameBits; // 0x10
s16 anmMax; // 0x12
u32 bannerOffset; // 0x14
u32 bannerTlutOffset; // 0x18
u32 iconOffset[8]; // 0x1C
u32 iconTlutOffset; // 0x3C
} IconState; // 0x40
void probeCard();
CardState* getCardSlotState();
FileInfo* getCardDirState();
IconState* getIconStateArray();
long getCardLastSendCmd();
long getCardLastSrcSlot();
long getCardLastCMDFCmdResult();
void sendCardFormatCmd(u8 slot);
void sendCardCopyCmd(u8 slot, s16 fileNo);
void sendCardMoveCmd(u8 slot, s16 fileNo);
void sendCardDeleteCmd(u8 slot, s16 fileNo);
const char* getIconComment(u8 slot, s16 fileNo);
void initCardThread();
#if defined(IPL_MEMORY_CARD_CPP) || defined(IPL_CARD_SEQUENCE_CPP)
BOOL shutdownCardThread();
#else
bool shutdownCardThread();
#endif
} // namespace memorycard
} // namespace ipl
#endif // IPL_MEMORY_CARD_LIB_H

View File

@@ -122,14 +122,6 @@ extern WWWProtocolFinalizeFn WWWProtocolFinished;
extern WWWProtocolFinalizeFn WWWProtocolFailed;
extern WWWAddProtocolFn WWWAddProtocol;
#ifdef IPL_SETTING_IMPLEMENTATION
namespace ipl {
namespace scene {
class Setting;
}
}
#endif
namespace www {
namespace arcreader {
class ArcContainer;
@@ -214,9 +206,6 @@ namespace ext_ead {
WWWHandle* GetHandle() { return mpBrowserHandle; }
private:
#ifdef IPL_SETTING_IMPLEMENTATION
friend class ::ipl::scene::Setting;
#endif
static BOOL SNotifyCallback_(WWWHandle* wwwBrowser, WWWHandlewindow* wwwWindow, WWWEvent event, WWWHandleEventData* eventData);
BOOL NotifyCallback_(WWWHandle* wwwBrowser, WWWHandlewindow* wwwWindow, WWWEvent event, WWWHandleEventData* eventData);

View File

@@ -14,15 +14,7 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
LayoutByNW4R(nw4r::lyt::MultiArcResourceAccessor* multiArc, const char* layoutName, EventObserver* event)
: nw4rmanager::Layout(multiArc, layoutName, event) {}
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual ~LayoutByNW4R();
#else
virtual ~LayoutByNW4R() {}
#endif
virtual void create(MEMAllocator* allocator);
virtual void init();

View File

@@ -20,10 +20,6 @@ namespace textinput {
virtual void moveNigaoeButton() {}
};
#ifdef MYTIINPUTFORM_IMPLEMENTATION
class ScrollButton;
#endif
class InputForm : public textinput::InputForm {
public:
typedef enum EditMode {
@@ -34,51 +30,14 @@ namespace textinput {
EM_Last
} EditMode;
#ifdef MYTIMANAGER_IMPLEMENTATION
InputForm(textinput::Manager* manager, nw4r::lyt::MultiArcResourceAccessor* multiArc,
const char* layoutName, EventObserver* event, const char* fontName)
: textinput::InputForm(manager, multiArc, layoutName, event, fontName),
unk_0x308(NULL), unk_0x30C(NULL), unk_0x310(NULL), unk_0x314(NULL),
mfScroll(0.0f), mfScrollFrom(0.0f), mfScrollTo(0.0f), mnLine(0),
mDrawRect(), mDefaultDrawSize(), mDefaultBoundSize(), mExScrollAnm(),
mpNigaoeObserver(NULL), mpDefaultNigaoe(NULL), mpSendString(NULL),
mbEdited(false), mbGoodBye(false), mbEditScrollUp(false), mbEditScrollDown(false),
mbCloseWithSend(false), mpScrollButton(NULL), mbScrollUp(false), mbScrollDown(false),
meEditMode(EM_Disp) {}
#endif
~InputForm();
#ifdef MYTIINPUTFORM_IMPLEMENTATION
virtual void moveCursorUp();
virtual void moveCursorDown();
virtual void onCommand(INPUT_COMMAND command, void* data);
virtual void create(MEMAllocator* allocator, inputform::EditBuffer* editBuffer);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void init();
virtual void draw();
virtual void calc();
virtual void doScroll(Scroll* scroll);
virtual u32 calcCursorPos(f32 x, f32 y);
virtual void drawCursor(f32 x, f32 y);
virtual nw4r::math::VEC2 getScale() const;
virtual void preDraw(u32 pos);
virtual void doLineFeed();
virtual void finishDraw(u32 pos);
virtual bool isInScroll();
#endif
virtual void setScroll(f32 scroll);
virtual void setAddScroll(f32 scroll, bool up, bool down);
virtual f32 getScroll() { return mfScroll; }
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual f32 getScrollFrom();
virtual f32 getScrollTo();
#else
virtual f32 getScrollFrom() { return mfScrollFrom; }
virtual f32 getScrollTo() { return mfScrollTo; }
#endif
virtual void open();
virtual void close();
@@ -131,11 +90,7 @@ namespace textinput {
void setEditScrollDown(bool editScrollDown) { mbEditScrollUp = editScrollDown; }
void setCloseWithSend(bool closeWithSend) { mbCloseWithSend = closeWithSend; }
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
void setEditMode(EditMode editMode);
#else
void setEditMode(EditMode editMode) { meEditMode = editMode; }
#endif
bool isEdited() { return mbEdited; }
bool isGoodBye() { return mbGoodBye; }
@@ -148,19 +103,9 @@ namespace textinput {
tistring::Decolated* getSendString() { return mpSendString; }
private:
#ifdef MYTIINPUTFORM_IMPLEMENTATION
nw4r::lyt::Pane* mpMemoPane;
nw4r::lyt::Pane* mpMemoRootPane;
nw4r::lyt::Pane* mpBoundPane;
nw4r::lyt::Pane* mpDrawPane;
#else
#ifdef MYTIMANAGER_IMPLEMENTATION
undefined4* unk_0x308;
#endif
undefined4* unk_0x30C;
undefined4* unk_0x310;
undefined4* unk_0x314;
#endif
f32 mfScroll; // 0x318
f32 mfScrollFrom; // 0x31C
f32 mfScrollTo; // 0x320
@@ -172,11 +117,7 @@ namespace textinput {
nw4r::lyt::Size mDefaultBoundSize; // 0x358
Mtx mDrawMtx; // 0x360
Mtx mBoundMtx; // 0x390
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
util::Animation mExScrollAnm; // 0x3C0
#else
u8 /*todo*/ mExScrollAnm[32]; // 0x3C0
#endif
NigaoeEventObserver* mpNigaoeObserver; // 0x3E0
GXTexObj* mpDefaultNigaoe; // 0x3E4
tistring::Decolated* mpSendString; // 0x3E8
@@ -186,11 +127,7 @@ namespace textinput {
bool mbEditScrollDown; // 0x3EF
bool mbCloseWithSend; // 0x3F0
u8 padding[3]; // 0x3F1
#ifdef MYTIINPUTFORM_IMPLEMENTATION
ScrollButton* mpScrollButton;
#else
undefined4* mpScrollButton;
#endif
undefined4* mpScrollButton; // 0x3F4
bool mbScrollUp; // 0x3F8
bool mbScrollDown; // 0x3F9
EditMode meEditMode; // 0x3FC

View File

@@ -16,13 +16,6 @@ namespace textinput {
T_Last,
} Type;
#ifdef MYTIMANAGER_IMPLEMENTATION
InputForm(textinput::Manager* manager, nw4r::lyt::MultiArcResourceAccessor* multiArc,
const char* layoutName, EventObserver* event, const char* fontName)
: textinput::MemoInputForm(manager, multiArc, layoutName, event, fontName),
unk_0x400(0), mbPhotoDraw(false), meType(T_MailAddressSel) {}
#endif
virtual nw4r::lyt::Material* getPhotoPaneMaterial();
virtual void onPhotoTrig();

View File

@@ -28,9 +28,6 @@ namespace textinput {
CT_NumericWithSeparator,
CT_NormalWithoutLineFeedWithSign,
CT_PredictWithoutLineFeed,
#ifdef MYTIMANAGER_IMPLEMENTATION
CT_PredictBigText,
#endif
CT_Last
} ConfigType;
@@ -81,11 +78,7 @@ namespace textinput {
virtual void start();
virtual void end();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual textinput::InputForm* createInputForm();
#else
virtual InputForm* createInputForm();
#endif
virtual void memoDraw();
@@ -100,16 +93,8 @@ namespace textinput {
virtual ConfigType getConfigType() { return meConfigType; }
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual void setSaveData();
#else
virtual void setSaveData_();
#endif
virtual void reflectSaveData();
#ifdef MYTIMANAGER_IMPLEMENTATION
void reflectSaveDataRev1();
void reflectSaveDataDefault();
#endif
virtual void configDefault();
virtual void configLetter();
@@ -126,21 +111,10 @@ namespace textinput {
virtual void configNormalWithoutLineFeedWithSign();
virtual void configPredictWithoutLineFeed();
virtual void configPredictBigText();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual textinput::MemoInputForm* createMemoInputForm();
virtual textinput::LetterInputForm* createLetterInputForm();
virtual textinput::InputForm* createBigTextInputForm();
virtual void* createBG();
#else
virtual void createMemoInputForm();
virtual void createLetterInputForm();
virtual void createBigTextInputForm();
virtual void createBG();
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
void* getBackGround() const { return mpBackGround; }
#endif
private:
State* mpCurrentState; // 0x40
@@ -161,11 +135,6 @@ namespace textinput {
class State {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
State() : mpManager(NULL) {}
Manager* getManager() const { return mpManager; }
void setManager(Manager* manager) { mpManager = manager; }
#endif
virtual ~State();
virtual Manager::StateType getStateType();
@@ -184,18 +153,6 @@ namespace textinput {
virtual void start();
virtual void end();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual InputForm* InputForm();
virtual keyboard::hwkey::HWKeyboard* HWKeyboard();
virtual keyboard::pctype::LayoutByNW4R* PCKeyboard();
virtual keyboard::cellphonetype::LayoutByNW4R* CellPhoneKeyboard();
virtual void* SignKeyboard();
virtual candidatebox::LayoutByNW4R* CandidateBox();
virtual toolbar::LayoutByNW4R* ToolBar();
virtual void* PredictLanguageSelectDialog();
virtual void* BG();
#endif
private:
Manager* mpManager; // 0x04
};

View File

@@ -48,9 +48,6 @@ namespace textinput {
class CandidateBoxCaller {
public:
#ifdef TIINPUTFORM_IMPLEMENTATION
CandidateBoxCaller() : mpCandidateBox(NULL) {}
#endif
// This candidate thing is a bit different from the dwarf
class Candidates {
public:
@@ -77,9 +74,6 @@ namespace textinput {
class Base : public CommandSender {
public:
#ifdef TIMANAGER_IMPLEMENTATION
Base(Manager* manager) : mpCandidates(NULL), mpAllocator(NULL), mbOn(false), mbInvalid(true), meLanguage(USA), mpManager(manager) {}
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override {}
@@ -114,9 +108,6 @@ namespace textinput {
class EventHandler : public nw4rmanager::TiEventHandler {
public:
#ifdef TIMANAGER_IMPLEMENTATION
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
#endif
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, Input* input) override; // 0x18
LayoutByNW4R* mpLayoutByNW4R; // 0xC
@@ -290,13 +281,6 @@ namespace textinput {
// TODO
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
public:
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mEventHandler(this), mpTiString(NULL),
mTextArea(0, this, this), mLeftScroll(1, this, this), mRightScroll(2, this, this), mOnOffButton(3, this, this),
mTextWindow(4, this, this), mbActive(true) {}
const UIOnOffButton& getOnOffButton() const { return mOnOffButton; }
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
@@ -325,11 +309,7 @@ namespace textinput {
virtual u16 getScroll() { return mTextArea.GetDispOffset(); } // 0x100
virtual bool isInScroll(); // 0x104
virtual void setActive(bool active); // 0x108
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isActive() const { return mbActive; }
#else
virtual bool isActive() const;
#endif // 0x10C
virtual bool isActive() const; // 0x10C
virtual void setSelectedTextPane(int pane) { mTextArea.SetSelectedText(pane); } // 0x110
virtual void setFocusedTextPane(int pane) { mTextArea.SetFocusedText(pane); } // 0x114
virtual int getFocusedTextPane() { return mTextArea.GetFocusedText(); } // 0x118
@@ -339,9 +319,6 @@ namespace textinput {
virtual void cancelStateFocusIn(); // 0x128
virtual void onEvent(UIObj*, u32, void*) override; // 0x12C
#ifdef TIINPUTFORM_IMPLEMENTATION
UITextArea& getTextArea() { return mTextArea; }
#endif
void onPressedShift(bool shift);
void onReleasedShift();
void startTurnOn(bool);

View File

@@ -2,62 +2,13 @@
#define TEXTINPUT_CELL_PHONE_H
#include "tiNw4rManager.h"
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#include "tiKeyboard.h"
#endif
namespace textinput {
namespace keyboard {
namespace cellphonetype {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class Base : public textinput::keyboard::KeyboardBase {
#else
class Base {
#endif
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
};
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
#ifdef TIMANAGER_IMPLEMENTATION
Base(Manager* manager) : mpManager(manager) {}
virtual int getType() override;
#else
virtual void getType() override;
#endif
virtual void onActive() override;
virtual void calc();
virtual void draw();
virtual InputMode getInputMode() const;
virtual bool isLocked() const;
virtual bool isNumeric() const;
virtual bool isNumericWithDot() const;
virtual bool isHoldingButton() const;
virtual void doNumericMode(bool);
virtual void changeInputMode(InputMode);
virtual bool isUpperCase();
virtual void setInputMode(InputMode);
virtual void setUpperCaseJP(bool);
virtual void setLangKeyActive(bool);
virtual bool onClose();
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void setAbcMode(bool);
virtual bool isZiActive();
virtual bool isAtokActive();
virtual void doInput();
virtual void updateFixMode();
#else
// TODO
virtual void vt_0x08();
virtual void vt_0x0C();
virtual void vt_0x10();
@@ -79,11 +30,7 @@ namespace textinput {
virtual void vt_0x4C();
virtual void vt_0x50();
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual void doNumericMode(bool);
#else
virtual void vt_0x54();
#endif
virtual void vt_0x58();
virtual void vt_0x5C();
virtual void vt_0x60();
@@ -91,103 +38,17 @@ namespace textinput {
virtual void vt_0x68(bool);
virtual bool onClose();
#endif
// TODO enum?
int getInputType() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
private:
u32 mPreviousInputMode;
u32 mCurrentInputMode;
bool mbInputModeLocked;
bool mbNumericMode;
bool mbNumericWithDotMode;
bool mbUpperCaseMode;
bool mbAbcMode;
bool mbLanguageKeyMode;
u32 mHoldingButton;
void* mpInputModeTable;
MEMAllocator* mpAllocator;
#ifdef TIMANAGER_IMPLEMENTATION
Manager* mpManager;
#else
void* mpInputSettings;
#endif
u32 mInputState;
#endif
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpEventHandler(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void setCommandReceiver(CommandReceiver* receiver);
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual void setLanguage(Language language);
virtual void update();
virtual void onActive();
virtual void calc();
virtual void draw();
virtual void changeInputMode(InputMode mode);
virtual void setInputMode(InputMode mode);
virtual void setUpperCaseJP(bool upper);
virtual void setLangKeyActive(bool active);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void setAbcMode(bool abc);
virtual void doNumericMode(bool);
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog);
virtual void setSignWindow(signwindow::LayoutByNW4R* window);
#else
virtual void doNumericMode(bool);
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
#endif
virtual void doNumericWithDotMode(bool);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual bool onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
bool hasLineFeedButton() const { return mbLineFeedButton; }
private:
bool mbLineFeedButton;
#ifdef TIMANAGER_IMPLEMENTATION
GXTexObj mSpaceTexture;
GXTexObj mSpaceTextureCN;
GXTexObj mSpaceTextureKR;
nw4rmanager::TiEventHandler* mpEventHandler;
predictlang::LayoutByNW4R* mpPredictDialog;
signwindow::LayoutByNW4R* mpSignWindow;
#endif
public:
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual nw4rmanager::AnmPane* getAnmPane(InputMode mode);
virtual void throwReleaseForAll();
virtual void changeAnimationAllToNormal();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void changeKeyTop(const struct PaneNameToCharCode* table);
virtual void changeSpaceKeyTop(const struct PaneNameToCharCode* table);
#endif
};
} // namespace cellphonetype

View File

@@ -92,9 +92,6 @@ namespace textinput {
EVENT_RELEASE
};
#ifdef TIINPUTFORM_IMPLEMENTATION
virtual void init();
#else
virtual void init() { // 0x10
for (int i = 0; i < GUI_POINTS_MAX; i++) {
mbPointed[i] = false;
@@ -103,7 +100,6 @@ namespace textinput {
mFlightDuration[i] = 0;
}
}
#endif
GUIComponent(u32 id)
: GUIInterface(), mbInitialize(false), mDraggingButton(0xFFFF), mID(id), mbTriggerTarget(false), mpManager(NULL), mpListener(NULL) {

View File

@@ -11,9 +11,6 @@ namespace textinput {
namespace input {
class HKBManager {
public:
#ifdef TIMANAGER_IMPLEMENTATION
void ClearState();
#endif
static HKBManager& getInstance() { return sInstance; }
void Initialize();
@@ -22,26 +19,6 @@ namespace textinput {
u32 GetModifierState() const;
void SetModifierState(u32, u32);
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
class KeySet {
public:
u8 GetKey() const;
wchar_t GetWChar() const;
bool IsValid() const;
KeySet GetNext() const;
KeySet(const KeySet& other)
: mpManager(other.mpManager), mKind(other.mKind), mIndex(other.mIndex), mDevice(other.mDevice), mCharacter(other.mCharacter) {}
private:
const HKBManager* mpManager;
u8 mKind;
s8 mIndex;
u8 mDevice;
u16 mCharacter;
};
KeySet GetTriggeredKeySet() const;
KeySet GetRepeatedKeySet() const;
void SetForceModifierState(u32 mask, u32 state);
#else
class KeySet {
private:
keyboard::cellphonetype::PaneNameToCharCode* pPaneNameToCharCode; // 0x00
@@ -50,7 +27,6 @@ namespace textinput {
u16 uType; // 0x28
};
#endif
private:
u8 unk_0x00[0xFC];

View File

@@ -8,37 +8,16 @@ namespace textinput {
class Manager;
namespace keyboard {
namespace hwkey {
#ifdef TIMANAGER_IMPLEMENTATION
class HWKeyboard : public CommandSender {
#else
class HWKeyboard : CommandSender {
#endif
public:
HWKeyboard(Manager *);
#ifdef TIMANAGER_IMPLEMENTATION
inline ~HWKeyboard();
#else
~HWKeyboard();
#endif
#ifdef TIMANAGER_IMPLEMENTATION
void setLanguage(Destination destination, Language language);
#endif
virtual void init();
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
wchar_t convertWCCode(wchar_t code) const;
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
#else
virtual void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
#endif
virtual bool updateInput(input::HKBManager& hkbManager);
#ifdef TIINPUTFORM_IMPLEMENTATION
void resetQuoteState() { mbSingleQuoteClosing = 0; mbDoubleQuoteClosing = 0; }
#endif
private:
void updateShift(input::HKBManager& hkbManager);
void controlKeyTriggeredHandler(input::HKBManager);
@@ -47,13 +26,8 @@ namespace textinput {
Manager* mpManager; // 0x10
u8 field_0x14; // 0x14
#ifdef TIINPUTFORM_IMPLEMENTATION
u8 mbSingleQuoteClosing;
u8 mbDoubleQuoteClosing;
#else
u8 field_0x15; // 0x15
u8 field_0x16; // 0x16
#endif
};

View File

@@ -13,43 +13,11 @@
#include "tiZiString.h"
#include "tiSEId.h"
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
extern "C" wchar_t KPRGetChar(KPRQueue* queue);
extern "C" void KPRPutChar(KPRQueue* queue, wchar_t character);
extern "C" void KPRClearQueue(KPRQueue* queue);
extern "C" void KPRInitRegionUS();
extern "C" u8 KPRLookAhead(KPRQueue* queue, wchar_t* character, wchar_t* combining);
#endif
namespace textinput {
#ifdef TIMANAGER_IMPLEMENTATION
class Manager;
#endif
namespace inputform {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class Base;
class EventHandler;
class LayoutByNW4R;
#endif
class EditBuffer {
#ifdef TIMANAGER_IMPLEMENTATION
friend class textinput::Manager;
public:
EditBuffer() : mpString(NULL), mpUnfixString(NULL), mpZiString(NULL), mpAllocator(NULL) {}
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
friend class LayoutByNW4R;
friend class Base;
#endif
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void create(MEMAllocator* allocator);
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual ~EditBuffer();
#else
~EditBuffer();
#endif
private:
void* mpString; // 0x04
@@ -59,27 +27,6 @@ namespace textinput {
};
class DeadKeyStream {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
public:
DeadKeyStream() { KPRInitRegionUS(); init(); }
static wchar_t ToCombineClass(Language language, wchar_t code);
static wchar_t ToIndependentClass(wchar_t code);
inline wchar_t getChar();
void init();
u8 lookAhead() { return KPRLookAhead(&mKPRQueue, NULL, NULL); }
void putChar(wchar_t character) { KPRPutChar(&mKPRQueue, character); }
bool isEmpty() const { return mKPRQueue.oCount == 0; }
void clear() { KPRClearQueue(&mKPRQueue); }
private:
#ifdef TIMANAGER_IMPLEMENTATION
friend class textinput::Manager;
#endif
static bool sbCompatibleFilterEnabled;
static inline bool isCompatible(wchar_t character);
#elif defined(TI_PC_KEYBOARD_IMPLEMENTATION)
public:
static wchar_t ToIndependentClass(wchar_t code);
#endif
private:
KPRQueue mKPRQueue; // 0x00
};
@@ -128,52 +75,13 @@ namespace textinput {
// TODO - location
class RowInfoManager {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
friend class LayoutByNW4R;
friend class Base;
public:
RowInfoManager(u16 maxLength) : mpInfo(NULL), mMaxLength(maxLength), mpAllocator(NULL) {}
void init();
~RowInfoManager();
#endif
private:
Info_* mpInfo; // 0x00
u16 mMaxLength; // 0x04
MEMAllocator* mpAllocator; // 0x08
};
#ifdef TISIGNWINDOW_IMPLEMENTATION
bool isAtokActive() const;
#endif
virtual ~Base();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
Base(Manager* manager);
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onCommand(INPUT_COMMAND command, void* data);
void setCursorPos(tistring::Decolated* string, u32 pos);
void calcCursorTimer();
bool isAtokActive() const;
bool isVacancy() const;
void dirtyCacheAll();
tistring::Decolated* getCurrentString(bool inputting);
void moveCandidateToIdx(s32 index);
void onPressDownHWKB();
void onPressLeftHWKB();
void onPressRightHWKB();
void toggleAtokMode_(u8 operation);
void onSpaceKeyHWKB(u32 modifiers);
void onHKBCtrlCode(HVKCode code, u32 modifiers);
void confirmInput_();
void confirmInputting_(wchar_t character, bool direct, u16 letterMode, bool confirmOnly, void* holdingKey);
void inputCharZi_(wchar_t character, u32 modifiers);
void inputCharDefault_(wchar_t character, u32 modifiers);
void inputInputting_(wchar_t character);
inline bool hasZiPredictions() const;
inline bool usesZiPrediction() const;
inline void resetPredictionContext();
inline void resetInputRelation();
#endif
virtual void create(MEMAllocator* allocator, EditBuffer* editBuffer);
@@ -229,12 +137,7 @@ namespace textinput {
virtual void enableSpaceByRight(bool rightWithSpace);
virtual void onClose();
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
tistring::WithAtok* getCurrentString(bool fixed);
virtual bool canConvert() { return getCurrentString(false) == mpUnfixString; }
#else
virtual bool canConvert();
#endif
virtual void setString(const wchar_t* string);
@@ -264,10 +167,6 @@ namespace textinput {
virtual void onSE(sound::SE seId);
#ifdef MYTIMANAGER_IMPLEMENTATION
void dirtyCacheAll();
#endif
virtual void clear();
virtual u32 calcCursorPos(f32 x, f32 y);
@@ -284,21 +183,8 @@ namespace textinput {
virtual void makeUpCursorPos(CursorPos* cursorPos, u32 pos, s32 startLine, s32 endLine);
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
protected:
#if !defined(TIINPUTFORM_IMPLEMENTATION) && !defined(TIMANAGER_IMPLEMENTATION)
void setCursorPos(tistring::Decolated* string, u32 pos);
void calcCursorTimer();
#endif
void resetRelation();
#else
private:
#endif
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
nw4r::ut::Rect mRect;
#else
Rect mRect;
#endif
Rect mRect; // 0x120
nw4r::math::MTX34 mMtx; // 0x130
Destination meDestination; // 0x160
tistring::Decolated* mpString; // 0x164
@@ -306,9 +192,6 @@ namespace textinput {
tistring::WithZi* mpZiString; // 0x16C
InputMode meInputMode; // 0x170
PredictMode mePredictMode; // 0x174
#ifdef TIMANAGER_IMPLEMENTATION
friend class textinput::Manager;
#endif
bool mbPredictOn; // 0x178
bool mbDoWordWrap; // 0x179
bool mbRightWithSpace; // 0x17A
@@ -344,14 +227,7 @@ namespace textinput {
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
friend class EventHandler;
inline const nw4r::lyt::Pane* getLanguageTextPane() const;
#endif
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
LayoutByNW4R(textinput::Manager*, nw4r::lyt::MultiArcResourceAccessor*, const char*, EventObserver*, const char*);
#endif
~LayoutByNW4R();
virtual void init();
@@ -366,9 +242,6 @@ namespace textinput {
virtual nw4r::math::VEC2 getScale() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void updateRepeatInput(u32 trig, u32 hold);
#endif
virtual void updateInputCommon(int chan, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(textinput::input::HKBManager& hkbManager);
@@ -379,37 +252,10 @@ namespace textinput {
virtual void setRootPaneScaleFor16x9();
virtual void setRootPaneScaleFor4x3();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual void onSE(sound::SE seId);
#endif
virtual void visibleSeparator(bool flag);
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
protected:
const void* mpLayoutData;
const void* mpLanguageData;
const char* mpFontName;
bool mbUpVisible;
bool mbDownVisible;
bool mbRepeat;
nw4rmanager::TiEventHandler* mpInputEventHandler;
nw4r::ut::ResFont mFont;
int mUpRepeat;
int mDownRepeat;
int mLeftRepeat;
int mRightRepeat;
int mDeleteRepeat;
int mConfirmRepeat;
u32 mRepeatButtons;
#else
private:
#ifdef MYTIMANAGER_IMPLEMENTATION
u8 unk_0x2C0[0x48];
#else
u8 unk_0x2C0[0x4C];
#endif
#endif
};
}
typedef inputform::LayoutByNW4R InputForm;

View File

@@ -8,41 +8,17 @@ namespace textinput {
class KeyboardBase : public CommandSender {
public:
#ifdef TIMANAGER_IMPLEMENTATION
KeyboardBase() : meLanguage(JP) {}
#endif
virtual ~KeyboardBase() {}
#if !defined(TI_PC_KEYBOARD_IMPLEMENTATION) && !defined(TIMANAGER_IMPLEMENTATION) && !defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void create(MEMAllocator* alloc) override;
virtual void init() override;
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual void sendCommand(u32 command, void*) override;
#endif
#if !defined(TIMANAGER_IMPLEMENTATION) && !defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void updateFromReceiver(u32, void*) override;
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void onKey(u32, void*);
#else
virtual void onKey(u32);
#endif
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
virtual int getType();
#else
virtual void getType();
#endif
virtual void setLanguage(Language language);
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
#ifdef TISIGNWINDOW_IMPLEMENTATION
virtual Language getLanguage() const;
#else
virtual Language getLanguage() const { return meLanguage; }
#endif
virtual void update() {}
#else
virtual Language getLanguage() const;
virtual void update();
#endif
virtual void onActive();
protected:

View File

@@ -19,10 +19,6 @@ namespace textinput {
bool isHoldingShift() const {
return isHWPressedShift() || isPressedShiftB();
}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
u8 isCapsLock() const { return mbCpasLock; }
void setPressedShiftB(bool pressed) { mbPressedShiftB = pressed; }
#endif
u8 isHWPressedShift() const { return mbPressedShift; }
u8 isPressedShiftB() const { return mbPressedShiftB; }
void setHWPressedShift(const u8& arg) { mbPressedShift = arg; }

View File

@@ -28,20 +28,11 @@ namespace textinput {
virtual void onEvent(nw4r::lyt::Pane* pane, u32 event) {} // 0x10
virtual void onSE(sound::SE seId) {}
#ifdef TIMANAGER_IMPLEMENTATION
virtual void onOK();
virtual void onCancel();
virtual void onOutOfLength();
#else
virtual void onOK() { printf("OK!\n"); }
virtual void onCancel() { printf("Cancel!\n"); }
virtual void onOutOfLength() { printf("OutOfLength\n"); }
#endif
};
#ifdef TIMANAGER_IMPLEMENTATION
namespace predictlang { class LayoutByNW4R; }
#endif
class Manager : public Base {
public:
Manager(MEMAllocator* allocator, nw4r::lyt::MultiArcResourceAccessor* multiArc, textinput::EventObserver* event);
@@ -65,9 +56,6 @@ namespace textinput {
virtual void setLanguage(Language language);
virtual Language getLanguage() const { return meLanguage; }
#ifdef MYTIMANAGER_IMPLEMENTATION
Language getLanguageForMemo() const { return meLanguage; }
#endif
virtual void setDestination(Destination destination);
@@ -78,44 +66,12 @@ namespace textinput {
virtual void setAspectRatio(bool b4x3);
#ifdef MYTIMANAGER_IMPLEMENTATION
MEMAllocator* getAllocatorForMemo() const { return mpAllocator; }
inputform::EditBuffer* getEditBufferForMemo() const { return mpEditBuffer; }
void setEditBufferForMemo(inputform::EditBuffer* editBuffer) { mpEditBuffer = editBuffer; }
void setHWKeyboardForMemo(keyboard::hwkey::HWKeyboard* keyboard) { mpHWKeyboard = keyboard; }
nw4r::lyt::MultiArcResourceAccessor* getMultiArcForMemo() const { return mpMultiArcResourceAccessor; }
EventObserver* getEventObserverForMemo() const { return mpEventObserver; }
InputForm* getInputFormForMemo() const { return mpInputForm; }
void setInputFormForMemo(InputForm* inputForm) { mpInputForm = inputForm; }
toolbar::LayoutByNW4R* getToolBarForMemo() const { return mpToolBar; }
candidatebox::LayoutByNW4R* getCandidateBoxForMemo() const { return mpCandidateBox; }
void setPCKeyboardForMemo(keyboard::pctype::LayoutByNW4R* keyboard) { mpPCKeyboard = keyboard; }
void setCellPhoneKeyboardForMemo(keyboard::cellphonetype::LayoutByNW4R* keyboard) { mpCellPhoneKeyboard = keyboard; }
void setCandidateBoxForMemo(candidatebox::LayoutByNW4R* candidateBox) { mpCandidateBox = candidateBox; }
void setToolBarForMemo(toolbar::LayoutByNW4R* toolBar) { mpToolBar = toolBar; }
void setPredictLanguageDialogForMemo(void* dialog) { mpPredictLanguageDialog = dialog; }
void setSignWindowForMemo(void* signWindow) { mpSignWindow = signWindow; }
void* getSignWindowForMemo() const { return mpSignWindow; }
keyboard::pctype::LayoutByNW4R* getPCKeyboardForMemo() const { return mpPCKeyboard; }
keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboardForMemo() const { return mpCellPhoneKeyboard; }
Destination getDestinationForMemo() const { return meDestination; }
void initAspect();
#endif
virtual void setSecretInputMode(bool secretInputMode) { mpInputForm->setSecretModeOn(secretInputMode); }
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(TIMANAGER_IMPLEMENTATION)
void enableKSXFilter(bool compatibleFilter);
#endif
virtual void setDefaultPredictionJP(int num, const char** predicts);
virtual void setFixedPredictionJP(int num, const char** predicts);
#ifdef TIMANAGER_IMPLEMENTATION
virtual void setTitleText(wchar_t* titleText);
void initAspect();
#else
virtual void setTitleText(const wchar_t* titleText);
#endif
virtual void start() {}
virtual void end() {}
@@ -160,10 +116,6 @@ namespace textinput {
void enableCompatibleFilter(bool compatibleFilter);
bool isVacancy() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
bool isPredictTurning() const;
void startPredictTurnOn(bool enabled);
#endif
private:
MEMAllocator* mpAllocator; // 0x04
@@ -177,14 +129,9 @@ namespace textinput {
InputForm* mpInputForm; // 0x1C
candidatebox::LayoutByNW4R* mpCandidateBox; // 0x20
toolbar::LayoutByNW4R* mpToolBar; // 0x24
#ifdef TIMANAGER_IMPLEMENTATION
predictlang::LayoutByNW4R* mpPredictLanguageDialog;
keyboard::signwindow::LayoutByNW4R* mpSignWindow;
#else
void* mpPredictLanguageDialog; // 0x28
void* mpSignWindow; // 0x2C
#endif
EventObserver* mpEventObserver; // 0x30
Destination meDestination; // 0x34

View File

@@ -14,22 +14,12 @@ namespace textinput {
class TiEventHandler : public gui::EventHandler {
public:
typedef struct Input {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
u32 controller;
f32 x;
f32 y;
u32 trigger;
u32 hold;
u32 release;
u8 remaining[8];
#else
// todo
u32 field_0x00; // 0x00
u8 dummy[8];
u32 field_0x0C; // 0x0C
u32 field_0x10; // 0x10
u8 dummy2[12];
#endif
} Input;
virtual void onEvent(gui::GUIComponent& comp, u32 event, void* data); // 0x0C
@@ -96,29 +86,11 @@ namespace textinput {
virtual void init() {} // 0x08
virtual void calc(); // 0x0C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void onAnmEvent(AnmPaneEvent) {}
#else
virtual void onAnmEvent(AnmPaneEvent paneEvent);
#endif // 0x10
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual void changeAnimation(u32 id); // 0x14
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isInAnimation() { return mpCurrentAnim != NULL; }
#else
virtual bool isInAnimation();
#endif // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Anim* searchAnimation(u32 id) {
for (Anim* animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, NULL)); animation != NULL;
animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, animation))) {
if (animation->muID == id) return animation;
}
return NULL;
}
#else
virtual Anim* searchAnimation(u32 id);
#endif // 0x1C
virtual bool isInAnimation(); // 0x18
virtual Anim* searchAnimation(u32 id); // 0x1C
virtual ~AnmPane(); // 0x20
@@ -156,11 +128,6 @@ namespace textinput {
class AnimPaneGroup {
public:
#ifdef MYTIINPUTFORM_IMPLEMENTATION
AnimPaneGroup(nw4r::lyt::Group* group) : mpGroup(group) {
nw4r::ut::List_Init(&mAnmPaneList, offsetof(AnmPane, mGroupLink));
}
#endif
virtual void create() {} // 0x08
virtual void init() {} // 0x0C
@@ -214,11 +181,7 @@ namespace textinput {
virtual nw4r::lyt::Pane* get(int i) { return mpaFifo[i]; } // 0x10
virtual nw4r::lyt::Pane* getLast() { // 0x14
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
for (int i = MAX_COUNT-1; i > -1; i--) {
#else
for (int i = MAX_COUNT-1; i > -1; i++) {
#endif
if (mpaFifo[i] != NULL) {
return mpaFifo[i];
}
@@ -263,16 +226,8 @@ namespace textinput {
virtual void setProjectionMtx(); // 0x48
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* pane) { mAnmPaneFifo.push(pane); }
#else
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* paneLastDraw);
#endif // 0x4C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void initPaneLastDrawReceived() { mAnmPaneFifo.init(); }
#else
virtual void initPaneLastDrawReceived();
#endif // 0x50
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* paneLastDraw); // 0x4C
virtual void initPaneLastDrawReceived(); // 0x50
virtual void setVisible(const char* paneName, bool flag); // 0x54
virtual bool isVisible(const char* paneName, bool* result) const; // 0x58

View File

@@ -1,15 +1,8 @@
#ifndef TEXTINPUT_PC_KEYBOARD_H
#define TEXTINPUT_PC_KEYBOARD_H
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
#include "tiPcKeyboardImpl.h"
#else
#include "tiNw4rManager.h"
#include "tiTextInputBase.h"
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
#include "tiKeyboard.h"
#endif
namespace textinput {
class Manager;
@@ -18,29 +11,11 @@ namespace textinput {
namespace pctype {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
class UIObj {
public:
class Listener {
public:
virtual void onEvent(UIObj*, u32, void*);
};
};
#endif
// TODO
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
class Base : public textinput::keyboard::KeyboardBase {
#else
class Base : public CommandSender {
#endif
public:
enum TranslateMode {
TM_00,
#ifdef TIINPUTFORM_IMPLEMENTATION
TM_Kana,
TM_Roman,
#endif
};
enum InputType {
@@ -51,48 +26,6 @@ namespace textinput {
IT_04,
};
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
};
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
virtual void getType() override;
virtual void setLanguage(Language) override;
virtual void onActive() override;
virtual void inputCharCode(u16);
virtual void getState();
virtual bool isShiftOn() const;
virtual bool isCapsOn() const;
virtual bool isABC();
virtual void setABC(bool);
virtual InputMode getABCInputMode() const;
virtual InputMode getAIUInputMode() const;
virtual TranslateMode getTranslateMode() const;
virtual void setTranslateMode(TranslateMode);
virtual void onlyQwerty(bool);
virtual void setLangKeyActive(bool);
virtual void setInputModeJP(bool, u32, u32);
virtual void setInputModeCK(u32);
virtual void refreshState();
virtual void changeABCInputMode(InputMode);
virtual void changeAIUInputMode(InputMode);
virtual void onClose();
virtual void getWCCode(char*);
virtual void getControlKey(char*);
virtual void sendInputWChar(u16, bool);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
#else
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual void init();
@@ -128,72 +61,17 @@ namespace textinput {
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
private:
u8 mKeyboardInputFlags[8];
const void* mpKeyStateTable;
u32 mTranslateMode;
u32 mABCInputMode;
u32 mAIUInputMode;
u32 mCurrentInputType;
u32 mInputState;
const void* mpLanguageData;
#ifdef TIINPUTFORM_IMPLEMENTATION
MEMAllocator* mpAllocator;
#endif
bool mbOnlyQwerty;
bool mbLanguageKeyActive;
u16 mKeyboardFlags;
void* mpInputSettings;
void* mpCurrentKeyState;
public:
#ifdef TIINPUTFORM_IMPLEMENTATION
bool isQwertyOnly() const { return mbOnlyQwerty; }
bool isLanguageKeyActive() const { return mbLanguageKeyActive; }
#endif
u32 getTranslateModeForMemo() const { return mTranslateMode; }
u32 getABCInputModeForMemo() const { return mABCInputMode; }
u32 getAIUInputModeForMemo() const { return mAIUInputMode; }
#endif
};
// TODO
class LayoutByNW4R : public Base, public nw4rmanager::Layout
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
, public UIObj::Listener
#endif
{
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
// TODO - ...
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
virtual void draw();
virtual void calc();
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual void onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#ifdef TIINPUTFORM_IMPLEMENTATION
bool hasLineFeedButton() const { return mbLineFeedButton; }
private:
void* mpPredictLanguageDialog;
void* mpSignWindow;
bool mbLineFeedButton;
public:
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
};
} // namespace pctype
@@ -202,5 +80,4 @@ namespace textinput {
} // namespace textinput
#endif
#endif // TEXTINPUT_HW_KEYBOARD_H

View File

@@ -1,394 +0,0 @@
#ifndef TEXTINPUT_PC_KEYBOARD_IMPL_H
#define TEXTINPUT_PC_KEYBOARD_IMPL_H
#include "tiKeyboard.h"
#include "tiNw4rManager.h"
#include "tiPkData.h"
namespace textinput {
class Manager;
namespace predictlang {
class LayoutByNW4R;
}
namespace keyboard {
namespace signwindow {
class LayoutByNW4R;
}
}
namespace keyboard {
namespace signwindow {
#ifndef TISIGNWINDOW_IMPLEMENTATION
#ifdef TIMANAGER_IMPLEMENTATION
struct LanguageDependencyData;
class Base : public KeyboardBase {
public:
Base(Manager* manager) : mpAllocator(NULL), mpManager(manager) {}
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual int getType();
virtual void setLanguage(Language language);
virtual bool isLocked();
virtual void setPage(u8 page);
virtual u8 getPage();
virtual void movePrevSignPage();
virtual void moveNextSignPage();
virtual void close();
private:
u32 mInputState;
const LanguageDependencyData* mpLanguageData;
MEMAllocator* mpAllocator;
Manager* mpManager;
};
class EventHandler;
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mbActive(false), mbInput(false), mpEventHandler(NULL), mpCaller(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onKey(u32 event, void* data);
virtual void movePrevSignPage();
virtual void moveNextSignPage();
virtual void close();
virtual void draw();
virtual void open(KeyboardBase* keyboard, bool repeat);
virtual bool isActive();
virtual void onChangeAnmState(AnmEvent event, nw4rmanager::AnmPane* pane, nw4rmanager::Anim* animation);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(input::HKBManager& hkb);
virtual void throwReleaseForAll();
virtual void resetAnmSignWindow();
virtual void setSignKeyTop(u16 first, u16 count);
virtual void setPageNumber(u16 page);
virtual void endToClose();
virtual void startToInput();
virtual void movePrevSignWindow();
virtual void moveNextSignWindow();
private:
bool mbActive;
bool mbInput;
EventHandler* mpEventHandler;
KeyboardBase* mpCaller;
};
#else
class Base : public KeyboardBase {
public:
virtual bool isLocked();
virtual void setPage(u8 page);
virtual u8 getPage();
virtual void movePrevSignPage();
virtual void moveNextSignPage();
virtual void close();
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
virtual void draw();
virtual void open(KeyboardBase* keyboard, bool repeat);
virtual bool isActive();
};
#endif
#endif
}
namespace pctype {
struct GridKey {
char paneName[18];
wchar_t codes[4];
};
struct ControlKey {
char paneName[20];
u32 key;
};
struct VisiblePanes {
u16 visibleCount;
u16 hiddenCount;
const char* visible[24];
const char* hidden[24];
};
struct Ablaut {
wchar_t code;
wchar_t alternatives[7];
};
struct LanguageData {
const PaneNameToCharCodeWithModeAscii* ascii;
const GridKey* grid;
const ControlKey* controls;
const VisiblePanes* panes;
const Ablaut* ablaut;
};
class Base : public KeyboardBase {
public:
enum TranslateMode {
TM_Direct,
TM_Roman,
TM_Kana
};
enum InputMode {
IM_Direct,
IM_01,
IM_02,
IM_03,
IM_04,
IM_05,
IM_Hiragana,
IM_Katakana
};
enum InputType {
IT_00,
IT_01,
IT_02,
IT_03,
IT_04
};
struct State {
bool rejected;
u8 inputFlags[7];
};
class KeyState {
public:
void refresh_();
void refreshText(nw4r::lyt::Pane* root);
void setABCFlag(u32 flags);
u32 getABCFlag() const { return abcFlags & ~15; }
u32 getABCMode() const { return abcFlags & 15; }
wchar_t getWCCode(u32 index);
wchar_t getWCCode(char* paneName) NO_INLINE;
void setABCMode(u32 mode) {
if ((abcFlags & 15) != mode) {
abcFlags = (abcFlags & ~15) | (mode & 15);
refresh_();
}
}
void setAIUMode(u32 mode) {
if ((aiuFlags & 15) != mode) {
aiuFlags = (aiuFlags & ~15) | (mode & 15);
refresh_();
}
}
u32 abcFlags;
u32 inputType;
u32 aiuFlags;
Language language;
const LanguageData* data;
Base* owner;
};
#ifdef TIMANAGER_IMPLEMENTATION
Base(Manager* manager) {
mKeyState.abcFlags = 0;
mKeyState.inputType = 0;
mKeyState.aiuFlags = 0;
mKeyState.language = USA;
mKeyState.data = NULL;
mKeyState.owner = this;
mpAllocator = NULL;
mbOnlyQwerty = false;
mpManager = manager;
}
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual inline void init();
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual int getType();
virtual void setLanguage(Language language);
virtual void onActive();
virtual void inputCharCode(wchar_t code);
virtual State* getState();
virtual bool isShiftOn() const;
virtual bool isCapsOn() const;
virtual bool isABC();
virtual void setABC(bool abc);
virtual InputMode getABCInputMode() const;
virtual InputMode getAIUInputMode() const;
virtual TranslateMode getTranslateMode() const;
virtual void setTranslateMode(TranslateMode mode);
virtual void onlyQwerty(bool only);
virtual void setLangKeyActive(bool active);
virtual void setInputModeJP(bool, u32, u32);
virtual void setInputModeCK(u32);
virtual void refreshState();
virtual void changeABCInputMode(InputMode mode);
virtual void changeAIUInputMode(InputMode mode);
virtual void onClose();
virtual wchar_t getWCCode(char* paneName);
virtual u32 getControlKey(char* paneName);
virtual void sendInputWChar(wchar_t code, bool repeat);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
protected:
State mState;
const LanguageData* mpInitialLanguageData;
KeyState mKeyState;
MEMAllocator* mpAllocator;
bool mbOnlyQwerty;
bool mbLanguageKeyActive;
Manager* mpManager;
};
class LayoutByNW4R;
class AnmPane;
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpKeyboard(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent* component, u32 event, Input* input);
private:
LayoutByNW4R* mpKeyboard;
};
class UIObj : public gui::EventHandler {
public:
class Listener {
public:
virtual void onEvent(UIObj*, u32, void*) = 0;
};
UIObj(u32 id, LayoutByNW4R* layout, Listener* listener) : mId(id), mpLayout(layout), mpListener(listener) {}
virtual ~UIObj();
virtual void onEvent(gui::GUIComponent& component, u32 event, void* data);
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
protected:
u32 mId;
LayoutByNW4R* mpLayout;
Listener* mpListener;
};
class UIModifierButton : public UIObj {
public:
UIModifierButton(u32 id, LayoutByNW4R* layout, Listener* listener);
inline void Create(nw4rmanager::Layout* layout, const char* pane, const char* bounding);
inline void SetState(bool enabled, u32 inactiveAnimation);
virtual ~UIModifierButton();
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
gui::PaneComponent* mpPaneComponent;
gui::PaneComponent* mpBoundingComponent;
AnmPane* mpAnimation;
bool mbOn;
};
class UIModePanel : public UIObj {
public:
UIModePanel(u32 id, LayoutByNW4R* layout, Listener* listener);
virtual ~UIModePanel();
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
void Create(nw4rmanager::Layout* layout);
u32 mMode;
gui::PaneComponent* mpPaneComponents[5];
gui::PaneComponent* mpBoundingComponents[5];
AnmPane* mpAnimations[5];
nw4r::lyt::Pane* mpEnglishText;
nw4r::lyt::Pane* mpHangulText;
nw4r::lyt::Pane* mpModeSelect;
GXTexObj mDirectTexture;
GXTexObj mPinyinTexture;
GXTexObj mEnglishTexture;
GXTexObj mHangulTexture;
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
public:
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpKeyboardEventHandler(NULL),
mShiftButton(1, this, this), mCapsButton(0, this, this), mModePanel(2, this, this) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual void setLanguage(Language language);
virtual void onActive();
virtual void inputCharCode(wchar_t code);
virtual void setABC(bool abc);
virtual void setTranslateMode(TranslateMode mode);
virtual void onlyQwerty(bool only);
virtual void setLangKeyActive(bool active);
virtual void setInputModeJP(bool abc, u32 abcMode, u32 aiuMode);
virtual void setInputModeCK(u32 mode);
virtual void refreshState();
virtual void onClose();
virtual void sendInputWChar(wchar_t code, bool repeat);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void draw();
virtual void calc();
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog);
virtual void setSignWindow(signwindow::LayoutByNW4R* window);
virtual void setLineFeedButton(bool visible);
virtual void setPredictLanguageButton(bool visible);
virtual void setSignWindowButton(bool visible);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(input::HKBManager& hkb);
virtual void changeAnimationAllToNormal();
virtual void throwReleaseForAll();
virtual void cancelStateFocusIn();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void updateDakuten();
virtual void initLayout();
virtual void onEvent(UIObj* object, u32 event, void* data);
void onPressedCaps();
void onPressedShift(bool shift);
void onReleasedShift();
void createAnmPane_(MEMAllocator* allocator);
private:
EventHandler* mpKeyboardEventHandler;
predictlang::LayoutByNW4R* mpPredictDialog;
signwindow::LayoutByNW4R* mpSignWindow;
bool mbLineFeed;
UIModifierButton mShiftButton;
UIModifierButton mCapsButton;
UIModePanel mModePanel;
};
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer), mAnimation(0) {}
virtual void init();
virtual void changeAnimation(u32 animation);
virtual ~AnmPane();
virtual int getState() const { return mAnimation; }
virtual int getKeyType() const { return mKeyType; }
protected:
int mAnimation;
int mKeyType;
};
class NormalButtonAnmPane : public AnmPane {
public:
NormalButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 0; }
virtual ~NormalButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
class ShiftCapsAnmPane : public AnmPane {
public:
ShiftCapsAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer), mbOn(false) { mKeyType = 1; }
virtual ~ShiftCapsAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
bool isFocused() const;
private:
bool mbOn;
};
class ToggleButtonAnmPane : public AnmPane {
public:
ToggleButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 2; }
virtual ~ToggleButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
class OnOffButtonAnmPane : public AnmPane {
public:
OnOffButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 3; }
virtual ~OnOffButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
}
}
}
#endif

View File

@@ -14,17 +14,11 @@ namespace textinput {
class Base : public CommandSender {
public:
#if defined(TI_PREDICTLANG_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
Base(Manager* manager) : mePredictMode(inputform::Base::PM_USEn), mpAllocator(NULL), mpManager(manager) {}
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual ~Base();
virtual void init();
virtual void create(MEMAllocator* allocator) override;
#else
virtual void create(MEMAllocator* allocator) override { mpAllocator = allocator; }
#endif
virtual void setPredictMode(inputform::Base::PredictMode mode) { mePredictMode = mode; }
protected:
@@ -38,11 +32,7 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(resAccessor, layoutName, observer), mbActive(false), mbInput(false),
mpEventHandler(NULL), meDestination(DST_US), mpCaller(NULL) {}
#elif defined(TI_PREDICTLANG_SAMPLE_CLASS)
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_prdicSelWidw_a.brlyt", observer), mbActive(false), mbInput(false),
mpEventHandler(NULL), meDestination(DST_US), mpCaller(NULL) {}
@@ -78,21 +68,12 @@ namespace textinput {
keyboard::KeyboardBase* mpCaller; // 0xD4
};
#if defined(TI_PREDICTLANG_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
#ifdef TIMANAGER_IMPLEMENTATION
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, resAccessor, observer, layoutName) {}
#else
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual ~Sample();
#else
virtual ~Sample() {}
#endif
};
#endif

View File

@@ -1,134 +0,0 @@
#ifndef TEXTINPUT_SIGN_WINDOW_H
#define TEXTINPUT_SIGN_WINDOW_H
#include "tiKeyboard.h"
#include "tiNw4rManager.h"
#include "tiSwData.h"
namespace textinput {
class Manager;
namespace keyboard {
namespace signwindow {
struct LanguageDependency {
u8 count;
const PaneNameToCharCodeInSignMode* keys;
};
class Base : public KeyboardBase {
public:
virtual ~Base();
virtual void create(MEMAllocator*) override;
virtual void init() override;
virtual void onKey(u32, void*) override;
virtual bool isLocked();
virtual void setPage(u8);
virtual u8 getPage();
virtual void movePrevSignPage();
virtual void moveNextSignPage();
virtual void close();
virtual int getType() override;
virtual void setLanguage(Language) override;
protected:
u8 mInputFlags;
bool mbLocked;
bool mbRepeat;
u8 muPage;
const LanguageDependency* mpLanguageDependency;
MEMAllocator* mpAllocator;
Manager* mpManager;
};
class EventHandler;
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator*) override;
virtual void init() override;
virtual void onKey(u32, void*) override;
virtual void movePrevSignPage() override;
virtual void moveNextSignPage() override;
virtual void close() override;
virtual void draw() override;
virtual void open(KeyboardBase*, bool);
virtual bool isActive();
virtual void onChangeAnmState(AnmEvent, nw4rmanager::AnmPane*, nw4rmanager::Anim*) override;
virtual bool updateInput(int, f32, f32, u32, u32, u32, void*) override;
virtual bool updateInput(input::HKBManager&) override;
virtual void throwReleaseForAll();
virtual void resetAnmSignWindow();
virtual void setSignKeyTop(u16, u16);
virtual void setPageNumber(u16);
virtual void endToClose();
virtual void startToInput();
virtual void movePrevSignWindow();
virtual void moveNextSignWindow();
bool mbActive;
bool mbInput;
EventHandler* mpEventHandler;
KeyboardBase* mpKeyboard;
};
class Sample : public LayoutByNW4R {
public:
virtual ~Sample();
};
class EventHandler : public nw4rmanager::TiEventHandler {
public:
explicit EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent*, u32, Input*) override;
LayoutByNW4R* mpLayoutByNW4R;
};
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: nw4rmanager::AnmPane(pane, observer), muAnimation(0) {}
inline virtual ~AnmPane();
virtual void init() override;
virtual void changeAnimation(u32) override;
virtual u32 getKeyType() const;
protected:
s32 muAnimation;
u32 muKeyType;
};
class CellPhoneSignAllAnmPane : public AnmPane {
public:
CellPhoneSignAllAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: AnmPane(pane, observer) { muKeyType = 0; }
virtual ~CellPhoneSignAllAnmPane();
virtual void init() override;
virtual void onAnmEvent(AnmPaneEvent) override;
};
class CellPhoneSignScrollAnmPane : public AnmPane {
public:
CellPhoneSignScrollAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: AnmPane(pane, observer) { muKeyType = 1; }
virtual ~CellPhoneSignScrollAnmPane();
virtual void init() override;
virtual void onAnmEvent(AnmPaneEvent) override;
};
class CellPhoneSignButtonPane : public AnmPane {
public:
CellPhoneSignButtonPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: AnmPane(pane, observer) { muKeyType = 2; }
virtual ~CellPhoneSignButtonPane();
virtual void init() override;
virtual void onAnmEvent(AnmPaneEvent) override;
};
}
}
}
#endif

View File

@@ -3,9 +3,6 @@
#include <revolution/types.h>
#include <revolution/mem/allocator.h>
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#include <revolution/kpr.h>
#endif
namespace textinput {
namespace tistring {
@@ -39,11 +36,7 @@ namespace textinput {
virtual wchar_t* getWCString() const { return mpszString; }
virtual void setCandidate(wchar_t candidate) { mwcCandidate = candidate; }
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual wchar_t getCandidate() const { return mwcCandidate; }
#else
virtual wchar_t getCandidate() { return mwcCandidate; }
#endif
virtual bool hasCandidate() const;
virtual wchar_t getLastWChar();
@@ -61,71 +54,14 @@ namespace textinput {
};
class KanaStream {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
public:
KPRQueue mQueue;
wchar_t mPending;
wchar_t mOutput[5];
#else
private:
u8 field_0x00[0x24];
#endif
};
class Decolated : public StringBase {
public:
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
Decolated(u16 maxLen) : StringBase(maxLen), mCursorStart(0), mCursorEnd(0), mbSustain(false), mTranslateMode(0) { initKanaConverter(); }
#else
Decolated(u16 maxLen) : StringBase(maxLen), field_0x18(0), field_0x1C(0), field_0x20(0), field_0x24(0) { initKanaConverter(); }
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual ~Decolated();
enum TranslateMode { TM_Direct, TM_Kana, TM_Roman, TM_Hangul };
virtual void clear();
virtual void set(const wchar_t* string);
virtual void setLength(u16 length);
void setTranslateMode(TranslateMode mode);
TranslateMode getTranslateMode() const { return static_cast<TranslateMode>(mTranslateMode); }
void inputString(const wchar_t* string, TranslateMode mode);
virtual void inputChar(wchar_t ch);
virtual void inputString(const wchar_t* string);
virtual void deleteChar();
virtual void backSpace();
virtual void confirm(const wchar_t* string);
virtual bool moveCursorRight();
virtual bool moveCursorLeft();
virtual void setCursorPos(u32 pos);
virtual void onSustain();
virtual void offSustain();
virtual bool isOnSustain();
virtual u32 getCursorPos() const;
virtual void getCursorPos(u32* start, u32* end);
virtual bool canBackSpace();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual bool deleteForward();
#else
virtual void deleteForward();
#endif
virtual void getSelected(u32& start, u32& end);
virtual wchar_t getWCharAtCursor();
virtual void replaceAtCursor(wchar_t ch);
virtual bool isDakuten();
virtual void converDakuten();
virtual bool isHandaku();
virtual void converHandaku();
virtual void convertAll();
virtual bool isSmall();
virtual void converSmall();
virtual bool atTheBeginningOfASentence();
virtual void initKanaConverter();
virtual wchar_t* getKanaBuffer();
virtual bool isKanaFix() const;
virtual void confirmKana();
virtual void clearKana();
virtual void EnableKSXFilter(bool enable);
#else
virtual void inputChar();
virtual void inputString();
virtual void deleteChar();
@@ -159,75 +95,15 @@ namespace textinput {
virtual void clearKana();
virtual void EnableKSXFilter();
#endif
private:
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
u32 mCursorStart;
u32 mCursorEnd;
bool mbSustain;
u32 mTranslateMode;
#else
u32 field_0x18; // 0x18
u32 field_0x1C; // 0x1C
u8 field_0x20; // 0x20
u32 field_0x24; // 0x24
#endif
KanaStream mKanaStream; // 0x28
};
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class WithAtok : public Decolated {
public:
WithAtok(u16 maxLength) : Decolated(maxLength) {}
virtual ~WithAtok();
virtual void pushBack(wchar_t ch);
virtual void popBack();
virtual void inputChar(wchar_t ch);
virtual void backSpace();
virtual void confirm(const wchar_t* string);
virtual bool moveCursorRight();
virtual bool moveCursorLeft();
virtual void getCursorPos(u32* start, u32* end);
struct DrawInfo {
const wchar_t* string;
u32 start;
u32 end;
u32 selectedStart;
u32 selectedEnd;
};
virtual bool isFix();
virtual void setFix(bool fix);
virtual void initConverting();
virtual bool isConverting();
virtual wchar_t* getConfirmedWCString() const;
virtual int getCurrentNumPredicted();
virtual void getPredicted(int index, wchar_t* string);
virtual void commitPredicted(int index);
virtual void setSelectedCandidate(s32 index);
virtual bool isCandidateSelected();
virtual s32 getSelectedCandidate();
virtual void init();
virtual void setInputting(wchar_t ch);
virtual void getDrawString(DrawInfo& info);
virtual void openDictionary(void* atok, int atokSize, void* apot, int apotSize, void* nintendo, int nintendoSize);
virtual void closeDictionary();
virtual bool hasConfirmedString();
virtual void enableConfirmedString(bool enable);
virtual void startConverting();
virtual bool isDictionaryOpened();
virtual void changeKanaMode(bool kana);
virtual wchar_t getInputStringLength();
virtual void resetRelation();
virtual void setFixMode(bool fixed);
virtual void setFixPrediction(int count, const char** predictions);
virtual void setDefaultPrediction(int count, const char** predictions);
virtual s16 getSelectedConverting();
virtual s32 getFixedPredictionNum();
};
#else
class WithAtok : public StringBase {};
#endif
}
}

View File

@@ -6,17 +6,10 @@
#include <nw4r/ut/CharWriter.h>
#include <nw4r/ut/Rect.h>
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#include <string.h>
#endif
namespace textinput {
namespace textdrawer {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class Base : public nw4r::ut::CharWriter {
#else
class Base : nw4r::ut::CharWriter {
#endif
public:
typedef struct ViewPort {
f32 xOrig; // 0x00
@@ -34,23 +27,9 @@ namespace textinput {
} CursorPos;
typedef struct DrawInfo {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
nw4r::ut::Rect rect;
wchar_t character;
#else
u8 unk_0x00[32];
#endif
} DrawInfo;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
Base() : mpDrawAllocator(NULL), mfViewX(0.0f), mfViewY(0.0f), mfViewWidth(0.0f), mfViewHeight(0.0f),
mfVIWidth(640.0f), mbAspect4x3(false), mbDrawClipped(false), muLine(0), mfLineSpacing(0.0f),
mfCharacterSpacing(0.0f), mfFontWidth(0.0f), mfFontHeight(0.0f), mfModifyStartY(0.0f), mfMinScrollY(0.0f),
muDrawStartPos(0), muDrawEndPos(65535), mbSecretMode(false), muDrawModifyStartLine(0), muDrawModifyEndLine(0),
muDrawModifyStartPos(0), muDrawModifyEndPos(0), muCachedStartPos(0), muCachedEndPos(0), mbDrawCache(false),
mfCachedCursorX(0.0f), mfCachedCursorY(0.0f), mfDrawScrollY(0.0f), muCachedCursorPosition(0),
mbCursorCache(false), mbMaintainCursorCache(true) { memset(&mCachedCursor, 0, sizeof(mCachedCursor)); }
#endif
virtual void create(MEMAllocator* allocator);
virtual void draw(CursorPos* cursorPos);
virtual void draw();
@@ -94,80 +73,20 @@ namespace textinput {
virtual u32 getEndPos() const;
// todo
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual void setDrawModifyScopeLine(s32 startLine, s32 endLine);
virtual void setDrawCacheScopeLine(s32 startLine, s32 endLine);
virtual void modifyCursorCache(s32 line, u32 position, f32 x, f32 y, f32 width, f32 height);
#else
virtual void setDrawModifyScopeLine();
virtual void setDrawCacheScopeLine();
virtual void modifyCursorCache();
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual bool isEnableCursorCache() const;
#else
virtual void isEnableCursorCache();
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual u32 getDrawModifyStartLine() const;
virtual u32 getDrawModifyEndLine() const;
#else
virtual void getDrawModifyStartLine();
virtual void getDrawModifyEndLine();
#endif
virtual u32 getDrawCacheStartPos() const;
virtual void dirtyDrawCache();
virtual void dirtyCursorCache();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
protected:
MEMAllocator* mpDrawAllocator;
u8 mDrawConfiguration[0x34];
f32 mfViewX;
f32 mfViewY;
f32 mfViewWidth;
f32 mfViewHeight;
f32 mfVIWidth;
bool mbAspect4x3;
bool mbDrawClipped;
u32 muLine;
f32 mfLineSpacing;
f32 mfCharacterSpacing;
f32 mfFontWidth;
f32 mfFontHeight;
f32 mfModifyStartY;
f32 mfMinScrollY;
u32 muDrawStartPos;
u32 muDrawEndPos;
u32 muDrawCacheStartPos;
#else
private:
u8 unk_0x50[0x78];
#endif
bool mbSecretMode; // 0xC8
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
u32 muDrawModifyStartLine;
u32 muDrawModifyEndLine;
u32 muDrawModifyStartPos;
u32 muDrawModifyEndPos;
u32 muCachedStartPos;
u32 muCachedEndPos;
bool mbDrawCache;
f32 mfCachedCursorX;
f32 mfCachedCursorY;
f32 mfDrawScrollY;
u32 muCachedCursorPosition;
CursorPos mCachedCursor;
bool mbCursorCache;
bool mbMaintainCursorCache;
#elif defined(MYTIINPUTFORM_IMPLEMENTATION)
protected:
u8 mDrawState[0x27];
f32 mfDrawScrollY;
u8 mDrawCacheState[0x14];
#else
u8 unk_0xCC[0x3C];
#endif
};
}
}

View File

@@ -39,10 +39,6 @@ namespace textinput {
f32 y; // 0x08
} Scroll;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
enum HVKCode { HVK_None = 0 };
#endif
class Base {
public :
virtual ~Base() {}
@@ -54,25 +50,11 @@ namespace textinput {
class CommandSender;
class CommandReceiver : public Base {
public:
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
CommandReceiver() { clearSender(); }
virtual ~CommandReceiver();
#endif
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
struct Scroll {
bool absY;
f32 x;
f32 y;
};
#endif
typedef enum INPUT_COMMAND {
INPUT_COMMAND_0 = 0,
INPUT_COMMAND_37 = 37,
} INPUT_COMMAND;
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
struct ChangePredictMode { u32 mode; bool enabled; };
#endif
virtual void clearSender();
virtual void onCommand(INPUT_COMMAND command, void* data);
virtual void addSender(CommandSender* cmdSend);
@@ -86,13 +68,7 @@ namespace textinput {
CommandSender() : mpCommandReceiver(NULL) {}
virtual void setCommandReceiver(CommandReceiver* cmdRecv);
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual void sendCommand(u32 command, void* data) {
if (mpCommandReceiver != NULL) mpCommandReceiver->onCommand(static_cast<CommandReceiver::INPUT_COMMAND>(command), data);
}
#else
virtual void sendCommand(u32, void*);
#endif
virtual void updateFromReceiver(u32, void*) {}
nw4r::ut::Link mLink; // 0x00

View File

@@ -10,7 +10,7 @@ namespace textinput {
namespace toolbar {
class Base {
public:
#if defined(TI_TOOLBAR_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TI_TOOLBAR_SAMPLE_CLASS
Base(Manager* manager) : mQwerty(true), meLanguage(USA), mpAllocator(NULL), mpManager(manager) {}
#endif
@@ -35,11 +35,7 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(resAccessor, layoutName, observer), mpEventHandler(NULL),
mbIsEnableQwertyChg(false) {}
#elif defined(TI_TOOLBAR_SAMPLE_CLASS)
#ifdef TI_TOOLBAR_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_VK_toolbar_a.brlyt", observer), mpEventHandler(NULL),
mbIsEnableQwertyChg(false) {}
@@ -121,21 +117,12 @@ namespace textinput {
KeyType meKeyType; // 0x30
};
#if defined(TI_TOOLBAR_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TI_TOOLBAR_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
#ifdef TIMANAGER_IMPLEMENTATION
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, resAccessor, observer, layoutName) {}
#else
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual ~Sample();
#else
virtual ~Sample() {}
#endif
};
#else
class Sample {};

View File

@@ -7,9 +7,6 @@
namespace textinput {
namespace util {
#ifdef TIINPUTFORM_IMPLEMENTATION
wchar_t HankakuToZenkaku(wchar_t ch);
#endif
wchar_t toWLower(wchar_t ch);
wchar_t toWUpper(wchar_t ch);
@@ -49,11 +46,7 @@ namespace textinput {
public:
Animation() : mfAnimationTime(0.0f), mbInAnimation(false), mbSE(false), mpAnimObserver(NULL) {}
#ifdef TIINPUTFORM_IMPLEMENTATION
virtual void startAnm(f32 start, f32 end, f32 duration, AnimObserver* observer, void* data);
#else
virtual void startAnm(AnimObserver*, f32, f32, f32, void*);
#endif // 0x08
virtual void startAnm(AnimObserver*, f32, f32, f32, void*); // 0x08
virtual void calc(); // 0x0C
virtual f32 getValue(); // 0x10
virtual bool isActive(); // 0x14

View File

@@ -1,71 +1,14 @@
#ifndef TEXTINPUT_ZI_STRING_H
#define TEXTINPUT_ZI_STRING_H
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#include "tiString.h"
#include <eztx.h>
#endif
namespace textinput {
namespace tistring {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class WithZi : public Decolated {
public:
enum PredictLanguage { PL_Default };
enum LetterMode { LM_Lower, LM_Normal, LM_Upper };
WithZi(u16 maxLength) : Decolated(maxLength), mbDictionaryOpen(false), mbContextChanged(false),
mCurrentWordLength(0), mpDictionaries(NULL), mpDictionaryWork(NULL), mInputLength(0),
mCandidateCount(0), mOemDictionaryId(0), mDictionaryLanguage(0xff), mSelectedCandidate(0),
mPredictLanguage(0), mLetterMode(2), mpHoldingKey(NULL), mbKoreanPartialConfirm(false) {}
virtual ~WithZi();
virtual void init();
virtual void setInputting(wchar_t ch);
virtual int getCurrentNumPredicted();
virtual void getPredicted(int index, wchar_t* string);
virtual const wchar_t* getCurrentSelected();
virtual u16 getInputStringLength();
virtual void setSelectedCandidate(s32 index);
virtual bool isFix();
virtual void setPredictLaunguage(PredictLanguage language);
virtual void changeLetterMode(LetterMode mode);
virtual void ChangeDictionaryLanguage(u8 language);
virtual void setCellPhoneHoldingkey(void* key);
virtual void setElementBuffer();
virtual u8 getPredictLanguage();
s32 getSelectedCandidateIndex() const { return mSelectedCandidate; }
void openDictionary(void* ziDict, void* ziOemDict);
void setCurrentWord(const wchar_t* string);
void update();
const wchar_t* getCurrentInput();
s32 getCurrentInput(wchar_t* buffer, u32 length);
void clearCandidates();
void partialConfirmForKR();
private:
EZTXGetParam mSearch;
u32 mSearchState;
bool mbDictionaryOpen;
bool mbContextChanged;
u32 mCurrentWordLength;
EZTXLanguageEntry* mpDictionaries;
void* mpDictionaryWork;
u16 mInputLength;
s32 mCandidateCount;
u32 mOemDictionaryId;
u8 mDictionaryLanguage;
s32 mSelectedCandidate;
u32 mPredictLanguage;
u32 mLetterMode;
void* mpHoldingKey;
bool mbKoreanPartialConfirm;
};
#else
class WithZi {
public:
virtual ~WithZi();
void openDictionary(void* ziDict, void* ziOemDict);
};
#endif
}
}

View File

@@ -8,21 +8,15 @@
#include <cstring>
#include "global/decomp/utils.h"
namespace ipl {
namespace gui {
class PaneComponent : public ::gui::PaneComponent {};
class PaneManager : public ::gui::PaneManager {
public:
#ifdef IPL_GCW_PANEMANAGER_CTOR_OUT_OF_LINE
PaneManager(::gui::EventHandler* event, const nw4r::lyt::DrawInfo* drawInfo, EGG::Heap* heap, EGG::Allocator* allocator, bool bDisableCon = false) NO_INLINE;
#else
PaneManager(::gui::EventHandler* event, const nw4r::lyt::DrawInfo* drawInfo, EGG::Heap* heap, EGG::Allocator* allocator, bool bDisableCon = false) :
::gui::PaneManager(event, allocator, drawInfo),
mpHeap(heap),
mbDisableCon(bDisableCon) {}
#endif
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~PaneManager();

View File

@@ -180,11 +180,7 @@ namespace ipl {
/*** TODO: These always generate a weak. Try and make them not do that. ***/
const nw4r::ut::Rect getTextDrawRect(const nw4r::lyt::TextBox* textBox) const { return textBox->GetTextDrawRect(mDrawInfo); }
#ifdef IPL_SDMEMORY_GET_TEXT_DRAW_RECT_OUT_OF_LINE
const nw4r::ut::Rect getTextDrawRect(const char* paneName) const;
#else
const nw4r::ut::Rect getTextDrawRect(const char* paneName) const { return getTextDrawRect(nw4r::ut::DynamicCast<nw4r::lyt::TextBox*>(mLayout.GetRootPane()->FindPaneByName(paneName))); }
#endif
const nw4r::ut::Rect getPaneRect(nw4r::lyt::Pane* pane) const { return pane->GetPaneRect(mDrawInfo); }
const nw4r::ut::Rect getPaneRect(const char* paneName) const { return getPaneRect(mLayout.GetRootPane()->FindPaneByName(paneName)); }

View File

@@ -7,18 +7,11 @@
#include "utility/iplFrameController.h"
#ifdef IPL_GCW_INTP_CTOR_OUT_OF_LINE
#include "global/decomp/utils.h"
#endif
namespace ipl {
namespace math {
template <typename T>
class Interporation : public utility::FrameController {
public:
#ifdef IPL_BOARD_OBJECT_INLINE_INTERPOLATION_DTORS
virtual ~Interporation();
#endif
void init(int playback, f32 maxFrame, f32 minFrame, const T& start, const T& end, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
@@ -41,15 +34,6 @@ namespace ipl {
template <typename T>
class LinearIntp : public Interporation<T> {
public:
#ifdef IPL_GCW_INTP_CTOR_OUT_OF_LINE
LinearIntp() NO_INLINE;
#endif
#if defined(IPL_BOARD_OBJECT_INLINE_INTERPOLATION_DTORS) || defined(IPL_GC_WINDOW_CPP)
virtual ~LinearIntp();
#endif
#ifdef IPL_GC_WINDOW_CPP
T get() const;
#else
T get() const {
T r = mEnd * getCurrentFrame();
T b = mStart * (mMaxFrame - mFrame);
@@ -57,11 +41,9 @@ namespace ipl {
return b * (f64)(1.0f / getMaxFrame());
}
#endif
T get2() const { return (((mStart * (mMaxFrame - mFrame)) + (mEnd * mFrame)) / mMaxFrame); }
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
template <typename T>
class __declspec(novtable) HermiteIntp : public utility::FrameController {

View File

@@ -35,10 +35,6 @@ namespace ipl {
return x;
}
}
#ifdef IPL_CONTROLLER_OUT_OF_LINE_ABS_CLAMP
template <>
f32 abs_clamp<f32>(const f32& x, const f32& y);
#endif
typedef struct MTX33 : public nw4r::math::MTX33 {
} MTX33;
@@ -59,27 +55,19 @@ namespace ipl {
x = r.x;
y = r.y;
}
#ifdef IPL_CONTROLLER_OUT_OF_LINE_VEC2
VEC2(f32 fx, f32 fy);
#else
VEC2(f32 fx, f32 fy) {
x = fx;
y = fy;
}
#endif
void operator=(const VEC2& r);
VEC2 operator*(f32 val) const { return VEC2(x * val, y * val); }
#ifdef IPL_CONTROLLER_OUT_OF_LINE_VEC2
void set(f32 fx, f32 fy);
#else
void set(f32 fx, f32 fy) {
x = fx;
y = fy;
}
#endif
void clear() {
y = 0;
@@ -103,15 +91,11 @@ namespace ipl {
y = r.y;
z = 0.0f;
}
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP) || defined(IPL_GC_WINDOW_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fy;
z = fz;
}
#endif
VEC3& operator+=(const VEC3& rhs) {
VEC3Add(this, this, &rhs);

View File

@@ -1,277 +1,44 @@
#ifndef IPL_SCENE_ADDRESS_H
#define IPL_SCENE_ADDRESS_H
#include "iplSceneUIHeader.h"
#include "scene/button/iplButton.h"
#include "iplSceneHeader.h"
#include <revolution/nwc24.h>
namespace ipl {
namespace nigaoe {
class Object;
}
namespace scene {
class AddressEvent;
class FriendListCache {
public:
enum {
FRIEND_MAX = 100,
};
FriendListCache() : mbOpened(false) {}
BOOL init();
void fin();
void add(u32 index, const NWC24FriendInfo& info);
void update(u32 index, const wchar_t* name, u64 fdId);
void del(u32 index);
void swap(u32 index1, u32 index2);
BOOL isValidId(const NWC24UserId& userId);
BOOL isDupId(const NWC24UserId& userId);
BOOL isDupMail(const char* mailAddr);
void sendRegisterMail(u32 index);
s32 check();
s32 getErrCode() const;
const NWC24FriendInfo& getInfo(int index) const { return mInfos[index]; }
BOOL isThere(u32 index) const { return mbThere[index]; }
u32 getRegFriendNum() const { return mRegFriendNum; }
NWC24UserId getMyUserId() const { return mMyUserId; }
s32 getLastErr() const { return mErrCode; }
private:
NWC24FriendInfo mInfos[FRIEND_MAX]; // 0x0000
u8 mbThere[FRIEND_MAX]; // 0x7D00
NWC24UserId mMyUserId; // 0x7D68
u32 mRegFriendNum; // 0x7D70
u8 mSendWork[0x2000]; // 0x7D74
s32 mErrCode; // 0x9D74
bool mbOpened; // 0x9D78
NWC24FriendInfo mInfos[100];
};
FADER_SCENE_CLASS(Address), public ButtonEventHandlerBase {
FADER_SCENE_CLASS(Address) {
public:
Address(EGG::Heap * heap, int mode);
virtual ~Address();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void destroy();
virtual FaderSceneCommand calcFadein();
virtual void initCalcNormal();
virtual FaderSceneCommand calcNormal();
virtual void initCalcFadeout();
virtual FaderSceneCommand calcFadeout();
virtual void calcCommonAfter();
virtual void onEventDerived(u32 compId, u32 event, const controller::Interface* con);
Address(EGG::Heap * heap, int);
virtual void destroy() override;
enum {
SCENE_ADD_WII = 1,
SCENE_ADD_EMAIL,
};
enum {
BTN_MAX = 5,
BTN_SPACE_MAX = BTN_MAX - 1,
PAGE_MAX = 20,
};
int getChosenFriendIndex() {
return mChosenFriend;
return unk_0xC0;
}
FriendListCache* getFriendCache() {
return mpFriendCache;
return unk_0x274;
}
private:
enum {
FADEIN_STATE_WAIT_OPEN = 0,
FADEIN_STATE_FADEIN,
FADEIN_STATE_DONE,
};
enum {
STATE_INIT = 0,
STATE_COVER_NORMAL,
STATE_COVER_FORWARD,
STATE_COVER_BACKWARD,
STATE_NORMAL,
STATE_FORWARD,
STATE_BACKWARD,
STATE_LOOP_FORWARD,
STATE_LOOP_BACKWARD,
STATE_DECIDE,
STATE_DRAG,
STATE_RELEASE,
STATE_WAIT_CHILD_CST,
STATE_WAIT_CHILD_DST,
STATE_WAIT_CHILD_FADEOUT,
STATE_MSG_NET,
STATE_WAIT_PARENTAL,
STATE_WAIT_PARENTAL_DST,
STATE_MSG_WC,
STATE_WAIT_PARENTAL_WC,
STATE_WAIT_PARENTAL_DST_WC,
STATE_MSG_NWC24_ERROR,
STATE_MSG_FI_FULL,
STATE_MSG_PARENTAL,
STATE_MSG_OPEN_FAILURE,
STATE_WAIT_DIALOG,
STATE_DONE,
};
class MiiObj {
public:
MiiObj();
~MiiObj();
void init(nw4r::lyt::Pane* pane);
void set(u64 fdId);
void reset();
static void create_callback(nigaoe::Object* object, void* work);
GXTexObj mTexObj; // 0x00
nigaoe::Object* mpNigaoe; // 0x20
nw4r::lyt::Material* mpMaterial; // 0x24
};
struct DragInfo {
nw4r::math::VEC2 mPos; // 0x00
int mChan; // 0x08
int mPage; // 0x0C
int mButton; // 0x10
int mNextCount; // 0x14
int mPrevCount; // 0x18
int unk_0x1C; // 0x1C
bool mbDragging; // 0x20
};
void fistt_wait_open();
void fistt_fadein();
void onInitFriendList();
void stt_cover_normal();
void stt_cover_forward();
void stt_cover_backward();
void stt_normal();
void stt_forward();
void stt_backward();
void stt_loop_forward();
void stt_loop_backward();
void stt_decide();
void stt_drag();
void stt_release();
void stt_wait_child_cst();
void stt_wait_child_dst();
void stt_wait_child_fadeout();
void stt_msg_net();
void stt_wait_parental();
void stt_wait_parental_dst();
void stt_msg_wc();
void stt_wait_parental_wc();
void stt_wait_parental_dst_wc();
void stt_msg_nwc24_error();
void stt_msg_fi_full();
void stt_msg_parental();
void stt_msg_open_failure();
void stt_wait_dialog();
void add_translate(nw4r::lyt::Pane* pane, const math::VEC2& offset);
void set_friend(const char* paneName, u32 friendNo, u32 buttonNo, MiiObj& miiObj, bool bDrag);
void set_page_text(const char* paneName, int page);
void set_textbox(const char* paneName, const wchar_t* text);
void set_textbox(const char* paneName, u32 msgId);
void reset_friend();
void start_point_event(const char* paneName, controller::Interface* con);
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
void start_drag_event(const char* paneName, const controller::Interface* con);
void start_drag_point_event(const char* paneName, controller::Interface* con);
void start_drag_left_event(const char* paneName);
void start_release_event(const char* paneName);
void on_point_event(int buttonNo, controller::Interface* con);
void left_point_event(int buttonNo);
int get_button_no(const char* paneName);
int get_button_space_no(const char* paneName);
void reset_gui(bool bKeepPointed);
BOOL is_selectable(u32 friendNo);
void onNextPage();
void onPreviousPage();
void set_err_msg(wchar_t* errMsg, u32 errMsgLen, NWC24Err err);
void entry_friend();
bool isReleasableArea(int page, int buttonNo);
void changePage_onDrag();
void movePane_onDrag();
DragInfo mDrag; // 0x64
int mMode; // 0x88
layout::Object* mpLayout; // 0x8C
int unk_0x90; // 0x90
AddressEvent* mpEvent; // 0x94
gui::PaneManager* mpGui; // 0x98
layout::Object* mpBackLayout; // 0x9C
layout::Object* mpDialogLayout; // 0xA0
int mFadeinState; // 0xA4
int mWaitOpenCount; // 0xA8
int mState; // 0xAC
int mPage; // 0xB0
int mNextPageNum; // 0xB4
int mPrevPageNum; // 0xB8
int mSelectedButton; // 0xBC
u32 mChosenFriend; // 0xC0
bool mbFaceValid[BTN_MAX]; // 0xC4
int mPointCount[BTN_MAX]; // 0xCC
bool mbParentalOK; // 0xE0
bool mbCover; // 0xE1
MiiObj mMiiObj[BTN_MAX]; // 0xE4
MiiObj mNextMiiObj[BTN_MAX]; // 0x1AC
FriendListCache* mpFriendCache; // 0x274
GXTexObj mDragTexObj; // 0x278
u8* mpWork; // 0x298
f32 mDragOffsetX; // 0x29C
static const math::VEC2 smcPageOffset;
friend class AddressEvent;
#ifdef IPL_ADDRESS_EDIT_CPP
friend class AddressEdit;
#endif
};
class AddressEvent : public ::gui::EventHandler {
public:
AddressEvent(Address* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
Address* mpInstance; // 0x0C
int mTrigChan; // 0x10
u8 unk_0x58[0x68];
int unk_0xC0;
u8 unk_0xC4[0x1B0];
FriendListCache* unk_0x274;
u8 unk_0x278[0x28];
};
} // namespace scene
} // namespace ipl

View File

@@ -2,128 +2,22 @@
#define IPL_SCENE_ADDRESS_EDIT_H
#include "iplSceneHeader.h"
#include "scene/button/iplButton.h"
#include <RFL_Types.h>
#include <revolution/nwc24.h>
namespace ipl {
namespace nigaoe {
class Object;
}
namespace scene {
class AddressEditEvent;
class AddressInputEvent;
class FriendListCache;
FADER_SCENE_CLASS(AddressEdit), public ButtonEventHandlerBase {
FADER_SCENE_CLASS(AddressEdit) {
public:
AddressEdit(EGG::Heap * heap, int friendCode);
virtual ~AddressEdit();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void initCalcNormal();
virtual void initCalcFadeout();
virtual void calcCommonAfter();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
virtual void onEventDerived(u32 compId, u32 event, const controller::Interface* con);
void stt_msg_code_add();
void stt_msg_code_edit();
void stt_msg_parental();
void stt_msg_nwc24_error();
void reset_gui();
void start_point_event(const char* paneName, controller::Interface* controller);
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
void start_ipt_point_event(const char* paneName, int channel);
void start_ipt_left_event(const char* paneName, int channel);
void start_ipt_trig_event(const char* paneName, int channel);
int get_button_no(const char*);
void add_friendinfo();
void delete_friendinfo();
void set_textbox(nw4r::lyt::Pane*, const wchar_t*);
void setDefaultTitleText(const wchar_t*, bool);
static void wiiid_utf16(u64, wchar_t*);
static void nigaoe_create_callback_add(ipl::nigaoe::Object*, void*);
static void nigaoe_create_callback_edit(ipl::nigaoe::Object*, void*);
void set_err_msg(wchar_t*, u32, NWC24Err);
void get_friendinfo();
static u64 utf16_wiiid(const wchar_t*);
void stt_add_code_fadein();
void stt_add_code_fadeout();
void stt_add_code_input();
void stt_add_code_normal();
void stt_add_confirm_fadein();
void stt_add_confirm_fadeout();
void stt_add_confirm_normal();
void stt_add_mii_fadein();
void stt_add_mii_fadeout();
void stt_add_mii_input();
void stt_add_mii_normal();
void stt_add_name_fadein();
void stt_add_name_fadeout();
void stt_add_name_input();
void stt_add_name_normal();
void stt_ipt_input();
void stt_ipt_normal();
void stt_ipt_wait_fadein();
void stt_ipt_wait_fadeout();
void stt_msg_add_rlt();
void stt_msg_code_invalid();
void stt_msg_del_rlt();
void stt_msg_dup_email();
void stt_msg_dup_wii_no();
void stt_msg_my_wii_no();
void stt_msg_net();
void stt_msg_no_established();
void stt_msg_no_mii();
void stt_msg_no_mii_add();
void stt_msg_wc();
void stt_select_mii();
void stt_wait_btn_fadein();
void stt_wait_btn_fadeout();
void stt_wait_del_msg_fadein();
void stt_wait_del_msg_fadeout();
void stt_wait_del_msg_fadeout_to_rlt();
void stt_wait_delete();
void stt_wait_decide_anm_add();
void stt_wait_parental();
void stt_wait_parental_dst();
void stt_wait_parental_dst_wc();
void stt_wait_parental_wc();
void stt_normal();
void stt_wait_decide_anm();
void update_friendinfo();
void requestSceneChange(int sceneId, void* args) { reserveSceneChange(sceneId, args); }
u32 getPreviousScene() const { return getPrevSceneID(); }
EGG::Heap* getHeap() { return getSceneHeap(); }
::gui::Manager* getGuiManager() { return mpManager; }
class String {
public:
void clear();
const wchar_t* getDispCodeLong() const;
void setName(const wchar_t* value);
void setEMail(const wchar_t* value);
void setWiiNo(const wchar_t* value);
BOOL isDupCode() const;
BOOL isMyCode() const;
wchar_t mValue[0x102];
wchar_t mName[0x0c];
wchar_t mDisplayText[0x102];
bool mbValidMail;
bool mbNameNotEmpty;
bool mbHasWiiNo;
AddressEdit* mpCallbackOwner;
};
enum {
@@ -131,27 +25,8 @@ namespace ipl {
SCENE_ADD_EMAIL,
};
int mState;
layout::Object* mpCodeLayout;
AddressEditEvent* mpEditEvent;
gui::PaneManager* mpEditGui;
layout::Object* mpNameLayout;
AddressInputEvent* mpInputEvent;
gui::PaneManager* mpInputGui;
layout::Object* mpBackgroundLayout;
int mMode;
int mSelectedButton;
int mSubState;
s32 mPointCount[5];
u32 mSelectedFriend;
TextBalloon* mpBalloon;
nand::LayoutFile* mpBalloonFile;
String mString;
bool mbParentalOK;
nigaoe::Object* mpNigaoe;
RFLCreateID mCreateID;
int mNigaoeState;
FriendListCache* mpFriendCache;
private:
u8 unk_0x58[0x498];
};
} // namespace scene
} // namespace ipl

View File

@@ -19,13 +19,6 @@
namespace ipl {
namespace scene {
extern wchar_t scTextDateJpnFormat[];
extern wchar_t scTextDateKorFormat[];
extern wchar_t scTextDateGerFormat[];
extern wchar_t scTextDatePalengFormat[];
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
extern const u32 scWeekMsgId[];
#endif
class focus_object;
SCENE_CLASS(Board), public ButtonEventHandlerBase {
public:
@@ -88,57 +81,13 @@ namespace ipl {
void set_text_date();
void set_text_date(const utility::Date& date, const char* paneName);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_jpn(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* sep1 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* sep2 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateJpnFormat, date.month, sep1, date.day, sep2, weekStart, week, weekEnd);
}
void get_text_kor(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* sep1 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* sep2 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateKorFormat, date.month, sep1, date.day, sep2, weekStart, week, weekEnd);
}
#else
void get_text_jpn(const utility::Date& date, wchar_t* text, u32 textLen);
void get_text_kor(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void get_text_spa(const utility::Date& date, wchar_t* text, u32 textLen);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_ger(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateGerFormat, date.day, date.month, weekStart, week, weekEnd);
}
#else
void get_text_ger(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void get_text_usaeng(const utility::Date& date, wchar_t* text, u32 textLen);
void get_text_usafre(const utility::Date& date, wchar_t* text, u32 textLen);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_paleng(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
swprintf(text, textLen, scTextDatePalengFormat, week, date.day, date.month);
}
#else
void get_text_paleng(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void show_ricon();
void hide_ricon();
@@ -277,17 +226,8 @@ namespace ipl {
STATE_DONE,
};
#ifdef IPL_BOARD_INLINE_GETTERS
static Button* get_button() {
return static_cast<Button*>(System::getScene(SCENE_BUTTON));
}
static Arrow* get_arrow() {
return static_cast<Arrow*>(System::getScene(SCENE_ARROW));
}
#else
static Button* get_button();
static Arrow* get_arrow();
#endif
static const int OBJECTS_ON_SCREEN = 10;

View File

@@ -85,9 +85,6 @@ namespace ipl {
}
const utility::BScroller& getBInst() { return mBScroller; }
#ifdef IPL_SDMEMORY_SCROLLER_BINST_RESET
void resetBInst() { mBScroller.reset(); }
#endif
bool isDownEnd() const { return mScroller.isDownEnd(); }
bool isUpEnd() const { return mScroller.isUpEnd(); }
@@ -101,9 +98,6 @@ namespace ipl {
void setDownLimit(f32 v) { mScroller.setDownLimit(v); }
void setUpLimit(f32 v) { mScroller.setUpLimit(v); }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mScroller.setState(state); }
#endif
bool isActive() const { return mScroller.isActive(); }

View File

@@ -35,14 +35,7 @@ namespace ipl {
virtual void onSend();
virtual int sendMessageByNWC24(NWC24UserId userId, const wchar_t* wcString);
#ifdef IPL_ADDRESS_MATCHING
virtual void setFriendInfo(const NWC24FriendInfo& info) {
mbToFriend = true;
mFriendInfo = info;
}
#else
virtual void setFriendInfo(const NWC24FriendInfo& info);
#endif
virtual void setPhoto(const GXTexObj& texObj);
virtual int sendToWii(NWC24UserId userId, const wchar_t* wcString);

View File

@@ -1,44 +0,0 @@
#ifndef IPL_SCENE_GC_SAVE_DATA_H
#define IPL_SCENE_GC_SAVE_DATA_H
#include <nw4r/ut.h>
#include "scene/memoryCard/iplMemoryCardBase.h"
#include "math/iplMathTypes.h"
namespace ipl {
namespace scene {
class GCSaveData : public MemoryBase {
friend class MemoryCard;
public:
GCSaveData(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName,
math::VEC3 translate);
virtual ~GCSaveData();
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onTrig(const char* paneName);
void calc();
void draw();
void update();
void init();
void setTranslate(const nw4r::math::VEC3& translate);
const nw4r::math::VEC3* getTranslate();
void setBalloon(TextBalloon* balloon);
private:
MemoryBaseEvent* mpEvent; // 0x34
TextBalloon* mpBalloon; // 0x38
u8 mSlot; // 0x3C
s16 mIndex; // 0x3E
nw4r::ut::Link mLink; // 0x40
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_GC_SAVE_DATA_H

View File

@@ -1,99 +0,0 @@
#ifndef IPL_SCENE_GC_WINDOW_H
#define IPL_SCENE_GC_WINDOW_H
#include "scene/memoryCard/iplMemoryCardBase.h"
#include "scene/memoryCard/iplMemoryCardManager.h"
#include "math/iplMathTypes.h"
#include "math/iplInterporation.h"
namespace ipl {
namespace scene {
class GCWindow : public MemoryBase, public MemCardEventHandler {
#ifdef IPL_MEMORY_CARD_CPP
friend class MemoryCard;
#endif
public:
GCWindow(EGG::Heap*, nand::LayoutFile*, const char*, const char*);
virtual ~GCWindow();
void init(const math::VEC3&, MemoryCardManager*, u8, short);
void calc();
void draw();
void destroy();
void onPoint(const char*, controller::Interface*);
void onLeft(const char*);
void onTrig(const char*);
private:
void on_wait();
void on_fadein();
void on_normal();
void on_fadeout1st();
void on_fadeout_yes1st();
void on_focus_move();
void on_focus_copy();
void on_focus_del();
void on_select_out();
void on_dialog();
void on_error_message();
void on_process();
void on_error_message1st();
void on_error_message2nd();
void on_error_message3rd();
void on_format1st();
void on_format2nd();
void on_format3rd();
void on_format4th();
void on_format_error();
void change_textbox_doing();
void change_textbox_done();
void set_texture(const char*, const GXTexObj&);
public:
virtual void onMemEvent(long, u8);
bool isProcess();
void stop_wait_anim();
private:
int mState;
MemoryBaseEvent* mpEvent;
MemoryCardManager* mpMemoryCardManager;
math::LinearIntp<math::VEC3> mLinearInterp;
math::VEC3 mTranslate;
u8 mCardState;
short mCardIndex;
int mOperation;
bool mActive;
bool mWaiting;
u8 mFlags0[2];
u8 mFlags1[2];
};
class SavedataEditWindow : public MemoryBase {
public:
SavedataEditWindow(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName);
virtual void init();
virtual void calc();
virtual void draw();
virtual void destroy();
private:
void add_animation(const char* fileName, const char* groupName) {
AnmName animation = {fileName, groupName};
MemoryBase::add_animation(&animation, 1);
}
void on_normal();
void on_fadein();
void on_fadeout1st();
void on_focus_del();
void on_select_out();
void on_fadeout_yes1st();
int mState;
MemoryBaseEvent* mpEvent;
math::LinearIntp<math::VEC3> mLinearInterp;
math::VEC3 mTranslate;
bool mActive;
};
}
}
#endif

View File

@@ -3,91 +3,14 @@
#include "iplSceneHeader.h"
#include "scene/memoryCard/iplMemoryCardBase.h"
#include "scene/memoryCard/iplMemoryCardManager.h"
#include "math/iplMathTypes.h"
namespace ipl {
namespace scene {
class GCSaveData;
class GCWindow;
class SavedataEditWindow;
class MemoryCard : public Base, public MemoryBase {
SCENE_CLASS(MemoryCard) {
public:
MemoryCard(EGG::Heap* heap);
virtual ~MemoryCard();
virtual BOOL isResetAcceptable() const;
virtual void prepare();
virtual void create();
virtual void calc();
virtual void draw();
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onTrig(const char* paneName);
void onFocus(void* data);
void onRelease();
MemoryCardManager* getManager() { return mpManager; }
MemoryCard(EGG::Heap * heap);
private:
enum {
SLOT_A = 0,
SLOT_B,
};
void on_fadein1st();
void on_fadein2nd();
void on_normal();
void on_scroll_r();
void on_scroll_l();
void on_change_tag1st();
void on_change_tag2nd();
void on_fadeout1st();
void on_fadeout2nd();
void on_error();
void on_insert_card();
void on_detach_card();
void start_savedata_fadein();
void start_savedata_fadeout();
void start_errormessage_fadein();
int update_slot();
#ifdef IPL_MEMORY_CARD_CPP
bool can_scroll_r() const { return mIconCount > 30 && mState == 2; }
bool can_scroll_l() const { return mIconIndex >= 0 && mState == 2; }
#endif
void show_arw();
void show_capacity(u8 slot);
void scroll_common();
void start_scroll_r();
void start_scroll_l();
private:
s32 mState; // 0x88
s32 mPrevState; // 0x8C
u8 mSlot; // 0x90
u8 unk_0x91[3]; // 0x91
s32 mSlotState[2]; // 0x94
s16 mIconIndex; // 0x9C
s16 mIconCount; // 0x9E
u8 mShowArwR; // 0xA0
u8 mShowArwL; // 0xA1
u8 unk_0xA2[2]; // 0xA2
MemoryCardManager* mpManager; // 0xA4
MemoryBaseEvent* mpEvent; // 0xA8
nw4r::ut::List mSaveDataList; // 0xAC
nand::LayoutFile* mBalloonLayoutFile; // 0xB8
nw4r::ut::List mBalloonList; // 0xBC
GCSaveData* mpFocusSaveData; // 0xC8
GCWindow* mpGCWindow; // 0xCC
u8 unk_0x54[0x7C];
};
} // namespace scene
} // namespace ipl

View File

@@ -1,144 +0,0 @@
#ifndef IPL_SCENE_MEMORY_CARD_BASE_H
#define IPL_SCENE_MEMORY_CARD_BASE_H
#include <nw4r/ut.h>
#include "layout/iplLayout.h"
#include "layout/iplGuiManager.h"
#include "system/iplController.h"
namespace ipl {
namespace scene {
class TextBalloon;
class SettingButton;
class MemoryBase;
}
namespace nand {
class LayoutFile;
}
namespace scene {
class MemoryBaseEvent : public ::gui::EventHandler {
public:
#ifdef IPL_MEMORYCARD_BASE_EVENT_OUT_OF_LINE
MemoryBaseEvent(MemoryBase* base);
#else
MemoryBaseEvent(MemoryBase* base) : mpBase(base) {}
#endif
virtual ~MemoryBaseEvent();
virtual void onEvent(u32 componentID, u32 event, void* data);
private:
MemoryBase* mpBase; // 0x0C
};
class MemoryBase {
public:
class Anm {
public:
Anm(layout::GroupAnimator* anim) : mAnim(anim) {}
virtual ~Anm();
layout::GroupAnimator* mAnim; // 0x04
nw4r::ut::Link mLink; // 0x08
};
class Button {
public:
Button(nw4r::lyt::Pane* pane) : unk_0x04(0), mPane(pane) {}
virtual ~Button();
u32 unk_0x04; // 0x04
nw4r::lyt::Pane* mPane; // 0x08
nw4r::ut::Link mLink; // 0x0C
};
class AnmButton {
public:
AnmButton(const char* name, Anm* anm1, Anm* anm2, Anm* anm3)
: unk_0x04(0), mName(name), mCurrentAnm(NULL), mAnm1(anm1), mAnm2(anm2), mAnm3(anm3),
unk_0x24(0), mLastCmd(0), mpBalloon(NULL) {}
virtual ~AnmButton();
void calc();
void onCmdRecv(int command);
void setBalloon(TextBalloon* balloon);
int unk_0x04; // 0x04
const char* mName; // 0x08
Anm* mCurrentAnm; // 0x0C
Anm* mAnm1; // 0x10
Anm* mAnm2; // 0x14
Anm* mAnm3; // 0x18
nw4r::ut::Link mLink; // 0x1C
u32 unk_0x24; // 0x24
int mLastCmd; // 0x28
TextBalloon* mpBalloon; // 0x2C
};
struct AnmName {
const char* anmFile;
const char* groupName;
};
#ifdef IPL_MEMORYCARD_BASE_CTOR_OUT_OF_LINE
MemoryBase();
#else
MemoryBase() : mpLayout(NULL), unk_0x08(NULL) {
nw4r::ut::List_Init(&mAnmList, offsetof(Anm, mLink));
nw4r::ut::List_Init(&mButtonList, offsetof(Button, mLink));
nw4r::ut::List_Init(&mAnmButtonList, offsetof(AnmButton, mLink));
}
#endif
#ifdef IPL_MEMORYCARD_BASE_OUT_OF_LINE
virtual ~MemoryBase();
#else
virtual ~MemoryBase() {}
#endif
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onMove(const char* paneName);
virtual void onTrig(const char* paneName);
virtual void add_button(const char** paneNames, int count);
virtual void add_anmbutton(const char* paneName, Anm* anm1, Anm* anm2, Anm* anm3);
virtual Button* get_button(const char* paneName);
virtual AnmButton* get_anmbutton(const char* paneName);
virtual void clear_button(const char* paneName);
virtual void add_animation(const AnmName* anmNames, int count);
virtual Anm* get_animation(int index);
virtual void do_animation(int index);
virtual void do_animation(int index, bool flag);
virtual void stop_animation(int index);
virtual bool is_animation(int index);
virtual bool is_fadein_enable();
virtual void set_visible(const char* paneName, bool flag);
void set_textbox(const char* paneName, u32 message);
void set_textbox(const char* paneName, u32 message, int x, int y);
void set_textbox(const char* paneName, const wchar_t* text, f32 x, f32 y);
void set_textbox(const char* paneName, const wchar_t* text);
SettingButton* get_setting_button();
void change_button_text_close();
void change_button_text_return();
void change_button_text_ok();
void show_button_return();
void show_button_ok();
protected:
layout::Object* mpLayout; // 0x04
nand::LayoutFile* unk_0x08; // 0x08
gui::PaneManager* mpPaneManager; // 0x0C
nw4r::ut::List mAnmList; // 0x10
nw4r::ut::List mButtonList; // 0x1C
nw4r::ut::List mAnmButtonList; // 0x28
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_MEMORY_CARD_BASE_H

View File

@@ -1,115 +0,0 @@
#ifndef IPL_SCENE_MEMORY_CARD_MANAGER_H
#define IPL_SCENE_MEMORY_CARD_MANAGER_H
#include <revolution/types.h>
#include <revolution/gx.h>
#include <private/card.h>
#include <wchar.h>
#include "iplMemoryCardLib.h"
namespace ipl {
namespace scene {
class MemCardEventHandler {
public:
MemCardEventHandler() {}
virtual ~MemCardEventHandler();
virtual void onMemEvent(long event, u8 slot);
};
typedef struct MCFile {
u32 fileNo; // 0x00
u32 unk_0x04; // 0x04
u32 unk_0x08; // 0x08
s32 sortKey; // 0x0C
} MCFile; // 0x10
typedef struct MCFileCell {
wchar_t comment[2][0x40]; // 0x000
s16 iconAnmCounter; // 0x100
u16 unk_0x102; // 0x102
GXTexObj icon; // 0x104
GXTexObj banner; // 0x124
GXTlutObj iconTlut; // 0x144
GXTlutObj bannerTlut; // 0x150
} MCFileCell; // 0x15C
class MemoryCardManager {
public:
MemoryCardManager() {
MCFileCell* pCell = mFileCell[0];
do {
pCell->iconAnmCounter = 0;
wmemset(pCell->comment[0], 0, 0x40);
pCell++;
} while (pCell < mFileCell[2]);
mLastResult = 0;
mLastCmd = 0;
__CARDSetDiskID(NULL);
memorycard::initCardThread();
sort_file_array(0);
sort_file_array(1);
}
virtual ~MemoryCardManager();
void calc();
bool isSlotReady(u8 slot);
bool isSlotNoCard(u8 slot);
long isSlotWrongDevice(u8 slot);
void sort_file_array(u8 slot);
void sendCardCmdMove(u8 slot, s16 index);
void sendCardCmdCopy(u8 slot, s16 index);
void sendCardCmdDelete(u8 slot, s16 index);
void sendCardCmdFormat(u8 slot);
bool isDistSlot(u8 slot, long* pState);
bool isMoveEnable(u8 slot, u32 index, long* pCode);
bool isCopyEnable(u8 slot, u32 index, long* pCode);
bool isIconValidate(u8 slot, s16 index);
bool isBannerEnable(u8 slot, s16 index);
void update_icon_anm();
void update_file_array(u8 slot);
void update_change_cardstate(u8 slot);
GXTexObj* create_icon(u8 slot, s16 index);
GXTexObj* create_icon(u8 slot, s16 index, long start);
GXTexObj* _create_icon(u8 slot, s16 fileNo, long start);
const wchar_t* getComment(u8 slot, s16 index, int which);
GXTexObj* create_banner(u8 slot, s16 index);
#ifdef IPL_GC_WINDOW_CPP
u32 getBlocks(u8 slot, s16 index);
#else
u16 getBlocks(u8 slot, s16 index);
#endif
#ifdef IPL_MEMORY_CARD_CPP
u32 getFreeBlocks(u8 slot);
#else
u16 getFreeBlocks(u8 slot);
#endif
void setEventHandler(MemCardEventHandler* eventHandler) {
mpEventHandler = eventHandler;
}
private:
u32 unk_0x04; // 0x00004
MCFile mFile[2][0x7F]; // 0x00008
MCFileCell mFileCell[2][0x7F]; // 0x00FE8
s32 mLastResult; // 0x16930
s32 mLastCmd; // 0x16934
u32 unk_0x16938; // 0x16938
MemCardEventHandler* mpEventHandler; // 0x1693C
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_MEMORY_CARD_MANAGER_H

View File

@@ -11,12 +11,6 @@
namespace ipl {
namespace scene {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
namespace {
class SDChannelSelectButtonEventHandler;
}
#endif
class SDButtonEventHandlerBase : public ::gui::EventHandler {
public:
virtual void onEvent(u32 compId, u32 event, void* data);
@@ -97,17 +91,8 @@ namespace ipl {
void startLeftEvent(const char* paneName);
bool isActive() const;
#ifdef IPL_SD_CHANNEL_TITLE_CPP
bool isLeftArrowVisible() const { return mbArrowVisible[ARROW_BTN_LEFT]; }
static const char* getButtonName(int button) { return smButtonName[button]; }
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void setEventHandler(::gui::EventHandler * event,
::gui::EventHandler * optOutEvent = NULL);
#else
void setEventHandler(::gui::EventHandler * event, ::gui::EventHandler * optOutEvent);
#endif
void setText(const char* paneName, u32 msgId);
void setText(const char* paneName, const wchar_t* text);
@@ -171,10 +156,6 @@ namespace ipl {
friend class SDArrow;
friend class SDButtonEventHandlerBase;
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class SDChannelSelect;
friend class SDChannelSelectButtonEventHandler;
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -1,164 +0,0 @@
#ifndef IPL_SCENE_SD_MEMORY_H
#define IPL_SCENE_SD_MEMORY_H
#include <revolution.h>
#include "layout/iplLayout.h"
#include "layout/iplGuiManager.h"
#include "scene/board/iplFocusObject.h"
#include "scene/channelEdit/iplNandSDCardManager.h"
namespace ipl {
namespace scene {
class SDChannelSelect;
class SDMemory {
public:
struct TitleRange {
s32 mByteSize;
u32 mCount;
};
SDMemory();
~SDMemory();
void create(EGG::Heap* heap, nand::LayoutFile* layoutFile, SDChannelSelect* channelSelect);
void setTitleLists(const TitleRange& nandTitles, const TitleRange& sdTitles);
bool calc();
void draw();
void setScrollLimit();
void updateSideArrows();
void resetScrollArrows();
void updateScrollArrows(u32 previousDownEnd, u32 previousUpEnd, u32 downEnd, u32 upEnd);
void showDownArrow();
void showUpArrow();
void hideDownArrow();
void hideUpArrow();
void showLeftArrow();
void showRightArrow();
void hideLeftArrow();
void hideRightArrow();
#ifdef IPL_SD_CHANNEL_TITLE_CPP
public:
#else
private:
#endif
s32 updateState();
void drawTransferTitles();
void onDialogState0();
void onDialogState2();
bool onDialogState3();
void onDialogState4();
void onDialogState6();
void onDialogState7();
void onDialogState8();
void onDialogState9();
void onDialogState10();
void onDialogState11();
void onDialogState12();
void onDialogState13();
void onDialogState14();
void onDialogState15();
void onDialogState16();
void onDialogState17();
void onDialogState18();
void onDialogState19();
bool onDialogState20();
void onDialogState21();
bool onDialogState22();
void onDialogState23();
bool onDialogState24();
void resetDialogPaneAnimations();
s32 getControlPaneIndex(const char* paneName);
void activateControlPane(const char* paneName, ::gui::Component* component);
void deactivateControlPane(const char* paneName);
void cancelControlPane(const char* paneName);
s32 getTitlePaneIndex(const char* paneName);
void activateTitlePane(const char* paneName, ::gui::Component* component);
void deactivateTitlePane(const char* paneName);
void selectTitlePane(const char* paneName);
s32 getDialogPaneIndex(const char* paneName);
void activateDialogPane(const char* paneName, ::gui::Component* component);
void deactivateDialogPane(const char* paneName);
void selectDialogPane(const char* paneName);
class ControlPaneEventHandler : public ::gui::EventHandler {
public:
ControlPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class TitlePaneEventHandler : public ::gui::EventHandler {
public:
TitlePaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class DialogPaneEventHandler : public ::gui::EventHandler {
public:
DialogPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
layout::Object* mpMainLayout;
layout::Object* mpTitleLayout;
layout::Object* mpDialogLayout;
layout::Object* mpProgressLayout;
gui::PaneManager* mpPaneManagers[3];
s32 mDialogState;
s32 mProcessState;
s32 mDisplayMode;
s32 mMessageId;
u32 mErrorCode;
u32 mPanelStates[3];
u32 mTitlePanelStates[5];
u32 mPanelAnimationStates[4];
SDChannelSelect* mpSDChannelSelect;
TitleRange mNandTitleRange;
TitleRange mSDTitleRange;
u32 mTitleCount;
u32 mCurrentTitle;
u32 mTitleFlags;
ESTitleId mTitleIds[96];
wchar_t mTitleNames[96][21];
u32 mTitleNameCount;
u32 mSDTitleCount;
ESTitleId mSDTitleIds[96];
u32 mNandTitleCount;
u32 mNandTitleNameCount;
ESTitleId mNandTitleIds[96];
wchar_t mCurrentTitleName[0x840];
u8 mTransferFlags[4];
u32 mTransferStatus;
u64 mTransferStartTime;
s32 mTransferFrame;
struct TitleListState {
ESTitleId* mpTitles;
u32 mCount;
ESTitleId* mpSecondaryTitles;
u32 mSecondaryCount;
ESTitleId* mpNames;
u32 mNameCount;
} mTitleListState;
scroller mScroller;
s32 mButtonState;
u8 mControllerFlags[4];
#ifndef IPL_SD_CHANNEL_TITLE_CPP
u32 mFinalState[3];
u8 mFinalFlags[4];
#endif
};
} // namespace scene
} // namespace ipl
#endif

View File

@@ -1,402 +1,18 @@
#ifndef IPL_SCENE_SD_CHANNEL_SELECT_H
#define IPL_SCENE_SD_CHANNEL_SELECT_H
#include "iplSceneUIHeader.h"
#include "math/iplInterporation.h"
#include "scene/sdButton/iplSDButton.h"
#include "system/iplChannelRsoThread.h"
#include "system/iplNandSDWorker.h"
#include "iplSceneHeader.h"
namespace ipl {
namespace scene {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
class SDChannelSelect;
namespace {
class SDChannelSelectEventHandler;
class SDChannelSelectButtonEventHandler;
}
#endif
class SDChannelObj {
public:
SDChannelObj(EGG::Heap* heap, int page, int index);
~SDChannelObj();
EGG::Heap* getHeap() const { return mpHeap; }
int getPage() const { return mPage; }
int getIndex() const { return mIndex; }
nw4r::math::VEC3& getTranslate() const;
#if defined(IPL_SD_CHANNEL_TITLE_CPP) || defined(IPL_SD_CHANNEL_OBJ_CPP)
public:
#else
private:
#endif
friend class SDChannelSelect;
nw4r::ut::Link mListLink;
EGG::ExpHeap* mpDialogHeap;
EGG::ExpHeap* mpChannelHeap;
EGG::Heap* mpHeap;
#ifdef IPL_SD_CHANNEL_OBJ_CPP
int mState;
#else
u32 mState;
#endif
int mPage;
int mIndex;
nand::LayoutFile* mpLayoutFile;
nw4r::lyt::Pane* mpPane;
#ifdef IPL_SD_CHANNEL_OBJ_CPP
nand::File* mpPaneAnimator;
#else
layout::Animator* mpPaneAnimator;
#endif
layout::Object* mpBaseLayout;
layout::Animator* mpBaseAnimator;
layout::Object* mpPageLayout;
layout::Animator* mpPageAnimators[3];
int mPageAnimation;
int mPageAnimationFrame;
layout::Object* mpDialogLayout;
layout::Animator* mpDialogAnimator;
int mDialogState;
int mDialogFrame;
int mDialogTimer;
int mAnimationState;
nw4r::lyt::Group* mpNewMessageGroup;
#ifdef IPL_SD_CHANNEL_OBJ_CPP
layout::Animator* mpNewMessageAnimator;
#else
int mNewMessageCount;
#endif
u8 mbNewMessageGroupActive;
int mNewMessageState;
int mNewMessageFrame;
f32 mOffsetX;
f32 mOffsetY;
f32 mAspectRatioScale;
int mStateFlags;
void* mpThumbnailData;
NandSDWorker::SDAppMetaEntry mAppMeta;
};
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap);
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E32C8(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E34E0(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3354(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E33EC(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E3480(SDChannelObj* channel, bool selected);
extern "C" void iplSDChannelObj_813E34E8(SDChannelObj* channel, int enabled);
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel);
union SDChannelSelectCommandArguments {
u32 values[3];
NandSDWorker::AppBlocksInfo* appBlocks[3];
NandSDWorker::TitleIdList* titleLists[3];
void* pointers[3];
};
struct SDChannelSelectCommand {
u32 type;
u64 titleId;
SDChannelSelectCommandArguments arguments;
void copyFrom(const SDChannelSelectCommand& other);
};
struct SDChannelSelectCommandQueue {
SDChannelSelectCommand commands[4];
int capacity;
int count;
int readIndex;
int writeIndex;
SDChannelSelectCommandQueue(u32 capacity, u32 count, u32 readIndex, u32 writeIndex)
: capacity(capacity), count(count), readIndex(readIndex), writeIndex(writeIndex) {
}
bool push(const SDChannelSelectCommand& command);
bool pop();
};
struct SDChannelSelectTitleInfo {
ESTitleId32 titleId;
bool used;
};
struct SDChannelSelectNoticeQueue {
SDChannelSelectCommand notices[42];
int capacity;
int count;
int readIndex;
int writeIndex;
SDChannelSelectNoticeQueue(u32 capacity, u32 count, u32 readIndex, u32 writeIndex)
: capacity(capacity), count(count), readIndex(readIndex), writeIndex(writeIndex) {
}
bool pop();
};
FADER_SCENE_CLASS(SDChannelSelect) {
public:
enum {
PAGE_COUNT = 5,
};
SDChannelSelect(EGG::Heap * heap);
SDChannelSelect(EGG::Heap* heap);
virtual ~SDChannelSelect();
NandSDWorker::WorkSDState getSDState() const {
return static_cast<NandSDWorker::WorkSDState>(mCurrentSDState);
}
NandSDWorker* getWorker() const { return mpSDWorker; }
virtual BOOL isResetProcessDone();
virtual void startResetting();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void destroy();
virtual void initCalcFadeout();
virtual void calcCommon();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
void onButtonEvent(const char* paneName, u32 event,
const controller::Interface* controller);
BOOL onEventDerived(const char* paneName, u32 event,
controller::Interface* controller);
bool collectTitlesByUsage(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
static const char* mscChannelPaneNames[PAGE_COUNT][MAX_CHANNEL_INDEX];
static const char* mscBasePaneNames[PAGE_COUNT];
static const char* mscPicturePaneNames[PAGE_COUNT];
static const char* mscEdgePaneNames[PAGE_COUNT];
static const char* mscClockPaneNames[3];
static const char* mscMaskPaneName;
#if defined(IPL_SD_CHANNEL_TITLE_CPP) || defined(IPL_SD_CHANNEL_OBJ_CPP)
public:
#else
private:
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class SDChannelSelectEventHandler;
friend class SDChannelSelectButtonEventHandler;
#endif
void enqueueStartNotice();
bool enqueueFinishNotice();
bool enqueueNotice(u32 highTitleId, u32 lowTitleId, u32 result);
bool enqueueLoadNotice();
bool enqueuePageNotice();
bool enqueueResultNotice(u32 result);
bool enqueueChannelNotice(u32 controller, u32 page, u32 index, u32 value);
bool enqueueMoveNotice(u32 controller, u32 page, u32 index);
bool enqueueStateNotice(u32 controller, u32 page, u32 index, u32 state);
bool enqueueErrorNotice(u32 page, u32 index);
bool enqueueCommandNotice(u32 page, u32 index, u32 command);
bool enqueueDeleteNotice(u32 controller, u32 page, u32 index);
void clearCommandQueue();
void clearNoticeQueue();
void calcChannelObjects();
void updateChannelObjects();
void updateChannelObject(SDChannelObj* channel);
void drawChannelTransitionObjects();
void drawChannelObjects();
bool isChannelInCalc(int page, int index, int currentPage) const;
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int currentPage) const;
int getCenterChannelIndex(const char* paneName) const;
nw4r::lyt::Pane* getCenterChannelPane(int index) const;
nw4r::lyt::Pane* getChannelPane(int index) const;
static math::VEC3 getChannelPanePosition(SDChannelSelect* scene, int index);
void calcPageAnimations();
void processNormalInput();
void updateArrowVisibility();
void processWorkerState();
void updateDialogAnimation();
void initializeNormalPage();
void updatePageTransform();
void setChannelScissor(const SDChannelObj* channel) const;
bool isCurrentTitleUsageEnough(const s32* usage) const;
void getCurrentTitleUsage(s32* bytes, s32* blocks) const;
bool collectTitlesByChannelOrder(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesFromNandUsage(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesBySpecialChannels(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesForMode(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount, int searchMode);
bool findAdjacentChannel(int direction, int* page, int* index) const;
void setStateAndPlaySelectSound(int state) NO_INLINE;
void finishDialogOperation();
void finishDialogTransition();
void processWorkerCommands();
void handleWorkerStartup();
void handleNandTitleCount();
void handleNandTitleUsage();
void handleNandTitleUsageComplete();
void handleSDTitleList();
void handleSDTitleListResult();
void refreshAfterSDTitleList();
void handleSDChannelUpdateComplete();
void updateChannelNotices(int pageOffset, int index);
void handleSDMountComplete();
void handleCopyComplete();
void handleDeleteComplete();
void handleMoveComplete();
void handleStorageCheckComplete();
void handleCardCommand();
void handleSDCardReady();
void handleSDLocationUpdateComplete();
void handleSDLocationReadComplete();
void handleBackupFitComplete();
void handleNandSDCleanupComplete();
void handleSDDeleteComplete();
bool setDialogMessage(u32 state, u32 message);
static int compareTitleUsage(const void* lhs, const void* rhs);
static int compareTitleInfo(const void* lhs, const void* rhs);
void createChannelList(int page, bool force);
void destroyChannelObject(SDChannelObj* channel);
void destroyUnusedChannelObjects(int currentPage, SDChannelObj* keepChannel);
void refreshChannelList();
bool hasChannelObject(int page, int index) const;
SDChannelObj* findChannelObject(int page, int index) const;
void createChannelObject(int page, int index);
void createBaseLayout();
void createSceneLayouts();
BOOL isChannelMoveTarget(int page, int index) const;
void selectChannel(int page, int index);
BOOL prepareRestarting(int page);
void startPageTransition(int page, int index);
void setCurrentPageAndRefresh(int page, int index, SDChannelObj* keepChannel);
void handleFourPageDialog();
void handleThreePageDialog();
void setPageActionFrame();
void advancePageAnimation();
void finishPageScroll();
void finishCardDialog();
void flushSaveDataAndMountSD();
void startDrag(const controller::Interface* controller, int page, int index);
void finishDrag();
void moveDrag();
void updateDragState();
void updateDragPageTransition();
void finishDragWait();
void finishDragPageTransition();
void applyChannelMove();
void finishChannelMove();
void resetDragPreview();
void finishDragPageChange();
BOOL isPageCreated(int page) const;
void refreshPageObjects(int page, SDChannelObj* keepChannel, int noticeIndex);
void updateChannelObjectOrder(int page);
void moveChannelObjectsToDrawOrder(int page, int mode);
void setLayoutFrame(int state);
BOOL tellStartingZoomAnm();
void initPageAnimations(const math::VEC3& position, int direction);
static BOOL isChannelReady(const SDChannelObj* channel);
nw4r::ut::List mChannelObjects;
nand::LayoutFile* mpLayoutFile;
layout::Object* mpLayout;
math::HermiteIntp<math::VEC3>* mpPageAnimations[4];
gui::PaneManager* mpPaneManager;
layout::Object* mpNoCardLayout;
layout::Object* mpPageLayouts[3];
layout::Object* mpDialogLayout;
SDButtonEventHandlerBase* mpButtonEventHandler;
int mState;
int mCurrentPage;
int mPageCount;
int mCurrentChannelIndex;
f32 mThumbOffsetX;
f32 mThumbOffsetY;
math::VEC3 mPosition;
math::VEC2 mScale;
f32 mAspectRatioScale;
bool mbLeftArrowVisible;
bool mbRightArrowVisible;
u8 mArrowState;
u8 mNoCardState;
EGG::UnitHeap* mpLayoutHeap;
EGG::ExpHeap* mpDialogHeap;
EGG::ExpHeap* mpChannelHeap;
EGG::ExpHeap* mpThumbnailHeap;
nw4r::math::VEC2 mPointerPosition;
int mControllerChannel;
int mSourcePage;
int mSourceIndex;
int mDestinationPage;
int mDestinationIndex;
int mPendingPage;
int mPendingIndex;
int mMoveState;
bool mbButtonEnabled;
bool mbDialogActive;
u16 mInputFlags;
void* mpCurrentChannel;
layout::Object* mpStateLayout;
layout::Animator* mpHelpLayout;
EGG::ExpHeap* mpRsoHeap;
channel::RsoThread* mpRsoThread;
u32 mCommandQueueState;
SDChannelSelectCommandQueue mCommandQueue;
SDChannelSelectNoticeQueue mNoticeQueue;
int mCurrentSDState;
int mPreviousSDState;
int mWorkerState;
int mWorkerCommand;
EGG::Heap* mpWorkerHeap;
EGG::Heap* mpThumbnailWorkHeap;
NandSDWorker* mpSDWorker;
ESTitleId32* mpSDTitleIds;
SDChannelSelectTitleInfo* mpSDTitleInfo;
NandSDWorker::TitleUsage* mpNandTitleInfo;
s32 mFirstTitleCount;
s32 mSecondTitleCount;
SDChannelObj* mpCurrentLoadedChannel;
u32 mSDTitleCount;
u32 mNandTitleCount;
u32* mpChannelTitleIds;
u32 mPendingOperation;
int mLastOperation;
layout::Object* mpErrorLayout;
layout::Object* mpPointerLayout;
layout::Object* mpHelpButtonLayout;
int mOperationResult;
u8 mbShowNoCardMessage;
u8 mbOperationActive;
u8 mbSDCardBroken;
int mOperationState;
int mDialogState;
nand::File* mpSaveDataFile;
u32 mAnimationState;
u32 mAnimationTarget;
OSTime mOperationStartTime;
nand::File* mpCorruptIconFile;
u8 mbHazardTitleFound;
u8 mbChannelLimitReached;
u8 mbInitialLoadComplete;
u8 mbNeedsRefresh;
u8 unk_0x58[0x728];
};
}
}
} // namespace scene
} // namespace ipl
#endif
#endif // IPL_SCENE_SD_CHANNEL_SELECT_H

View File

@@ -3,104 +3,15 @@
#include "iplSceneHeader.h"
#ifdef IPL_SD_CHANNEL_TITLE_CPP
#include "math/iplInterporation.h"
#include "scene/sdChannelMemory/iplSDMemory.h"
#include "system/iplChannelRsoThread.h"
#include "utility/iplCapture.h"
#include <private/es.h>
#include <nw4r/snd/SoundHandle.h>
#endif
namespace ipl {
namespace scene {
class SDChannelSelect;
class SDButtonEventHandlerBase;
FADER_SCENE_CLASS(SDChannelTitle) {
public:
SDChannelTitle(EGG::Heap * heap, SDChannelSelect * chanSel);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual ~SDChannelTitle();
virtual void prepare();
virtual void create();
virtual void calcCommon();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual void initCalcFadeout();
virtual FaderSceneCommand calcFadeout();
virtual void draw();
virtual void destroy();
BOOL isResetAcceptable();
virtual void startResetting();
using Base::reserveAllSceneDestruction;
using Base::createChildScene;
s32 mState;
EGG::ExpHeap* mpBannerHeap;
EGG::ExpHeap* mpCaptureHeap;
s32 mPage;
s32 mIndex;
s32 mPageCount;
s32 mNextScene;
s32 mParentalResult;
math::VEC3 mPosition;
u32 mLaunchFrame;
s32 mStartButtonState;
bool mbBannerStarting;
layout::Animator* mpButtonAnimations[7][6];
math::HermiteIntp<f32>* mpFade;
SDChannelSelect* mpChannelSelect;
nand::LayoutFile* mpLayoutFile;
layout::Object* mpLayout;
gui::PaneManager* mpPaneManager;
layout::Object* mpIconLayout;
EGG::ExpHeap* mpIconHeap;
layout::Object* mpProgressLayout;
s32 mLoadedIndex;
nand::LayoutFile* mpBannerFiles[2];
nand::File* mpSoundFiles[2];
layout::Object* mpBannerLayout;
layout::Animator* mpBannerAnimations[3];
nw4r::snd::SoundHandle* mpSoundHandle;
nand::File* mpSaveFile;
u32 mWpadStopTick;
s32 mHoverCounts[2];
SDButtonEventHandlerBase* mpButtonEventHandler;
utility::Capture* mpScreenCapture;
utility::Capture* mpBannerCapture;
ESTmdView* mpTmd;
u8 mbTmdReady;
u8 mTitleFlags;
u16 mMakerCode;
u8 mbStartAnimation;
s32 mScriptState;
s32 mScriptEnabled;
bool mbStopScript;
u32 mScriptFrame;
u32 mScriptDuration;
nand::File* mpScriptFile;
EGG::ExpHeap* mpScriptHeaps[2];
s32 mScriptHeapIndex;
channel::RsoThread* mpRsoThread;
EGG::ExpHeap* mpRsoHeap;
layout::Animator* mpScriptAnimations[16];
bool mbScriptFailed;
EGG::ExpHeap* mpScriptHeap;
ESTitleId mTitleId;
SDMemory::TitleRange mTitleRange;
u8 mUnknownTitleWork[0x800];
SDMemory mMemory;
u32 mErrorMessage;
s32 mChangeFrame;
u8 mbCopiedTitle;
u8 mbResetAcceptable;
nw4r::snd::SoundHandle* mpCopySound;
#else
private:
u8 unk_0x58[0x3460];
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -1,32 +0,0 @@
#ifndef IPL_SCENE_SETTING_AOSS_H
#define IPL_SCENE_SETTING_AOSS_H
#include <revolution/ncd/NCDTypes.h>
#include <revolution/types.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct AOSSInitInput {
u16 flags;
u8 mode;
u8 reserved;
u16 ssidLength;
u8 ssid[0x100];
s16 options[5];
u8 optionData[6];
u8 status;
u8 result[0x154];
} AOSSInitInput;
int AOSSi_Init(AOSSInitInput* input);
int AOSS_Init_old(AOSSInitInput* input);
void* AOSSi_Alloc(u32 size);
void AOSSi_Free(void* block);
#ifdef __cplusplus
}
#endif
#endif

View File

@@ -17,11 +17,7 @@ namespace ipl {
virtual ~APScanThread(); // 0x08
virtual void* Run(); // 0x0C
#ifdef IPL_SETTING_IMPLEMENTATION
virtual void unk_0x2C();
#else
virtual void unk_0x2C() = 0;
#endif
virtual void unk_0x2C() = 0; // 0x2C
void setResultData(unsigned short* buffer);
void setParam();

View File

@@ -3,171 +3,14 @@
#include "iplSceneHeader.h"
#ifdef IPL_SETTING_IMPLEMENTATION
#include <revolution/os.h>
#include "layout/iplGuiManager.h"
#include "layout/GUIManager.h"
#include "iplwww/www_wiisetting.h"
#include "iplwww/www_browser.h"
#include "system/iplKeyboard.h"
#include "system/iplNand.h"
#include "utility/iplThread.h"
extern "C" {
#include <revolution/wd.h>
}
#endif
namespace ipl {
namespace controller {
class Interface;
}
}
namespace ipl {
namespace scene {
#ifdef IPL_SETTING_IMPLEMENTATION
class Setting;
class APScanThread;
class APEvent : public ::gui::EventHandler {
public:
APEvent(Setting* setting) : ::gui::EventHandler(), mpSetting(setting) {}
virtual void onEvent(u32 componentID, u32 event, void* data);
private:
Setting* mpSetting;
};
struct SettingAnimation {
u8 unknown[0x14];
int state;
};
struct SettingAPScanList {
u8 unknown[0x14];
u16 count;
u8 entries[0x7fe];
union {
WDBssDesc_* currentDescriptor;
u16* currentDescriptorWords;
};
};
#endif
FADER_SCENE_CLASS(Setting) {
public:
Setting(EGG::Heap * heap, int arg);
#ifdef IPL_SETTING_IMPLEMENTATION
virtual ~Setting();
bool isAnimating();
void getFuncMsgQ();
void resetFuncMsgQ();
void createBrowser();
void initDirectUrl();
void initString();
void initWiiSettingData();
void initNickName();
void initSecurityKey();
void initSSID();
void initIP();
void initDNS();
void initProxy();
void initBasic();
void initMTU();
void initSecA();
void initVersion();
void updateController_();
void setSE();
void changeVideoMode();
bool isInitialSequenceExit(const ::ipl::controller::Interface* input);
bool updateScreenMode();
void initHTMLText();
void initMessage();
void initKeyboard(const char* text);
bool checkInputString(const wchar_t* text);
int checkIPString(const wchar_t* text);
void setDefaultBackString();
void calcKeyboard();
void calcSetting();
void onTextInputOK();
void setDisPos();
void setNickName();
void setSecurityKey();
void setSSID();
void setIP();
void setDNS();
void setProxy();
void setBasic();
void setMTU();
void setParePass();
void setPareRePass();
void setPareJudgePass();
void setSecA();
void setReSecA();
void setMasterKey();
void adjustSecA(wchar_t* text);
void reAdjustSecA();
u8 checkTextNum(const char* text);
bool checkSpace();
void convertIP(char* destination, const u8* address);
void convertRevIP(u8* destination, const char* address);
void initScroll();
void updateScroll();
void setAPDraw();
int getRadioLevel(const WDBssDesc_* descriptor);
void setUseEULA_Init_();
void setUseEULA_Cancel_();
void setUseEULA_Start_();
void setUseEULA_WaitStopMotor_();
bool validateEULA_();
void setUpdate_Init_();
void setUpdate_WaitAcceptDialog_();
void setUpdate_ConnectTestStart_();
void setUpdate_ConnectTestCreateWait_();
void setUpdate_ConnectTestRun_();
void setUpdate_ConnectTestFailed_();
void setUpdate_SuccessDialog_();
void setUpdate_NoUpdateDialog_();
void setUpdate_EULAInit_();
void setUpdate_Reboot_();
void makeErrorMessage();
bool calcSafeMode();
void waitStart();
void waitFinish();
bool isWaitPlaying();
void initAP();
void resetAP();
void redrawAP();
void scanAP();
void setNUP();
void setUSBAP();
void cancelUSBAP();
void AOSSProcess();
void RakuProcess();
void setUpdate_();
void setUseEULA_();
void start_point_event(const char* pageName);
void start_trig_event(const char* pageName);
void start_left_event(const char* pageName);
int get_arw_no(const char* paneName);
int get_ap_no(const char* buttonName);
void makeSupportCode();
int getErrorNum();
virtual void destroy();
virtual void prepare();
virtual void create();
virtual void calc();
virtual void draw();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
virtual BOOL isResetAcceptable() const;
#endif
void setInitializeResult(bool, int);
u16 getProfileID();
void setInitializeResult(bool, int);
void setConnectTestResult(int, int, bool, int);
int getUpdateTiming();
@@ -182,85 +25,7 @@ namespace ipl {
};
private:
#ifdef IPL_SETTING_IMPLEMENTATION
int mUpdateTiming;
u8 unk_0x5C;
u8 unk_0x5D[3];
nand::Base* mpWWWLibraryFile;
nand::Base* mpSettingHTMLFile;
nand::Base* mpWWWArchiveFile;
nand::Base* mpFontFile;
nand::Base* mpBackgroundTPLFile;
int unk_0x74;
int unk_0x78;
int unk_0x7C;
int mProfileIDMode;
int unk_0x84;
int mAOSSState;
int mRakuState;
int mFuncMsgPending;
int unk_0x94;
ESTitleId mUpdateTitleId;
u32 mPrepareTick;
u8 mSettingData[0x16];
u8 unk_0xBA[2];
nand::LayoutFile* mpSettingLayoutFile;
layout::Object* mpChangeLayout;
layout::Object* mpMainLayout;
layout::Object* mpWaitLayout;
SettingAnimation* mpFirstAnimation;
SettingAnimation* mpSecondAnimation;
APEvent* mpEventHandler;
gui::PaneManager* mpPaneManager;
void* mpUSBAPThread;
utility::ut_thread* mpAOSSThread;
utility::ut_thread* mpRakuRakuThread;
APScanThread* mpAPScanThread;
SettingAPScanList mAPScanList;
void* mpMem1BrowserBuffer;
u32 unk_0x908;
void* mpMem2BrowserBuffer;
void* mpBrowserStringBuffer;
int unk_0x914;
int unk_0x918;
u8 unk_0x91C[4];
ext_ead::www::ImeData* mpBrowserData;
www::wiisetting::WiiData* mpWiiSettingData;
www::wiisetting::WiiFlag* mpWiiSettingFlag;
u8 unk_0x92C;
u8 unk_0x92D[3];
int unk_0x930;
www::wiisetting::SetStringBuf* mpStringBuffer;
#ifdef IPL_SETTING_IMPLEMENTATION
wchar_t unk_0x938[0x101];
#else
u8 unk_0x938[0x202];
#endif
u8 unk_0xB3A;
u8 mBrowserCreated;
keyboard::Manager::State mKeyboardState;
int mInitialArgument;
int mAspectRatio;
int mProgressiveMode;
int mEuRgb60Mode;
u8 mIsResetAcceptable;
u8 unk_0xB5D[3];
OSMessageQueue mFuncMessageQueue;
OSMessage mFuncMessages[5];
int unk_0xB94;
int mState;
int unk_0xB9C;
OSTime mCreatePageTime;
u32 unk_0xBA8;
u8 unk_0xBAC;
u8 unk_0xBAD[3];
u8 unk_0xBB0[0x10];
static void* mem1Buffer_;
static void* mem2Buffer_;
#else
u8 unk_0x58[0xB68];
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -36,11 +36,6 @@
#define MAX_CHANNEL_INFO_SIZE CHANNEL_INFO_SIZE(MAX_CHANNEL_PAGE, MAX_CHANNEL_INDEX)
namespace ipl {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
namespace scene {
class SDChannelSelect;
}
#endif
namespace channel {
enum {
PRIMARY_TYPE_NONE = 0,
@@ -373,9 +368,6 @@ namespace ipl {
char* getChJumpData() { return mChJumpData; }
private:
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class ipl::scene::SDChannelSelect;
#endif
typedef struct MD5Head {
u8 magic[4]; // 0x00 (`IMD5`; "IPL MD5"?)
u32 length; // 0x04

View File

@@ -62,204 +62,6 @@ namespace ipl {
};
// clang-format on
#ifdef IPL_CONTROLLER_NATIVE_HIERARCHY
#ifdef IPL_CONTROLLER_OUT_OF_LINE_INTERFACE
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature;
#else
#ifdef IPL_CONTROLLER_INLINE_INTERFACE
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature implementation
#else
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature;
#endif
#endif
class Interface {
public:
virtual ~Interface() = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getType() const, { return -1; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getChannel() const, { return -1; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool down(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool downTrg(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool upTrg(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinch() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchTrg() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchOffTrg() const, { return 0; })
virtual int decide() const = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool repeat(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(BOOL rumble(int type = 0), { return FALSE; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(void cancelRumbling(), { })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getHoldFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getTrigFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getReleaseFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicHoldFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicTrigFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicReleaseFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getDpdPos() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getDpdProjectionPos() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getHorizon() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(f32 getDpdDistance() const, { return 0.0f; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(KPADStatus* getKPADStatus() const, { return NULL; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(PADStatus* getPADStatus() const, { return NULL; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool isValidBtn() const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool isValidDpd() const, { return false; })
virtual void setForceInvalid(bool flag) = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getMainStickX() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getMainStickY() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getSubStickX() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getSubStickY() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(void read(), { })
};
#undef IPL_CONTROLLER_DEFAULT_VIRTUAL
#ifdef IPL_CONTROLLER_INLINE_INTERFACE
inline Interface::~Interface() {}
#endif
class Base : public Interface {
public:
Base(int chan, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
unk_0x1C = 0;
KPADEnableDPD(chan);
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &status;
}
Base(int chan, int type, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = type;
unk_0x1C = 0;
KPADEnableDPD(chan);
}
virtual ~Base();
virtual int getType() const override;
virtual int getChannel() const override;
virtual int decide() const override;
virtual BOOL rumble(int timer = 0) override;
virtual void cancelRumbling() override;
virtual void setForceInvalid(bool flag) override;
virtual void read() override;
protected:
u8 mButton;
u32 unk_0x08;
OSTick mLastRumbleTime;
s32 mRumbleType;
u32 mChan;
u32 mType;
u8 unk_0x1C;
u8 unk_0x1D;
u8 unk_0x1E;
KPADStatus* unk_0x20;
};
class Revolution : public Base {
public:
Revolution(int chan, KPADStatus& status) : Base(chan, status) {}
Revolution(int chan, int type, KPADStatus& status);
virtual ~Revolution();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual int pinch() const override;
virtual int pinchTrg() const override;
virtual int pinchOffTrg() const override;
virtual bool repeat(u32 button) const override;
virtual f32 getDpdDistance() const override;
virtual KPADStatus* getKPADStatus() const override;
virtual int getReleaseFlag() const override;
virtual int getTrigFlag() const override;
virtual int getHoldFlag() const override;
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual bool isValidBtn() const override;
virtual bool isValidDpd() const override;
virtual void read() override;
};
class Classic : public Revolution {
public:
Classic(int chan, KPADStatus& status);
virtual ~Classic();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual int getClassicHoldFlag() const override;
virtual int getClassicTrigFlag() const override;
virtual int getClassicReleaseFlag() const override;
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual bool isValidDpd() const override;
virtual void read() override;
virtual BOOL isValidDpdClassic() const;
private:
math::VEC2 unk_0x24;
int unk_0x2C;
};
class Master : public Interface {
public:
Master(Interface** controllers) : mpControllers(controllers) {}
virtual ~Master();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual bool repeat(u32 button) const override;
virtual int decide() const override;
virtual void setForceInvalid(bool flag) override;
private:
bool call(u32 button, bool (Interface::*func)(u32) const) const;
Interface** mpControllers;
};
class Core : public Revolution {
public:
Core(int chan, int type, KPADStatus& status) : Revolution(chan, type, status) {}
virtual ~Core();
};
class FreeStyle : public Revolution {
public:
FreeStyle(int chan, int type, KPADStatus& status) : Revolution(chan, type, status) {}
virtual ~FreeStyle();
};
class Manager {
public:
Manager(EGG::Heap* heap);
void read();
Interface* getController(int chan);
Interface* getMasterController();
Interface* getYoungController();
static void* alloc(u32 size);
static int free(void* ptr);
private:
static void* mpBuf;
static EGG::Heap* mpParentHeap;
static EGG::ExpHeap* mpHeap;
static EGG::Allocator* mpAllocator;
Interface* mControllers[4];
u32 mControllerStorage[4][12];
Master mMaster;
KPADStatus mKPADStatus[4];
s32 mInvalidCount[4];
};
#else
class Base {
public:
Base(int chan, KPADStatus& arg1) {
@@ -316,11 +118,11 @@ namespace ipl {
virtual bool setForceInvalid(bool flag); // 0x74
virtual int getMainStickX() const; // 0x78
virtual int getMainStickY() const; // 0x7C
virtual f32 getMainStickX() const; // 0x78
virtual f32 getMainStickY() const; // 0x7C
virtual int getSubStickX() const; // 0x80
virtual int getSubStickY() const; // 0x84
virtual f32 getSubStickX() const; // 0x80
virtual f32 getSubStickY() const; // 0x84
virtual void read(); // 0x88
@@ -367,10 +169,10 @@ namespace ipl {
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual int getMainStickX() const override;
virtual int getMainStickY() const override;
virtual int getSubStickX() const override;
virtual int getSubStickY() const override;
virtual f32 getMainStickX() const override;
virtual f32 getMainStickY() const override;
virtual f32 getSubStickX() const override;
virtual f32 getSubStickY() const override;
virtual BOOL rumble(int type = 0) override;
virtual void read() override;
};
@@ -426,7 +228,6 @@ namespace ipl {
class Classic : public Revolution {
public:
Classic(int arg0, KPADStatus& arg1);
virtual ~Classic();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
@@ -467,7 +268,6 @@ namespace ipl {
static EGG::Allocator* mpAllocator;
u8 dummy[0x2F8];
};
#endif
} // namespace controller
} // namespace ipl

View File

@@ -118,11 +118,6 @@ namespace ipl {
int getLastResult() { return mLastResult; }
/** @return If the dialog is moving onto the next state. */
bool doingNextState() { return mbNextState; }
#ifdef IPL_SDMEMORY_DIALOG_STATE_ACCESSOR
int getStateForSDMemory() const { return mState; }
int getResultForSDMemory() const { return mResult; }
void setTitleForSDMemory(const wchar_t* text) { set_title(text); }
#endif
/*=================*/
/* DIALOG BUTTON 0 */
@@ -327,9 +322,6 @@ namespace ipl {
void setProgBarLength(int len) { mProgBarLen = len; }
/** @return The current length of the progress bar */
int getProgBarLength() { return mProgBarLen; }
#ifdef IPL_SDMEMORY_DIALOG_PROGRESS_FRAME_ACCESSOR
int getProgBarFrame() const { return mProgBarFrame; }
#endif
/**
* Dialog component handler (Automatically executed by the GUI manager)

View File

@@ -54,24 +54,14 @@ namespace ipl {
const wchar_t* wcString; // 0x04
u32 stringLimit; // 0x08
u32 rowLimit; // 0x0C
#ifdef IPL_ADDRESS_EDIT_CPP
KeyboardSetting(KeyboardType keyboardType, const wchar_t* value, u32 limit, u32 rows);
#endif
} KeyboardSetting;
typedef struct State {
textinput::MemoManager::StateType type; // 0x00
KeyboardState iplType; // 0x04
bool pressOK; // 0x08
#ifdef IPL_SETTING_IMPLEMENTATION
u8 reservedByte;
#else
u8 unused_0x09;
#endif
wchar_t* wcString; // 0x0C
#ifdef IPL_SETTING_IMPLEMENTATION
State& operator=(const State& other);
#endif
} State;
Manager() : mpManager(NULL), mEvent(), mCurrentConChan(0), mbActivated(false), mpSaveFile(NULL) {}

View File

@@ -151,10 +151,6 @@ namespace ipl {
BOOL is_terminated();
BOOL is_working();
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void requestCancel() { unk_0x04 = true; }
#endif
WIISaveBannerFile* get_cached_nand_save_banner(ESTitleId titleId);
void* get_cached_nand_app_thumbnail(ESTitleId titleId, u32*);
WIISaveBannerFile* get_cached_sd_save_banner(ESTitleId32 titleId);
@@ -183,10 +179,6 @@ namespace ipl {
static const int SD_APP_BACKUP_THUMBNAIL_LENGTH = 0xC800;
#ifdef IPL_SDMEMORY_COMPLETION_PCT_ACCESSOR
static int getCompletionPct() { return s_completion_pct; }
#endif
protected:
static const int FAT_PAGES = 8;
static const int DATA_PAGES = 32;

View File

@@ -38,9 +38,6 @@ namespace ipl {
}
const GXTexObj& getIconTexture() const { return mFaceTexObj; }
#ifdef IPL_ADDRESS_MATCHING
u8* getIconImage() const { return mpIconTex; }
#endif
u32 getIndex() const { return mFaceId; }
BOOL created() const { return mbCreated; }

View File

@@ -15,17 +15,10 @@
#define SAVEDATA_VERSION 3
namespace ipl {
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
namespace scene {
class SDChannelSelect;
}
#endif
namespace channel {
class Manager;
}
namespace savedata {
extern "C" BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
class Manager {
public:
Manager(EGG::Heap* heap);
@@ -34,9 +27,6 @@ namespace ipl {
void initManager();
void setPrevPage(int prevPage);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
int& getSDPrevPage() { return mData.prevSDPage; }
#endif
void setChanInfo(int page, int index, const channel::SInfo& chanInfo);
void setMemoSetting(const textinput::extend::savedata::MemoSetting& memoSetting);
@@ -58,13 +48,6 @@ namespace ipl {
int getPrevPage() { return mLastPrevPage; }
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
int getLastSDPrevPage() { return mLastSDPrevPage; }
void setLastSDPrevPage(int page) { mLastSDPrevPage = page; }
BOOL didntGotoSDMenu() const { return mData.didntGotoSDMenu; }
void setDidntGotoSDMenu(BOOL value) { mData.didntGotoSDMenu = value; }
#endif
bool hasPhotoMP3Dummy() { return mbPhotoMP3; }
bool hasPhoto2Title() { return mbPhoto2; }
bool hasPhoto2DummyCheck() { return mbPhoto2Check; }
@@ -77,9 +60,6 @@ namespace ipl {
void iplSavedata_813596B8(ESTitleId titleId);
private:
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
friend class ipl::scene::SDChannelSelect;
#endif
BOOL checkValidApp(ESTitleId titleId);
static void initManagerTask(void* work);
@@ -171,7 +151,6 @@ namespace ipl {
u8 unused_0x504[28];
friend class channel::Manager;
friend BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
};
} // namespace savedata
} // namespace ipl

View File

@@ -20,12 +20,7 @@ namespace ipl {
Date() : year(MIN_YEAR), month(MIN_MONTH), day(MIN_DAY) {}
Date(int myYear, int myMonth, int myDay) : year(myYear), month(myMonth), day(myDay) {}
#ifdef IPL_BOARD_DATE_CTOR_OUT_OF_LINE
Date(const OSCalendarTime& cal);
#else
Date(const OSCalendarTime& cal) : year(cal.year), month(cal.mon + 1), day(cal.mday) {}
#endif
#line 24 "include/utility/iplCalendar.h"
Date(const Date& date) : year(date.year), month(date.month), day(date.day) {}
static Date getMaxDate() {
@@ -132,9 +127,6 @@ namespace ipl {
return days[month - 1];
}
#ifdef IPL_BOARD_WEEK_FUNCTION_OUT_OF_LINE
static int getWeek(const Date& date) NO_INLINE;
#else
static int getWeek(const Date& date) NO_INLINE {
int month, year, day;
month = date.month;
@@ -146,8 +138,6 @@ namespace ipl {
}
return (day + (((month * 13) + 8) / 5) + ((year / 400) + ((year + (year / 4)) - (year / 100)))) % 7;
}
#endif
#line 147 "include/utility/iplCalendar.h"
static int getWeek(int year, int month, int day) NO_INLINE {
if (month <= 2) {

View File

@@ -49,9 +49,6 @@ namespace ipl {
public:
Scroller();
#ifdef IPL_SDMEMORY_SCROLLER_INIT_OUT_OF_LINE
void init();
#else
void init() {
mState = 0;
mScroll = 0.0f;
@@ -59,7 +56,6 @@ namespace ipl {
mUpLimit = 0.0f;
mDownLimit = 0.0f;
}
#endif
void calc();
f32 get() const;
@@ -73,9 +69,6 @@ namespace ipl {
void setDownLimit(f32 v) { mDownLimit = v; }
void setUpLimit(f32 v) { mUpLimit = v; }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mState = state; }
#endif
void addScroll(f32 v) { mScroll += v; }

View File

@@ -88,11 +88,7 @@ namespace nw4r {
PaneList& GetChildList() { return mChildList; }
const math::VEC3& GetTranslate() { return mTranslate; }
#ifdef IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE
void SetTranslate(const math::VEC3& translate);
#else
void SetTranslate(const math::VEC3& translate) { mTranslate = translate; }
#endif
void SetTranslate(const math::VEC2& translate) { SetTranslate(math::VEC3(translate.x, translate.y, 0.0f)); }
const math::VEC3& GetRotate() const { return mRotate; }

View File

@@ -55,12 +55,6 @@ namespace nw4r {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
return mTextColors[type];
}
#ifdef IPL_SDMEMORY_SET_TEXT_COLORS
void SetTextColors(const ut::Color& first, const ut::Color& second) {
mTextColors[0] = first;
mTextColors[1] = second;
}
#endif
void SetTextColor(u32 type, ut::Color value) {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
mTextColors[type] = value;

View File

@@ -50,10 +50,6 @@ namespace nw4r {
f32 FrSqrt(f32 x);
u32 CntBit1(u32 x);
#ifdef IPL_ADDRESS_MATCHING
inline f32 FSqrt(f32 x) { return (x <= 0.0f) ? 0.0f : x * FrSqrt(x); }
#endif
} // namespace math
} // namespace nw4r

View File

@@ -118,10 +118,6 @@ namespace nw4r {
return *this;
}
#ifdef IPL_ADDRESS_MATCHING
VEC2 operator-() const { return VEC2(-x, -y); }
#endif
VEC2 operator+(const VEC2& rhs) const { return VEC2(x + rhs.x, y + rhs.y); }
VEC2 operator-(const VEC2& rhs) const { return VEC2(x - rhs.x, y - rhs.y); }
VEC2 operator*(f32 val) const { return VEC2(val * x, val * y); }
@@ -134,10 +130,6 @@ namespace nw4r {
bool operator!=(const VEC2& rhs) const { return x != rhs.x || y != rhs.y; }
} VEC2;
#ifdef IPL_ADDRESS_MATCHING
inline f32 VEC2LenSq(const VEC2* p) { return p->x * p->x + p->y * p->y; }
#endif
typedef struct VEC3 VEC3;
inline VEC3* VEC3Transform(VEC3* pOut, const MTX34* pMtx, const VEC3* pVec);
@@ -157,15 +149,11 @@ namespace nw4r {
y = pF[1];
z = pF[2];
}
#if defined(IPL_SD_CHANNEL_SELECT_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fy;
z = fz;
}
#endif
operator Vec*() { return reinterpret_cast<Vec*>(this); }
operator const Vec*() const { return reinterpret_cast<const Vec*>(this); }

View File

@@ -16,9 +16,7 @@ namespace nw4r {
#endif
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#ifndef IPL_CONTROLLER_TRIVIAL_RECT_DTOR
~Rect() {}
#endif
void SetWidth(f32 width) { right = left + width; }
void SetHeight(f32 height) { bottom = top + height; }

View File

@@ -37,9 +37,6 @@ namespace nw4r {
} // namespace detail
template <typename TDerived, typename TBase>
#ifdef IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST
TDerived DynamicCast(TBase* pPtr);
#else
inline TDerived DynamicCast(TBase* pPtr) {
const detail::RuntimeTypeInfo* pDerivedTypeInfo = detail::GetTypeInfoFromPtr_(static_cast<TDerived>(NULL));
if (pPtr->GetRuntimeTypeInfo()->IsDerivedFrom(pDerivedTypeInfo)) {
@@ -47,7 +44,6 @@ namespace nw4r {
}
return NULL;
}
#endif
} // namespace ut
} // namespace nw4r

View File

@@ -133,7 +133,7 @@ void RFLiEndWorking(RFLErrcode errcode) {
RFLiEndWorkingReason(errcode, 0);
}
inline NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag) {
NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag) {
NANDCommandBlock* block = &RFLiGetAccInfo(type)->commandBlock;
RFLiCallbackTag* store = &RFLiGetAccInfo(type)->callbackTag;
@@ -147,7 +147,7 @@ inline NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag
return block;
}
inline RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
RFLiCallbackTag* stored;
RFLi_ASSERTLINE_NULL(block, 312);
@@ -159,7 +159,7 @@ inline RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
return stored->tag;
}
inline RFLiFileType RFLiGetType(NANDCommandBlock* block) {
RFLiFileType RFLiGetType(NANDCommandBlock* block) {
RFLiCallbackTag* stored;
RFLi_ASSERTLINE_NULL(block, 335);
@@ -171,7 +171,7 @@ inline RFLiFileType RFLiGetType(NANDCommandBlock* block) {
return stored->type;
}
inline NANDFileInfo* RFLiGetWorkingFile(RFLiFileType type) {
NANDFileInfo* RFLiGetWorkingFile(RFLiFileType type) {
RFLi_ASSERTLINE_RANGE(type, RFLiFileType_Database, RFLiFileType_Max, 356);
if (!RFLAvailable()) {

View File

@@ -160,12 +160,11 @@ typedef struct _ziGetParam {
ziWChar* candidates; // 0x18
ziU8 maxCandidates; // 0x1C
ziWChar firstCandidate; // 0x1E
ziU8 unk_0x20; // 0x20
ziU8 wordCandidates; // 0x1F
ziU8 count; // 0x20
ziU8 letters; // 0x21
ziU8 count; // 0x22
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
ziU8* scratch; // 0x22
} ziGetParam;
typedef struct _ziLanguageEntry {
@@ -173,195 +172,20 @@ typedef struct _ziLanguageEntry {
ziU8* tableData; // 0x04
} ziLanguageEntry;
typedef struct _zi8DawgRec {
ziU8* node;
ziU32 attr;
ziU16 key;
ziU8 unk_0x0A[2];
ziU8* back;
} zi8DawgRec;
typedef struct _zi8DawgCtx {
ziU8 lang; // 0x00
ziU8 key; // 0x01
ziU16 cnt; // 0x02
ziU16 cap; // 0x04
ziU8 unk_0x06[2];
ziU8* p08; // 0x08
ziU8* p0C; // 0x0C
ziU8* table; // 0x10
ziU8* p14; // 0x14
zi8DawgRec recs[0x32]; // 0x18
ziU32 unk_0x338; // 0x338
} zi8DawgCtx;
typedef struct _ziUwdNode {
struct _ziUwdNode* next;
ziU8* word;
} ziUwdNode;
struct __zi8_work_data_s {
ziU8 unk_0x00;
ziU8 unk_0x01;
ziU8 unk_0x02[2];
ziLanguageEntry* langEntries; // 0x04
ziU8 unk_0x08;
ziU8 unk_0x09;
ziU8 unk_0x0A;
ziU8 unk_0x0B;
ziU32 unk_0x08;
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 unk_0x16;
ziU8 unk_0x17;
ziU32 unk_0x14;
ziU8 unk_0x18;
ziU8 unk_0x19;
ziU16 unk_0x1A;
ziU8 unk_0x1C[3];
ziU8 unk_0x1F;
ziU16 unk_0x20[0x40];
ziU16 unk_0xA0[0x42];
ziU8 unk_0x1C[0x108];
ziU16* unk_0x124[1];
ziU8* unk_0x128;
ziU8 unk_0x12C;
ziU8 unk_0x12D;
ziU8 unk_0x12E;
ziU8 unk_0x12F;
ziPtr unk_0x130[2];
ziU8 unk_0x138;
ziU8 unk_0x139[3];
ziU32 unk_0x13C;
ziU8 unk_0x140;
ziU8 unk_0x141[0x43];
ziU8 unk_0x184[0x43];
ziU8 uwdCount; // 0x1C7
ziUwdNode uwdNodes[0x20]; // 0x1C8
ziUwdNode* uwdList; // 0x2C8
ziU32 pudTable[0x10]; // 0x2CC
ziU8 pudCount; // 0x30C
ziU8 unk_0x30D[3];
ziU32 unk_0x310;
ziU32 unk_0x314;
ziU32 unk_0x318;
ziU8 pdRemoveOpt; // 0x31C
ziU8 unk_0x31D;
ziU8 unk_0x31E;
ziU8 unk_0x31F;
ziU8 (*oemMatch)(ziU16 idx, ziWChar* buf, ziU8 len, ziPtr data); //0x320
ziU16 oemLen; //0x324
ziU8 unk_0x326[2];
ziU32 oemIdx; //0x328
ziPtr oemData; //0x32C
ziU8 unk_0x330[8];
ziU32 unk_0x338;
ziU8 unk_0x33C[0x1FC];
ziU8 unk_0x538;
ziU8 unk_0x539;
ziU8 unk_0x53A[0x40];
ziWChar unk_0x57A[0x641];
ziPtr unk_0x11FC;
ziPtr userKeys[0x83]; // 0x1200
ziU8 unk_0x140C[4];
ziU32 unk_0x1410;
ziU8 unk_0x1414[4];
ziU8 unk_0x1418;
ziU8 unk_0x1419;
ziU16 unk_0x141A;
ziU8 unk_0x141C;
ziU8 unk_0x141D;
ziU8 unk_0x141E;
ziU8 unk_0x141F;
ziU8 unk_0x1420[4];
zi8DawgCtx dawgCtx; // 0x1424
ziU8 unk_0x1760[4]; // 0x1760
ziU8* unk_0x1764; // 0x1764
ziU8 unk_0x1768;
ziU8 unk_0x1769[0x81];
ziU16 unk_0x17EA;
ziU8 unk_0x17EC;
ziU8 unk_0x17ED[3];
ziU8* unk_0x17F0;
ziWChar unk_0x17F4[0x40]; // 0x17F4..0x1874
ziU16 unk_0x1874;
ziU8 unk_0x1876;
ziU8 unk_0x1877;
ziU8 unk_0x1878;
ziU8 unk_0x1879;
ziWChar unk_0x187A[0x41];
ziU8 unk_0x18FC;
ziU8 unk_0x18FD;
ziWChar unk_0x18FE[0x41];
ziU8 unk_0x1980;
ziU8 unk_0x1981;
ziU8 unk_0x1982;
ziU8 unk_0x1983;
ziU8 unk_0x1984;
ziU8 unk_0x1985;
ziU8 unk_0x1986;
ziU8 unk_0x1987;
ziWChar unk_0x1988[0x41];
ziU8 unk_0x1A0A;
ziU8 unk_0x1A0B[0x85];
ziWChar unk_0x1A90;
ziWChar unk_0x1A92[0x41];
ziU8 unk_0x1B14;
ziU8 unk_0x1B15[3];
ziU16* unk_0x1B18;
ziU16 unk_0x1B1C;
ziU16 unk_0x1B1E;
ziU16 unk_0x1B20;
ziU16 unk_0x1B22;
ziU8 unk_0x1B24;
ziU8 unk_0x1B25[3];
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B28;
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B2C;
ziU8 unk_0x1B30;
ziU8 unk_0x1B31;
ziU16 unk_0x1B32;
ziU16 unk_0x1B34;
ziU16 unk_0x1B36;
ziU16 unk_0x1B38;
ziU8 unk_0x1B3A;
ziU8 unk_0x1B3B;
ziU8 unk_0x1B3C;
ziU8 unk_0x1B3D;
ziU8 unk_0x1B3E;
ziU8 unk_0x1B3F;
ziU16 unk_0x1B40;
ziU8 unk_0x1B42[2];
};
typedef struct ziMatchParam {
ziU8 count; // 0x00
ziU8 arr1[0xC]; // 0x01
ziU8 arrD[0xC]; // 0x0D
ziU8 arr19[4]; // 0x19
ziU8 arr1D[4]; // 0x1D
ziU8 pad_0x21; // 0x21
ziU16 field22; // 0x22
ziU8 length; // 0x24
ziU8 nCand; // 0x25
ziWChar phon[0x10]; // 0x26
ziWChar phon2[0x10]; // 0x46
ziWChar first; // 0x66
ziWChar first2; // 0x68
ziWChar comp; // 0x6A
ziU8 nSeg; // 0x6C
ziU8 segs1[0xC0]; // 0x6D
ziU8 segsD[0xC0]; // 0x12D
ziU8 pad_0x1ED; // 0x1ED
} ziMatchParam;
#define ZI_WORK ((struct __zi8_work_data_s*)__zi8_work_data)
#define ZI_NEED_WORK , ziPtr __zi8_work_data

View File

@@ -1,49 +0,0 @@
#include <zi8clib/zitypes.h>
const ziWChar Zi8PunctTable[40] = {
0xFF0C, 0x3002, 0x3001, 0xFF1A, 0xFF1F, 0xFF01, 0x3005, 0x2026,
0x2015, 0xFF1B, 0xFF0E, 0x30FB, 0x201C, 0x201D, 0xFF08, 0xFF09,
0x300C, 0x300D, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15,
0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF0F, 0xFF05, 0xFFE5, 0xFF04,
0xFFE1, 0x20AC, 0x203B, 0xFF20, 0x0000,
};
ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
ziS32 limit = ((ziU16*)__zi8_work_data)[8] - 1;
ziS32 count = 0;
ziU8 i = 0;
ziU16 fc = param->firstCandidate;
ziU16 j = 0;
for (;;) {
if (Zi8PunctTable[j] == 0) {
break;
}
if (fc == 0) {
count++;
if (ZI_WORK->unk_0x00 == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
if ((ziU8)i >= limit) {
break;
}
}
if (count >= param->maxCandidates) {
break;
}
} else {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
return count;
}
}
} else {
fc--;
}
j++;
}
if (ZI_WORK->unk_0x00 == 0) {
param->letters = count;
}
return count;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,108 +0,0 @@
#include <zi8clib/zitypes.h>
ziU16 Zi8MatchAltSound(ziU8* elements, ziU16 count, ziU8* table, ziU16 ch,
ziU32 mask, ziU16 target, ziU8 flags ZI_NEED_WORK) {
ziU8 hi;
ziU8 lo;
ziS32 i;
ziS32 j;
ziS32 mid;
ziU16 off;
ziU16 w;
hi = (ziU8)((ziU16)ch >> 8);
lo = (ziU8)ch;
flags = (ziU8)(flags >> 3);
if (count == 0) {
return 0;
}
j = 0;
i = count - 1;
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
j = i;
goto up;
}
if ((elements + j * 4)[1] == hi && (elements + j * 4)[0] == lo) {
goto up;
}
goto search;
up:
i = j;
body:
if (((elements + i * 4)[3] & 0xE) == 0 ||
((elements + i * 4)[3] & flags) != 0) {
off = (ziU16)(((ziU16)(elements + i * 4)[2] |
(((ziU16)(elements + i * 4)[3] & 1) << 8)) << 1);
w = (ziU16)((((ziU16)(elements + i * 4)[3] & 0xF0) >> 4) |
(table[off] | ((ziU16)table[off + 1] << 8)));
if (target == (w & (ziU16)mask)) {
return w;
}
}
i++;
if (i >= count) {
goto down_start;
}
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
goto body;
}
down_start:
i = j;
goto dec;
down_body:
if (((elements + i * 4)[3] & 0xE) == 0 ||
((elements + i * 4)[3] & flags) != 0) {
off = (ziU16)(((ziU16)(elements + i * 4)[2] |
(((ziU16)(elements + i * 4)[3] & 1) << 8)) << 1);
w = (ziU16)((((ziU16)(elements + i * 4)[3] & 0xF0) >> 4) |
(table[off] | ((ziU16)table[off + 1] << 8)));
if (target == (w & (ziU16)mask)) {
return w;
}
}
dec:
i--;
if (i < 0) {
goto fail;
}
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
goto down_body;
}
fail:
return 0;
search:
if ((elements + j * 4)[1] == hi && (elements + j * 4)[0] == lo) {
goto up;
}
if ((((ziU16)(elements + j * 4)[1] << 8) | (ziU16)(elements + j * 4)[0]) > ch) {
return 0;
}
mid = (j + i) / 2;
if (mid == j) {
return 0;
}
if ((((ziU16)(elements + mid * 4)[1] << 8) | (ziU16)(elements + mid * 4)[0]) >= ch) {
i = mid;
goto hi_check;
}
j = mid;
goto search;
hi_check:
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
j = i;
goto up;
}
if ((((ziU16)(elements + i * 4)[1] << 8) | (ziU16)(elements + i * 4)[0]) < ch) {
return 0;
}
mid = (j + i) / 2;
if (mid == j) {
return 0;
}
if ((((ziU16)(elements + mid * 4)[1] << 8) | (ziU16)(elements + mid * 4)[0]) >= ch) {
i = mid;
goto hi_check;
}
j = mid;
goto search;
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,212 +0,0 @@
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU8 Zi8getKeyLayout(ziU8 lang, ziU16 key, ziWChar* layout, ziU8 mode ZI_NEED_WORK);
extern ziChar Zi8ConvertWC2UC(ziWChar ch, ziU8 language ZI_NEED_WORK);
extern ziU32 Zi8AlphaGetCandidates(ziGetParam* param, ziPtr sw ZI_NEED_WORK);
extern ziU8 Zi8SyllablesROMdata(ziWChar* keys, ziU8 count, ziU8 lang, ziWChar* out,
ziU16 a, ziU8 b, ziU8* cntOut, ziU8 c ZI_NEED_WORK);
typedef struct _ziSwParam {
ziU8 flag;
ziU8 unk_0x01[0xB];
ziS32 count;
ziU16 cap;
ziU8 unk_0x12[2];
} ziSwParam;
ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
ziWChar buf[0x40];
ziWChar buf2[0x32];
ziS32 rem;
ziS32 cur;
ziS32 firstCand;
ziS32 count;
ziWChar* pNext;
ziU16 err;
ziU8 flag14;
ziU8 flag13;
ziU8 flag12;
ziU8 flag11;
ziU8 sylCnt;
ziWChar* out;
ziU8* u28;
ziS32 i;
firstCand = param->firstCandidate;
count = 0;
u28 = 0;
pNext = 0;
flag14 = 1;
flag13 = 1;
flag12 = 0;
flag11 = 0;
sylCnt = 0;
err = 0x64;
if (param->currentWord != 0 && param->wordCharCount != 0 &&
param->currentWord[param->wordCharCount - 1] != 0x20) {
flag11 = 1;
}
if (param->elementCount == 0 || (param->elementCount == 1 && flag11 == 0)) {
count = Zi8AlphaGetCandidates(param, sw, ZI_WORK);
goto end;
}
if (sw->flag != 0 || (param->getOptions & 0xFD) != 0x81) {
out = buf;
rem = 0x40;
} else {
out = (ziWChar*)param->candidates;
rem = sw->cap - 1;
}
if ((param->getOptions & 0xFD) == 0x80) {
u28 = (ziU8*)param->candidates;
rem = sw->cap - 1;
}
if (rem <= param->elementCount) {
err = 0x168;
goto end;
}
if ((Zi8GetTableCount(param->language, 0x1F, ZI_WORK) & 8) != 0) {
flag14 = 0;
}
if (param->elements[0] == 0xEFF1 && param->elementCount > 1 && flag14 != 0) {
buf[0] = 0x2D;
} else {
Zi8getKeyLayout(param->language, param->elements[0], buf, 1, ZI_WORK);
}
out[0] = buf[0];
Zi8SyllablesROMdata(param->elements, param->elementCount, param->language, out,
(ziU16)rem, 0, &sylCnt, flag11, ZI_WORK);
if (sylCnt != 0) {
cur = sylCnt;
} else {
cur = 1;
}
if (cur == param->elementCount) goto L5dc;
if (firstCand != 0) {
firstCand--;
goto L5dc;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L5dc;
}
for (i = cur; i < param->elementCount; i += sylCnt) {
if (param->elements[i] == 0xEFF1 && param->elementCount - i > 1 && flag14 != 0) {
buf2[0] = 0x2D;
} else {
Zi8getKeyLayout(param->language, param->elements[i], buf2, 1, ZI_WORK);
}
out[i] = buf2[0];
Zi8SyllablesROMdata(param->elements + i, param->elementCount - i, param->language,
out + i, (ziU16)rem, 0, &sylCnt, 1, ZI_WORK);
if (sylCnt == 0) {
sylCnt = 1;
}
}
if (u28 != 0) {
for (i = 0; i < param->elementCount; i++) {
u28[i] = Zi8ConvertWC2UC(out[i], param->language, ZI_WORK);
}
u28[i++] = 0;
u28[i] = 0;
u28 += i;
} else {
out[i++] = 0;
out[i] = 0;
out += i;
}
rem -= i;
if (++count >= param->maxCandidates) goto end;
if (rem > param->elementCount) goto L5dc;
goto end;
L5dc:
while (cur >= 1) {
flag12 = 0;
goto rom;
found:
flag12 = 1;
if (cur == 1) {
flag13 = 0;
}
L464:
if (out[0] >= 0xEFF1 && out[0] <= 0xF010) {
goto dec;
}
L464b:
if (firstCand != 0) {
firstCand--;
goto L560;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L560;
}
if (u28 != 0) {
for (i = 0; i < cur; i++) {
u28[i] = Zi8ConvertWC2UC(out[i], param->language, ZI_WORK);
}
u28[i++] = 0;
u28[i] = 0;
u28 += i;
} else {
i = cur;
out[i++] = 0;
out[i] = 0;
out += i;
}
rem -= i;
if (++count >= param->maxCandidates) goto end;
if (rem <= cur) goto end;
L560:
if (pNext != 0) {
if (*pNext == 0) goto end;
out[0] = *pNext++;
goto L464b;
}
rom:
if (Zi8SyllablesROMdata(param->elements, (ziU8)cur, param->language, out,
(ziU16)rem, flag12, 0, flag11, ZI_WORK) != 0) {
goto found;
}
dec:
cur--;
}
if (flag13 == 0) goto end;
if (param->elements[0] == 0xEFF1 && param->elementCount > 1 && flag14 != 0) {
buf2[0] = 0x2D;
buf2[1] = 0;
Zi8getKeyLayout(param->language, param->elements[0], &buf2[1], 1, ZI_WORK);
for (i = 1; buf2[i] != 0; i++) {
if (buf2[i] == 0x2D) break;
}
while (buf2[i] != 0) {
buf2[i] = buf2[i + 1];
i++;
}
} else {
Zi8getKeyLayout(param->language, param->elements[0], buf2, 1, ZI_WORK);
}
cur = 1;
pNext = buf2;
goto L560;
end:
if (sw->flag != 0) {
param->letters = 0;
} else {
param->letters = (ziU8)count;
}
Zi8LogError(err, ZI_WORK);
return count;
}

View File

@@ -1,15 +0,0 @@
#include <zi8clib/zi8getc.h>
#include <zi8clib/zitypes.h>
extern ziU8 _Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK);
ziU8 Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK) {
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3D = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
return _Zi8GetCandidates(getParam, ZI_WORK);
}

View File

@@ -1,75 +0,0 @@
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
extern void Zi8Memset(ziPtr p, ziU32 v, ziU32 len);
extern void Zi8SetLatinSearchOrder(ziU32 a, ziU8 b ZI_NEED_WORK);
extern void ZADP_Zi8SetPDremoveOpt(ziU8 a ZI_NEED_WORK);
extern ziU16 Zi8GetFormatVersion(ziU8 a ZI_NEED_WORK);
extern void Zi8ZHsetZYfuzzyPairs(ziU32* a ZI_NEED_WORK);
extern void Zi8ZHsetPYfuzzyPairs(ziU32* a ZI_NEED_WORK);
extern void Zi8SetParentalControls(ziU8 a ZI_NEED_WORK);
ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ziU32 zyFuzzy;
ziU32 pyFuzzy;
ziU32* pzyFuzzy;
ziU32* ppyFuzzy;
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->unk_0x1A = 0x20;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B40 = 0;
ZI_WORK->unk_0x1B38 = 0;
ZI_WORK->langEntries = langEntries;
if (ZI_WORK->langEntries == ZI8_NULL) {
Zi8LogError(0x578, ZI_WORK);
return 0;
}
if (ZI_WORK->langEntries->language == 0) {
Zi8LogError(0x582, ZI_WORK);
return 0;
}
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->unk_0x538 = 0;
ZI_WORK->unk_0x1C[3] = 0;
ZI_WORK->unk_0x141A = 0x100;
Zi8SetLatinSearchOrder(0, 0, ZI_WORK);
ZADP_Zi8SetPDremoveOpt(1, ZI_WORK);
ZI_WORK->unk_0x17 = 5;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->unk_0x1B28.bits.msb = 1;
ZI_WORK->unk_0x1B2C.bits.msb = 1;
zyFuzzy = ZI_WORK->unk_0x1B2C.word;
pzyFuzzy = &zyFuzzy;
Zi8ZHsetZYfuzzyPairs(pzyFuzzy, ZI_WORK);
pyFuzzy = ZI_WORK->unk_0x1B28.word;
ppyFuzzy = &pyFuzzy;
Zi8ZHsetPYfuzzyPairs(ppyFuzzy, ZI_WORK);
Zi8SetParentalControls(2, ZI_WORK);
Zi8LogError(0x64, ZI_WORK);
return 1;
}
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len) {
if ((ziU16)len > 6 && p[0] == 0x7A && p[1] == 0x69 && p[2] == 0x63 &&
p[3] == 0x6F && p[4] == 0x72 && p[5] == 0x70) {
return 1;
}
if ((ziU16)len > 6 && p[0] == 0x39 && p[1] == 0x34 && p[2] == 0x32 &&
p[3] == 0x36 && p[4] == 0x37 && p[5] == 0x37) {
return 1;
}
return 0;
}

View File

@@ -1,138 +0,0 @@
#include <zi8clib/zi8is.h>
#include <zi8clib/zierror.h>
extern ziU8 Zi8LangSupported(ziU8 lang ZI_NEED_WORK);
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU8 _Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK);
extern void Zi8Memset(ziPtr p, ziU32 v, ziU32 len);
ziU8 Zi8GetZHCharSet(ziPtr workData) {
ziU8 charSet = 0;
ziU8 bak;
ziU16 v0;
ziU16 v1;
ziU16 v2;
ziU32 addr;
ziU8* p;
ziWChar candBuf[0x10];
ziGetParam getParam;
Zi8LogError(0x64, workData);
if (Zi8LangSupported(1, workData) == 0) {
Zi8ReplaceLastError(0x26C, workData);
return 0;
}
if (Zi8GetTableCount(1, 10, workData) != 0) {
bak = ((struct __zi8_work_data_s*)workData)->unk_0x18;
((struct __zi8_work_data_s*)workData)->unk_0x18 = 1;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v0 = (ziU16)((ziU16)p[0] | ((ziU16)p[1] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = 0;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v1 = (ziU16)((ziU16)p[2] | ((ziU16)p[3] << 8));
v2 = (ziU16)((ziU16)p[4] | ((ziU16)p[5] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = bak;
if (v0 != 0) {
if (v0 > 0x4E20) {
charSet |= 8;
} else {
charSet |= 1;
}
}
if (v1 != 0) {
if (v1 > 0x2710) {
charSet |= 2;
} else {
charSet |= 0x10;
}
}
if (v2 != 0) {
charSet |= 4;
}
return charSet;
}
Zi8Memset(&getParam, 0, 0x2C);
getParam.language = 1;
getParam.context = 1;
getParam.getOptions = 0;
getParam.candidates = candBuf;
getParam.maxCandidates = 1;
getParam.subLanguage = 1;
retry:
getParam.getMode = 0;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
goto next;
}
getParam.getMode = 1;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
goto next;
}
getParam.getMode = 2;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
}
next:
if (getParam.subLanguage == 1) {
getParam.subLanguage = 4;
goto retry;
}
if (getParam.subLanguage == 4) {
getParam.subLanguage = 2;
goto retry;
}
return charSet;
}
ziBool Zi8IsComponent(ziWChar ch ZI_NEED_WORK) {
if (ch >= 0xEF10 && ch < 0xF305) {
return 1;
}
return 0;
}
ziBool Zi8IsCharacter(ziWChar ch ZI_NEED_WORK) {
ziU16 count;
ziU8 hi;
ziU8 lo;
ziU32 addr;
ziU8* table;
ziU16 i;
if (ch >= 0x3105 && ch <= 0x3129) {
return 1;
}
switch (ch) {
case 0x2C7:
case 0x2C9:
case 0x2CA:
case 0x2CB:
case 0x2D9:
return 1;
}
switch (ch) {
case 0x3002:
case 0xFF01:
case 0xFF0C:
case 0xFF1F:
return 1;
}
hi = (ziU8)(((ziU16)ch >> 8) & 0xFF);
lo = (ziU8)ch;
count = Zi8GetTableCount(1, 0, ZI_WORK);
addr = Zi8GetTableAddress(1, 0, ZI_WORK);
table = (ziU8*)addr;
for (i = 0; i < count; i++) {
if (table[6] == hi && table[7] == lo) {
return 1;
}
table += 0xC;
}
return 0;
}

View File

@@ -1,144 +0,0 @@
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
typedef struct { ziU8 b[0xC]; } ziE12;
#define WORKP ((struct __zi8_work_data_s*)__zi8_work_data)
ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
ziU8 hi;
ziU8 lo;
ziU16 count;
ziU32 table;
ziU32 table2;
ziU16 i;
ziU8* e;
ziU8* p;
hi = (ziU8)(((ziU16)ch >> 8) & 0xFF);
lo = (ziU8)ch;
count = Zi8GetTableCount(1, 0, __zi8_work_data);
table = Zi8GetTableAddress(1, 0, __zi8_work_data);
table2 = Zi8GetTableAddress(1, 1, __zi8_work_data);
if (buf == ZI8_NULL) {
for (i = 0; i < 0x40; i++) {
if (ch == WORKP->unk_0x20[i]) {
i = WORKP->unk_0xA0[i];
e = (ziU8*)table + i * 0xC;
if (i >= count) {
break;
}
if (hi != e[6] || lo != e[7]) {
break;
}
p = (ziU8*)(table2 +
(((e[9] & 0xF) << 16) |
(e[0xB] | (e[0xA] << 8))));
if (WORKP->unk_0x16 != 0) {
switch (p[0] & 7) {
case 2:
p += 2;
break;
case 3:
case 4:
p += 3;
break;
case 5:
p += 4;
break;
default:
p += 1;
break;
}
}
if ((p[0] & 0x80) == 0) {
break;
}
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
}
}
e = (ziU8*)table;
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->unk_0x18) {
if ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
goto map;
}
if ((ziU16)ch >= WORKP->unk_0x1B20 && (ziU16)ch <= WORKP->unk_0x1B22) {
i = (ziU16)(WORKP->unk_0x1B1E + (ch - WORKP->unk_0x1B20) -
WORKP->unk_0x1B1C + 1);
goto map;
}
return 0xFFFF;
map:
i = WORKP->unk_0x1B18[i];
if (i != 0xFFFF) {
e = (ziU8*)table + i * 0xC;
if (hi == e[6] && lo == e[7]) {
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
}
return 0xFFFF;
}
i = 0;
while (i < count) {
if (lo == e[7] && hi == e[6]) {
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
e += 0xC;
i++;
}
return 0xFFFF;
}
ziU16 Zi8Uni2Ord(ziU16 ch ZI_NEED_WORK) {
return Zi8Uni2Ptr(ch, ZI8_NULL, __zi8_work_data);
}
ziU16 Zi8Ord2Uni(ziU16 ord ZI_NEED_WORK) {
ziU8* p;
if ((ziU16)ord >= Zi8GetTableCount(1, 0, __zi8_work_data)) {
Zi8LogError(0x132, __zi8_work_data);
return 0;
}
p = (ziU8*)Zi8GetTableAddress(1, 0, __zi8_work_data);
p += ord * 0xC;
Zi8LogError(0x64, __zi8_work_data);
return (ziU16)(((ziU16)p[6] << 8) + p[7]);
}
ziU16 Zi8Ord2Ord(ziU16 ord ZI_NEED_WORK) {
ziU32 table;
ziU16 count;
ziU8* p;
count = Zi8GetTableCount(1, 0, __zi8_work_data);
table = Zi8GetTableAddress(1, 0, __zi8_work_data);
if (ord == 0 || (ziU16)ord >= count) {
Zi8LogError(0x132, __zi8_work_data);
return ord;
}
p = (ziU8*)table + (ord - 1) * 0xC;
while (ord != 0) {
if (p[6] != p[0x12] || p[7] != p[0x13]) {
break;
}
p -= 0xC;
ord--;
}
Zi8LogError(0x64, __zi8_work_data);
return ord;
}

View File

@@ -1,99 +0,0 @@
#include <zi8clib/zi8space.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zitypes.h>
extern ziU8 Zi8GetPyPhonetic(ziWChar* src, ziU8 i, ziWChar* a, ziWChar* b, ziU8* c,
ziU16* d, ziU16* e ZI_NEED_WORK);
extern ziU8 Zi8GetBpmfPhonetic(ziWChar* src, ziU8 i, ziWChar* a, ziWChar* b,
ziU16* d, ziU16* e ZI_NEED_WORK);
ziU8 Zi8ZHaddSpace(ziWChar* src, ziU8 count, ziWChar* dst,
ziU16 maxLen ZI_NEED_WORK) {
ziWChar candBuf[0x10];
ziWChar pyBuf[0x10];
ziU16 m;
ziU16 vE;
ziU16 vC;
ziU8 n;
ziU8 flag;
ziU8 v9;
ziU8 isPy;
int i;
int k;
ziWChar* psrc;
ziWChar* pdst;
psrc = src;
n = count;
pdst = dst;
m = maxLen;
if (n == 0) {
Zi8LogError(0x137, ZI_WORK);
return 0;
}
if ((psrc[0] >= 0xF361 && psrc[0] <= 0xF37A) ||
(psrc[0] >= 0xF341 && psrc[0] <= 0xF35A)) {
isPy = 1;
} else if (psrc[0] >= 0xF305 && psrc[0] <= 0xF329) {
isPy = 0;
} else {
goto fail;
}
i = 2;
while (i <= n) {
if (isPy) {
flag = Zi8GetPyPhonetic(psrc, i, candBuf, pyBuf, &v9, &vE, &vC, ZI_WORK);
if (i == v9) {
i++;
continue;
}
} else {
if ((psrc[i - 1] == 0xF360 && psrc[i - 2] != 0xF360) ||
Zi8GetBpmfPhonetic(psrc, i, candBuf, pyBuf, &vE, &vC, ZI_WORK) !=
0) {
i++;
continue;
}
}
if (i-- >= m - 1) {
goto fail;
}
m -= i + 1;
for (k = 0; k < i; k++) {
pdst[k] = psrc[k];
}
if (pdst[k - 1] != 0xF360 &&
(pdst[k - 1] < 0xF331 || pdst[k - 1] > 0xF335)) {
pdst[k++] = ZI_WORK->unk_0x1A;
}
psrc += i;
n -= i;
pdst += k;
i = 2;
}
if (i-- > m) {
goto fail;
}
for (k = 0; k < i; k++) {
pdst[k] = psrc[k];
}
pdst[k] = 0;
Zi8LogError(0x64, ZI_WORK);
return 1;
fail:
if ((ziU8)count >= (ziU16)maxLen) {
count = (ziU8)(maxLen - 1);
}
for (i = 0; i < count; i++) {
dst[i] = src[i];
}
dst[i] = 0;
Zi8LogError(0x64, ZI_WORK);
return 1;
}

View File

@@ -1,534 +0,0 @@
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 value;
ziU16 count;
ziU32 i;
count = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
for (i = 0; (ziU16)i < count; i++) {
value = (ziU16)(((ziU16)table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 7] << 8) |
table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 8]);
if (key == value) {
Zi8LogError(0x64, ZI_WORK);
return i;
}
}
Zi8LogError(0x96A, ZI_WORK);
return 0xFFFF;
}
void Zi8_81483118(ziGetParam* param, ziU8* output) {
ziU8 i;
for (i = 0; i < 5; i++) {
output[i] = 0;
}
switch (param->elementCount) {
case 9:
output[4] |= (ziU8)((param->elements[8] & 0xF) << 4);
case 8:
output[3] = param->elements[7] & 0xF;
case 7:
output[3] |= (ziU8)((param->elements[6] & 0xF) << 4);
case 6:
output[2] = param->elements[5] & 0xF;
case 5:
output[2] |= (ziU8)((param->elements[4] & 0xF) << 4);
case 4:
output[1] = param->elements[3] & 0xF;
case 3:
output[1] |= (ziU8)((param->elements[2] & 0xF) << 4);
case 2:
output[0] = param->elements[1] & 0xF;
case 1:
output[0] |= (ziU8)((param->elements[0] & 0xF) << 4);
case 0:
break;
}
}
ziU32 Zi8_81483264(const ziGetParam* param ZI_NEED_WORK) {
ziU8 i;
if (param->scratch == ZI8_NULL) {
Zi8LogError(0x164, ZI_WORK);
return 1;
}
for (i = 0; i < param->maxCandidates; i++) {
((ziU16*)param->scratch)[i] = 0;
}
Zi8LogError(0x64, ZI_WORK);
return 0;
}
ziU32 Zi8_81483308(ziGetParam* param, ziU16 key, ziU8* count ZI_NEED_WORK) {
ziU8 i;
Zi8LogError(0x64, ZI_WORK);
if (param->scratch == ZI8_NULL) {
Zi8ReplaceLastError(0x164, ZI_WORK);
return 1;
}
for (i = 0; i < param->maxCandidates; i++) {
if (key == ((ziU16*)param->scratch)[i]) {
return 1;
}
}
((ziU16*)param->scratch)[*count] = key;
if (++*count >= param->maxCandidates) {
*count = 0;
}
return 0;
}
ziBool Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU8 i;
Zi8LogError(0x64, ZI_WORK);
if (param->scratch == ZI8_NULL) {
Zi8ReplaceLastError(0x164, ZI_WORK);
return 0;
}
for (i = 0; i < param->maxCandidates; i++) {
if (key == ((ziU16*)param->scratch)[i]) {
return 1;
}
}
return 0;
}
ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
ziU8* inserted ZI_NEED_WORK) {
ziBool matches;
ziS32 entry;
ziS32 tableA;
ziS32 tableB;
ziU16 tableCount;
ziU8 matched;
ziU32 j;
ziS32 i;
ziU8 candidateIndex;
union {
ziU32 words[13];
ziU8 bytes[52];
} local;
matched = 0;
local.words[0] = 0;
local.bytes[4] = 0;
Zi8LogError(0x64, ZI_WORK);
if (param->elementCount == 0) {
if (*remaining >= *count) {
for (i = 0; i < *count; i++) {
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
*remaining = *remaining - *count;
*count = 0;
} else {
for (i = 0; i < *remaining; i++) {
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
for (i = 0; i < ((ziS32)*count - (ziS32)*remaining); i++) {
param->candidates[i] = param->candidates[(ziU32)*remaining + i];
}
*count = *count - (ziU8)*remaining;
*remaining = 0;
}
return 1;
} else if (param->elementCount <= 9) {
tableA = Zi8GetTableAddress(param->language, 9, ZI_WORK);
tableB = Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (tableA == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
return 0;
} else if (tableB == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
return 0;
} else {
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local.bytes);
i = 0;
while (i < tableCount && matched < *count) {
matches = ZI8_TRUE;
entry = (i << 3) + tableA + i;
j = 0;
if (param->elementCount > 1) {
for (j = 0; (j & 0xFF) < (ziU32)(param->elementCount >> 1); j++) {
if (local.bytes[j & 0xFF] != *((ziU8*)entry + (j & 0xFF))) {
matches = ZI8_FALSE;
break;
}
}
}
if (matches && (param->elementCount & 1) != 0 &&
((local.bytes[j & 0xFF] & 0xF0) != (*((ziU8*)entry + (j & 0xFF)) & 0xF0))) {
matches = ZI8_FALSE;
}
if (matches) {
for (candidateIndex = 0; candidateIndex < *count; candidateIndex++) {
if (param->candidates[candidateIndex] ==
(ziU16)((*((ziU8*)entry + 7) << 8) | *((ziU8*)entry + 8))) {
matched++;
param->candidates[candidateIndex] =
param->candidates[candidateIndex] & 0x7FFF;
break;
}
}
}
i++;
}
if ((ziU16)matched >= *remaining) {
matched = *count;
*count = 0;
for (i = 0; i < matched; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
if (*remaining == 0) {
if (*count != i) {
param->candidates[*count] = param->candidates[i];
}
*count = *count + 1;
} else {
*remaining = *remaining - 1;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
}
}
*remaining = 0;
} else {
for (i = 0; i < *count; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
}
*remaining = *remaining - (ziU16)matched;
*count = 0;
}
}
} else {
*count = 0;
return 0;
}
return 0;
}
ziU32 Zi8GetKOcandidates(ziGetParam* param, ziU8* options ZI_NEED_WORK) {
ziBool bVar1;
ziU8 bVar2;
ziS32 iVar4;
ziU32 uVar6;
ziU8* pbVar7;
union {
ziU32 words[10];
ziU8 bytes[40];
} local_28;
ziU8 local_57;
ziU8 local_56;
ziU8 local_55;
ziU8 local_54;
ziU8 local_53;
ziS8 local_52;
ziU16 local_50;
ziU16 local_4E;
ziU16 local_4C;
ziU16 local_4A;
ziU16 local_48;
ziS32 local_44;
ziS32 local_2C;
ziS32 local_30;
ziU32 local_34;
ziU32 local_38;
ziU32 local_3C;
ziU32 local_40;
local_4E = 0xFFFF;
local_34 = 0;
local_28.words[0] = 0;
local_28.bytes[4] = 0;
local_52 = 0;
local_53 = 0;
local_54 = 0;
local_55 = 0;
local_50 = param->firstCandidate;
local_3C = 0;
local_40 = 0;
local_57 = 0;
Zi8LogError(100, ZI_WORK);
Zi8_81483264(param, ZI_WORK);
iVar4 = Zi8GetTableAddress(ZI8_LANG_KO, 9, ZI_WORK);
local_2C = Zi8GetTableAddress(ZI8_LANG_KO, 10, ZI_WORK);
if (iVar4 == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
uVar6 = 0;
} else {
if (local_2C == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
uVar6 = 0;
goto LAB_000114C4;
}
if (*options == 0) {
param->letters = 0;
param->count = 0;
param->candidates[0] = 0;
}
Zi8LogError(100, ZI_WORK);
if (param->wordCharCount != 0) {
local_48 = Zi8_8148302C(param->currentWord[0], (ziU8*)iVar4, ZI_WORK);
if ((local_48 != 0xFFFF) &&
((((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 8) != 0)) {
local_38 = (ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 6] |
((ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 3) << 16 |
(ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 5] << 8;
local_52 = param->wordCharCount - 1;
local_53 = 1;
pbVar7 = (ziU8*)(local_2C + local_38);
LAB_00010D44:
if (local_52 != 0) {
local_48 = Zi8_8148302C(param->currentWord[local_53], (ziU8*)iVar4, ZI_WORK);
if (local_48 == (ziU16)((*pbVar7 & 0x1F) << 8 | pbVar7[1])) {
local_52 = local_52 - 1;
local_53 = local_53 + 1;
if ((*pbVar7 & 0x40) == 0) {
pbVar7 = pbVar7 + 2;
goto LAB_00010D44;
}
local_52 = param->wordCharCount - 1;
local_53 = 1;
} else {
local_53 = 1;
local_52 = param->wordCharCount - 1;
}
}
if (local_52 == 0) {
local_48 = (*pbVar7 & 0x1F) << 8 | pbVar7[1];
local_4C = (ziU16)(((ziU8*)((ziU32)local_48 * 9 + (ziU32)local_48 + (ziU32)iVar4))[7] << 8 |
((ziU8*)((ziU32)local_48 * 9 + (ziU32)local_48 + (ziU32)iVar4))[8]);
if (param->wordCharCount == 1) {
if (local_48 == local_4E) {
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
}
local_52 = param->wordCharCount;
goto LAB_00011114;
}
local_4E = local_48;
if (param->elementCount == 0) {
if (local_50 == 0) {
if (*options != 0) {
local_3C = local_3C + 1;
if ((ziS32)local_3C < *(ziS32*)(options + 0xC)) {
goto LAB_000110E8;
}
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
uVar6 = param->letters;
goto LAB_000114C4;
}
} else {
local_50 = local_50 + -1;
}
} else {
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
param->count = local_54;
param->letters = local_54;
if (param->maxCandidates <= local_54) {
if (*options == 0) {
uVar6 = local_54;
goto LAB_000114C4;
}
local_3C = local_3C + local_54;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_3C) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->count = 0;
param->letters = 0;
local_54 = 0;
}
}
}
} else {
for (local_40 = 0;
(local_40 < local_54 &&
(local_4C != param->candidates[local_40]));
local_40 = local_40 + 1) {
}
if ((local_40 == local_54) &&
(Zi8_814833F0(param, local_4C, ZI_WORK) == 0)) {
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (bVar2 < param->maxCandidates) {
goto LAB_000110E8;
}
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
param->count = local_54;
param->letters = local_54;
if (param->maxCandidates <= local_54) {
if (*options == 0) {
uVar6 = local_54;
goto LAB_000114C4;
}
local_3C = local_3C + local_54;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_3C) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->count = 0;
param->letters = 0;
local_54 = 0;
}
}
}
}
LAB_000110E8:
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
}
local_52 = param->wordCharCount;
LAB_00011114:
local_52 = local_52 + -1;
local_53 = 1;
pbVar7 = pbVar7 + 2;
if ((*pbVar7 & 0x80) != 0) {
goto LAB_00011124;
}
goto LAB_00010D44;
}
}
LAB_00011124:
local_34 = local_3C;
if (local_54 != 0) {
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
uVar6 = local_34;
if ((*options != 0) &&
(local_3C = local_3C + local_54, uVar6 = local_3C,
*(ziS32*)(options + 0xC) <= (ziS32)local_3C)) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
local_34 = uVar6;
param->count = local_54;
param->letters = local_54;
}
if (param->elementCount < 10) {
if ((param->elementCount == 0) || (*options != 0)) {
local_56 = 1;
} else {
local_56 = 0;
}
local_4A = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local_28.bytes);
do {
for (local_30 = 0; local_30 < (ziS32)(ziU32)local_4A; local_30 = local_30 + 1) {
bVar1 = ZI8_TRUE;
local_44 = iVar4 + local_30 * 9;
local_55 = 0;
if (1 < param->elementCount) {
for (local_55 = 0;
(ziU32)local_55 < (ziU32)((ziS32)(ziU32)param->elementCount >> 1);
local_55 = local_55 + 1) {
if (local_28.bytes[local_55] != *(ziU8*)(local_44 + local_55)) {
bVar1 = ZI8_FALSE;
break;
}
}
}
if ((bVar1 && ((param->elementCount & 1) != 0)) &&
((local_28.bytes[local_55] & 0xF0) !=
(*(ziU8*)(local_44 + local_55) & 0xF0))) {
bVar1 = ZI8_FALSE;
}
if (bVar1) {
bVar2 = local_56;
if ((param->elementCount & 1) == 0) {
if ((*(ziU8*)(local_44 + local_55) & 0xF0) == 0) {
if (local_56 == 0) {
goto LAB_000113B0;
}
bVar2 = *options;
}
if (bVar2 == 0) {
goto LAB_00011478;
}
} else {
if ((*(ziU8*)(local_44 + local_55) & 0xF) != 0) {
goto LAB_000113AC;
}
if (local_56 != 0) {
bVar2 = *options;
goto LAB_000113AC;
}
}
LAB_000113AC:
if (bVar2 == 0) {
goto LAB_00011478;
}
LAB_000113B0:
if (local_50 == 0) {
if (*options == 0) {
param->candidates[local_54] =
(ziU16)((*(ziU8*)(local_30 * 9 + iVar4 + 7) << 8) |
*(ziU8*)(local_30 * 9 + iVar4 + 8));
local_54 = local_54 + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
uVar6 = param->letters;
goto LAB_000114C4;
}
} else {
local_34 = local_34 + 1;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_34) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
}
} else {
local_50 = local_50 + -1;
}
}
LAB_00011478:
;
}
local_56 = local_56 + 1;
} while (local_56 < 2);
uVar6 = local_34;
if (*options == 0) {
uVar6 = param->letters;
}
} else {
param->letters = 0;
uVar6 = 0;
}
}
LAB_000114C4:
return uVar6;
}

View File

@@ -8,13 +8,8 @@ extern "C" {
#endif
void __VISetRGBModeImm();
#ifdef VI_MATCHING_SOURCE
BOOL __VIResetRFIdle();
BOOL __VIResetSIIdle();
#else
void __VIResetRFIdle();
void __VIResetSIIdle();
#endif
void __VIGetCurrentPosition(s16* x, s16* y);

View File

@@ -150,11 +150,7 @@ typedef struct DVDErrorInfo {
void DVDInit();
BOOL DVDReadAbsAsyncPrio(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback, s32 prio);
#ifdef BS2_MACH_FIVE_ARG_READ
BOOL DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback);
#else
BOOL DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback, s32 prio);
#endif
BOOL DVDReadDiskID(DVDCommandBlock* block, DVDDiskID* diskID, DVDCommandCallback callback);
BOOL DVDCompareDiskID(const DVDDiskID* id1, const DVDDiskID* id2);

View File

@@ -27,13 +27,8 @@ void VISetNextFrameBuffer(void* fb);
void VISetBlack(BOOL setBlack);
void VISetTrapFilter(BOOL setTrap);
#ifdef VI_MATCHING_SOURCE
BOOL VIResetDimmingCount();
BOOL VIEnableDimming(BOOL enableDim);
#else
void VIResetDimmingCount();
void VIEnableDimming(BOOL enableDim);
#endif
u32 VIGetRetraceCount();
u32 VIGetDTVStatus();

File diff suppressed because it is too large Load Diff

View File

@@ -1,127 +0,0 @@
#include <revolution/fa/types.h>
#include <revolution/types.h>
static s32 pf_error_to_api_error[] = {FA_ERR_SUCCESS, FA_ERR_EINVAL, FA_ERR_EINVAL, FA_ERR_ENOENT, FA_ERR_EBUSY, FA_ERR_ENOTEMPTY, FA_ERR_ENOSPC,
FA_ERR_ENOEXEC, FA_ERR_EEXIST, FA_ERR_ENOEXEC, FA_ERR_EINVAL, FA_ERR_EWRTPROTECT, FA_ERR_ENOSYS, FA_ERR_ENOEXEC,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_EACCES, FA_ERR_EIO, FA_ERR_ENOEXEC, FA_ERR_EACCES, FA_ERR_ENOENT,
FA_ERR_ENFILE, FA_ERR_EMFILE, FA_ERR_EISDIR, FA_ERR_EACCES, FA_ERR_EPERM, FA_ERR_ENOEXEC, FA_ERR_ENOEXEC,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_ENOMEM, FA_ERR_EINVAL, FA_ERR_EINVAL, FA_ERR_ENOEXEC, FA_ERR_ENOENT,
FA_ERR_ENOEXEC, FA_ERR_ENOEXEC, FA_ERR_EFBIG, FA_ERR_EBADF, FA_ERR_ENOLCK};
s32 PFAPI_ParseOpenModeString(const char* mode_str) {
s32 open_mode = 0;
u32 i = 0;
if (mode_str == NULL) {
open_mode = 10;
return open_mode;
}
switch (mode_str[i++]) {
case 'r': {
open_mode = 2;
break;
}
case 'w': {
open_mode = 1;
break;
}
case 'a': {
open_mode = 4;
break;
}
default: {
return 0;
}
}
if (mode_str[i] == 'b') {
i++;
}
switch (mode_str[i++]) {
case 0: {
return open_mode;
}
case 't':
default: {
return 0;
}
case '+': {
switch (mode_str[i]) {
case 0: {
return open_mode | 8;
}
default: {
return 0;
}
}
}
}
return 0;
}
s32 PFAPI_convertError(s32 err) {
if (err == 0) {
return 0;
}
if (err == -1) {
return -1;
}
if (err > 0 && err < 0xA0) {
return pf_error_to_api_error[err];
}
if (err == 0x1000) {
err = FA_ERR_EIO;
}
return err;
}
s32 PFAPI_convertDriverError(s32 err) {
if (err == 0) {
return 0;
}
if (err <= 0) {
return err;
}
if ((u32)err < 0xA0) {
err = 1;
}
return err;
}
s32 PFAPI_convertReturnValue(s32 err) {
if (err == 0) {
return 0;
}
return -1;
}
s32 PFAPI_convertReturnValue4feof(s32 err) {
if (err == 1) {
return 1;
}
if (err == 0) {
return 0;
}
return -1;
}
void* PFAPI_convertReturnValue2NULL(s32 err, void* p_stream) {
void* ret;
if (err) {
ret = NULL;
} else {
ret = p_stream;
}
return ret;
}
s32 PFAPI_convertReturnValue4unmount(s32 err) {
if (err == 0) {
return 0;
}
if (err == 1) {
return 1;
}
return -1;
}

View File

@@ -1,986 +0,0 @@
#include <private/vf/PrFILE2/fatfs/pf_cache.h>
typedef struct PFCACHE_BPB {
pf_u16 bytes_per_sector;
pf_u16 num_reserved_sectors;
pf_u16 num_root_dir_entries;
pf_u8 sectors_per_cluster;
pf_u8 num_FATs;
pf_u32 total_sectors;
pf_u32 sectors_per_FAT;
pf_u32 root_dir_cluster;
pf_u16 fs_info_sector;
pf_u16 backup_boot_sector;
pf_u16 ext_flags;
pf_u8 media;
pf_s32 fat_type;
pf_u8 log2_bytes_per_sector;
pf_u8 log2_sectors_per_cluster;
pf_u8 num_active_FATs;
pf_u16 num_root_dir_sectors;
pf_u32 active_FAT_sector;
pf_u32 first_root_dir_sector;
pf_u32 first_data_sector;
pf_u32 num_clusters;
} PFCACHE_BPB;
struct PF_VOLUME {
PFCACHE_BPB bpb;
pf_u32 num_free_clusters;
pf_u32 last_free_cluster;
pf_u8 file_and_directory_state[0x1624 - 0x40];
PF_SECTOR_CACHE cache;
};
enum { FAT_32 = 2 };
extern void* pf_memcpy(void* dest, const void* src, pf_u32 size);
extern void* pf_memset(void* dest, pf_s32 value, pf_u32 size);
extern pf_s32 PFDRV_lread(PF_VOLUME* p_vol, pf_u8* buffer, pf_u32 sector, pf_u32 num_sector, pf_u32* p_num_success);
extern pf_s32 PFDRV_lwrite(PF_VOLUME* p_vol, const pf_u8* buffer, pf_u32 sector, pf_u32 num_sector, pf_u32* p_num_success);
pf_s32 PFCACHE_FlushAllCaches(PF_VOLUME* p_vol);
#pragma dont_inline on
pf_s32 PFCACHE_InitPageList(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, PF_CACHE_PAGE* pages, PF_CACHE_BUFFER* buffers, pf_u32 num,
pf_u32 size, pf_bool is_fat) {
pf_u32 i;
pf_u32 bps_per_buf;
*pp_head = pages;
bps_per_buf = (p_vol->bpb.bytes_per_sector >> 9) * size;
if ((num / bps_per_buf) == 0) {
return 30;
}
if ((num / bps_per_buf) == 1) {
pages->p_prev = pages;
pages->p_next = pages;
pages->buffer = *buffers;
pages->p_buf = *buffers;
pages->p_mod_sbuf = PF_NULL;
pages->p_mod_ebuf = PF_NULL;
pages->size = size;
pages->sector = 0xFFFFFFFF;
pages->option = 0;
pages->signature = PF_NULL;
pages->stat &= ~(0x01 | 0x02);
if (is_fat) {
pages->stat |= 0x04;
} else {
pages->stat &= ~0x04;
}
return 0;
}
pages->p_prev = &pages[(num - (num % bps_per_buf)) - bps_per_buf];
pages->p_next = &pages[bps_per_buf];
pages->buffer = *buffers;
pages->p_buf = *buffers;
pages->p_mod_sbuf = PF_NULL;
pages->p_mod_ebuf = PF_NULL;
pages->size = size;
pages->sector = 0xFFFFFFFF;
pages->option = 0;
pages->signature = PF_NULL;
pages->stat &= ~(0x01 | 0x02);
if (is_fat) {
pages->stat |= 0x04;
} else {
pages->stat &= ~0x04;
}
for (i = bps_per_buf; i < (num - (num % bps_per_buf) - bps_per_buf); i += bps_per_buf) {
pages[i].p_prev = &pages[i - bps_per_buf];
pages[i].p_next = &pages[i + bps_per_buf];
pages[i].buffer = buffers[i];
pages[i].p_buf = buffers[i];
pages[i].p_mod_sbuf = PF_NULL;
pages[i].p_mod_ebuf = PF_NULL;
pages[i].size = size;
pages[i].sector = 0xFFFFFFFF;
pages[i].option = 0;
pages[i].signature = PF_NULL;
pages[i].stat &= ~(0x01 | 0x02);
if (is_fat) {
pages[i].stat |= 0x04;
} else {
pages[i].stat &= ~0x04;
}
}
pages[(num - (num % bps_per_buf)) - bps_per_buf].p_prev = &pages[((num - (num % bps_per_buf)) - bps_per_buf) - bps_per_buf];
pages[(num - (num % bps_per_buf)) - bps_per_buf].p_next = pages;
pages[(num - (num % bps_per_buf)) - bps_per_buf].buffer = buffers[(num - (num % bps_per_buf)) - bps_per_buf];
pages[(num - (num % bps_per_buf)) - bps_per_buf].p_buf = buffers[(num - (num % bps_per_buf)) - bps_per_buf];
pages[(num - (num % bps_per_buf)) - bps_per_buf].p_mod_sbuf = PF_NULL;
pages[(num - (num % bps_per_buf)) - bps_per_buf].p_mod_ebuf = PF_NULL;
pages[(num - (num % bps_per_buf)) - bps_per_buf].size = size;
pages[(num - (num % bps_per_buf)) - bps_per_buf].sector = 0xFFFFFFFF;
pages[(num - (num % bps_per_buf)) - bps_per_buf].option = 0;
pages[(num - (num % bps_per_buf)) - bps_per_buf].signature = PF_NULL;
pages[(num - (num % bps_per_buf)) - bps_per_buf].stat &= ~(0x01 | 0x02);
if (is_fat) {
pages[(num - (num % bps_per_buf)) - bps_per_buf].stat |= 0x04;
} else {
pages[(num - (num % bps_per_buf)) - bps_per_buf].stat &= ~0x04;
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
PF_CACHE_PAGE* PFCACHE_SearchForPage(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_head, pf_u32 sector) {
PF_CACHE_PAGE* p_page;
if (sector == 0xFFFFFFFF) {
return PF_NULL;
}
if ((p_head->stat & 1) == 0) {
return PF_NULL;
}
if (p_head->sector <= sector && p_head->sector + p_head->size - 1 >= sector) {
p_head->p_buf = &p_head->buffer[(sector - p_head->sector) << p_vol->bpb.log2_bytes_per_sector];
return p_head;
}
for (p_page = p_head->p_next; p_page != p_head; p_page = p_page->p_next) {
if ((p_page->stat & 1) == 0) {
return PF_NULL;
}
if (p_page->sector <= sector && p_page->sector + p_page->size - 1 >= sector) {
p_page->p_buf = &p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
return p_page;
}
}
return PF_NULL;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_bool PFCACHE_SearchForFreePage(PF_CACHE_PAGE* p_head, PF_CACHE_PAGE** pp_page) {
PF_CACHE_PAGE* p_page;
for (p_page = p_head->p_prev; p_page != p_head; p_page = p_page->p_prev) {
if ((p_page->stat & 1) == 0) {
*pp_page = p_page;
return PF_TRUE;
}
if (p_page->sector != 0xFFFFFFFF) {
*pp_page = p_page;
return PF_FALSE;
}
}
if ((p_page->stat & 1) == 0) {
*pp_page = p_page;
return PF_TRUE;
}
if (p_page->sector != 0xFFFFFFFF) {
*pp_page = p_page;
return PF_FALSE;
}
*pp_page = PF_NULL;
return PF_FALSE;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_FlushPageIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_page) {
pf_s32 err;
pf_u32 num_success;
pf_u32 size;
if (p_page != PF_NULL && (p_page->stat & 0x02) != 0 && p_page->sector != 0xFFFFFFFF) {
if (p_page->p_mod_sbuf == PF_NULL) {
size = p_page->size;
err = PFDRV_lwrite(p_vol, p_page->buffer, p_page->sector, size, &num_success);
} else {
size = (((pf_u32)p_page->p_mod_ebuf >> p_vol->bpb.log2_bytes_per_sector) -
((pf_u32)p_page->p_mod_sbuf >> p_vol->bpb.log2_bytes_per_sector)) + 1;
err = PFDRV_lwrite(p_vol, p_page->p_mod_sbuf,
p_page->sector + ((pf_u32)(p_page->p_mod_sbuf - p_page->buffer) >> p_vol->bpb.log2_bytes_per_sector),
size, &num_success);
}
if (err != 0) {
return err;
}
if (num_success != size) {
return 17;
}
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->stat &= ~2;
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoAllocatePage(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool* p_is_hit) {
pf_s32 err;
*pp_page = PFCACHE_SearchForPage(p_vol, *pp_head, sector);
if (*pp_page != PF_NULL) {
*p_is_hit = PF_TRUE;
} else {
*p_is_hit = PF_FALSE;
if (PFCACHE_SearchForFreePage(*pp_head, pp_page) == 0) {
if (*pp_page == 0) {
*pp_page = PF_NULL;
return 30;
}
err = PFCACHE_FlushPageIfNeeded(p_vol, *pp_page);
if (err != 0) {
*pp_page = PF_NULL;
return err;
}
(*pp_page)->p_mod_sbuf = NULL;
(*pp_page)->p_mod_ebuf = NULL;
}
if (sector != 0xFFFFFFFF) {
if (((*pp_page)->stat & 0x04) != 0) {
(*pp_page)->sector = sector - (sector % (*pp_page)->size);
(*pp_page)->p_buf = &(*pp_page)->buffer[(sector % (*pp_page)->size) << p_vol->bpb.log2_bytes_per_sector];
} else {
if (p_vol->bpb.fat_type == FAT_32 && (sector < p_vol->bpb.first_data_sector || sector >= p_vol->bpb.total_sectors)) {
if (sector == p_vol->bpb.fs_info_sector) {
(*pp_page)->size = 1;
}
}
(*pp_page)->sector = sector - (sector % (*pp_page)->size);
(*pp_page)->p_buf = &(*pp_page)->buffer[(sector % (*pp_page)->size) << p_vol->bpb.log2_bytes_per_sector];
}
} else {
(*pp_page)->sector = sector;
(*pp_page)->p_buf = (*pp_page)->buffer;
}
(*pp_page)->stat |= 0x01;
}
{
PF_CACHE_PAGE* p_page = *pp_page;
if (p_page != *pp_head) {
if (p_page == (*pp_head)->p_prev) {
*pp_head = p_page;
} else {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
*pp_head = p_page;
}
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoReadPage(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool set_sig) {
pf_u32 num_success;
pf_bool is_hit;
pf_s32 err;
err = PFCACHE_DoAllocatePage(p_vol, pp_head, sector, pp_page, &is_hit);
if (err != 0) {
return err;
}
if (!is_hit) {
err = PFDRV_lread(p_vol, (*pp_page)->buffer, (*pp_page)->sector, (*pp_page)->size, &num_success);
if (err != 0) {
{
PF_CACHE_PAGE* p_page = *pp_page;
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == *pp_head) {
*pp_head = p_page->p_next;
} else if (p_page != (*pp_head)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
return err;
}
if (num_success != (*pp_page)->size && p_vol->bpb.total_sectors != ((*pp_page)->sector + num_success)) {
{
PF_CACHE_PAGE* p_page = *pp_page;
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == *pp_head) {
*pp_head = p_page->p_next;
} else if (p_page != (*pp_head)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
return 17;
}
(*pp_page)->stat &= ~2;
(*pp_page)->p_mod_sbuf = NULL;
(*pp_page)->p_mod_ebuf = NULL;
if (set_sig) {
(*pp_page)->signature = p_vol->cache.signature;
} else {
(*pp_page)->signature = PF_NULL;
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoReadPageAndFlushIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, pf_u32 sector, PF_CACHE_PAGE** pp_page,
pf_bool set_sig) {
pf_u32 num_success;
pf_bool is_hit;
pf_s32 err;
err = PFCACHE_DoAllocatePage(p_vol, pp_head, sector, pp_page, &is_hit);
if (err != 0) {
return err;
}
if (!is_hit) {
err = PFDRV_lread(p_vol, (*pp_page)->buffer, (*pp_page)->sector, (*pp_page)->size, &num_success);
if (err != 0) {
{
PF_CACHE_PAGE* p_page = *pp_page;
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == *pp_head) {
*pp_head = p_page->p_next;
} else if (p_page != (*pp_head)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
return err;
}
if (num_success != (*pp_page)->size && p_vol->bpb.total_sectors != ((*pp_page)->sector + num_success)) {
{
PF_CACHE_PAGE* p_page = *pp_page;
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == *pp_head) {
*pp_head = p_page->p_next;
} else if (p_page != (*pp_head)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
return 17;
}
(*pp_page)->stat &= ~2;
(*pp_page)->p_mod_sbuf = NULL;
(*pp_page)->p_mod_ebuf = NULL;
if (set_sig) {
(*pp_page)->signature = p_vol->cache.signature;
} else {
(*pp_page)->signature = PF_NULL;
}
} else if (set_sig && ((*pp_page)->stat & 0x02) != 0 && (p_vol->cache.mode & 0x02) != 0 && (*pp_page)->signature != p_vol->cache.signature) {
err = PFCACHE_FlushPageIfNeeded(p_vol, *pp_page);
if (err != 0) {
*pp_page = PF_NULL;
return err;
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoReadNumSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, pf_u8* p_buf, pf_u32 sector, pf_u32 num_sector,
pf_u32* p_num_success) {
PF_CACHE_PAGE* p_page;
pf_s32 err;
pf_u32 num_rest_sector;
pf_u32 num_success_sector;
*p_num_success = 0;
err = PFDRV_lread(p_vol, p_buf, sector, num_sector, p_num_success);
if (err != 0) {
return err;
}
p_page = PF_NULL;
num_rest_sector = *p_num_success;
num_success_sector = *p_num_success;
do {
if (p_page == PF_NULL) {
p_page = *pp_head;
} else {
p_page = p_page->p_next;
if (p_page == *pp_head) {
p_page = PF_NULL;
goto found_page;
}
}
for (; (p_page->stat & 1) != 0; p_page = p_page->p_next) {
if (p_page->sector != 0xFFFFFFFF) {
p_page->p_buf = p_page->buffer;
goto found_page;
}
}
p_page = PF_NULL;
found_page:
if (p_page != PF_NULL && p_page->sector != 0xFFFFFFFF) {
if (p_page->sector <= sector && p_page->sector + p_page->size >= sector + num_success_sector) {
pf_memcpy(p_buf, &p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector],
num_success_sector << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= num_success_sector;
} else if (p_page->sector >= sector && p_page->sector + p_page->size <= sector + num_success_sector) {
pf_memcpy(&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector], p_page->buffer,
p_page->size << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size;
} else if (p_page->sector > sector && p_page->sector < sector + num_success_sector &&
p_page->sector + p_page->size >= sector + num_success_sector) {
pf_memcpy(&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector], p_page->buffer,
(p_page->size - (p_page->sector + p_page->size - (sector + num_success_sector))) << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size - ((p_page->sector + p_page->size) - (sector + num_success_sector));
} else if (p_page->sector < sector && (p_page->sector + p_page->size) > sector &&
(p_page->sector + p_page->size) <= (sector + num_success_sector)) {
pf_memcpy(p_buf, &p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector],
(p_page->size - (sector - p_page->sector)) << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size - (sector - p_page->sector);
}
}
} while (p_page != PF_NULL && num_rest_sector != 0);
if (*p_num_success != num_sector && p_vol->bpb.total_sectors != (sector + *p_num_success)) {
return 17;
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoWritePage(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, PF_CACHE_PAGE* p_page, pf_bool set_sig) {
pf_s32 err;
if (p_page != *pp_head) {
if (p_page == (*pp_head)->p_prev) {
*pp_head = p_page;
} else {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = *pp_head;
p_page->p_prev = (*pp_head)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
*pp_head = p_page;
}
}
p_page->stat |= 2;
if (p_page->p_mod_sbuf == PF_NULL) {
p_page->p_mod_sbuf = p_page->p_buf;
p_page->p_mod_ebuf = p_page->p_buf;
} else if (p_page->p_buf < p_page->p_mod_sbuf) {
p_page->p_mod_sbuf = p_page->p_buf;
} else if (p_page->p_buf > p_page->p_mod_ebuf) {
p_page->p_mod_ebuf = p_page->p_buf;
}
if (set_sig) {
p_page->signature = p_vol->cache.signature;
} else {
p_page->signature = PF_NULL;
}
if ((p_vol->cache.mode & 0x01) != 0 || ((p_vol->cache.mode & 0x04) != 0 && (p_page->stat & 0x04) != 0)) {
err = PFCACHE_FlushPageIfNeeded(p_vol, p_page);
if (err != 0) {
return err;
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoWriteSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector) {
PF_CACHE_PAGE* p_page;
pf_u32 num_success;
pf_s32 err;
p_page = PFCACHE_SearchForPage(p_vol, *pp_head, sector);
if (p_page != PF_NULL) {
pf_memcpy(p_page->p_buf, (pf_u8*)p_buf, p_vol->bpb.bytes_per_sector);
p_page->stat |= 2;
if (p_page->p_mod_sbuf == PF_NULL) {
p_page->p_mod_sbuf = p_page->p_buf;
p_page->p_mod_ebuf = p_page->p_buf;
} else if (p_page->p_buf < p_page->p_mod_sbuf) {
p_page->p_mod_sbuf = p_page->p_buf;
} else if (p_page->p_buf > p_page->p_mod_ebuf) {
p_page->p_mod_ebuf = p_page->p_buf;
}
err = PFCACHE_FlushPageIfNeeded(p_vol, p_page);
if (err != 0) {
return err;
}
} else {
err = PFDRV_lwrite(p_vol, p_buf, sector, 1, &num_success);
if (err != 0) {
return err;
}
if (num_success != 1) {
return 17;
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector,
pf_u32 num_sector, pf_u32* p_num_success) {
PF_CACHE_PAGE* p_page = PF_NULL;
pf_s32 err;
pf_u32 num_rest_sector = num_sector;
pf_u8* p_sbuf;
pf_u8* p_ebuf;
pf_u32 num_overlap;
pf_u32 last_sector;
*p_num_success = 0;
do {
if (p_page == PF_NULL) {
p_page = *pp_head;
} else {
p_page = p_page->p_next;
if (p_page == *pp_head) {
p_page = PF_NULL;
goto found_page;
}
}
for (; (p_page->stat & 1) != 0; p_page = p_page->p_next) {
if (p_page->sector != 0xFFFFFFFF) {
p_page->p_buf = p_page->buffer;
goto found_page;
}
}
p_page = PF_NULL;
found_page:
if (p_page != PF_NULL && p_page->sector != 0xFFFFFFFF) {
if (p_page->sector <= sector && (p_page->sector + p_page->size) >= (sector + num_sector)) {
pf_memcpy(&p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector], (pf_u8*)p_buf,
num_sector << p_vol->bpb.log2_bytes_per_sector);
*p_num_success += num_rest_sector;
num_rest_sector = 0;
p_page->stat |= 2;
p_sbuf = &p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
p_ebuf = &(&p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector])[(num_sector - 1)
<< p_vol->bpb.log2_bytes_per_sector];
if (p_page->p_mod_sbuf == NULL) {
p_page->p_mod_sbuf = p_sbuf;
p_page->p_mod_ebuf = p_ebuf;
} else if (p_sbuf < p_page->p_mod_sbuf) {
p_page->p_mod_sbuf = p_sbuf;
} else if (p_page->p_mod_ebuf < p_ebuf) {
p_page->p_mod_ebuf = p_ebuf;
}
} else if (p_page->sector >= sector && (p_page->sector + p_page->size) <= (sector + num_sector)) {
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
p_page->size << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size;
*p_num_success += p_page->size;
p_page->stat |= 2;
p_page->p_mod_sbuf = p_page->buffer;
p_page->p_mod_ebuf = &p_page->buffer[(p_page->size - 1) << p_vol->bpb.log2_bytes_per_sector];
} else if (p_page->sector > sector && p_page->sector < (sector + num_sector) &&
(p_page->sector + p_page->size) >= (sector + num_sector)) {
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
(sector + num_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector);
num_overlap = p_page->size - ((p_page->sector + p_page->size) - (num_sector + sector));
last_sector = p_page->sector + num_overlap - 1;
*p_num_success += num_overlap;
num_rest_sector -= num_overlap;
p_page->stat |= 2;
p_ebuf = &p_page->buffer[(last_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
p_page->p_mod_sbuf = p_page->buffer;
if (p_page->p_mod_ebuf == NULL || p_page->p_mod_ebuf < p_ebuf) {
p_page->p_mod_ebuf = p_ebuf;
}
} else if (p_page->sector < sector && (p_page->sector + p_page->size) > sector &&
(p_page->sector + p_page->size) <= (sector + num_sector)) {
pf_memcpy(&p_page->buffer[(sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector], (pf_u8*)p_buf,
(p_page->size - (sector - p_page->sector)) << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size - (sector - p_page->sector);
*p_num_success += p_page->size - (sector - p_page->sector);
p_page->stat |= 2;
p_sbuf = &p_page->buffer[(p_page->size - (sector - p_page->sector) - 1) << p_vol->bpb.log2_bytes_per_sector];
if (p_page->p_mod_sbuf == NULL || p_sbuf < p_page->p_mod_sbuf) {
p_page->p_mod_sbuf = p_sbuf;
}
p_page->p_mod_ebuf = &p_page->buffer[(p_page->size - 1) << p_vol->bpb.log2_bytes_per_sector];
}
}
} while (p_page != PF_NULL && num_rest_sector != 0);
if (num_rest_sector != 0) {
err = PFDRV_lwrite(p_vol, p_buf, sector, num_sector, p_num_success);
if (err != 0) {
return err;
}
}
return 0;
}
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoFlushCache(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_head) {
PF_CACHE_PAGE* p_page;
pf_s32 err;
pf_s32 first_err;
first_err = 0;
p_page = p_head;
if ((p_page->stat & 0x01) == 0) {
return 0;
}
if ((p_vol->cache.mode & 1) != 0 || ((p_vol->cache.mode & 4) != 0 && (p_page->stat & 4) != 0)) {
return 0;
}
do {
if ((p_page->stat & 0x01) == 0) {
break;
}
err = PFCACHE_FlushPageIfNeeded(p_vol, p_page);
if (err != 0 && first_err == 0) {
first_err = err;
}
p_page = p_page->p_next;
} while (p_page != p_head);
return first_err;
}
#pragma dont_inline reset
void PFCACHE_SetCache(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_cache_page, PF_CACHE_BUFFER* p_cache_buf, pf_u16 num_fat_pages, pf_u16 num_data_pages) {
p_vol->cache.pages = p_cache_page;
p_vol->cache.buffers = p_cache_buf;
p_vol->cache.num_fat_pages = num_fat_pages;
p_vol->cache.num_data_pages = num_data_pages;
}
void PFCACHE_SetFATBufferSize(PF_VOLUME* p_vol, pf_u32 size) {
if (size != 0) {
p_vol->cache.fat_buff_size = size;
}
}
void PFCACHE_SetDataBufferSize(PF_VOLUME* p_vol, pf_u32 size) {
if (size != 0) {
p_vol->cache.data_buff_size = size;
}
}
pf_s32 PFCACHE_InitCaches(PF_VOLUME* p_vol) {
pf_s32 err;
p_vol->cache.mode &= ~0x01;
p_vol->cache.mode |= 0x02;
p_vol->cache.mode &= ~0x04;
pf_memset(p_vol->cache.buffers, 0, (p_vol->cache.num_fat_pages + p_vol->cache.num_data_pages) << 9);
err = PFCACHE_InitPageList(p_vol, &p_vol->cache.p_current_fat, p_vol->cache.pages, p_vol->cache.buffers, p_vol->cache.num_fat_pages,
p_vol->cache.fat_buff_size, PF_TRUE);
if (err != 0) {
return err;
}
err = PFCACHE_InitPageList(p_vol, &p_vol->cache.p_current_data, &p_vol->cache.pages[p_vol->cache.num_fat_pages],
(PF_CACHE_BUFFER*)p_vol->cache.buffers[p_vol->cache.num_fat_pages], p_vol->cache.num_data_pages,
p_vol->cache.data_buff_size, PF_FALSE);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_SetWriteThroughMode(PF_VOLUME* p_vol) {
pf_s32 err = PFCACHE_FlushAllCaches(p_vol);
if (err != 0) {
return err;
}
p_vol->cache.mode |= 1;
return 0;
}
pf_s32 PFCACHE_SetWriteBackMode(PF_VOLUME* p_vol) {
p_vol->cache.mode &= ~1;
return 0;
}
pf_s32 PFCACHE_AllocateFATPage(PF_VOLUME* p_vol, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool* p_is_hit) {
pf_s32 err;
if (p_vol->cache.p_current_fat == 0) {
p_vol->cache.pages->buffer = *p_vol->cache.buffers;
p_vol->cache.pages->p_buf = *p_vol->cache.buffers;
*pp_page = p_vol->cache.pages;
return 0;
}
err = PFCACHE_DoAllocatePage(p_vol, &p_vol->cache.p_current_fat, sector, pp_page, p_is_hit);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_AllocateDataPage(PF_VOLUME* p_vol, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool* p_is_hit) {
pf_s32 err;
if (p_vol->cache.p_current_data == 0) {
p_vol->cache.pages->buffer = *p_vol->cache.buffers;
p_vol->cache.pages->p_buf = *p_vol->cache.buffers;
*pp_page = p_vol->cache.pages;
return 0;
}
err = PFCACHE_DoAllocatePage(p_vol, &p_vol->cache.p_current_data, sector, pp_page, p_is_hit);
if (err != 0) {
return err;
}
return 0;
}
void PFCACHE_FreeFATPage(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_page) {
if (p_vol->cache.p_current_fat != 0) {
p_page->p_mod_sbuf = NULL;
p_page->stat &= ~3;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == p_vol->cache.p_current_fat) {
p_vol->cache.p_current_fat = p_page->p_next;
} else if (p_page != (p_vol->cache.p_current_fat)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = p_vol->cache.p_current_fat;
p_page->p_prev = (p_vol->cache.p_current_fat)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
}
void PFCACHE_FreeDataPage(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_page) {
if (p_vol->cache.p_current_data != 0) {
p_page->p_mod_sbuf = NULL;
p_page->stat &= ~3;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == p_vol->cache.p_current_data) {
p_vol->cache.p_current_data = p_page->p_next;
} else if (p_page != (p_vol->cache.p_current_data)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = p_vol->cache.p_current_data;
p_page->p_prev = (p_vol->cache.p_current_data)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
}
pf_s32 PFCACHE_ReadFATPage(PF_VOLUME* p_vol, pf_u32 sector, PF_CACHE_PAGE** pp_page) {
pf_s32 err;
err = PFCACHE_DoReadPage(p_vol, &p_vol->cache.p_current_fat, sector, pp_page, 0U);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_ReadDataPage(PF_VOLUME* p_vol, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool set_sig) {
pf_s32 err;
err = PFCACHE_DoReadPage(p_vol, &p_vol->cache.p_current_data, sector, pp_page, set_sig);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_ReadDataPageAndFlushIfNeeded(PF_VOLUME* p_vol, pf_u32 sector, PF_CACHE_PAGE** pp_page, pf_bool set_sig) {
pf_s32 err;
err = PFCACHE_DoReadPageAndFlushIfNeeded(p_vol, &p_vol->cache.p_current_data, sector, pp_page, set_sig);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_ReadDataNumSector(PF_VOLUME* p_vol, pf_u8* p_buf, pf_u32 sector, pf_u32 num_sector, pf_u32* p_num_success) {
pf_s32 err;
if (sector >= p_vol->bpb.total_sectors) {
return 16;
}
err = PFCACHE_DoReadNumSector(p_vol, &p_vol->cache.p_current_data, p_buf, sector, num_sector, p_num_success);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_WriteFATPage(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_page) {
pf_s32 err;
err = PFCACHE_DoWritePage(p_vol, &p_vol->cache.p_current_fat, p_page, 0);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_WriteDataPage(PF_VOLUME* p_vol, PF_CACHE_PAGE* p_page, pf_bool set_sig) {
pf_s32 err;
err = PFCACHE_DoWritePage(p_vol, &p_vol->cache.p_current_data, p_page, set_sig);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_WriteFATSectorAndFreeIfNeeded(PF_VOLUME* p_vol, const pf_u8* p_buf, pf_u32 sector) {
pf_s32 err;
if (sector >= p_vol->bpb.total_sectors) {
return 16;
}
err = PFCACHE_DoWriteSector(p_vol, &p_vol->cache.p_current_fat, p_buf, sector);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_WriteDataNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, const pf_u8* p_buf, pf_u32 sector, pf_u32 num_sector, pf_u32* p_num_success) {
pf_s32 err;
if (sector >= p_vol->bpb.total_sectors) {
return 16;
}
err = PFCACHE_DoWriteNumSectorAndFreeIfNeeded(p_vol, &p_vol->cache.p_current_data, p_buf, sector, num_sector, p_num_success);
if (err != 0) {
return err;
}
return 0;
}
PF_CACHE_PAGE* PFCACHE_SearchDataCache(PF_VOLUME* p_vol, pf_u32 sector) {
return PFCACHE_SearchForPage(p_vol, p_vol->cache.p_current_data, sector);
}
pf_s32 PFCACHE_FlushFATCache(PF_VOLUME* p_vol) {
pf_s32 err;
err = PFCACHE_DoFlushCache(p_vol, p_vol->cache.p_current_fat);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_FlushDataCache(PF_VOLUME* p_vol) {
pf_s32 err;
err = PFCACHE_DoFlushCache(p_vol, p_vol->cache.p_current_data);
if (err != 0) {
return err;
}
return 0;
}
pf_s32 PFCACHE_FlushDataCacheSpecific(PF_VOLUME* p_vol, void* signature) {
pf_s32 err = 0;
PF_CACHE_PAGE* p_head;
PF_CACHE_PAGE* p_page;
if ((p_vol->cache.mode & 7) != 0) {
p_head = p_vol->cache.p_current_data;
p_page = p_head;
if (p_page->signature == PF_NULL || p_page->signature == signature) {
err = PFCACHE_FlushPageIfNeeded(p_vol, p_page);
if (err != 0) {
return err;
}
}
for (p_page = p_page->p_next; p_page != p_head; p_page = p_page->p_next) {
if (p_page->signature == PF_NULL || p_page->signature == signature) {
err = PFCACHE_FlushPageIfNeeded(p_vol, p_page);
if (err != 0) {
return err;
}
continue;
}
}
}
return err;
}
pf_s32 PFCACHE_FlushAllCaches(PF_VOLUME* p_vol) {
pf_s32 err;
err = PFCACHE_DoFlushCache(p_vol, p_vol->cache.p_current_fat);
if (err != 0) {
return err;
}
err = PFCACHE_DoFlushCache(p_vol, p_vol->cache.p_current_data);
if (err != 0) {
return err;
}
return 0;
}
void PFCACHE_FreeAllCaches(PF_VOLUME* p_vol) {
while ((p_vol->cache.p_current_fat->stat & 0x01) != 0) {
{
PF_CACHE_PAGE* p_page = p_vol->cache.p_current_fat;
if (p_vol->cache.p_current_fat != 0) {
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == p_vol->cache.p_current_fat) {
p_vol->cache.p_current_fat = p_page->p_next;
} else if (p_page != (p_vol->cache.p_current_fat)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = p_vol->cache.p_current_fat;
p_page->p_prev = (p_vol->cache.p_current_fat)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
}
}
while ((p_vol->cache.p_current_data->stat & 0x01) != 0) {
{
PF_CACHE_PAGE* p_page = p_vol->cache.p_current_data;
if (p_vol->cache.p_current_data != 0) {
p_page->stat &= ~3;
p_page->p_mod_sbuf = NULL;
p_page->p_mod_ebuf = NULL;
p_page->sector = 0xFFFFFFFF;
p_page->signature = PF_NULL;
if (p_page == p_vol->cache.p_current_data) {
p_vol->cache.p_current_data = p_page->p_next;
} else if (p_page != (p_vol->cache.p_current_data)->p_prev) {
p_page->p_prev->p_next = p_page->p_next;
p_page->p_next->p_prev = p_page->p_prev;
p_page->p_next = p_vol->cache.p_current_data;
p_page->p_prev = (p_vol->cache.p_current_data)->p_prev;
p_page->p_next->p_prev = p_page;
p_page->p_prev->p_next = p_page;
}
}
}
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,747 +0,0 @@
#include <private/vf/PrFILE2/fatfs/pf_entry.h>
typedef struct PFITER_FAT_HINT {
pf_u32 chain_index;
pf_u32 cluster;
pf_u32 previous_cluster;
} PFITER_FAT_HINT;
typedef struct PFITER_FFD {
pf_u32 start_cluster;
pf_u32 current_start_cluster;
pf_u32* p_start_cluster;
PF_LAST_CLUSTER last_cluster;
PF_FAT_LAST_ACCESS last_access_cluster;
PF_CLUSTER_LINK cluster_link;
PFITER_FAT_HINT* p_hint;
PF_VOLUME* p_vol;
} PFITER_FFD;
typedef struct PFITER_ENT_ITER {
pf_u32 index;
PF_VOLUME* p_vol;
PFITER_FFD ffd;
pf_u32 file_sector_index;
pf_u32 sector;
pf_u16 offset;
pf_u16 offset_mask;
pf_u8 buf[32];
pf_u8 log2_entries_per_sector;
} PFITER_ENT_ITER;
typedef struct PFITER_BPB {
pf_u16 bytes_per_sector;
pf_u16 num_reserved_sectors;
pf_u16 num_root_dir_entries;
pf_u8 sectors_per_cluster;
pf_u8 num_FATs;
pf_u32 total_sectors;
pf_u32 sectors_per_FAT;
pf_u32 root_dir_cluster;
pf_u16 fs_info_sector;
pf_u16 backup_boot_sector;
pf_u16 ext_flags;
pf_u8 media;
pf_s32 fat_type;
pf_u8 log2_bytes_per_sector;
pf_u8 log2_sectors_per_cluster;
pf_u8 num_active_FATs;
pf_u16 num_root_dir_sectors;
pf_u32 active_FAT_sector;
pf_u32 first_root_dir_sector;
pf_u32 first_data_sector;
pf_u32 num_clusters;
} PFITER_BPB;
struct PF_VOLUME {
PFITER_BPB bpb;
};
typedef struct PFITER_CONTEXT_VOLUME {
pf_u32 stat;
pf_s32 context_id;
PF_VOLUME* p_vol;
} PFITER_CONTEXT_VOLUME;
typedef struct PFITER_VOLUME_SET {
pf_u32 flags;
pf_u32 reserved;
PF_VOLUME* current_volume;
PFITER_CONTEXT_VOLUME context_volumes[3];
pf_s32 num_attached;
pf_s32 num_mounted;
pf_u32 config;
void* user_data;
pf_s32 last_error;
pf_s32 last_driver_error;
void (*code_callbacks[6])(void);
pf_u32 setting;
} PFITER_VOLUME_SET;
extern PFITER_VOLUME_SET pf_vol_set;
pf_s8* PFSTR_GetStrPos(PF_STR*, pf_u32);
pf_u32 PFSTR_GetCodeMode(PF_STR* p_str);
void PFSTR_MoveStrPos(PF_STR* p_str, pf_s16 num_char);
pf_u16 PFSTR_StrLen(PF_STR* p_str);
pf_u16 PFSTR_StrNumChar(PF_STR* p_str, pf_u32 target);
pf_s32 PFSTR_StrCmp(const PF_STR* p_str, const pf_s8* s);
pf_s32 PFSTR_StrNCmp(PF_STR* p_str, const pf_s8* s, pf_u32 target, pf_s16 offset, pf_u16 num);
void* pf_memcpy(void* dst, void* src, pf_u32 length);
void* pf_memset(void* dst, pf_s32 c, pf_u32 length);
pf_s32 pf_strncmp(const pf_s8* s1, const pf_s8* s2, pf_u32 length);
pf_u8 PFENT_CalcCheckSum(PF_DIR_ENT* p_ent);
void PFENT_LoadShortNameFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf);
void PFENT_loadEntryNumericFieldsFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf);
pf_s32 PFENT_LoadLFNEntryFieldsFromBuf(PF_DIR_ENT* p_ent, const pf_u8* buf);
pf_s32 PFENT_GetRootDir(PF_VOLUME* p_vol, PF_DIR_ENT* p_ent);
pf_s32 PFFAT_GetSectorSpecified(PFITER_FFD* p_ffd, pf_u32 file_sector_index, pf_u32 may_allocate, pf_u32* p_sector);
pf_s32 PFFAT_getBeforeChain(PF_VOLUME* p_vol, pf_u32 start_cluster, pf_u32 lActive, pf_u32* p_cluster);
pf_s32 PFFAT_ResetFFD(PFITER_FFD* p_ffd, pf_u32* p_start_cluster);
pf_s32 PFFAT_InitFFD(PFITER_FFD* p_ffd, PFITER_FAT_HINT* p_hint, PF_VOLUME* p_vol, pf_u32* p_start_cluster);
void PFPATH_InitTokenOfPath(PF_STR* p_str, pf_s8* path, pf_u32 code_mode);
pf_s32 PFPATH_GetNextTokenOfPath(PF_STR* p_str, pf_bool wildcard);
pf_bool PFPATH_MatchFileNameWithPattern(const pf_s8* file_name, PF_STR* p_pattern, pf_bool is_long_name);
void PFPATH_getLongNameformShortName(pf_s8* short_name, pf_s8* long_name, pf_u8 flag);
pf_u32 PFPATH_GetLengthFromShortname(const pf_s8* sSrc);
pf_u32 PFPATH_GetLengthFromUnicode(const pf_u16* sSrc);
pf_s32 PFPATH_transformInUnicode(pf_u16* sDestStr, const pf_s8* sSrcStr);
pf_bool PFPATH_GetExtShortNameIndex(PF_STR* p_str, pf_u32* p_index);
pf_s32 PFSEC_ReadData(PF_VOLUME* p_vol, pf_u8* p_buf, pf_u32 sector, pf_u16 offset, pf_u32 size, pf_u32* p_success_size, pf_bool set_sig);
pf_s32 PFSEC_WriteData(PF_VOLUME* p_vol, const pf_u8* p_buf, pf_u32 sector, pf_u16 offset, pf_u32 size, pf_u32* p_success_size, pf_bool set_sig);
pf_s32 PFVOL_GetCurrentDir(PF_VOLUME*, PF_DIR_ENT*);
pf_s32 PFCACHE_AllocateDataPage(PF_VOLUME*, pf_u32, PF_CACHE_PAGE**, pf_bool*);
pf_s32 PFCACHE_FreeDataPage(PF_VOLUME*, PF_CACHE_PAGE*);
pf_s32 PFENT_RecalcEntryIterator(PFITER_ENT_ITER*, pf_u32);
pf_s32 PFENT_ITER_IteratorInitialize(PFITER_ENT_ITER*, pf_u32);
pf_bool PFENT_ITER_IsAtLogicalEnd(PFITER_ENT_ITER*);
pf_s32 PFENT_ITER_MoveTo(PFITER_ENT_ITER*, pf_u32, pf_u32);
pf_s32 PFENT_ITER_Advance(PFITER_ENT_ITER*, pf_u32);
pf_s32 PFENT_ITER_Retreat(PFITER_ENT_ITER*, pf_u32);
pf_s32 PFENT_ITER_FindDirEntryFromCluster(PFITER_ENT_ITER*, PF_DIR_ENT*, pf_u32, pf_bool*);
#pragma dont_inline on
pf_s32 PFENT_RecalcEntryIterator(PFITER_ENT_ITER* p_iter, pf_u32 may_allocate) {
pf_u32 file_sector_index;
pf_u32 previous_fsindex;
pf_u32 sector_count;
pf_s32 err;
PF_CACHE_PAGE* page;
pf_u32 success_size;
pf_bool hit;
file_sector_index = p_iter->index >> p_iter->log2_entries_per_sector;
previous_fsindex = p_iter->file_sector_index;
if (file_sector_index != p_iter->file_sector_index) {
p_iter->file_sector_index = file_sector_index;
err = PFFAT_GetSectorSpecified(&p_iter->ffd, file_sector_index, 0, &p_iter->sector);
if (err != 0) return err;
if (p_iter->sector == -1U && may_allocate != 0) {
err = PFFAT_GetSectorSpecified(&p_iter->ffd, file_sector_index, 1, &p_iter->sector);
if (err != 0) return err;
if (p_iter->sector != -1U && previous_fsindex != -1U) {
err = PFCACHE_AllocateDataPage(p_iter->p_vol, -1U, &page, &hit);
if (err != 0) return err;
pf_memset(page->p_buf, 0, p_iter->p_vol->bpb.bytes_per_sector);
for (sector_count = 0; sector_count < p_iter->p_vol->bpb.sectors_per_cluster; ++sector_count) {
err = PFSEC_WriteData(p_iter->p_vol, page->p_buf, p_iter->sector + sector_count, 0,
p_iter->p_vol->bpb.bytes_per_sector, &success_size, 0);
if (err != 0) {
PFCACHE_FreeDataPage(p_iter->p_vol, page);
return err;
}
if (success_size != p_iter->p_vol->bpb.bytes_per_sector) {
PFCACHE_FreeDataPage(p_iter->p_vol, page);
return 17;
}
}
PFCACHE_FreeDataPage(p_iter->p_vol, page);
}
}
}
p_iter->offset = (p_iter->index & p_iter->offset_mask) * 32;
return 0;
}
#pragma dont_inline reset
static inline pf_s32 PFENT_ITER_LoadEntry(PFITER_ENT_ITER* p_iter) {
pf_u32 success_size;
pf_s32 err;
if (p_iter->sector == -1) {
return 16;
}
err = PFSEC_ReadData(p_iter->p_vol, p_iter->buf, p_iter->sector, p_iter->offset, 0x20U, &success_size, 0U);
if (success_size != 0x20) {
return 17;
}
return err;
}
static inline pf_s32 PFENT_ITER_DoMoveTo(PFITER_ENT_ITER* p_iter, pf_u32 index, pf_u32 may_allocate) {
pf_u32 prev_index = p_iter->index;
pf_s32 err;
p_iter->index = index;
err = PFENT_RecalcEntryIterator(p_iter, may_allocate);
if (err != 0) {
p_iter->index = prev_index;
PFENT_RecalcEntryIterator(p_iter, 0U);
return err;
}
err = PFENT_ITER_LoadEntry(p_iter);
if (err != 0) {
return err;
}
return 0;
}
static inline void PFENT_ITER_MakeLongFileName(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
pf_s32 lengthName;
signed char filename[13];
lengthName = 0;
PFPATH_getLongNameformShortName(p_ent->short_name, filename, p_iter->buf[0xC]);
lengthName = PFPATH_transformInUnicode(p_ent->long_name, filename);
p_ent->num_entry_LFNs = ((lengthName % 13) ? 1 : 0) + (lengthName / 13);
p_ent->check_sum = PFENT_CalcCheckSum(p_ent);
p_ent->ordinal = 1;
}
static inline pf_s32 InitializeIterator(PFITER_ENT_ITER* p_iter, pf_u32 index) {
p_iter->p_vol = p_iter->ffd.p_vol;
p_iter->log2_entries_per_sector = p_iter->p_vol->bpb.log2_bytes_per_sector - 5;
p_iter->offset_mask = (1 << p_iter->log2_entries_per_sector) - 1;
p_iter->file_sector_index = -1U;
return PFENT_ITER_DoMoveTo(p_iter, index, 0);
}
static inline pf_s32 AdvanceIterator(PFITER_ENT_ITER* p_iter, pf_u32 may_allocate) {
pf_s32 err = PFENT_ITER_DoMoveTo(p_iter, p_iter->index + 1, may_allocate);
if (err != 0) return err;
return 0;
}
static inline void LoadNumericEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
PFENT_loadEntryNumericFieldsFromBuf(p_ent, p_iter->buf);
p_ent->entry_sector = p_iter->sector;
p_ent->entry_offset = p_iter->offset;
p_ent->p_vol = p_iter->ffd.p_vol;
if ((p_ent->attr & 0x10) && p_ent->start_cluster == 0) p_ent->start_cluster = 1;
}
pf_s32 PFENT_ITER_DoFindEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_STR* p_pattern,
pf_u32 attr_required, pf_u32 attr_forbidden, pf_bool* p_is_found) {
pf_s32 err = 0;
pf_u32 index_search_from;
pf_u32 is_extsfn = 0;
*p_is_found = 0;
if (PFSTR_StrCmp(p_pattern, (pf_s8*)"..") == 0 && (p_ent->attr & 0x10) && p_ent->start_cluster == 1) return 2;
if (PFSTR_StrCmp(p_pattern, (pf_s8*)".") == 0) {
*p_is_found = 1;
return 0;
}
p_ent->num_entry_LFNs = 0;
p_ent->ordinal = 0;
p_ent->check_sum = 0;
p_ent->long_name[0] = 0;
if ((pf_vol_set.setting & 2) == 2) is_extsfn = PFPATH_GetExtShortNameIndex(p_pattern, &index_search_from);
if (is_extsfn == 1) {
for (err = InitializeIterator(p_iter, index_search_from - 1);; err = PFENT_ITER_Retreat(p_iter, 0)) {
pf_s32 attr;
if (err != 0) return err;
if ((p_iter->buf[11] & 15) == 15) {
if (PFENT_LoadLFNEntryFieldsFromBuf(p_ent, p_iter->buf) != 0) return 3;
if (!(p_iter->buf[0] & 0x40)) continue;
} else return 0;
err = InitializeIterator(p_iter, index_search_from);
if (err != 0) return err;
attr = p_iter->buf[11];
if (attr == 0) attr = 0x40;
if (attr_required & 0x80) {
attr_required &= 0x7f;
attr_forbidden &= 0x7f;
if ((attr_required && (pf_s32)(attr_required & attr) != (pf_s32)attr_required) ||
(attr_forbidden && (pf_s32)(attr_forbidden & attr) == (pf_s32)attr_forbidden)) err = -1;
} else if (attr_required != 0x7f && attr != attr_required &&
(!(attr & attr_required) || (attr & attr_forbidden))) err = -1;
if (err == -1) return 0;
if (attr & 8) return 3;
PFENT_LoadShortNameFromBuf(p_ent, p_iter->buf);
if (PFPATH_MatchFileNameWithPattern(p_ent->short_name, p_pattern, 0)) {
LoadNumericEntry(p_iter, p_ent);
*p_is_found = 1;
return 0;
}
goto finish;
}
}
for (; PFENT_ITER_IsAtLogicalEnd(p_iter) == PF_FALSE; err = AdvanceIterator(p_iter, 0)) {
pf_s32 attr;
if (err != 0) return err;
if (p_iter->buf[0] == 0) break;
if (p_iter->buf[0] == 0xe5) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
attr = p_iter->buf[11];
if ((attr & 15) == 15) {
if (PFENT_LoadLFNEntryFieldsFromBuf(p_ent, p_iter->buf) != 0) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
}
continue;
}
if (attr == 0) attr = 0x40;
if (attr_required & 0x80) {
attr_required &= 0x7f;
attr_forbidden &= 0x7f;
if ((attr_required && (pf_s32)(attr_required & attr) != (pf_s32)attr_required) ||
(attr_forbidden && (pf_s32)(attr_forbidden & attr) == (pf_s32)attr_forbidden)) err = -1;
} else if ((pf_u8)attr_required != 0x7f && (pf_u32)attr != (pf_u8)attr_required &&
(!(attr & (pf_u8)attr_required) || (attr & (pf_u8)attr_forbidden))) err = -1;
if (err == -1) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
if (attr & 8) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
}
PFENT_LoadShortNameFromBuf(p_ent, p_iter->buf);
if (p_ent->num_entry_LFNs && p_ent->ordinal == 1 && p_ent->check_sum == PFENT_CalcCheckSum(p_ent) &&
PFPATH_MatchFileNameWithPattern((pf_s8*)p_ent->long_name, p_pattern, 1)) {
LoadNumericEntry(p_iter, p_ent);
*p_is_found = 1;
return 0;
}
if (PFPATH_MatchFileNameWithPattern(p_ent->short_name, p_pattern, 0)) {
if (p_iter->buf[12] & 0x18) PFENT_ITER_MakeLongFileName(p_iter, p_ent);
LoadNumericEntry(p_iter, p_ent);
*p_is_found = 1;
return 0;
}
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
}
finish:
return 0;
}
pf_s32 PFENT_ITER_DoGetEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLUME* p_vol, PF_STR* p_path, pf_bool wildcard,
pf_bool no_look_last_token) {
pf_s8* p;
PF_STR token;
pf_bool is_found;
PFITER_FAT_HINT hint;
pf_u32 start_cluster;
PF_DIR_ENT current_ent;
pf_s32 err;
pf_u32 code_mode;
if (PFSTR_StrNCmp(p_path, (pf_s8*)":", 1, 1, 1) == 0) {
PFSTR_MoveStrPos(p_path, 2);
}
if ((PFSTR_StrNCmp(p_path, (pf_s8*)"\\", 1, 0, 1) == 0 || PFSTR_StrNCmp(p_path, (pf_s8*)"/", 1, 0, 1) == 0)) {
err = PFENT_GetRootDir(p_vol, p_ent);
if (err != 0) {
return err;
}
if (PFSTR_StrNumChar(p_path, 1) == 1 && (PFSTR_StrNCmp(p_path, (pf_s8*)"\0", 2, 0, 1) == 0)) {
return 0;
}
} else {
err = PFVOL_GetCurrentDir(p_vol, p_ent);
if (err != 0) {
return err;
}
}
p = PFSTR_GetStrPos(p_path, 1);
PFFAT_InitFFD(&p_iter->ffd, &hint, p_vol, &p_iter->ffd.current_start_cluster);
p_iter->ffd.current_start_cluster = p_ent->start_cluster;
code_mode = PFSTR_GetCodeMode(p_path);
PFPATH_InitTokenOfPath(&token, p, code_mode);
for (err = PFPATH_GetNextTokenOfPath(&token, wildcard); token.p_head != 0; err = PFPATH_GetNextTokenOfPath(&token, wildcard)) {
if (err != 0) {
return err;
}
if (no_look_last_token != 0 && (PFSTR_StrNCmp(&token, (pf_s8*)"\0", 2, 0, 1) == 0)) {
break;
}
if ((p_ent->attr & 0x10) == 0) {
return 2;
}
if (PFSTR_StrLen(&token) == 0) {
return 2;
}
p_iter->ffd.current_start_cluster = p_ent->start_cluster;
PFFAT_ResetFFD(&p_iter->ffd, &p_iter->ffd.current_start_cluster);
err = InitializeIterator(p_iter, 0);
if (err != 0) {
return err;
}
start_cluster = *p_iter->ffd.p_start_cluster;
err = PFENT_ITER_DoFindEntry(p_iter, p_ent, &token, 0x7F, 0, &is_found);
if (err != 0) {
return err;
}
if (!is_found) {
err = PFPATH_GetNextTokenOfPath(&token, wildcard);
if (err != 0) {
return err;
}
return (token.p_head == PF_NULL) + 2;
}
if (!wildcard) {
if ((p_ent->attr & 0x10) != 0 && p_ent->start_cluster == 1) {
p_ent->path_len = 3;
continue;
}
if ((p_ent->attr & 0x10) != 0 && p_ent->short_name[0] == '.' && p_ent->short_name[1] == '.') {
PFFAT_ResetFFD(&p_iter->ffd, &p_ent->start_cluster);
err = InitializeIterator(p_iter, 0);
if (err != 0) {
return err;
}
current_ent.attr = p_ent->attr;
current_ent.start_cluster = p_ent->start_cluster;
err = PFENT_ITER_FindDirEntryFromCluster(p_iter, &current_ent, start_cluster, &is_found);
if (err != 0) {
return err;
}
if (is_found == 0) {
return 2;
}
if (current_ent.num_entry_LFNs != 0) {
p_ent->path_len -= PFPATH_GetLengthFromUnicode(current_ent.long_name);
} else {
p_ent->path_len -= PFPATH_GetLengthFromShortname(&current_ent.short_name[0]);
}
p_ent->path_len--;
continue;
}
if ((p_ent->attr & 0x10) == 0 || p_ent->short_name[0] != '.') {
p_ent->path_len = (PFSTR_StrNumChar(&token, 1) + 1) + p_ent->path_len;
if ((PFSTR_StrNCmp(&token, (pf_s8*)"\0", 2, 0, 1) != 0)) {
p_ent->path_len -= PFSTR_StrNumChar(&token, 2);
}
}
continue;
}
}
return 0;
}
pf_s32 PFENT_ITER_IteratorInitialize(PFITER_ENT_ITER* p_iter, pf_u32 index_start_from) {
pf_s32 err;
p_iter->p_vol = p_iter->ffd.p_vol;
p_iter->log2_entries_per_sector = p_iter->p_vol->bpb.log2_bytes_per_sector - 5;
p_iter->offset_mask = (1 << p_iter->log2_entries_per_sector) - 1;
p_iter->file_sector_index = -1;
err = PFENT_ITER_DoMoveTo(p_iter, index_start_from, 0U);
return err;
}
pf_bool PFENT_ITER_IsAtLogicalEnd(PFITER_ENT_ITER* p_iter) {
pf_s32 err;
pf_u32 save_index;
pf_u32 save_fsindex;
if (p_iter->sector == -1U || p_iter->buf[0] == 0 || p_iter->index >= (1000000 - 1)) {
save_index = p_iter->index;
save_fsindex = p_iter->file_sector_index;
p_iter->index = (p_iter->file_sector_index + 1) << p_iter->log2_entries_per_sector;
err = PFENT_RecalcEntryIterator(p_iter, PF_FALSE);
if (err != 0) {
p_iter->index = save_index;
p_iter->file_sector_index = save_fsindex;
return PF_TRUE;
}
if (p_iter->sector != -1) {
err = PFENT_ITER_LoadEntry(p_iter);
if (err != 0) {
return PF_TRUE;
}
return PF_FALSE;
}
return PF_TRUE;
}
return PF_FALSE;
}
pf_s32 PFENT_ITER_MoveTo(PFITER_ENT_ITER* p_iter, pf_u32 index, pf_u32 may_allocate) {
pf_s32 err;
if (p_iter->index != index || p_iter->sector != -1U || may_allocate == PF_FALSE) {
err = PFENT_ITER_DoMoveTo(p_iter, index, may_allocate);
if (err != 0) {
return err;
}
}
return 0;
}
pf_s32 PFENT_ITER_Advance(PFITER_ENT_ITER* p_iter, pf_u32 may_allocate) {
return PFENT_ITER_MoveTo(p_iter, p_iter->index + 1, may_allocate);
}
pf_s32 PFENT_ITER_FindCluster(PF_DIR_ENT* p_ent, pf_u32 cluster, pf_bool* p_is_found) {
PFITER_FAT_HINT hint;
pf_u32 entries_per_sector;
pf_u32 current_cluster;
PFITER_ENT_ITER iter;
pf_u32 sector_index;
pf_s32 err;
*p_is_found = 0;
if (p_ent->entry_sector < p_ent->p_vol->bpb.first_data_sector) return 0;
current_cluster = (p_ent->entry_sector - p_ent->p_vol->bpb.first_data_sector) >> p_ent->p_vol->bpb.log2_sectors_per_cluster;
sector_index = (p_ent->p_vol->bpb.sectors_per_cluster - 1) & (p_ent->entry_sector - p_ent->p_vol->bpb.first_data_sector);
if (current_cluster == cluster) {
*p_is_found = 1;
return 0;
}
iter.ffd.p_start_cluster = &current_cluster;
iter.ffd.p_hint = &hint;
iter.ffd.p_vol = p_ent->p_vol;
iter.ffd.start_cluster = 1;
iter.ffd.cluster_link.buffer = PF_NULL;
iter.log2_entries_per_sector = p_ent->p_vol->bpb.log2_bytes_per_sector - 5;
iter.file_sector_index = sector_index;
entries_per_sector = 1 << iter.log2_entries_per_sector;
iter.offset_mask = entries_per_sector - 1;
iter.p_vol = p_ent->p_vol;
iter.sector = p_ent->entry_sector;
iter.offset = p_ent->entry_offset;
iter.index = ((pf_u32)p_ent->entry_offset >> 5) + sector_index * entries_per_sector;
hint.chain_index = 0;
hint.cluster = current_cluster;
hint.previous_cluster = 1;
if (iter.index < 2) {
hint.chain_index = 1;
iter.file_sector_index += p_ent->p_vol->bpb.sectors_per_cluster;
iter.index += entries_per_sector << p_ent->p_vol->bpb.log2_sectors_per_cluster;
}
while (iter.index != 0) {
err = PFENT_ITER_LoadEntry(&iter);
if (err != 0) return err;
if (pf_strncmp((pf_s8*)iter.buf, (pf_s8*)"..", 2) == 0) break;
err = PFENT_ITER_Retreat(&iter, 0);
if (err != 0) return err;
if (current_cluster == cluster) {
*p_is_found = 1;
return 0;
}
if (current_cluster <= 2) return 0;
if (iter.index < 1) {
++hint.chain_index;
iter.file_sector_index += p_ent->p_vol->bpb.sectors_per_cluster;
iter.index += (1 << iter.log2_entries_per_sector) << p_ent->p_vol->bpb.log2_sectors_per_cluster;
}
}
current_cluster = (PF_SWAP_16(*(pf_u16*)&iter.buf[20]) << 16) | PF_SWAP_16(*(pf_u16*)&iter.buf[26]);
hint.chain_index = 0;
iter.file_sector_index = 0;
hint.cluster = current_cluster;
iter.sector = p_ent->p_vol->bpb.first_data_sector + ((current_cluster - 2) << p_ent->p_vol->bpb.log2_sectors_per_cluster);
iter.offset = 32;
iter.index = 1;
while (current_cluster > 2) {
err = PFENT_ITER_LoadEntry(&iter);
if (err != 0) return err;
if (pf_strncmp((pf_s8*)iter.buf, (pf_s8*)"..", 2) == 0) {
if (current_cluster == cluster) {
*p_is_found = 1;
return 0;
}
current_cluster = (PF_SWAP_16(*(pf_u16*)&iter.buf[20]) << 16) | PF_SWAP_16(*(pf_u16*)&iter.buf[26]);
hint.cluster = current_cluster;
iter.sector = p_ent->p_vol->bpb.first_data_sector + ((current_cluster - 2) << p_ent->p_vol->bpb.log2_sectors_per_cluster);
} else return 0;
}
return 0;
}
pf_s32 PFENT_ITER_Retreat(PFITER_ENT_ITER* p_iter, pf_u32 may_allocate) {
pf_u32 before_cluster;
pf_u32 cur_cluster;
pf_s32 err;
if (p_iter->index == 0) {
return 0;
}
if (p_iter->file_sector_index != ((p_iter->index - 1) >> p_iter->log2_entries_per_sector)) {
cur_cluster = ((p_iter->sector - p_iter->p_vol->bpb.first_data_sector) >> p_iter->p_vol->bpb.log2_sectors_per_cluster) + 2;
if ((p_iter->file_sector_index % p_iter->p_vol->bpb.sectors_per_cluster) == 0 || p_iter->p_vol->bpb.sectors_per_cluster == 1) {
if (p_iter->p_vol->bpb.fat_type == FAT_32 ||
(*p_iter->ffd.p_start_cluster > 1 && p_iter->p_vol->bpb.first_data_sector <= p_iter->sector)) {
err = PFFAT_getBeforeChain(p_iter->p_vol, cur_cluster, cur_cluster, &before_cluster);
if (err != 0) {
return err;
}
if (before_cluster == -1) {
return 14;
}
} else {
before_cluster = *p_iter->ffd.p_start_cluster;
}
} else {
before_cluster = cur_cluster;
}
p_iter->index--;
p_iter->file_sector_index--;
if (p_iter->p_vol->bpb.fat_type == FAT_32 || *p_iter->ffd.p_start_cluster > 1 && p_iter->p_vol->bpb.first_data_sector <= p_iter->sector) {
p_iter->sector = (p_iter->p_vol->bpb.first_data_sector + ((before_cluster - 2) << p_iter->p_vol->bpb.log2_sectors_per_cluster)) +
(p_iter->file_sector_index & (p_iter->p_vol->bpb.sectors_per_cluster - 1));
} else {
p_iter->sector--;
}
p_iter->offset = (p_iter->index & p_iter->offset_mask) * 0x20;
return 0;
}
return PFENT_ITER_MoveTo(p_iter, p_iter->index - 1, may_allocate);
}
pf_s32 PFENT_ITER_FindDirEntryFromCluster(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, pf_u32 cluster, pf_bool* p_is_found) {
pf_u8 attr;
pf_s32 err = 0;
*p_is_found = PF_FALSE;
p_ent->num_entry_LFNs = 0;
p_ent->ordinal = 0;
p_ent->check_sum = 0;
if ((p_ent->attr & 0x10) && p_ent->start_cluster == 1) return 2;
for (; PFENT_ITER_IsAtLogicalEnd(p_iter) == PF_FALSE; err = AdvanceIterator(p_iter, PF_FALSE)) {
if (err != 0) {
return err;
}
if (p_iter->buf[0] == 0xE5) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
attr = p_iter->buf[0xB];
if ((attr & (0x01 | 0x02 | 0x04 | 0x08)) == (0x01 | 0x02 | 0x04 | 0x08)) {
err = PFENT_LoadLFNEntryFieldsFromBuf(p_ent, p_iter->buf);
if (err != 0) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
}
continue;
}
if ((attr & 0x08) != 0) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
if ((attr & 0x10) == 0) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
PFENT_LoadShortNameFromBuf(p_ent, p_iter->buf);
if (p_ent->num_entry_LFNs != 0 && p_ent->ordinal == 1 && p_ent->check_sum == PFENT_CalcCheckSum(p_ent)) {
PFENT_loadEntryNumericFieldsFromBuf(p_ent, p_iter->buf);
p_ent->entry_sector = p_iter->sector;
p_ent->entry_offset = p_iter->offset;
p_ent->p_vol = p_iter->ffd.p_vol;
if ((p_ent->attr & 0x10) != 0 && p_ent->start_cluster != cluster) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
continue;
}
if ((p_ent->attr & 0x10) != 0 && p_ent->start_cluster == 0) {
p_ent->start_cluster = 1;
}
*p_is_found = 1;
}
if ((p_iter->buf[0xC] & (0x10 | 0x08)) != 0) {
PFENT_ITER_MakeLongFileName(p_iter, p_ent);
}
PFENT_loadEntryNumericFieldsFromBuf(p_ent, p_iter->buf);
p_ent->entry_sector = p_iter->sector;
p_ent->entry_offset = p_iter->offset;
p_ent->p_vol = p_iter->ffd.p_vol;
if ((p_ent->attr & 0x10) && p_ent->start_cluster != cluster) {
p_ent->num_entry_LFNs = 0;
p_ent->long_name[0] = 0;
*p_is_found = 0;
continue;
}
if ((p_ent->attr & 0x10) && p_ent->start_cluster == 0) p_ent->start_cluster = 1;
*p_is_found = 1;
return 0;
}
return 0;
}
pf_s32 PFENT_ITER_FindEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_STR* p_pattern,
pf_u32 attr_required, pf_u32 attr_forbidden, pf_bool* p_is_found) {
pf_s32 err;
*p_is_found = 0;
if (attr_required & attr_forbidden) return 10;
if (PFSTR_StrNCmp(p_pattern, (pf_s8*)":", 1, 1, 1) == 0) PFSTR_MoveStrPos(p_pattern, 2);
if (PFSTR_StrNCmp(p_pattern, (pf_s8*)"\\", 1, 0, 1) == 0 || PFSTR_StrNCmp(p_pattern, (pf_s8*)"/", 1, 0, 1) == 0) {
err = PFENT_GetRootDir(p_iter->p_vol, p_ent);
if (err != 0) return err;
if (PFSTR_StrNumChar(p_pattern, 1) == 1 && PFSTR_StrNCmp(p_pattern, (pf_s8*)"\0", 2, 0, 1) == 0) return 0;
} else {
err = PFVOL_GetCurrentDir(p_iter->p_vol, p_ent);
if (err != 0) return err;
}
err = PFENT_ITER_DoFindEntry(p_iter, p_ent, p_pattern, attr_required, attr_forbidden, p_is_found);
if (err != 0) return err;
return 0;
}
pf_s32 PFENT_ITER_FindEntryNoPathCheck(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_STR* p_pattern,
pf_u32 attr_required, pf_u32 attr_forbidden, pf_bool* p_is_found) {
pf_s32 err;
*p_is_found = 0;
if (attr_required & attr_forbidden) return 10;
err = PFENT_ITER_DoFindEntry(p_iter, p_ent, p_pattern, attr_required, attr_forbidden, p_is_found);
if (err != 0) return err;
return 0;
}
pf_s32 PFENT_ITER_GetEntryOfPath(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLUME* p_vol, PF_STR* p_path, pf_u32 no_look_last_token) {
return PFENT_ITER_DoGetEntry(p_iter, p_ent, p_vol, p_path, 0, no_look_last_token);
}
pf_s32 PFENT_ITER_GetEntryOfPattern(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLUME* p_vol, PF_STR* p_path) {
return PFENT_ITER_DoGetEntry(p_iter, p_ent, p_vol, p_path, 1, 1);
}
pf_s32 PFENT_ITER_GetEntryOfIter(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
PFENT_LoadShortNameFromBuf(p_ent, p_iter->buf);
PFENT_loadEntryNumericFieldsFromBuf(p_ent, p_iter->buf);
p_ent->entry_sector = p_iter->sector;
p_ent->entry_offset = p_iter->offset;
p_ent->p_vol = p_iter->p_vol;
return 0;
}
pf_s32 PFENT_ITER_GetLFNEntryName(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
pf_u32 i;
pf_s32 err;
if (p_ent->num_entry_LFNs != 0 && !(p_ent->small_letter_flag & 0x18)) {
for (i = 0; i < p_ent->num_entry_LFNs; ++i) {
pf_u16* destination;
err = PFENT_ITER_Retreat(p_iter, 0);
if (err != 0) return err;
err = PFENT_ITER_LoadEntry(p_iter);
if (err != 0) return err;
destination = &p_ent->long_name[(i * 26U) / 2U];
pf_memcpy(destination, &p_iter->buf[1], 10);
pf_memcpy(destination + 5, &p_iter->buf[14], 12);
pf_memcpy(destination + 11, &p_iter->buf[28], 4);
}
p_ent->long_name[(p_ent->num_entry_LFNs * 26U) / 2U] = 0;
}
return 0;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,53 +0,0 @@
#include <revolution/types.h>
s32 PFWAPI_ParseOpenModeString(const unsigned short* mode_str) {
s32 open_mode = 0;
u32 i = 0;
if (mode_str == NULL) {
open_mode = 10;
return open_mode;
}
switch (mode_str[i++]) {
case 'r': {
open_mode = 2;
break;
}
case 'w': {
open_mode = 1;
break;
}
case 'a': {
open_mode = 4;
break;
}
default: {
return 0;
}
}
if (mode_str[i] == 'b') {
i++;
}
switch (mode_str[i++]) {
case 0: {
return open_mode;
}
case 't':
default: {
return 0;
}
case '+': {
switch (mode_str[i]) {
case 0: {
return open_mode | 8;
}
default: {
return 0;
}
}
}
}
return 0;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,182 +0,0 @@
#ifndef PRIVATE_NHTTP_H
#define PRIVATE_NHTTP_H
#include <revolution/nhttp.h>
#include <revolution/os.h>
#include <revolution/ssl.h>
#define STR_POSTBOUND "--t9Sf4yfjf1RtvDu3AA"
#define LEN_POSTBOUND 18
#define LEN_URLBUF 256
#define MIN(AA, BB) (((AA) > (BB)) ? (BB) : (AA))
typedef struct NHTTPBgnEndInfo NHTTPBgnEndInfo;
typedef struct NHTTPRequestInfo NHTTPRequestInfo;
#define NHTTP_CONN_RECVBUF_SIZE 0x8000
typedef struct NHTTPConnectionInfo NHTTPConnectionInfo;
typedef enum NHTTPConnectionEvent
{
NHTTP_EVENT_NONE,
NHTTP_EVENT_POST_SEND,
NHTTP_EVENT_BODY_RECV_FULL,
NHTTP_EVENT_BODY_RECV_DONE,
NHTTP_EVENT_COMPLETE,
NHTTP_CALLBACK_EVENT_MAX,
} NHTTPConnectionEvent;
typedef s32 (*NHTTPConnectionCallback)(NHTTPConnectionInfo* connection,
NHTTPConnectionEvent event, void* arg);
typedef struct NHTTPConnectionCallbackParam
{
void* value;
u32 _unk4;
u32 _unk8;
u32 _unkC;
} NHTTPConnectionCallbackParam;
typedef struct NHTTPPostSendArg
{
const char* label;
char* buf;
u32 size;
u32 offset;
} NHTTPPostSendArg;
typedef struct NHTTPBodyBufArg
{
char* buf;
u32 size;
u32 offset;
} NHTTPBodyBufArg;
typedef struct NHTTPHeader
{
struct NHTTPHeader* next;
struct NHTTPHeader* prev;
char* name;
char* value;
u32 length;
u32 _unk14;
} NHTTPHeader;
typedef struct NHTTPReqQueue
{
struct NHTTPReqQueue* next;
struct NHTTPReqQueue* prev;
s32 requestId;
NHTTPRequestInfo* volatile request;
s32 _unk10;
} NHTTPReqQueue;
typedef struct NHTTPListInfo
{
NHTTPReqQueue* reqQueue;
s32 nextRequestId;
} NHTTPListInfo;
typedef struct NHTTPReqInfo
{
NHTTPReqQueue* reqQueue;
} NHTTPReqInfo;
typedef struct NHTTPi_HDRBUFLIST
{
struct NHTTPi_HDRBUFLIST* next_p;
u8 block[NHTTP_HDRRECVBUF_BLOCKLEN];
} NHTTPi_HDRBUFLIST;
typedef struct NHTTPResponseInfo
{
volatile s32 headerLen;
volatile s32 bodyLen;
volatile s32 totalBodyLen;
volatile s32 contentLength;
s32 isSuccess;
s32 isHeaderParse;
s32 httpStatus;
u32 recvBufLen;
char* allHeader_p;
char* foundHeader_p;
char* recvBuf_p;
NHTTPResponseCallback bufFull;
NHTTPResponseCleanup freeBuf;
NHTTPi_HDRBUFLIST* hdrBufBlock_p;
u8 hdrBufFirst[NHTTP_HDRRECVBUF_INILEN];
void* param_p;
} NHTTPResponseInfo;
struct NHTTPRequestInfo
{
BOOL cancel;
s32 state;
BOOL secure;
BOOL proxyEnabled;
BOOL isRawData;
s32 hostEnd;
s32 pathStart;
s32 method;
u32 port;
char* url;
char* host;
NHTTPResponseInfo* response;
NHTTPHeader* headers;
NHTTPHeader* postData;
char multipartBoundary[LEN_POSTBOUND + 2];
char authorization[0x5C];
s32 authorizationLength;
SSLId sslId;
const char* clientCertData;
u32 clientCertSize;
const char* privateKeyData;
u32 privateKeySize;
const char* rootCAData;
u32 rootCASize;
BOOL clientCertDefault;
u32 verifyOption;
NHTTPEncodingType encodingType;
void* _unkD4;
u32 builtinRootCA;
u32 builtinClientCert;
char proxyServer[0x100];
u32 proxyPort;
char proxyAuthorization[0x5C];
s32 proxyAuthorizationLength;
u32 recvBufferSize;
const void* postBuffer;
u32 postBufferSize;
void* _unk250;
};
struct NHTTPConnectionInfo
{
BOOL started;
s32 state;
s32 sslError;
u32 _unkC;
NHTTPRequestInfo* request;
NHTTPResponseInfo* response;
s32 requestId;
NHTTPConnectionCallback callback;
NHTTPConnectionInfo* next;
u32 _unk24;
u32 _unk28;
u32 virtualContentLength;
NHTTPReqCallback requestCallback;
u32 _unk34;
u32 _unk38;
u32 _unk3C;
u8 recvBuf[0x8000];
u32 recvBufOffset;
u32 recvBufDataLen;
u32 _unk8048;
u32 _unk804C;
u32 _unk8050;
u32 _unk8054;
u32 _unk8058;
u32 _unk805C;
};
#endif // PRIVATE_NHTTP_H

Some files were not shown because too many files have changed in this diff Show More