Compare commits

..

302 Commits

Author SHA1 Message Date
coah
fb2b60534b Decompile hardware keyboard input dispatch 2026-10-01 19:51:18 -05:00
coah
426555a34f match(SaveDataManager): decompile isEqualChannel (#677)
* match(SaveDataManager): decompile isEqualChannel

* cleanup(SaveDataManager): drop register keyword from isEqualChannel
2026-10-01 19:47:51 -05:00
coah
9acff80781 cleanup(CXStreamingUncompression): name remaining RL/LZ/Huffman fields (#680)
Follows #678 (outData/outDataLen). Renames length/flags/hdrLen and
Huffman wordBuffer/wordBits.
2026-10-01 19:45:41 -05:00
coah
3c9af06f34 Decompile hardware keyboard language selection (#700) 2026-10-01 19:43:23 -05:00
github-actions[bot]
824fe9fc0a docs: update progress [skip ci] 2026-10-02 00:38:30 +00:00
coah
34d6a62df3 match(tiPcKeyboard 138/141, AXFXChorusExp 5/7) (worker 1aeb77af) (#699) 2026-10-01 19:37:15 -05:00
github-actions[bot]
f97f091472 docs: update progress [skip ci] 2026-10-02 00:36:30 +00:00
coah
6c042d2a06 Correct memory-card conversion constant ownership (#697) 2026-10-01 19:35:48 -05:00
coah
53f70c85ce Correct L2CAP diagnostic string ownership (#696) 2026-10-01 19:35:42 -05:00
github-actions[bot]
7a24a5c17e docs: update progress [skip ci] 2026-10-02 00:30:05 +00:00
coah
37c7c21953 Restore hardware-keyboard function order and link unit (#698) 2026-10-01 19:29:25 -05:00
github-actions[bot]
a81b7c36fe docs: update progress [skip ci] 2026-10-02 00:16:19 +00:00
coah
d17ab22bf0 match(SOBasic): SOInetPtoN address family selection, 19/22 (worker 1e3ff7dd) (#695) 2026-10-01 19:15:29 -05:00
coah
17407ed1cb cleanup(iplButton): name anim-wait and new-mail anm flags (#694)
Rename Button calc busy flag and new-mail animation controls; update
ChannelTitle setter call sites.
2026-10-01 19:14:24 -05:00
coah
199883f758 cleanup(eZiText): rename work unk_0x16 to cangjieEnabled (#693)
Same Zi8GetFormatVersion(... ) & 2 pattern as ZiInfoWork.cangjieEnabled.
2026-10-01 19:14:18 -05:00
coah
edfb253724 cleanup(eZiText): rename work unk_0x538 to language (#692)
Assigned from parameters->language in zi8getc2; Matching zi8initd clears it.
2026-10-01 19:13:52 -05:00
coah
c8bb9f44da cleanup(iplDate): name focus state, pending cmd, point count (#691)
Rename Date focus SM fields used by onCmdRecv / pointer enter-leave.
2026-10-01 19:13:46 -05:00
coah
0d75b24a96 cleanup(CXStreamingUncompression): rename unk_0x0C to length (#690)
RL/LZ run and match length field (countdown while writing).
2026-10-01 19:11:21 -05:00
coah
262996a0de cleanup(NWC24MsgObj): rename unk_0x28/2C to date/receivedDate (#688)
Evidence from NWC24MBoxCtrl entry->date / entry->receivedDate copies.
2026-10-01 19:10:55 -05:00
coah
f095c9ea12 cleanup(iplCalendar): name draw list and search-task flag (#687)
Rename the secondary date list used for draw order and the vBOOL that
tracks the jam search task.
2026-10-01 19:10:27 -05:00
coah
f410332140 cleanup(iplNandSDWorker): rename unk_0x04 to mbCancel (#686)
requestCancel() sets this flag; work loops check it to abort.
2026-10-01 19:10:21 -05:00
coah
fed31b69b6 cleanup(iplBoardObject): name StandData step and angle index (#685)
Rename StandData lerp counter and angle index used by stt_stand.
2026-10-01 19:09:54 -05:00
coah
5ac1f65c4a cleanup(tiInputForm): name unused N_KOR/N_CHN sdata strings (#684)
lbl_816973A4 → scN_KOR, lbl_816973AC → scN_CHN.
2026-10-01 19:09:49 -05:00
coah
d9fbf88fb8 cleanup(eZiText): rename work unk_0x18 to subLanguage (#683)
Assigned from parameters->subLanguage in zi8getc2; Matching users
zi8is/zi8misc/zaddress updated.
2026-10-01 19:09:22 -05:00
github-actions[bot]
a77ce293ce docs: update progress [skip ci] 2026-10-02 00:09:13 +00:00
coah
e5f4e0e1f4 match(pf_cluster): InsertCluster and capacity check, 7/8 (worker a218bc12) (#689) 2026-10-01 19:08:17 -05:00
coah
c1cccf1c2c cleanup(iplTextWriter): rename unk_0x7D to mbResetAcceptable (#682)
Field is exactly what isResetAcceptable() returns; also update LetterWriter
uses of the inherited member.
2026-10-01 19:07:17 -05:00
coah
ded159048f cleanup(CDBAttr): name dirty / wiiIdDirty / wiiIdValid flags (#681)
Runtime flags after the attr buffer: lead dirty, wiiId-region dirty
(full write), and wiiId/attr loaded-valid.
2026-10-01 19:07:12 -05:00
coah
0ec86e7985 cleanup(jdec): name frame remX/remY remainder fields (#679)
Width/height leftover pixels after MCU tiling, set from remX/remY locals.
2026-10-01 19:06:45 -05:00
coah
30e1ef0938 cleanup(CXStreamingUncompression): name RL/LZ outData and outDataLen (#678)
Match Huffman context naming for the destination pointer and remaining
byte count on CXUncompContextRL/LZ.
2026-10-01 19:04:36 -05:00
coah
9ff511afd7 cleanup(RakuRakuThread): name BSS globals, alloc wrappers, syncProgress (#665)
- RakuRakuThread_810BDDD0 → sRakuAllocator
- RakuRakuThread_810BDDE0 → sRakuStatus
- RakuRakuThread_810BDED4 → sRakuMsgQueue
- RakuRakuThread_813FDEF0/FC → RakuSocketAlloc/Free
- RakuRakuThread_813FDF08/18 → RakuAtermAlloc/Free
- RakuRakuThread_813FDA04 → syncRakuProgress

DOL sha1 unchanged.
2026-10-01 19:00:34 -05:00
coah
2f206d7fe8 Add relocation-aware jump-table comparison and tests (#676) 2026-10-01 18:58:24 -05:00
coah
d6b044ff32 cleanup(BS2Mach): promote lbl_* aliases to real names (#675)
Replace address labels with the existing #define names (DvdReadPending,
TicketViews, CoverBlock, etc.) and drop the macros.

DOL sha1 unchanged.
2026-10-01 18:57:57 -05:00
coah
0e73a554de cleanup(AOSS): name protocol/state handlers (#671)
Rename remaining address-suffixed AOSS_* dispatch, reply, parse, and
send helpers. Pairs with crypto/connect helper rename PR.

DOL sha1 unchanged.
2026-10-01 18:57:52 -05:00
coah
d4cdae2177 cleanup(usb_kbd): name USBKBDCmdLED device and ledBits (#674)
Rename unk_0x00/unk_0x04 to match USBKBDSetLED parameters.
2026-10-01 18:55:13 -05:00
coah
4b831f9ec0 cleanup(ATERM): name protocol and crypto helpers (#673)
Rename remaining ATERM_814* address symbols to descriptive names for
network/stack, scan, association, AES key wrap, and MD5 helpers.

DOL sha1 unchanged.
2026-10-01 18:55:06 -05:00
coah
fbecedd948 cleanup(sdi_api): rename __sdCbArg.unk_0x0C to cmd (#672)
Field is assigned the SD command and switched on in __sdCb.
2026-10-01 18:52:58 -05:00
github-actions[bot]
f533c9f0f5 docs: update progress [skip ci] 2026-10-01 23:51:36 +00:00
github-actions[bot]
1366528dd6 docs: update progress [skip ci] 2026-10-01 23:50:59 +00:00
coah
bd27e72a48 match(tiPcKeyboard): LayoutByNW4R::updateInput (#670)
Force a u16 temporary for the Korean keymap table load so MWCC emits
clrlwi after lhz (instead of mr).
2026-10-01 18:50:45 -05:00
coah
08c53bbe23 cleanup(AOSS): name crypto and connect helpers (#669)
- AOSS_81401C9C → AOSSInitKeySchedule
- AOSS_81401DC0 → AOSSInitCrc32Table
- AOSS_81401E80 → AOSSXorBufferWithKey
- AOSS_81400830 → AOSSDecryptMessage
- AOSS_81401BBC → AOSSBuildInterfaceOption
- AOSS_814020CC → AOSSConnectAndAwaitHost

DOL sha1 unchanged.
2026-10-01 18:50:19 -05:00
coah
483005a940 link(d_nhttp_private): flip Matching after 100% objdiff (#668)
Unit is instruction-exact (7/7, 1320/1320) with clean C source.
Full 43U build keeps DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: linker <linker@local>
2026-10-01 18:50:14 -05:00
coah
b18d01602a cleanup(CardSequence): name card-thread helpers (#667)
Rename address-suffixed CardSequence_* helpers to descriptive names
(send/poll/map/clear/refresh/thread/error/state/icon/move).

DOL sha1 unchanged.
2026-10-01 18:49:47 -05:00
coah
e38a4cebfe cleanup(MemoryCardManager): rename qsort comparator (#666)
iplMemoryCardManager_813CD034 → compareMemoryCardSortEntries

DOL sha1 unchanged.
2026-10-01 18:49:40 -05:00
coah
81dc9d2b3d cleanup(pf_code): rename pf_valid_fn_char_8162E6B0 to pf_valid_fn_char (#664)
Drop address suffix so source matches symbols.txt. Clear scope:local so
NonMatching pf_path splits resolve the same global.
2026-10-01 18:49:14 -05:00
coah
f645518810 cleanup(vi3in1): rename Vdac_Flag_Changed_816991E0 to Vdac_Flag_Changed (#663)
Drop address suffix so source matches symbols.txt. Clear scope:local so
NonMatching vi.c splits resolve the same global.
2026-10-01 18:48:47 -05:00
coah
51713e735e cleanup(AOSSLink): name sleep/IP helpers and NCD config BSS (#662)
- AOSS_813FD17C → AOSSi_SleepAlarmHandler
- AOSS_813FD18C → AOSSi_SleepMs
- AOSS_813FD25C → AOSSi_StoreIpv4Octets
- AOSS_810BD4A8 → AOSSi_NcdIfConfig
- AOSS_810BD608 → AOSSi_NcdIpConfig

DOL sha1 unchanged.
2026-10-01 18:48:41 -05:00
coah
ca998ad7cf cleanup(puh_msc): rename uhg_msc_memid_8169971C to uhg_msc_memid (#661)
Drop address suffix on the MSC memory-pool id so source matches
symbols.txt. Mark the symbol global so NonMatching puh_msc_blk
splits resolve the same name.
2026-10-01 18:46:27 -05:00
github-actions[bot]
486c20c623 docs: update progress [skip ci] 2026-10-01 23:46:01 +00:00
coah
6adb0dc52e cleanup(CHANSVm): rename FormatString and LookupScopedObject (#660)
- CHANSVm_8145049C → CHANSVmFormatString
- CHANSVm_81455654 → CHANSVmLookupScopedObject

Unit remains carefully Equivalent; DOL sha1 unchanged.
2026-10-01 18:45:59 -05:00
coah
c9f64372cf cleanup(CHANSVm): rename blob offset/size helpers and MakeU64 (#659)
- CHANSVm_81450D14 → CHANSVmBlobResolveOffset
- CHANSVm_81451314 → CHANSVmBlobGetCount
- CHANSVm_81451348 → CHANSVmBlobHasSpace
- CHANSVm_814540E0 → CHANSVmMakeU64

Unit still Matching; DOL sha1 unchanged.
2026-10-01 18:45:53 -05:00
coah
9f4a70db74 match(pf_fat): PFFAT_GetSectorSpecified (#658)
Rewrite the error cleanup as switch(error) so MWCC emits the
target beq/b/li epilogue instead of a collapsed bne/li.

Unit pf_fat: 30/35 -> 31/35 funcs; 9900 -> 9968 / 12572 code bytes.
DOL sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-01 18:45:26 -05:00
coah
e305e6047c cleanup(CHANSVm): name float/int/string convert helpers (#657)
- CHANSVm_8144B1D8 → CHANSVmFloatSign
- CHANSVm_8144B30C → CHANSVmConvertToIntFromFloat
- CHANSVm_8144B430 → CHANSVmConvertToFloatFromUndefined
- CHANSVm_8144B470 → CHANSVmConvertToFloatFromInt
- CHANSVm_8144B4D4 → CHANSVmConvertToFloatFromStr
- CHANSVm_8144B62C → CHANSVmFloatToWString
- CHANSVm_8144B734 → CHANSVmConvertToStrFromFloat

Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:45:19 -05:00
coah
df48bc9f76 Restore SD title switch block emission order (#656) 2026-10-01 18:43:05 -05:00
coah
3bd814f042 cleanup(SDMemory): rename iplSDMemory_813EE358 to containsTitleId (#655)
Helper scans a title-id list for a match; unused SDMemory* param kept.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:42:39 -05:00
coah
51b78ed7da cleanup(iplBalloon): name fade/align/margin fields (#654)
Rename TextBalloon unk_ members and ctor/setPos params.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:40:27 -05:00
coah
3eb5d8faee cleanup(iplAOSSThread): name stack sentinel like RakuStack (#653)
Replace *(u32*)(mpStackBuffer + 0x3FC0) with AOSSStack::sentinel.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:40:21 -05:00
coah
d99950fc88 cleanup(tiCandidateBox): drop unused sdata2 float decls (#652)
Removed seven bare extern lbl_81694D* decls that were never referenced.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:38:09 -05:00
coah
98d03059bd cleanup(iplBoardObject): rename Cos/Sin Ghidra locals (#651)
dVar2 → cosF, dVar3 → sinF in BoardObject::stt_stand.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:37:42 -05:00
coah
830e2f3920 cleanup(iplSound): name pitch/volume sdata2 float constants (#650)
lbl_816946A8 → scSoundTwoF (2.0f), lbl_816946AC → scSoundOneF (1.0f),
lbl_816946B0 → scSoundThirtyF (30.0f), lbl_816946B4 → scSoundSixtyF (60.0f).
2026-10-01 18:37:35 -05:00
coah
c1b00d8a14 cleanup(Date): drop unused lbl_816948F0 sdata2 decl (#649)
Bare extern was never referenced; scDateZeroF remains.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:37:29 -05:00
coah
9acdd7f8dc cleanup(WDScan): name OUI sdata/sdata2 padding bytes (#648)
Rename leftover lbl_* pad bytes that sit between the RSN/WPA OUI
triples (and after scWpaFindOui*) so force_active and locals match
the existing sc* naming.
2026-10-01 18:37:02 -05:00
coah
abf047831a cleanup(tiInputForm): rename scInputForm0_7111111F to DegToFIdx (#647)
0.7111111f is 256/360 (degrees → nw4r SinFIdx units). Drop the
digit-heavy name that looked like an address suffix.

Verified: ninja build/43U/ok; fuzzy unchanged; DOL sha1 unchanged.
2026-10-01 18:35:19 -05:00
coah
17be3b014b cleanup(ChannelSelect): name updateDiskState asm labels (#646)
Rename address-suffixed local labels and jumptable_8164DE80 inside the
carefully Equivalent updateDiskState asm to case*/done semantic names.
symbols.txt updated for the jumptable; codegen unchanged.

Verified: ninja build/43U/ok; ~96.37% code / ~99.76% fuzzy; DOL sha1 unchanged.
2026-10-01 18:35:13 -05:00
coah
0d9d3d1081 cleanup(runtime): prefix Matching asm L_* labels with function names (#645)
Rename 65 bare address labels in Runtime helpers (__div2u/__div2i/__mod*,
__cvt_*, __shr2i) to FunctionName_L_<addr> for readability; codegen unchanged.

Verified: ninja build/43U/ok; runtime 100%/100%; DOL sha1 unchanged.
2026-10-01 18:35:07 -05:00
coah
196b14aa58 cleanup(CDBDatabase): prefix Matching asm L_* labels with function names (#644)
Rename 169 bare address labels inside the seven Search* asm functions to
FunctionName_L_<addr>, matching the nand_drv style, so local branches are
readable without changing codegen.

Verified: ninja build/43U/ok; CDBDatabase 100%/100%; DOL sha1 unchanged.
2026-10-01 18:34:25 -05:00
coah
1dde229702 cleanup(sdChannelSelect): drop unused iplSDChannelSelect_813DD240 decl (#643)
The real path is collectTitlesFromNandUsage; this extern was never called.
Build still OK; DOL sha1 unchanged.
2026-10-01 18:33:58 -05:00
coah
94c03497ff cleanup(SDChannelObj): name address-suffixed C helpers (#636)
Rename iplSDChannelObj_813E* helpers to semantic names (setHeaps,
createBaseLayout, getLocalizedName, etc.) across the unit, callers,
header, and symbols.txt. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~90% code /
~99.99% fuzzy.
2026-10-01 18:33:42 -05:00
coah
e9dd012c09 cleanup(zmtkey): name Zi8MapKeyCode helper (#642)
Rename Zi8_81484484 (OEM/private-use wchar → key index) to
Zi8MapKeyCode. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~67.1% code /
~99.85% fuzzy.
2026-10-01 18:33:31 -05:00
coah
90e7b0ff2c iplSensitivity: suppress inline Rect dtor weak (#641)
Define IPL_CONTROLLER_TRIVIAL_RECT_DTOR so this TU no longer emits
~nw4r::ut::Rect. Compiled .text becomes byte-identical to the extract
(1112 bytes). Matching still blocked on .sdata2 layout (48 vs 56).

Co-authored-by: linker <linker@users.noreply.github.com>
2026-10-01 18:33:24 -05:00
coah
f7ec594202 cleanup(tiInputForm): name float/color sdata constants (#626)
* cleanup(tiInputForm): name float/color sdata constants

Prefix scInputForm* to avoid colliding with other units'
scHalfF/scTwoF globals. Leave unused N_KOR/N_CHN decls.

* cleanup(tiInputForm): keep ChanAppBox scHalfF/scTwoF

0x81694900/0x81694904 belong to iplChanAppBox; restore those symbol
names and leave only tiInputForm-owned scInputForm* at 0x81694D28+.
2026-10-01 18:25:29 -05:00
github-actions[bot]
ceefb50e42 docs: update progress [skip ci] 2026-10-01 23:25:22 +00:00
coah
5d1a8bd697 Revert "Link iqdec_b65_frv32 via retail .s (#615)" (#640)
This reverts commit 40653c3c02.
2026-10-01 18:24:26 -05:00
coah
c42fb1fe71 cleanup(SDChannelTitle): name address-suffixed C helpers (#639)
Rename iplSDChannelTitle_813E* helpers to semantic names across the
unit and symbols.txt. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~80.9% code /
~99.76% fuzzy.
2026-10-01 18:23:38 -05:00
coah
8e96e8a722 match(SaveDataManager): decompile getNumValidChannel (#622)
Exact match (23/23, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Adds ChannelSlot/ChannelPage overlays (slots at +0x30, page stride 0xC0)
so the loop uses typed .valid/.titleId instead of raw byte loads.
2026-10-01 18:22:58 -05:00
coah
854cc579df Fix keyboard prediction and animation jump tables (#638) 2026-10-01 18:22:03 -05:00
coah
26a36e2964 Restore SD memory dialog-state dispatch mapping (#637) 2026-10-01 18:21:37 -05:00
coah
8729671a43 Match GC card-removal no-op jump target (#635) 2026-10-01 18:21:10 -05:00
coah
08f5f08a13 match(CDBDatabase): decompile CDBDatabaseCreateRecordAtOnce (#558)
Exact match (37/37, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.
Rebased onto latest main.
2026-10-01 18:20:54 -05:00
coah
893afc25b4 cleanup(tiHwKeyboard): name convertWCCode jumptable (#634)
Rename jumptable_81668EF8 to scHwKeyboardConvertWCCodeJumpTable.
2026-10-01 18:20:44 -05:00
coah
dee9f9d8ea cleanup(zikorean): name Korean lookup/match helpers (#633)
Rename Zi8_814813FC/81481E6C to Zi8LookupKoreanChar and
Zi8MatchKoreanSequence.
2026-10-01 18:20:39 -05:00
coah
728bfa984b cleanup(TMCJPEG): name decode-buffer refill helpers (#632)
Rename TMCJPEG_814EAF50/814EB108 to refillJpegBufferAfterFF
and refillJpegBuffer.
2026-10-01 18:15:59 -05:00
coah
921234fdac cleanup(rvl_dec): name literal-copy goto label (#631)
Rename LAB_813325b8 to copy_lit_tail.
2026-10-01 18:15:23 -05:00
coah
9d6f9dce74 cleanup(Contest): name NAT detection callback (#629)
Rename iplContest_813D54F8 to onNatDetectionDone.
2026-10-01 18:15:18 -05:00
coah
f1bcb9d78c cleanup(ChannelTitle): name disk TMD/tmp-title task callbacks (#628)
Rename address-suffixed static tasks to markTmdReadyTask and
deleteTmpTitleContentTask.
2026-10-01 18:14:53 -05:00
coah
efda1f0093 Restore SD state-machine switch case mappings (#623) 2026-10-01 18:14:28 -05:00
github-actions[bot]
115bc95101 docs: update progress [skip ci] 2026-10-01 23:12:57 +00:00
coah
cbac1eda5a match(KPAD): sensor interval constant pool data (worker 93817b04) (#630) 2026-10-01 18:12:12 -05:00
github-actions[bot]
f0de86aa16 docs: update progress [skip ci] 2026-10-01 23:11:14 +00:00
github-actions[bot]
215f40f835 docs: update progress [skip ci] 2026-10-01 23:10:30 +00:00
coah
5b364355cd match(NWC24Download 25/30, nup 19/23) (worker da66e510) (#627) 2026-10-01 18:10:29 -05:00
coah
ea8e69528f match(wad): _WADHash, 35/40 (worker ae91d0cb) (#625) 2026-10-01 18:09:19 -05:00
coah
2a5fbdb4b9 cleanup(tiInputForm): name pane/string labels (#620)
Rename known layout pane name placeholders; leave float
constants and unused N_KOR/N_CHN sdata decls for follow-ups.
2026-10-01 18:08:19 -05:00
coah
dd3cd80d9b match(CDBDatabase): decompile CDBDatabasePrivateCreateRecordAtOnceEx_ (#619)
Exact match (73/73, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 18:08:05 -05:00
github-actions[bot]
3cbe527d23 docs: update progress [skip ci] 2026-10-01 23:07:39 +00:00
coah
3ab6d87c3d cleanup(CHANSVm): name string labels and VmCmpEq bVar (#618)
Rename UTF-16 / class-name / printf / hex placeholders and
CHANSVmConstStringObject* companions; bVar1 → stringsMatch.
2026-10-01 18:07:38 -05:00
coah
40653c3c02 Link iqdec_b65_frv32 via retail .s (#615)
NonMatching/Equivalent source does not keep DOL SHA1. Assemble extracted unit and mark Matching.

Also fix --defsym VERSION_* for gas (needs =1).

Linked code: 62.047% -> 62.084% / 919 units
DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d

Co-authored-by: linker <linker@local>
2026-10-01 18:06:29 -05:00
github-actions[bot]
f0829ff810 docs: update progress [skip ci] 2026-10-01 23:06:06 +00:00
coah
ffdd7b58e0 cleanup(tiCandidateBox): name pane/string labels (#608)
Rename address placeholders for known pane names and related
sdata aliases; leave float constants for a follow-up.
2026-10-01 18:05:58 -05:00
coah
1a0f83a156 match(CDBDatabase): decompile CDBDatabaseCreateRecordAtOnceEx (#607)
Exact match (51/51, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 18:05:17 -05:00
coah
a3d088e4d3 match(d_nhttp_private): NHTTPDeleteConnection (#606)
Rewrite ConnectionStarted's null check as if/else so the inlined
WaitConnection path matches beq/bne block order (null → -1 first).

Before: 6/7 funcs, 908/1320 code bytes
After:  7/7 funcs, 1320/1320 code bytes
DOL sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-01 18:04:32 -05:00
coah
3b90bd66c6 cleanup(iplSound): name zero float constant (#599)
Rename lbl_816946A4 → scSoundZeroF (defined 0.0f). Leave other pitch
floats alone until they have Matching definitions.
2026-10-01 18:04:18 -05:00
coah
b395269be6 cleanup(iplChannelObj): rename leftover bVar locals (#605)
- bVar4 → foundLangGroup
- bVar3 → isNonRsoGroup
- bVar1 → shouldAdjustHeap
2026-10-01 18:04:05 -05:00
github-actions[bot]
60bc67e097 docs: update progress [skip ci] 2026-10-01 23:04:00 +00:00
coah
4e8223f3d4 cleanup(wad): sync WAD*Ex header params with .c (#592)
Match wad.h to wad.c (flags/offset/fileListOut/processCallback).
2026-10-01 18:03:49 -05:00
github-actions[bot]
3f36d5f4cc docs: update progress [skip ci] 2026-10-01 23:03:03 +00:00
coah
1f0dc64062 cleanup(kpad): sync KPADGetProjectionPos param names (#589)
Match the header to the .c (param_3/param_4 → rect/scale).
2026-10-01 18:02:56 -05:00
coah
5db0cd6086 cleanup(CDBDatabase): name error message string labels (#581)
Rename Matching lbl_* CDBReportError messages to scCdbMsg_*.
2026-10-01 18:02:31 -05:00
coah
54b44a3534 Restore keyboard unit filename and getter emission order, then link (#572) 2026-10-01 18:02:26 -05:00
coah
1493baaba0 match(pf_fat12): PFFAT12_WriteFATEntryWithBuf (#573)
Reorder locals and rewrite cross-byte stores as p_buf[offset+1].

Co-authored-by: matcher <matcher@local>
2026-10-01 18:02:05 -05:00
coah
22dd088277 match(SOBasic): SOPoll (#571)
Reorder locals (size, bytes, result, rm) for register allocation.

Co-authored-by: matcher <matcher@local>
2026-10-01 18:00:59 -05:00
coah
1bbc40cb3b cleanup(iplChannelObj): name layout/export/SE string labels (#556)
Replace Equivalent-unit lbl_* placeholders with scPaneName_/scBrlyt_/
scBrlan_/scExport_/scSE_ names; rename local_50 to langCodeBuf.
Update symbols.txt. Byte-identical; DOL sha1 unchanged.
2026-10-01 17:59:14 -05:00
coah
e6bf9cc669 cleanup(NWC24FriendList): rename friend-list path string (#533)
Rename lbl_8166E160 to scNwc24FlPath using a plain non-const char[]
declaration (no section attributes or pad objects).
2026-10-01 17:58:48 -05:00
coah
ffd9cc4a69 cleanup(iplDate): name zero float constant (#514)
String pane/brlan/SE labels already landed via #518. Rename the remaining
Matching .sdata2 zero float lbl_816948EC -> scDateZeroF.
2026-10-01 17:58:21 -05:00
coah
eb8f78788d cleanup(RsoSystem): name fatal OSFatal color/msg and zero float (#510)
lbl_8169622C..F → scRsoFatalColorR/G/B/A, lbl_81639230 → scRsoFatalMsg,
lbl_81694598 → scRsoZeroF.
2026-10-01 17:57:55 -05:00
github-actions[bot]
889823ed67 docs: update progress [skip ci] 2026-10-01 22:57:28 +00:00
coah
7dea4122fc match(tiInputForm): 217/221, replace two asm bodies with C++ (worker ec292914) (#621) 2026-10-01 17:56:40 -05:00
github-actions[bot]
1802d45758 docs: update progress [skip ci] 2026-10-01 22:48:56 +00:00
coah
130cc9e88e match(pf_fat): PFFAT_GetClusterAllocated (#570)
Reorder locals so p_start_cluster lands in r7 and p_vol in r8.

Co-authored-by: matcher <matcher@local>
2026-10-01 17:47:34 -05:00
coah
a801d1c5d6 cleanup(CXStreamingUncompression): rename Huffman init dest param (#568)
Match the Huffman prototype to the .c and the RL/LZ decls (param_2 → data).
2026-10-01 17:47:08 -05:00
coah
8ab07fbb20 Restore SD title button-string ownership (#567) 2026-10-01 17:46:43 -05:00
coah
f68fcc0f9b cleanup(lyt_window): name OSFatal color/msg constants (#566)
Rename assert-path sdata2 color bytes and Error#004 string labels.
2026-10-01 17:46:18 -05:00
coah
5ad481ae40 match(iplSaveDataManager): convert getAvailableInList to C (#563)
Exact match (28/28, diffs 0). Finds first zero titleId whose
chanInfo primaryType is not 1, using dens=12 for page/slot.
2026-10-01 17:45:53 -05:00
coah
713951c551 cleanup(ChannelTitle): rename play-limit hour/minute locals (#562)
Rename Ghidra local_38/local_58 to hourStr/minuteStr in the play-time
limit formatting path.
2026-10-01 17:45:28 -05:00
coah
b47507aa3f cleanup(sdi_api): rename leftover Ghidra param_* names (#560)
Rename ISD_GetHCRegister/GetDeviceStatus/GetCardSize and
sduCommand(v)/MultiBlockAsync parameters to descriptive names.
2026-10-01 17:44:43 -05:00
coah
01a73b600f cleanup(ChannelSelect): rename pane/SE string labels (#557)
Rename lbl_* pane and sound-effect string symbols to scPaneName_/scSE_
names; add missing WSD_SELECT definition. Build stays byte-identical.
2026-10-01 17:43:38 -05:00
coah
83b577cf62 match(CDBDatabase): convert CreateRecordImAtOnce_ to C (#555)
Exact match (84/84, diffs 0). Closed/readonly checks via instance flags,
OSTime to CDBDate via OS_BUS_CLOCK/4, then CDBRecordCreateAtOnce.
2026-10-01 17:42:32 -05:00
coah
f67990d237 cleanup(bta_dm_act): name compress check/callback params (#553)
Rename unused id on check_compress; align L2CAP compress callback
formals with pe_type/mem_level/wbits/direction/config/enable.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:41:10 -05:00
coah
ad85ad1537 cleanup(l2c_api): name compression API params (#552)
Rename SetCompression param_6 to config; RegisterCompression to p_callback/unused.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:41:02 -05:00
coah
f32665703f cleanup(AxAdpcmPlayer): rename iVar4 to pb (#551)
Rename Ghidra iVar4 to pb in getCurrAddr.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:40:35 -05:00
coah
e062e1c669 cleanup(uusb_ppc): name UUSB_Read/Write params (#550)
Rename pipe/buf/len on Read; pipe/unused on Write; fix debug print to use len.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:40:09 -05:00
coah
76a60f8c1a CDBDatabase: convert Search_ to matching C (#548)
Exact match (53/53, diffs 0). Builds CDBSearchConditions and calls
SearchYearLayer. DOL SHA1 unchanged.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 17:40:03 -05:00
github-actions[bot]
63579601e2 docs: update progress [skip ci] 2026-10-01 22:39:45 +00:00
coah
e46bac9a1b cleanup(hcisu_h2): name USB callback, receive, and init params (#549)
Rename Ghidra param_* on Matching hcisu_h2 helpers:
usb_cback event/status, receive_msg pipe, init taskId/mbox/bufSize.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:39:42 -05:00
coah
1f224c53c1 cleanup(usbkbd): name SetLED device and ledBits params (#547)
Rename USBKBDSetLED/Async param_1/param_2 to device/ledBits.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:38:34 -05:00
coah
30e2147479 match(sd_drv): pfd_st_removal_callback (#546)
Force store-before-load of media_inserted by reading it back
in the device check so MWCC emits li r0 / stw / lwz order.
2026-10-01 17:38:28 -05:00
coah
6ffcbf8f46 cleanup(bte_main): name usb close status param (#545)
Rename bta_usb_close_evt param_1 to status.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:38:01 -05:00
coah
47add32987 cleanup(bte_hcisu): name unused task param (#544)
Rename bte_hcisu_task param_1 to unused (never read).
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:37:34 -05:00
coah
e0ea552982 data(tiHwKeyboard): fix .rodata order for country maps (#543)
Move scCountryMap_* and controlKeys after the HWKeyboard methods that
emit the KeyInputData aggregate constant, so .rodata matches original
order (@6525, EU, NonEU, controlKeys). Leaves .sdata2 symbol-size /
.sdata section pad below 100%.

objdiff: .rodata 90.9% -> 100%; matched_data ~40% -> ~93.7%.
DOL sha1 unchanged (26116613f624061ba99c8d1a299aaa6efa85670d).

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:37:04 -05:00
coah
c7949ac4f0 cleanup(puh_ker_sem): name create_sem params (#542)
Rename uhf_ker_create_sem param_1/param_2 to initCount/flags.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:36:35 -05:00
coah
e697514b7b cleanup(CXSecureUncompression): name Huffman table verify params (#541)
Rename CXiVerifyHuffmanTable_ param_1/param_2 to table/bitSize.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:36:08 -05:00
coah
32c3f7f2cd cleanup(CXStreamingUncompression): name init/header params (#540)
Align RL/LZ init dest param with Huffman (data) and name
CXiReadHeader maxOutLen.
2026-10-01 17:36:01 -05:00
coah
1618565c1d Update SD title-check caller after NandSDWorker rename (#539) 2026-10-01 17:35:35 -05:00
coah
6040414eec cleanup(jdec_main): name JPEG AAN scale table (#538)
Rename lbl_8161E080 to scJpegAanScale for the 64-word IDCT scale
rodata copied into decode work.
2026-10-01 17:35:07 -05:00
coah
08acc800f1 cleanup(cntcache): name version and path string data (#537)
Rename packed string blob, title/data path format, and \" \\n\" sdata.
2026-10-01 17:34:41 -05:00
coah
0703b62968 cleanup(WPAD): name version and manage string data (#536)
Rename SDK version banner and WPADiManageHandler message blob.
2026-10-01 17:34:14 -05:00
github-actions[bot]
86c3cacc2d docs: update progress [skip ci] 2026-10-01 22:34:09 +00:00
coah
f7e6fc5387 cleanup(db_exception): name FPCSR flag local (#535)
Replace Ghidra uVar1 with fpcsr in ShowMainInfo_ FPE reporting.
2026-10-01 17:33:47 -05:00
coah
dfbb774ce4 Link fully matched tiTextDrawer (#532)
Promote keyboard/tiTextDrawer.cpp from NonMatching to Matching. All 24
functions are exact (3,476/3,476 code bytes) and the linked DOL stays
byte-identical, SHA-1 26116613f624061ba99c8d1a299aaa6efa85670d.

The unit's .sdata2 reports 44/48 bytes only because dtk folded the
section's 4-byte alignment pad into the last float symbol; the linker
restores the same pad, so no padding array or metadata change is needed.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:33:23 -05:00
coah
9b69048f06 cleanup(WDScan): name RSN/WPA OUI byte constants (#531)
Rename privacy-mode OUI sdata/sdata2 bytes used by WDGetPrivacyMode.
Leave unused pad bytes as address labels so section layout stays fixed.
2026-10-01 17:32:44 -05:00
coah
602b10ed43 data(CDBFileSystemUtils): match .sdata path separator (#530)
Replace lbl_816979E8 + .sdata section pragma with a plain
char CDBFSPathSeparator = '/' so the .sdata symbol size matches
the original (1 byte). Rename the symbol in symbols.txt to match.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:32:14 -05:00
github-actions[bot]
f0a91338f4 docs: update progress [skip ci] 2026-10-01 22:31:51 +00:00
coah
ff568a273c cleanup(rvl_dec): name Rvl_decode_ash C locals (#528)
Replace Ghidra locals in the non-asm ASH decoder path with
bitstream/huffman-oriented names.
2026-10-01 17:31:22 -05:00
coah
9f6ef656fd cleanup(rvl_dec): name Rvl_decode_szs C locals (#526)
Replace Ghidra locals in the non-asm SZS decoder path with
readable names (decodedSize, bitMask, copyLen, etc.).
2026-10-01 17:31:13 -05:00
coah
9d2f607b3f data(NHTTP_request): match multipart boundary .rodata size (#529)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:31:00 -05:00
coah
c836ab8bae cleanup(iplChannelManager): name title lookup and meta helpers (#520)
Rename Matching-only fn_8133A* APIs and update SD call sites plus
mangled symbols.txt entries.
2026-10-01 17:30:44 -05:00
coah
b889c52efc CDBDatabase: convert CleanUpEmptyDirectories to matching C (#527)
Exact match (133/133, diffs 0). Uses labeled error strings so the
DOL string pool stays identical to baserom.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 17:30:33 -05:00
coah
282c29b2c7 data(pf_entry): match default volume label size (#525)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:30:07 -05:00
coah
27e37fd7ee cleanup(sdi_api): rename path/format string blob (#524)
lbl_81691748 -> __sdPathData (packed SD reset OSReport format +
slot0/slot1/slotw path strings used by ISD_InitCard).
2026-10-01 17:29:41 -05:00
coah
00051c32c6 cleanup(iplChannelTitle): name group/pane/brlan string labels (#522)
Replace Matching-only lbl_* layout string placeholders and pointer
arrays with scGroup_/scPaneName_/scBrlan_ names; update symbols.txt.
2026-10-01 17:29:16 -05:00
coah
80fecf3aa3 cleanup(iplChanAppBox): name brlan/pane strings and sdata2 constants (#521)
Replace Matching-only lbl_* animation, pane, group, and float
placeholders; update symbols.txt.
2026-10-01 17:29:11 -05:00
github-actions[bot]
37724c57d6 docs: update progress [skip ci] 2026-10-01 22:27:32 +00:00
coah
1a32db7bdc fix: update iplSDChannelSelect caller missed by #496 rename (#554) 2026-10-01 17:26:54 -05:00
coah
2aab31c1f9 match(NHTTP_thread): NHTTPi_RecvProxyConnectHeader init order (#513)
Set cursor/index before ended so MWCC emits li r4 then li r5.
2026-10-01 17:18:22 -05:00
coah
24c84f5bfc cleanup: rename NandSDWorker SD app title check helpers (#496)
Rename iplNandSD_81348EA8/do_unk_8134C838 to
check_sd_app_titles_async/do_check_sd_app_titles. DOL sha1 unchanged.
2026-10-01 17:17:04 -05:00
coah
73de5786da cleanup(www_surface): rename CreateManager params to match cpp (#512)
param_10 → arcPath; rectW0/H0/W1/H1 → surfaceW/H, browserW/H.
Header-only rename aligned with www_surface.cpp.
2026-10-01 17:16:25 -05:00
coah
3abcd34252 cleanup(iplCalendar): name month/pos pane arrays and day-grid locals (#517)
Replace Matching-only lbl_* pane name tables and Ghidra locals in
the day layout path; update symbols.txt for the arrays.
2026-10-01 17:16:04 -05:00
coah
5c20a11fa8 Restore truncated PC-keyboard event thunk name (#519) 2026-10-01 17:15:31 -05:00
coah
f85a98a6e3 cleanup(iplSettingSelect): name exit-sequence helpers (#516)
Rename Matching-only fn_* exit/reboot helpers to descriptive
snake_case names; update mangled symbols.txt entries.
2026-10-01 17:15:19 -05:00
coah
137ee3242a cleanup(iplCSPane): name fatal OSFatal color/msg and zero float (#511)
lbl_81697844..47 → scCsFatalColorR/G/B/A, lbl_8166A6E3 → scCsFatalMsg,
lbl_81694FC0 → scCsZeroF.
2026-10-01 17:15:08 -05:00
coah
2368a9a774 cleanup(tiHwKeyboard): name EU/non-EU country map tables (#515)
Rename Matching-only setLanguage country lookup tables and
symbols.txt entries.
2026-10-01 17:13:57 -05:00
coah
90399bb6cf cleanup(iplDate): name calendar date pane/string labels (#518)
Matching-only renames in scene/calendar/iplDate (+ symbols.txt).
2026-10-01 17:13:54 -05:00
coah
fc831357ea CDBDatabase: convert Close and FindByKey to matching C (#491)
* CDBDatabase: convert Close and FindByKey to matching C

Replace asm bodies for CDBDatabaseClose and CDBDatabaseFindByKey with
equivalent C that matches instruction-exact (ctxdiff diffs 0). Unit stays
33/33 matched with 100% code and data.

* CDBDatabase: reuse labeled error strings for Close/FindByKey

Point CDBReportError at the existing lbl_ string pool entries so the
linked DOL matches baserom SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 17:13:50 -05:00
coah
e2191ae933 cleanup(TVRC): name timing constants and file header (#509)
lbl_816945C8/D0/D8/E0 → scTvrcMsPerSec/NsecPerSec/One/FloatMagic;
lbl_81696230 → scTvrcFileHeader ("TVR0").
2026-10-01 17:11:51 -05:00
coah
7d77c095c0 cleanup(iplSystem): name ortho viewport float constants (#508)
lbl_81694424..38 → scOrthoLeft/Right/Bottom/Top and scWideOrthoLeft/Right.
2026-10-01 17:10:58 -05:00
coah
db8ff7e141 cleanup(www_window): name debug/error format strings (#507)
lbl_816962F8 → scWwwErrorQ, lbl_81643B40 → scWwwTexBufFmt,
lbl_81643B5E → scWwwNoBrowserWin.
2026-10-01 17:10:19 -05:00
github-actions[bot]
2cb6c2dfae docs: update progress [skip ci] 2026-10-01 22:09:43 +00:00
coah
6f96235605 cleanup(tiGUIManager): name sdata2 zero/half/line-color constants (#506)
lbl_81694EE8 → scGuiZeroF, lbl_81694EF0 → scGuiHalfF,
lbl_81694EEC..F → scGuiLineColorR/G/B/A.
2026-10-01 17:09:30 -05:00
coah
367b042e63 Restore memo input vtable declarations and emission order (#505) 2026-10-01 17:08:19 -05:00
coah
feb7ba400d cleanup(Contest): rename NHTTP callback error; drop dead locals (#504)
param_1 → error in sNHTTPReqCallback; remove unused Ghidra locals
from IPLContestInitialize.
2026-10-01 17:07:39 -05:00
coah
20f4af8beb cleanup(NakamuraTest): rename Ghidra locals (#503)
iVar8 → nupResult, iVar7 → startupErr; drop unused iVar1 in conntestthread.
2026-10-01 17:06:56 -05:00
coah
dca6cd9aef cleanup(HermiteIntp): name start/end tangents (#502)
Rename Ghidra param_5/param_6 and unkVal0/unkVal1 to startTangent/endTangent
and mStartTangent/mEndTangent across the HermiteIntp header and users.
2026-10-01 17:05:40 -05:00
coah
a0700bf908 cleanup(NetSetup): rename param_1 → connType (#501)
iSOStartupEXThread arg is mConnType (passed to NETGetStartupErrorCodeEx).
2026-10-01 17:04:56 -05:00
coah
de058b4298 cleanup(NCDSetting): rename uVar1 → privacyMode (#500)
Local mapped privacy mode in setWDPrivacyMode; Matching-only rename.
2026-10-01 17:04:38 -05:00
github-actions[bot]
c5468cbe50 docs: update progress [skip ci] 2026-10-01 22:04:12 +00:00
coah
62591733eb cleanup(BoardObject): rename local_28 → truncatedThumb (#499)
Local wchar temporary used when truncating thumbnail text; Matching-only rename.
2026-10-01 17:03:10 -05:00
coah
e2488b073a cleanup: rename OptOutButton pane name strings (#498)
Rename lbl_816966F9/lbl_816967B5 to scPaneName_B_Stop/T_Stop.
DOL sha1 unchanged.
2026-10-01 17:02:53 -05:00
coah
9a8de22195 Link fully matched letter input form (#497) 2026-10-01 17:01:45 -05:00
coah
a6bf0e5f4f cleanup: rename AOSSThread SO alloc/free callbacks (#495)
Rename AOSSThread_813FCC8C/E4 to aossAlloc/aossFree. DOL sha1 unchanged.
2026-10-01 17:00:23 -05:00
coah
d434f5b897 cleanup: rename CdbBackup progress percent helper (#494)
Rename fn_8135B1C0 to getProgressPercent. DOL sha1 unchanged.
2026-10-01 17:00:18 -05:00
github-actions[bot]
0adc759b42 docs: update progress [skip ci] 2026-10-01 21:58:44 +00:00
coah
9c55b47c1d Emit hardware keyboard country tables after input template (#493) 2026-10-01 16:57:52 -05:00
coah
081329daa8 cleanup: rename TVRCManager start-delay counter (#492)
Rename lbl_8169877C to sTvrcStartDelay. DOL sha1 unchanged.
2026-10-01 16:57:46 -05:00
coah
a348c9777a cleanup: rename HBMController alarm-created flag (#490)
Rename lbl_816989BC to sAlarmCreated. DOL sha1 unchanged.
2026-10-01 16:55:12 -05:00
github-actions[bot]
d5204f5c62 docs: update progress [skip ci] 2026-10-01 21:54:05 +00:00
coah
cedc1f1390 cleanup: rename SaveDataManager title-cache helpers (#488)
Rename address-suffixed title-cache helpers to readable names without
changing codegen. DOL sha1 unchanged.
2026-10-01 16:54:01 -05:00
coah
ff0cce33f6 Correct concatenated cursor-cache method symbol (#487) 2026-10-01 16:53:27 -05:00
github-actions[bot]
2beeb23a47 docs: update progress [skip ci] 2026-10-01 21:53:24 +00:00
coah
35d9ed53b1 Fix letter animation rodata ownership boundary (#486) 2026-10-01 16:52:47 -05:00
coah
015d50906c Match tiTextDrawer Base::beginDraw height half via / 2.0f (#485)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 16:52:23 -05:00
github-actions[bot]
348da5bd89 docs: update progress [skip ci] 2026-10-01 21:52:04 +00:00
coah
cdceb82200 tiInputForm 214/221, 3 asm bodies left (worker 756360e6) (#489) 2026-10-01 16:50:38 -05:00
coah
1b56ea5051 Fix Korean jump-table ownership and link zikorean (#483)
* Correct Korean jump-table ownership and link the exact unit

* Correct Korean jump-table ownership and link the exact unit
2026-10-01 16:50:22 -05:00
coah
3946983f96 KPAD 19/29, kbd_lib 15/21 (objdiff) (worker 2ecd44fa) (#482) 2026-10-01 16:29:36 -05:00
github-actions[bot]
85d75cd0cf docs: update progress [skip ci] 2026-10-01 21:27:27 +00:00
coah
af39f2678f Match SD disk-info success return and restore its epilogue extent (#481)
* Restore the SD disk-info function's original epilogue extent

* Match explicit SD disk-info success return and update code total

* Match explicit SD disk-info success return and update code total
2026-10-01 16:26:40 -05:00
github-actions[bot]
d613662c54 docs: update progress [skip ci] 2026-10-01 21:17:45 +00:00
coah
0e6e235004 Correct PFSYS_TimeStamp's truncated symbol extent (#479)
* Include original stack restore and return in PFSYS_TimeStamp extent

* Account for timestamp epilogue in verified code-byte total
2026-10-01 16:17:08 -05:00
coah
020e1b6f0b iplSetting 105/112 (worker e1b8983d) (#480) 2026-10-01 16:16:23 -05:00
coah
3440aab039 Handle objects without .data in pool_diff (#478)
* Treat absent .data sections as empty string pools

* Test absent and unequal string pools
2026-10-01 16:11:01 -05:00
coah
dab806eaa2 Correct the 43U completion guard's expected unit count (#477) 2026-10-01 16:10:57 -05:00
github-actions[bot]
f4fd16f88f docs: update progress [skip ci] 2026-10-01 21:04:39 +00:00
coah
3d8de1a356 Link the exact-matching NAND driver (#476)
* Link NAND driver with verified storage layout

* Link NAND driver with verified storage layout

* Link NAND driver with verified storage layout
2026-10-01 16:03:40 -05:00
coah
8e43db0528 tiInputForm 210/221 (+8 KB matched code) (worker dad5faf7) (#475) 2026-10-01 16:00:46 -05:00
coah
21c9b95b1b NWC24Download 23/30 (worker 58d80e3c) (#474) 2026-10-01 15:41:52 -05:00
coah
d4bdd3462c iplAddress 94/101 (worker 98388c1d) (#473) 2026-10-01 15:40:46 -05:00
coah
f7d81a0196 CHANSVm 220/233 (worker 2f51b24f) (#472) 2026-10-01 12:31:21 -05:00
coah
4f35874d02 fix: drop unreferenced lbl_ double pinned in iplMemoryCard (#471) 2026-10-01 10:55:24 -05:00
coah
0a5cbaf78e iplAddress 93/101 (worker 81732f71) (#470) 2026-10-01 10:53:32 -05:00
coah
6e7c016ae3 CHANSVm 218/233 (worker 19444f58) (#469) 2026-10-01 10:52:18 -05:00
github-actions[bot]
e60306db62 docs: update progress [skip ci] 2026-10-01 14:03:51 +00:00
devin-ai-integration[bot]
5d0ced6a15 Link scene/memoryCard/iplMemoryCardBase (clean subset) (#468)
Gate Rect.~Rect and RuntimeTypeInfo.DynamicCast behind
IPL_MEMORYCARD_BASE_CPP so this TU emits the weak destructors and the
out-of-line dynamic cast the original object contains.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-01 14:03:09 +00:00
github-actions[bot]
858a507ddf docs: update progress [skip ci] 2026-10-01 12:54:41 +00:00
devin-ai-integration[bot]
ce424f1a3e Link scene/memoryCard/iplMemoryCard (clean subset) (#467)
Model MemCardEventListener as a novtable abstract base and give
MemCardEventHandler its full pure-virtual surface so the GCWindow and
MemoryCardManager vtables reproduce the original zero-slot layout.
Declare lbl_81694A78 as a file-scope const so the object exports the
u64->f64 conversion constant that iplMemoryCardBase.o references.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-01 12:54:08 +00:00
github-actions[bot]
bcb37e07ef docs: update progress [skip ci] 2026-10-01 11:41:02 +00:00
devin-ai-integration[bot]
11094c638a Link clib/zi8cinfo (#466)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 11:40:25 +00:00
coah
cb49bde9c6 NWC24Download 21/30 (worker b7c38d52) (#465) 2026-10-01 05:43:26 -05:00
coah
df9fd72e87 iplAddress 91/101, tiZiString 26/29 (worker 5e1635f3) (#464) 2026-10-01 05:37:54 -05:00
coah
0c554a1602 CHANSVm 217/233 (worker e7171d72) (#463) 2026-10-01 05:08:52 -05:00
coah
f00336cc8b NWC24Download 19/30, nup 18/23 (worker 1ac4946e) (#462) 2026-10-01 05:07:41 -05:00
coah
842bbc6942 tiCandidateBox 108/112, iplSDChannelSelect 117/129 (worker 993eabbf) (#461) 2026-10-01 05:06:29 -05:00
coah
ab01520044 CHANSVm: small fuzzy gains (worker b60f5370) (#460) 2026-10-01 03:31:36 -05:00
coah
5f948d3f3a AOSS 96.8, zi8alpha 94.2 (worker 5906998c) (#459) 2026-10-01 03:26:27 -05:00
coah
699f844395 CHANSVm 216/233 (worker b8f00dfb) (#458) 2026-10-01 03:05:28 -05:00
coah
3afb9d8425 iplSDChannelSelect 116/129, tiCandidateBox 104/112 (worker f7b4ed19) (#457) 2026-10-01 02:58:57 -05:00
coah
72c3f4ba2d zi8cgetc: tiny gains (worker 4e5688ba) (#456) 2026-10-01 02:45:50 -05:00
coah
905c45b998 AOSS 96.5, zi8alpha 93.1 (worker 58992861) (#455) 2026-10-01 02:41:34 -05:00
coah
5a849425b1 zi8cgetc: GetZH fuzzy 85 -> 96.4% (worker 68034ea8) (#454) 2026-10-01 02:16:35 -05:00
coah
fd11ddb195 AOSS fuzzy 96.3 (worker fc04bcfa) (#453) 2026-10-01 02:03:34 -05:00
coah
d9b51418b9 CHANSVm: blob unpack, hmac, slice, float parse (worker e953cfc4) (#452) 2026-10-01 02:02:26 -05:00
coah
87e7ab6922 iplSDChannelSelect, tiCandidateBox: structural fixes (worker d5dcdbc0) (#451) 2026-10-01 02:01:17 -05:00
github-actions[bot]
d186251506 docs: update progress [skip ci] 2026-10-01 05:27:53 +00:00
devin-ai-integration[bot]
cb58211725 Link cdb/CDBIntArray (#450)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 05:27:17 +00:00
github-actions[bot]
2dbf80c418 docs: update progress [skip ci] 2026-10-01 04:38:36 +00:00
devin-ai-integration[bot]
faee1f779d Link fa msc units + msc_drv (#449)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 04:37:58 +00:00
github-actions[bot]
a324e9a843 docs: update progress [skip ci] 2026-10-01 04:37:27 +00:00
devin-ai-integration[bot]
2bddfcde52 Link pfk_api, pfd_cmn, pf_cp932, pf_fat16, pf_stub (#448)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 04:36:51 +00:00
coah
776b7981df declsearch tool; odh/wad/KPAD/pf_dir closer (worker 8e7ae0d1) (#447) 2026-09-30 22:42:40 -05:00
coah
539693c76a AOSS fuzzy 88 -> 95, zi8alpha 93 (worker 3d36d663) (#446) 2026-09-30 22:25:48 -05:00
coah
3134c4c05a zi8cgetc: GetZH 81 -> 83% (worker ca7cac87) (#445) 2026-09-30 22:18:17 -05:00
coah
d60d10868a asm to C: CDBDatabase 33 -> 15 asm bodies, iplSound 14 -> 3 (worker d04fb346) (#444) 2026-09-30 22:16:35 -05:00
coah
735b0ab878 odh 22/28 (idct_fast, fdct_fast, LineDeconv* exact) (worker 8060e828) (#443) 2026-09-30 22:15:03 -05:00
coah
ea8d4d3b8a zi8cgetc: GetZH instruction count now matches (deficit 0), 81.4% (worker 04fae432) (#442) 2026-09-30 21:36:48 -05:00
coah
7329402a2c BS2Mach 24/29: NAND state globals volatile at definition (worker ddd698b1) (#441) 2026-09-30 21:34:55 -05:00
coah
e46168062b kbd_lib: kbdProcMod 63 -> 99.9%, data 100% (worker aef57ff5) (#440) 2026-09-30 21:27:26 -05:00
coah
b2074a70d7 regalloc sweep 2: CDBRecord 27/29 (worker 03558e7c) (#439) 2026-09-30 21:24:09 -05:00
coah
98648d19bb AOSS, zi8alpha: deficits shrinking (worker 59064877) (#438) 2026-09-30 21:00:22 -05:00
coah
d03219249b regalloc sweep: pf_dir 35/38, NWC24Mime 12/16 (worker edd57acb) (#437) 2026-09-30 20:50:49 -05:00
coah
3c23585249 zi8cgetc: GetZH deficit 78 -> 62 insns (worker 7d22ea37) (#436) 2026-09-30 20:44:21 -05:00
coah
b4745ba2da pf_path, iplAddressEdit closer (worker 1bceaa8f) (#435) 2026-09-30 20:36:41 -05:00
coah
fb3e7bd49a sub-90 functions: SDChannelSelect, AddressEdit closer (worker 35852f84) (#434) 2026-09-30 20:34:31 -05:00
coah
e34eac26ef ATERM/AOSS: small fuzzy gains (worker 52d046e2) (#433) 2026-09-30 20:29:11 -05:00
coah
565d039c01 zconvert 2/4 (worst 78 -> 99.6%) (worker 9f5c4222) (#432) 2026-09-30 20:27:10 -05:00
coah
46d7bc07cf wad: small fuzzy gains (worker ca7a1e52) (#431) 2026-09-30 20:18:01 -05:00
coah
6ec48a1b9a TMC_JPEG: RGB565 6/13 (worker c0724c9e) (#430) 2026-09-30 20:01:28 -05:00
coah
07b3a2b579 ATERM 14/26 (fuzzy 92 -> 96) (worker 8f2e6497) (#429) 2026-09-30 19:59:08 -05:00
coah
e1b46d09e8 wad 34/40 (worker cfd01890) (#428) 2026-09-30 19:48:56 -05:00
coah
a4d46cf340 NWC24Download 18/30, iplSetting 105/112 (worker 363488f7) (#427) 2026-09-30 19:44:27 -05:00
github-actions[bot]
46e8217f2f docs: update progress [skip ci] 2026-10-01 00:07:00 +00:00
devin-ai-integration[bot]
028e36cce2 Link kbd_lib_map_us (#426)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 00:06:18 +00:00
github-actions[bot]
6abc1f9bd8 docs: update progress [skip ci] 2026-09-30 23:37:01 +00:00
devin-ai-integration[bot]
b004e2be89 Link net sha1 + neterrorcode (#425)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 23:36:27 +00:00
coah
5c1794ef25 wad 32/40 (fuzzy 98.5) (worker 37d1b10e) (#424) 2026-09-30 18:07:25 -05:00
coah
c393274640 sweep: kbd_lib, tiZiString, exif closer (worker 374f661e) (#423) 2026-09-30 17:57:39 -05:00
coah
3bfbb0c9c3 zi8alpha/zi81key: small fuzzy gains (worker 004853ec) (#422) 2026-09-30 17:54:43 -05:00
coah
cdc22045a7 TMC_JPEG: RGB565 3/13 (96%), RGBA8 89%, idct 88%, iqdec 99% (worker 7b4f8d49) (#421) 2026-09-30 17:43:46 -05:00
github-actions[bot]
976fbeb804 docs: update progress [skip ci] 2026-09-30 22:37:48 +00:00
devin-ai-integration[bot]
725599dba0 Link 28 fa tail units (pdm + pf stubs + pfs_*) (#420)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 22:37:10 +00:00
coah
4d0c9e70d6 odh/AOSS: small fuzzy gains (worker f272e078) (#419) 2026-09-30 17:24:56 -05:00
coah
131d8f743c sd_drv round 4 (worker d3d9dcba) (#418) 2026-09-30 17:17:34 -05:00
coah
23067a3477 wad 29/40 (fuzzy 92 -> 97) (worker 2a411d12) (#417) 2026-09-30 17:04:12 -05:00
coah
c7958e9f67 sd_drv round 3 (worker 503a78aa) (#416) 2026-09-30 16:50:52 -05:00
coah
d9ee532e07 vi 28/30 (data 100%), nup 17/23 (worker 53f0591e) (#415) 2026-09-30 16:49:32 -05:00
github-actions[bot]
1d5184b30e docs: update progress [skip ci] 2026-09-30 21:38:54 +00:00
devin-ai-integration[bot]
a27b6aa96e Link 47 fa units (finfo..xdivide + pf_w_* batch) (#414)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 21:38:17 +00:00
coah
112149c8e5 KPAD 18/29 (fuzzy 84 -> 98.5) (worker e7585e33) (#413) 2026-09-30 16:09:46 -05:00
coah
45a6d499ec pfd_cmn 1/1, sd_drv 15/26 (worker 64325785) (#412) 2026-09-30 16:06:22 -05:00
github-actions[bot]
813110e681 docs: update progress [skip ci] 2026-09-30 20:40:48 +00:00
devin-ai-integration[bot]
f4a48bd996 Link 15 fa pf units (cdelete..fconcat) (#411)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 20:40:01 +00:00
coah
f1590c832e wad 27/40 (fuzzy 86 -> 92) (worker c964c352) (#410) 2026-09-30 15:30:30 -05:00
coah
d6cafeab4d zi8cgetc: GetZH closer, data 24 -> 72 (worker bb87205d) (#409) 2026-09-30 15:18:11 -05:00
coah
c047b544c1 nand_drv 18/18, sd_drv 13/26 (no volatile casts) (worker 26ae07cf) (#408) 2026-09-30 15:16:57 -05:00
coah
82dbaac35d CHANSVm: CHANSVmStep 96.4% (worker 87e5a30c) (#407) 2026-09-30 14:46:29 -05:00
coah
e8d4107b11 BS2Mach/BS2Update: closer (fuzzy only) (worker fb7be869) (#406) 2026-09-30 14:33:27 -05:00
coah
1b96b3956b tiInputForm: fuzzy 97 -> 99.5, 3 more asm bodies to C (worker d126d226) (#405) 2026-09-30 14:30:55 -05:00
github-actions[bot]
81c36c4db0 docs: update progress [skip ci] 2026-09-30 19:12:04 +00:00
devin-ai-integration[bot]
355564cd77 Link pf_fat32, pf_sector, pf_volume_apiadd, pf_buffering (#404)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 19:11:15 +00:00
coah
17b5d5946b Texture_MCUtoY8U8V8: nine functions ~50% -> 99% (registers only) (worker b2970e86) (#403) 2026-09-30 13:55:41 -05:00
github-actions[bot]
ed5a62397d docs: update progress [skip ci] 2026-09-30 18:50:46 +00:00
coah
2a34d3703b Revert "Link fa/driver nand_drv + msc_drv (#400)" (#402)
This reverts commit 787aa9d334.
2026-09-30 13:50:09 -05:00
coah
3f5248be4c CHANSVm: data 100%, all 121 jump-table relocations match (worker 7c42cd13) (#401) 2026-09-30 13:48:47 -05:00
github-actions[bot]
59e127f89a docs: update progress [skip ci] 2026-09-30 18:41:42 +00:00
328 changed files with 53698 additions and 34211 deletions

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 98.27% | 85.37% | 59.71% | 90.53% |
| 99.38% | 88.09% | 62.52% | 92.12% |
units 805/1027 complete, functions 12090/12563 matched.
units 921/1027 complete, functions 12232/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 -->

View File

@@ -29,8 +29,8 @@ force_active:
- strspn
- strcspn
- padding__Q23ipl5scene
- lbl_81695063
- lbl_81695067
- scRsnOuiPad
- scWpaOuiPad
- __vt__Q49textinput6extend4memo19NigaoeEventObserver
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.

View File

@@ -688,13 +688,13 @@ src/scene/memoryCard/iplMemoryCard.cpp:
.text start:0x813C9DCC end:0x813CC1FC
.rodata start:0x81610368 end:0x81610480
.data start:0x81651D30 end:0x81652640
.sdata2 start:0x81694A68 end:0x81694A80
.sdata2 start:0x81694A68 end:0x81694A78
.sdata start:0x81696C78 end:0x81696CA0
src/scene/memoryCard/iplMemoryCardBase.cpp:
.text start:0x813CC1FC end:0x813CD034
.data start:0x81652640 end:0x816526D0
.sdata2 start:0x81694A80 end:0x81694A88
.sdata2 start:0x81694A78 end:0x81694A88
src/scene/memoryCard/iplMemoryCardManager.cpp:
.text start:0x813CD034 end:0x813CE548
@@ -804,14 +804,14 @@ src/scene/sdChannelSelect/iplSDChannelObj.cpp:
.rodata start:0x81610608 end:0x81610918
.data start:0x81654B38 end:0x81654F98
.sdata2 start:0x81694B18 end:0x81694B60
.sdata start:0x81696DD0 end:0x81696E40
.sdata start:0x81696DD0 end:0x81696E30
src/scene/sdChannelTitle/iplSDChannelTitle.cpp:
.text start:0x813E4BBC end:0x813E947C
.rodata start:0x81610918 end:0x81610948
.data start:0x81654F98 end:0x81655638
.sdata2 start:0x81694B60 end:0x81694B88
.sdata start:0x81696E40 end:0x81696EF0
.sdata start:0x81696E30 end:0x81696EF0
src/scene/sdButton/iplSDButton.cpp:
.text start:0x813E947C end:0x813EA88C
@@ -1111,7 +1111,7 @@ src/keyboard/MyTiInputForm.cpp:
src/keyboard/MyTiLetterForm.cpp:
.text start:0x81444730 end:0x814454D8
.rodata start:0x816168B8 end:0x81616B88
.rodata start:0x816168B8 end:0x81616BC8
.data start:0x81668860 end:0x81668CD8
.sdata2 start:0x81694EB0 end:0x81694ED0
.sdata start:0x81697528 end:0x81697570
@@ -1138,7 +1138,7 @@ src/keyboard/tiHKBManager.cpp:
src/keyboard/tiHwKeyboard.cpp:
.bss start:0x810C8940 end:0x810C8950
.text start:0x81448AA4 end:0x81449C98
.rodata start:0x81616B88 end:0x81616C78
.rodata start:0x81616BC8 end:0x81616C78
.data start:0x81668EF8 end:0x81669018
.sdata2 start:0x81694EF8 end:0x81694F08
.sdata start:0x81697570 end:0x81697578
@@ -1405,7 +1405,7 @@ libs/RVLMiddleware/eZiText/src/clib/zikorean.c:
extab start:0x81330748 end:0x81330760
extabindex start:0x8133147C end:0x813314A0
.text start:0x814813FC end:0x81482840
.data start:0x8166B2B0 end:0x8166B3D0
.data start:0x8166B2B0 end:0x8166B3A8
libs/RVLMiddleware/eZiText/src/clib/ziswordw.c:
extab start:0x81330760 end:0x81330770
@@ -1417,6 +1417,7 @@ libs/RVLMiddleware/eZiText/src/clib/zkokeyp.c:
extab start:0x81330770 end:0x813307A8
extabindex start:0x813314B8 end:0x8133150C
.text start:0x8148302C end:0x8148447C
.data start:0x8166B3A8 end:0x8166B3D0
libs/RVLMiddleware/eZiText/src/clib/zierror.c:
.text start:0x8148447C end:0x81484484
@@ -3550,12 +3551,12 @@ libs/RVL_SDK/src/bte/l2c_csm.c:
libs/RVL_SDK/src/bte/l2c_link.c:
.text start:0x815AC630 end:0x815AD7BC
.data start:0x8168E930 end:0x8168EB68
.data start:0x8168E930 end:0x8168EBA0
libs/RVL_SDK/src/bte/l2c_main.c:
.bss start:0x811725E0 end:0x81172DC8
.text start:0x815AD7BC end:0x815AE7EC
.data start:0x8168EB68 end:0x8168EEA0
.data start:0x8168EBA0 end:0x8168EEA0
libs/RVL_SDK/src/bte/l2c_utils.c:
.text start:0x815AE7EC end:0x815B06B0
@@ -4192,11 +4193,11 @@ libs/RVL_SDK/src/fa/driver/nand_drv.c:
.sbss start:0x816996C0 end:0x816996E0
libs/RVL_SDK/src/fa/driver/sd_drv.c:
.bss start:0x811AF460 end:0x811AF6C0
.bss start:0x811AF460 end:0x811AF6C0 align:32
.text start:0x815EA41C end:0x815ED20C
.rodata start:0x816329E8 end:0x81632B58
.data start:0x81690D18 end:0x81691728
.sbss start:0x816996E0 end:0x81699708
.sbss start:0x816996E0 end:0x81699708 align:32
libs/RVL_SDK/src/fa/driver/pfd_cmn.c:
.text start:0x815ED20C end:0x815ED324

File diff suppressed because it is too large Load Diff

View File

@@ -812,8 +812,8 @@ config.libs = [
]
),
IPLSection("memoryCard", [
Object(NonMatching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(Matching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(Matching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
@@ -918,9 +918,9 @@ config.libs = [
Object(NonMatching, "keyboard/tiString.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiAtokString.cpp", extra_cflags=["-O4,p"]), # for 4.3J
Object(NonMatching, "keyboard/tiZiString.cpp", extra_cflags=["-O4,p"]), # for 4.3U and 4.3E
Object(NonMatching, "keyboard/tiTextDrawer.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiTextDrawer.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiNw4rManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiUtil.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiCpData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiSwData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
@@ -929,12 +929,12 @@ config.libs = [
Object(Matching, "keyboard/tiTextInputBase.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiDebug.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayout.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayoutGather.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiKoreanInput.cpp", extra_cflags=["-O4,p"]), # for 4.3K
@@ -987,7 +987,7 @@ config.libs = [
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
Object(NonMatching, "clib/zi8cgetc.c"),
Object(NonMatching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8copy.c"),
Object(NonMatching, "clib/zi8dawg.c"),
Object(Matching, "clib/zi8getc.c"),
@@ -1004,7 +1004,7 @@ config.libs = [
Object(Matching, "clib/zi8ver.c"),
Object(Matching, "clib/zi8ZHuwd.c"),
Object(NonMatching, "clib/zidawg1.c"),
Object(NonMatching, "clib/zikorean.c"),
Object(Matching, "clib/zikorean.c"),
Object(NonMatching, "clib/ziswordw.c"),
Object(NonMatching, "clib/zkokeyp.c"),
Object(Matching, "clib/zierror.c"),
@@ -1025,7 +1025,7 @@ config.libs = [
Object(NonMatching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecordFile.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(NonMatching, "cdb/CDBIntArray.c"),
Object(Matching, "cdb/CDBIntArray.c"),
Object(Matching, "cdb/CDBSystem.c"),
Object(Matching, "cdb/CDBAttr.c"),
Object(Matching, "cdb/CDBFBridge.c"),
@@ -1044,9 +1044,9 @@ config.libs = [
Object(Matching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(NonMatching, "net/sha1.c"),
Object(Matching, "net/sha1.c"),
Object(NonMatching, "net/hmac.c"),
Object(NonMatching, "net/neterrorcode.c"),
Object(Matching, "net/neterrorcode.c"),
Object(Matching, "net/NETVersion.c"),
Object(NonMatching, "net/aes.c"),
Object(Matching, "net/wireless_macaddr.c"),
@@ -1063,7 +1063,7 @@ config.libs = [
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_private.c"),
Object(Matching, "nhttp/d_nhttp.c"),
Object(Matching, "nhttp/d_nhttp_common.c"),
]
@@ -1687,9 +1687,9 @@ config.libs = [
Object(Matching, "fa/pf_service.c"),
Object(Matching, "fa/pf_str.c"),
Object(Matching, "fa/pf_driver.c"),
Object(NonMatching, "fa/pdm_api.c"),
Object(NonMatching, "fa/pdm_bpb.c"),
Object(NonMatching, "fa/pdm_disk.c"),
Object(Matching, "fa/pdm_api.c"),
Object(Matching, "fa/pdm_bpb.c"),
Object(Matching, "fa/pdm_disk.c"),
Object(NonMatching, "fa/pdm_partition.c"),
Object(NonMatching, "fa/pf_cache.c"),
Object(NonMatching, "fa/pf_cluster.c"),
@@ -1698,133 +1698,133 @@ config.libs = [
Object(NonMatching, "fa/pf_entry_iterator.c"),
Object(NonMatching, "fa/pf_fat.c"),
Object(NonMatching, "fa/pf_fat12.c"),
Object(NonMatching, "fa/pf_fat16.c"),
Object(NonMatching, "fa/pf_fat32.c"),
Object(Matching, "fa/pf_fat16.c"),
Object(Matching, "fa/pf_fat32.c"),
Object(Matching, "fa/pf_fatfs.c"),
Object(NonMatching, "fa/pf_file.c"),
Object(NonMatching, "fa/pf_path.c"),
Object(NonMatching, "fa/pf_sector.c"),
Object(Matching, "fa/pf_sector.c"),
Object(NonMatching, "fa/pf_volume.c"),
Object(NonMatching, "fa/pf_volume_apiadd.c"),
Object(NonMatching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_volume_apiadd.c"),
Object(Matching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_api_util.c"),
Object(Matching, "fa/pf_attach.c"),
Object(NonMatching, "fa/pf_buffering.c"),
Object(NonMatching, "fa/pf_cdelete.c"),
Object(NonMatching, "fa/pf_chdir.c"),
Object(NonMatching, "fa/pf_chdmod.c"),
Object(NonMatching, "fa/pf_chmod.c"),
Object(NonMatching, "fa/pf_cinsert.c"),
Object(Matching, "fa/pf_buffering.c"),
Object(Matching, "fa/pf_cdelete.c"),
Object(Matching, "fa/pf_chdir.c"),
Object(Matching, "fa/pf_chdmod.c"),
Object(Matching, "fa/pf_chmod.c"),
Object(Matching, "fa/pf_cinsert.c"),
Object(Matching, "fa/pf_closedir.c"),
Object(NonMatching, "fa/pf_combine.c"),
Object(NonMatching, "fa/pf_create.c"),
Object(NonMatching, "fa/pf_createdir.c"),
Object(NonMatching, "fa/pf_cut.c"),
Object(NonMatching, "fa/pf_derrnum.c"),
Object(Matching, "fa/pf_combine.c"),
Object(Matching, "fa/pf_create.c"),
Object(Matching, "fa/pf_createdir.c"),
Object(Matching, "fa/pf_cut.c"),
Object(Matching, "fa/pf_derrnum.c"),
Object(Matching, "fa/pf_detach.c"),
Object(NonMatching, "fa/pf_divide.c"),
Object(Matching, "fa/pf_divide.c"),
Object(Matching, "fa/pf_errnum.c"),
Object(NonMatching, "fa/pf_fadjust.c"),
Object(NonMatching, "fa/pf_fappend.c"),
Object(NonMatching, "fa/pf_fchdir.c"),
Object(Matching, "fa/pf_fadjust.c"),
Object(Matching, "fa/pf_fappend.c"),
Object(Matching, "fa/pf_fchdir.c"),
Object(Matching, "fa/pf_fclose.c"),
Object(NonMatching, "fa/pf_fconcat.c"),
Object(Matching, "fa/pf_fconcat.c"),
Object(Matching, "fa/pf_feof.c"),
Object(Matching, "fa/pf_ferror.c"),
Object(NonMatching, "fa/pf_finfo.c"),
Object(Matching, "fa/pf_finfo.c"),
Object(Matching, "fa/pf_flock.c"),
Object(Matching, "fa/pf_fopen.c"),
Object(NonMatching, "fa/pf_format.c"),
Object(Matching, "fa/pf_format.c"),
Object(Matching, "fa/pf_fread.c"),
Object(Matching, "fa/pf_fseek.c"),
Object(NonMatching, "fa/pf_fsetclstlink.c"),
Object(NonMatching, "fa/pf_fsexec.c"),
Object(Matching, "fa/pf_fsetclstlink.c"),
Object(Matching, "fa/pf_fsexec.c"),
Object(Matching, "fa/pf_fsfirst.c"),
Object(Matching, "fa/pf_fsnext.c"),
Object(Matching, "fa/pf_fstat.c"),
Object(Matching, "fa/pf_fsync.c"),
Object(Matching, "fa/pf_fwrite.c"),
Object(NonMatching, "fa/pf_getdev.c"),
Object(NonMatching, "fa/pf_getvol.c"),
Object(NonMatching, "fa/pf_getvolcfg.c"),
Object(NonMatching, "fa/pf_init_prfile2.c"),
Object(NonMatching, "fa/pf_insert.c"),
Object(NonMatching, "fa/pf_iswriteprotected.c"),
Object(Matching, "fa/pf_getdev.c"),
Object(Matching, "fa/pf_getvol.c"),
Object(Matching, "fa/pf_getvolcfg.c"),
Object(Matching, "fa/pf_init_prfile2.c"),
Object(Matching, "fa/pf_insert.c"),
Object(Matching, "fa/pf_iswriteprotected.c"),
Object(Matching, "fa/pf_mkdir.c"),
Object(Matching, "fa/pf_mount.c"),
Object(NonMatching, "fa/pf_move.c"),
Object(Matching, "fa/pf_move.c"),
Object(Matching, "fa/pf_opendir.c"),
Object(Matching, "fa/pf_readdir.c"),
Object(NonMatching, "fa/pf_regctx.c"),
Object(Matching, "fa/pf_regctx.c"),
Object(Matching, "fa/pf_remove.c"),
Object(Matching, "fa/pf_rename.c"),
Object(Matching, "fa/pf_rewinddir.c"),
Object(Matching, "fa/pf_rmdir.c"),
Object(NonMatching, "fa/pf_rmvvol.c"),
Object(Matching, "fa/pf_rmvvol.c"),
Object(Matching, "fa/pf_seekdir.c"),
Object(NonMatching, "fa/pf_setclstlink.c"),
Object(NonMatching, "fa/pf_setcode.c"),
Object(NonMatching, "fa/pf_setencode.c"),
Object(NonMatching, "fa/pf_settailbuf.c"),
Object(NonMatching, "fa/pf_setupfsi.c"),
Object(NonMatching, "fa/pf_setvol.c"),
Object(NonMatching, "fa/pf_setvolcfg.c"),
Object(NonMatching, "fa/pf_sync.c"),
Object(Matching, "fa/pf_setclstlink.c"),
Object(Matching, "fa/pf_setcode.c"),
Object(Matching, "fa/pf_setencode.c"),
Object(Matching, "fa/pf_settailbuf.c"),
Object(Matching, "fa/pf_setupfsi.c"),
Object(Matching, "fa/pf_setvol.c"),
Object(Matching, "fa/pf_setvolcfg.c"),
Object(Matching, "fa/pf_sync.c"),
Object(Matching, "fa/pf_telldir.c"),
Object(Matching, "fa/pf_unmount.c"),
Object(NonMatching, "fa/pf_unregctx.c"),
Object(NonMatching, "fa/pf_xdivide.c"),
Object(Matching, "fa/pf_unregctx.c"),
Object(Matching, "fa/pf_xdivide.c"),
Object(Matching, "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"),
Object(NonMatching, "fa/pf_w_chmod.c"),
Object(NonMatching, "fa/pf_w_cinsert.c"),
Object(NonMatching, "fa/pf_w_combine.c"),
Object(NonMatching, "fa/pf_w_create.c"),
Object(NonMatching, "fa/pf_w_createdir.c"),
Object(NonMatching, "fa/pf_w_cut.c"),
Object(NonMatching, "fa/pf_w_divide.c"),
Object(NonMatching, "fa/pf_w_fconcat.c"),
Object(NonMatching, "fa/pf_w_fopen.c"),
Object(NonMatching, "fa/pf_w_fsexec.c"),
Object(NonMatching, "fa/pf_w_fsfirst.c"),
Object(NonMatching, "fa/pf_w_fsnext.c"),
Object(NonMatching, "fa/pf_w_fstat.c"),
Object(NonMatching, "fa/pf_w_insert.c"),
Object(NonMatching, "fa/pf_w_mkdir.c"),
Object(NonMatching, "fa/pf_w_move.c"),
Object(NonMatching, "fa/pf_w_opendir.c"),
Object(NonMatching, "fa/pf_w_remove.c"),
Object(NonMatching, "fa/pf_w_rename.c"),
Object(NonMatching, "fa/pf_w_rmdir.c"),
Object(NonMatching, "fa/pf_w_xdivide.c"),
Object(NonMatching, "fa/pf_filelock.c"),
Object(NonMatching, "fa/pf_stub.c"),
Object(NonMatching, "fa/pf_system.c"),
Object(NonMatching, "fa/pf_stub_standard.c"),
Object(NonMatching, "fa/pfs_attach.c"),
Object(NonMatching, "fa/pfs_buffering.c"),
Object(NonMatching, "fa/pfs_create.c"),
Object(NonMatching, "fa/pfs_createdir.c"),
Object(NonMatching, "fa/pfs_detach.c"),
Object(NonMatching, "fa/pfs_errnum.c"),
Object(NonMatching, "fa/pfs_fclose.c"),
Object(NonMatching, "fa/pfs_finfot.c"),
Object(NonMatching, "fa/pfs_fopen.c"),
Object(NonMatching, "fa/pfs_format.c"),
Object(NonMatching, "fa/pfs_fread.c"),
Object(NonMatching, "fa/pfs_fseek.c"),
Object(NonMatching, "fa/pfs_fsfirst.c"),
Object(NonMatching, "fa/pfs_fsnext.c"),
Object(NonMatching, "fa/pfs_fstat.c"),
Object(NonMatching, "fa/pfs_fwrite.c"),
Object(NonMatching, "fa/pfs_getdev.c"),
Object(NonMatching, "fa/pfs_init_prfile2.c"),
Object(NonMatching, "fa/pfs_mount.c"),
Object(NonMatching, "fa/pfs_remove.c"),
Object(NonMatching, "fa/pfs_unmount.c"),
Object(NonMatching, "fa/pf_stub_unicode.c"),
Object(Matching, "fa/pf_w_cdelete.c"),
Object(Matching, "fa/pf_w_chdir.c"),
Object(Matching, "fa/pf_w_chdmod.c"),
Object(Matching, "fa/pf_w_chmod.c"),
Object(Matching, "fa/pf_w_cinsert.c"),
Object(Matching, "fa/pf_w_combine.c"),
Object(Matching, "fa/pf_w_create.c"),
Object(Matching, "fa/pf_w_createdir.c"),
Object(Matching, "fa/pf_w_cut.c"),
Object(Matching, "fa/pf_w_divide.c"),
Object(Matching, "fa/pf_w_fconcat.c"),
Object(Matching, "fa/pf_w_fopen.c"),
Object(Matching, "fa/pf_w_fsexec.c"),
Object(Matching, "fa/pf_w_fsfirst.c"),
Object(Matching, "fa/pf_w_fsnext.c"),
Object(Matching, "fa/pf_w_fstat.c"),
Object(Matching, "fa/pf_w_insert.c"),
Object(Matching, "fa/pf_w_mkdir.c"),
Object(Matching, "fa/pf_w_move.c"),
Object(Matching, "fa/pf_w_opendir.c"),
Object(Matching, "fa/pf_w_remove.c"),
Object(Matching, "fa/pf_w_rename.c"),
Object(Matching, "fa/pf_w_rmdir.c"),
Object(Matching, "fa/pf_w_xdivide.c"),
Object(Matching, "fa/pf_filelock.c"),
Object(Matching, "fa/pf_stub.c"),
Object(Matching, "fa/pf_system.c"),
Object(Matching, "fa/pf_stub_standard.c"),
Object(Matching, "fa/pfs_attach.c"),
Object(Matching, "fa/pfs_buffering.c"),
Object(Matching, "fa/pfs_create.c"),
Object(Matching, "fa/pfs_createdir.c"),
Object(Matching, "fa/pfs_detach.c"),
Object(Matching, "fa/pfs_errnum.c"),
Object(Matching, "fa/pfs_fclose.c"),
Object(Matching, "fa/pfs_finfot.c"),
Object(Matching, "fa/pfs_fopen.c"),
Object(Matching, "fa/pfs_format.c"),
Object(Matching, "fa/pfs_fread.c"),
Object(Matching, "fa/pfs_fseek.c"),
Object(Matching, "fa/pfs_fsfirst.c"),
Object(Matching, "fa/pfs_fsnext.c"),
Object(Matching, "fa/pfs_fstat.c"),
Object(Matching, "fa/pfs_fwrite.c"),
Object(Matching, "fa/pfs_getdev.c"),
Object(Matching, "fa/pfs_init_prfile2.c"),
Object(Matching, "fa/pfs_mount.c"),
Object(Matching, "fa/pfs_remove.c"),
Object(Matching, "fa/pfs_unmount.c"),
Object(Matching, "fa/pf_stub_unicode.c"),
Object(NonMatching, "fa/api/FAAttach.c"),
Object(Matching, "fa/api/FABuffering.c"),
@@ -1851,15 +1851,15 @@ config.libs = [
Object(Matching, "fa/api/FASetThreadPriority.c"),
Object(Matching, "fa/api/FAUnmount.c"),
Object(NonMatching, "fa/kernel/pfk_api.c"),
Object(Matching, "fa/kernel/pfk_api.c"),
Object(Matching, "fa/driver/nand_drv.c"),
Object(NonMatching, "fa/driver/sd_drv.c"),
Object(NonMatching, "fa/driver/pfd_cmn.c"),
Object(Matching, "fa/driver/pfd_cmn.c"),
Object(Matching, "fa/driver/msc_drv.c"),
Object(NonMatching, "fa/msc/puh_msc.c"),
Object(NonMatching, "fa/msc/puh_msc_cmd.c"),
Object(Matching, "fa/msc/puh_msc.c"),
Object(Matching, "fa/msc/puh_msc_cmd.c"),
Object(NonMatching, "fa/msc/puh_msc_blk.c"),
]
),
@@ -1887,7 +1887,7 @@ config.libs = [
RVLSDKLib("kbd", [
Object(NonMatching, "kbd/kbd_lib.c"),
Object(NonMatching, "kbd/kbd_lib_map_jp.c"),
Object(NonMatching, "kbd/kbd_lib_map_us.c"),
Object(Matching, "kbd/kbd_lib_map_us.c"),
Object(NonMatching, "kbd/kbd_lib_map_eu.c"),
]
),

View File

@@ -96,7 +96,7 @@ CHANSVmNativeClass* CHANSVmAddNativeClass(CHANSVm* vm, const char* clsName, CHAN
/*** CHANS Image ***/
/************************/
typedef vmBoolInt (*CHANSVmImageCtorCallback)(CHANSVm* vm);
typedef vmBoolInt (*CHANSVmImageCtorCallback)(CHANSVm* vm, vmPtr data);
typedef vmPtr (*CHANSVmImageAllocatorCallback)(CHANSVm* vm, u32 size);
void CHANSVmImageRegisterAllocator(CHANSVmImageAllocatorCallback allocCb, CHANSVmImageCtorCallback ctorCb);

View File

@@ -75,7 +75,7 @@ namespace homebutton {
private:
static bool sBatteryFlag[WPAD_MAX_CONTROLLERS];
static bool lbl_816989BC[WPAD_MAX_CONTROLLERS];
static bool sAlarmCreated[WPAD_MAX_CONTROLLERS];
static OSAlarm sAlarm[WPAD_MAX_CONTROLLERS];
static OSAlarm sAlarmSoundOff[WPAD_MAX_CONTROLLERS];

View File

@@ -35,8 +35,8 @@ namespace ext_ead {
class SurfaceManager {
public:
static void CreateManager(int rectW0, int rectH0, int rectW1, int rectH1, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* param_10);
static void CreateManager(int surfaceW, int surfaceH, int browserW, int browserH, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* arcPath);
static void DisposeManager();
static void RegisterArcFile(void* fileBuf);

View File

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

View File

@@ -3,7 +3,6 @@
#include "tiInputForm.h"
#include "tiString.h"
#include "tiUtil.h"
#include <nw4r/lyt/pane.h>
@@ -21,7 +20,9 @@ namespace textinput {
virtual void moveNigaoeButton() {}
};
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
class ScrollButton;
#endif
class InputForm : public textinput::InputForm {
public:
@@ -33,24 +34,51 @@ namespace textinput {
EM_Last
} EditMode;
InputForm(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName,
EventObserver* observer, const char* subName)
: textinput::InputForm(manager, resAccessor, arcName, observer, subName),
mpMemoPane(NULL), mpMemoRootPane(NULL), mpBoundPane(NULL), mpDrawPane(NULL),
#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(0.0f, 0.0f, 0.0f, 0.0f), mDefaultDrawSize(0.0f, 0.0f), mDefaultBoundSize(0.0f, 0.0f),
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) {}
mbEdited(false), mbGoodBye(false), mbEditScrollUp(false), mbEditScrollDown(false),
mbCloseWithSend(false), mpScrollButton(NULL), mbScrollUp(false), mbScrollDown(false),
meEditMode(EM_Disp) {}
#endif
~InputForm();
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_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; }
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; }
virtual f32 getScrollTo() { return mfScrollTo; }
#endif
virtual void open();
virtual void close();
@@ -72,7 +100,7 @@ namespace textinput {
virtual void onArrowRTrig();
virtual void onArrowLTrig();
virtual void setNigaoeEventObserver(NigaoeEventObserver* nigaoeObserver);
virtual void setNigaoeEventObserver(NigaoeEventObserver* nigaoeObserver) { mpNigaoeObserver = nigaoeObserver; }
virtual nw4r::lyt::Pane* getNigaoePane();
virtual nw4r::lyt::Material* getNigaoePaneMaterial();
@@ -94,33 +122,6 @@ namespace textinput {
virtual void onCommandOnEditMode(INPUT_COMMAND command, void* arg);
virtual void doAutoScroll();
#ifdef MYTIINPUTFORM_IMPLEMENTATION
virtual void pure_0() = 0;
virtual void pure_1() = 0;
virtual void pure_2() = 0;
virtual void pure_3() = 0;
virtual void pure_4() = 0;
virtual void pure_5() = 0;
#endif
virtual void create(MEMAllocator* allocator, inputform::EditBuffer* editBuffer);
virtual void moveCursorUp();
virtual void moveCursorDown();
virtual void onCommand(CommandReceiver::INPUT_COMMAND command, void* arg);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(textinput::input::HKBManager& hkbManager);
virtual void init();
virtual void draw();
virtual void calc();
virtual void doScroll(CommandReceiver::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);
virtual void doLineFeed();
virtual void finishDraw(u32);
virtual bool isInScroll();
/* For letter writing */
@@ -130,7 +131,11 @@ namespace textinput {
void setEditScrollDown(bool editScrollDown) { mbEditScrollUp = editScrollDown; }
void setCloseWithSend(bool closeWithSend) { mbCloseWithSend = closeWithSend; }
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
void setEditMode(EditMode editMode);
#else
void setEditMode(EditMode editMode) { meEditMode = editMode; }
#endif
bool isEdited() { return mbEdited; }
bool isGoodBye() { return mbGoodBye; }
@@ -142,11 +147,24 @@ namespace textinput {
tistring::Decolated* getSendString() { return mpSendString; }
#ifdef MYTILETTERFORM_IMPLEMENTATION
protected:
nw4r::lyt::Pane* mpMemoPane; // 0x308
nw4r::lyt::Pane* mpMemoRootPane; // 0x30C
nw4r::lyt::Pane* mpBoundPane; // 0x310
nw4r::lyt::Pane* mpDrawPane; // 0x314
#else
private:
#endif
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_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
@@ -158,7 +176,11 @@ namespace textinput {
nw4r::lyt::Size mDefaultBoundSize; // 0x358
Mtx mDrawMtx; // 0x360
Mtx mBoundMtx; // 0x390
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
util::Animation mExScrollAnm; // 0x3C0
#else
u8 /*todo*/ mExScrollAnm[32]; // 0x3C0
#endif
NigaoeEventObserver* mpNigaoeObserver; // 0x3E0
GXTexObj* mpDefaultNigaoe; // 0x3E4
tistring::Decolated* mpSendString; // 0x3E8
@@ -168,10 +190,13 @@ namespace textinput {
bool mbEditScrollDown; // 0x3EF
bool mbCloseWithSend; // 0x3F0
u8 padding[3]; // 0x3F1
ScrollButton* mpScrollButton; // 0x3F4
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
ScrollButton* mpScrollButton;
#else
undefined4* mpScrollButton;
#endif
bool mbScrollUp; // 0x3F8
bool mbScrollDown; // 0x3F9
u8 padding2[2]; // 0x3FA
EditMode meEditMode; // 0x3FC
};
}

View File

@@ -16,36 +16,42 @@ namespace textinput {
T_Last,
} Type;
InputForm(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName,
EventObserver* observer, const char* subName)
: MemoInputForm(manager, resAccessor, arcName, observer, subName),
mbPhotoScaledUp(false), mbPhotoDraw(false), meType(T_MailAddressSel) {}
~InputForm();
virtual void create(MEMAllocator* allocator, inputform::EditBuffer* editBuffer);
virtual void drawBody();
virtual void drawFooter();
virtual void open();
virtual void close();
virtual bool isWholePaneInAnimation();
#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
#ifdef MYTILETTERFORM_IMPLEMENTATION
virtual ~InputForm();
virtual void create(MEMAllocator*, inputform::EditBuffer*);
virtual void drawBody();
virtual void drawFooter();
virtual void open();
virtual void close();
virtual bool isWholePaneInAnimation();
#endif
virtual nw4r::lyt::Material* getPhotoPaneMaterial();
virtual void onPhotoTrig();
virtual void onPhotoPoint();
virtual void onPhotoLeft();
virtual bool isPhotoScaledUp();
virtual void setPhotoDraw(bool photoDraw);
virtual void setPhotoDraw(bool photoDraw) { mbPhotoDraw = photoDraw; }
virtual void setType(Type type);
virtual void setType(Type type) { meType = type; }
virtual void setSendOutMessage(const wchar_t* sendOutMessage);
void resizePhotoPane(f32 width, f32 height);
private:
bool mbPhotoScaledUp; // 0x400
#ifdef MYTILETTERFORM_IMPLEMENTATION
bool mbPhotoScaledUp;
#else
u8 unk_0x400;
#endif
bool mbPhotoDraw; // 0x401
Type meType; // 0x404
};

View File

@@ -8,10 +8,6 @@
namespace textinput {
namespace extend {
namespace bg {
class LayoutByNW4R;
}
namespace memo {
class State;
@@ -32,7 +28,9 @@ namespace textinput {
CT_NumericWithSeparator,
CT_NormalWithoutLineFeedWithSign,
CT_PredictWithoutLineFeed,
#ifdef MYTIMANAGER_IMPLEMENTATION
CT_PredictBigText,
#endif
CT_Last
} ConfigType;
@@ -83,21 +81,35 @@ namespace textinput {
virtual void start();
virtual void end();
virtual textinput::InputForm* createInputForm();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual textinput::InputForm* createInputForm();
#else
virtual InputForm* createInputForm();
#endif
virtual void memoDraw();
virtual void setSaveData(savedata::MemoSetting memoSetting);
virtual savedata::MemoSetting getSaveData();
virtual void setSaveData(savedata::MemoSetting memoSetting) {
mMemoSetting = memoSetting;
}
virtual savedata::MemoSetting getSaveData() { return mMemoSetting; }
virtual void changeState(StateTimeLine stateTimeLine);
virtual State* getState();
virtual State* getState() { return mpCurrentState; }
virtual void setState(StateType stateType);
virtual ConfigType getConfigType();
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();
@@ -114,24 +126,21 @@ namespace textinput {
virtual void configNormalWithoutLineFeedWithSign();
virtual void configPredictWithoutLineFeed();
virtual void configPredictBigText();
virtual InputForm* createMemoInputForm();
virtual letter::InputForm* createLetterInputForm();
virtual textinput::InputForm* createBigTextInputForm();
virtual bg::LayoutByNW4R* createBG();
#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
virtual void pure_0() {}
virtual void pure_1() {}
virtual void pure_2() {}
virtual void pure_3() {}
virtual void pure_4() {}
virtual void pure_5() {}
virtual void pure_6() {}
virtual void pure_7() {}
virtual void pure_8() {}
virtual void pure_9() {}
void reflectSaveDataRev1();
void reflectSaveDataDefault();
#ifdef MYTIMANAGER_IMPLEMENTATION
void* getBackGround() const { return mpBackGround; }
#endif
private:
State* mpCurrentState; // 0x40
@@ -140,22 +149,25 @@ namespace textinput {
MemoInputForm* mpMemoInputForm; // 0x50
LetterInputForm* mpLetterInputForm; // 0x54
textinput::InputForm* mpBigTextInputForm; // 0x58
keyboard::pctype::LayoutByNW4R* mpDefaultPCKeyboard; // 0x5C
keyboard::cellphonetype::LayoutByNW4R* mpDefaultCellPhoneKeyboard; // 0x60
void* mpDefaultPCKeyboard; // 0x5C
void* mpDefaultCellPhoneKeyboard; // 0x60
textinput::InputForm* mpDefaultInputForm; // 0x64
candidatebox::LayoutByNW4R* mpDefaultCandidateBox; // 0x68
toolbar::LayoutByNW4R* mpDefaultToolBar; // 0x6C
predictlang::LayoutByNW4R* mpDefaultPredictLanguageDialog; // 0x70
keyboard::signwindow::LayoutByNW4R* mpDefaultSignWindow; // 0x74
bg::LayoutByNW4R* mpBackGround; // 0x78
friend class State;
void* mpDefaultCandidateBox; // 0x68
void* mpDefaultToolBar; // 0x6C
void* mpDefaultPredictLanguageDialog; // 0x70
void* mpDefaultSignWindow; // 0x74
void* mpBackGround; // 0x78
};
class State {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
State() : mpManager(NULL) {}
Manager* getManager() const { return mpManager; }
void setManager(Manager* manager) { mpManager = manager; }
#endif
virtual ~State();
#ifdef MYTIMANAGER_MATCHING
virtual Manager::StateType getStateType() = 0;
virtual void create() = 0;
@@ -173,100 +185,43 @@ namespace textinput {
virtual void start() = 0;
virtual void end() = 0;
virtual InputForm* InputForm();
virtual keyboard::hwkey::HWKeyboard* HWKeyboard();
virtual keyboard::pctype::LayoutByNW4R* PCKeyboard();
#else
virtual Manager::StateType getStateType();
virtual void create();
virtual void init();
virtual void draw();
virtual void memoDraw();
virtual void calc();
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void start();
virtual void end();
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual InputForm* InputForm();
virtual keyboard::hwkey::HWKeyboard* HWKeyboard();
virtual keyboard::pctype::LayoutByNW4R* PCKeyboard();
virtual keyboard::cellphonetype::LayoutByNW4R* CellPhoneKeyboard();
virtual keyboard::signwindow::LayoutByNW4R* SignKeyboard();
virtual candidatebox::LayoutByNW4R* CandidateBox();
virtual toolbar::LayoutByNW4R* ToolBar();
virtual predictlang::LayoutByNW4R* PredictLanguageSelectDialog();
virtual bg::LayoutByNW4R* BG();
virtual void* SignKeyboard();
virtual candidatebox::LayoutByNW4R* CandidateBox();
virtual toolbar::LayoutByNW4R* ToolBar();
virtual void* PredictLanguageSelectDialog();
virtual void* BG();
#endif
protected:
private:
Manager* mpManager; // 0x04
friend class Manager;
};
class DispMemoState : public State {
public:
virtual ~DispMemoState();
virtual Manager::StateType getStateType();
virtual void create();
virtual void init();
virtual void draw();
virtual void memoDraw();
virtual void calc();
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void start();
virtual void end();
};
class AppearMemoState : public State {
public:
AppearMemoState() : mfAnim(0.0f) {}
virtual ~AppearMemoState();
virtual Manager::StateType getStateType();
virtual void create();
virtual void init();
virtual void draw();
virtual void memoDraw();
virtual void calc();
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void start();
virtual void end();
protected:
f32 mfAnim; // 0x08
};
class EditMemoState : public State {
public:
virtual ~EditMemoState();
virtual Manager::StateType getStateType();
virtual void create();
virtual void init();
virtual void draw();
virtual void memoDraw();
virtual void calc();
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void start();
virtual void end();
};
class DisappearMemoState : public AppearMemoState {
public:
virtual ~DisappearMemoState();
virtual Manager::StateType getStateType();
virtual void calc();
virtual void start();
};
}
}
typedef extend::memo::Manager MemoManager;
}
#include "MyTiBg.h"
#endif // TEXTINPUT_MY_MANAGER_H

View File

@@ -48,6 +48,9 @@ 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:
@@ -74,11 +77,9 @@ namespace textinput {
class Base : public CommandSender {
public:
#ifdef TI_CANDIDATEBOX_SAMPLE_CLASS
Base(Manager* manager)
: mpCandidates(NULL), mpAllocator(NULL), mbOn(false), mbInvalid(true), meLanguage(USA), mpManager(manager) {}
#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 {}
@@ -113,8 +114,9 @@ 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
@@ -185,7 +187,19 @@ namespace textinput {
void SetFocusedText(s32 pane) { mnFocusedIdx = pane; }
s32 GetFocusedText() { return mnFocusedIdx; }
f32 GetWidthScale_() const { return 608.0f / mfScreenWidth; }
#ifdef TI_CANDIDATEBOX_IMPLEMENTATION
f32 GetMargin_() const {
f32 margin;
if (mfScreenWidth > 700.0f) {
margin = 10.0f;
} else {
margin = 20.0f;
}
return margin;
}
#else
f32 GetMargin_() const { return mfScreenWidth > 700.0f ? 10.0f : 20.0f; }
#endif
s32 GetNextPageIdx_(s32 page) const;
s32 GetPrevPageIdx_(s32 page) const;
s32 GetDispNum() const;
@@ -288,13 +302,13 @@ namespace textinput {
// TODO
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
public:
#ifdef TI_CANDIDATEBOX_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, 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) {}
#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;
@@ -323,7 +337,11 @@ namespace textinput {
virtual u16 getScroll() { return mTextArea.GetDispOffset(); } // 0x100
virtual bool isInScroll(); // 0x104
virtual void setActive(bool active); // 0x108
virtual bool isActive() const; // 0x10C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isActive() const { return mbActive; }
#else
virtual bool isActive() const;
#endif // 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
@@ -333,13 +351,13 @@ 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);
UIOnOffButton& getOnOffButton() { return mOnOffButton; }
const UIOnOffButton& getOnOffButton() const { return mOnOffButton; }
private:
void createAnmPane_(MEMAllocator* allocator);
@@ -402,17 +420,6 @@ namespace textinput {
virtual void onAnmEvent(AnmPaneEvent paneEvent) override; // 0x10
};
#ifdef TI_CANDIDATEBOX_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
virtual ~Sample();
};
#else
class Sample {};
#endif
} // namespace candidatebox
} // namespace textinput

View File

@@ -1,226 +1,273 @@
#ifndef TEXTINPUT_CELL_PHONE_H
#define TEXTINPUT_CELL_PHONE_H
#include "tiKeyboard.h"
#include "tiNw4rManager.h"
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#include "tiKeyboard.h"
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
#include <revolution/gx.h>
#endif
namespace textinput {
class Manager;
#ifdef TI_CELLPHONE_SAMPLE_CLASS
class EventObserver;
#endif
namespace predictlang {
class LayoutByNW4R;
}
namespace keyboard {
#ifdef TI_CELLPHONE_IMPLEMENTATION
enum VKeyCode {
VK_LINE_FEED = 0,
VK_DELETE = 1,
VK_SIGN_INPUT = 9,
VK_PREDICT_LANGUAGE = 10,
VK_INPUT_MODE_02 = 11,
VK_INPUT_MODE_03 = 13,
VK_INPUT_MODE_00 = 18,
VK_INPUT_MODE_01 = 19,
VK_TOGGLE_ABC_MODE = 23,
};
#endif
namespace signwindow {
class LayoutByNW4R;
}
}
class KeyboardBase;
typedef enum VKeyCode {
VK_LF = 0,
VK_DELETE = 1,
VK_SPACE = 2,
VK_OTHERS = 9,
VK_PRDC = 0xA,
VK_TAG_02 = 0xB,
VK_TAG_03 = 0xD,
VK_UNKNOWN_11 = 0x11,
VK_TAG_00 = 0x12,
VK_TAG_01 = 0x13,
VK_SML_CPT = 0x17,
VK_NONE = 0x1B,
} VKeyCode;
namespace keyboard {
namespace cellphonetype {
class EventHandler;
#ifdef TI_CELLPHONE_IMPLEMENTATION
class CellPhoneAnmPane;
struct PaneNameToCharCode;
struct KeySet;
struct LanguageDependency;
class LayoutByNW4R;
class Base : public KeyboardBase {
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
class Base : public textinput::keyboard::KeyboardBase {
#else
class Base {
#endif
public:
typedef enum InputMode {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_SAMPLE_CLASS)
Base(Manager* manager) : mPreviousInputMode(0), mCurrentInputMode(0), mpManager(manager) {}
#endif
enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
IM_05,
} InputMode;
};
#ifdef TI_CELLPHONE_SAMPLE_CLASS
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) {}
#endif
#if defined(TI_CELLPHONE_IMPLEMENTATION)
virtual u32 getType() override;
#elif defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
virtual int getType() override;
#elif defined(TIHWKEYBOARD_IMPLEMENTATION)
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();
#ifdef TI_CELLPHONE_IMPLEMENTATION
wchar_t convertToZiCellphoneInput_(wchar_t value);
#endif
#else
virtual void vt_0x08();
virtual void vt_0x0C();
virtual void vt_0x10();
virtual void vt_0x14();
virtual void vt_0x18();
virtual void vt_0x1C();
virtual void vt_0x20();
virtual void vt_0x24();
virtual void vt_0x28();
virtual void vt_0x2C();
virtual void vt_0x30();
virtual void vt_0x34();
virtual void vt_0x38();
virtual void vt_0x3C();
virtual void vt_0x40();
virtual void vt_0x44();
virtual void create(MEMAllocator* allocator) override; // 0x0C
virtual void init() override; // 0x10
virtual void setCommandReceiver(CommandReceiver* receiver) override; // 0x14
virtual void sendCommand(u32, void*) override; // 0x18
virtual void updateFromReceiver(u32, void*) override; // 0x1C
virtual void onKey(u32, void*); // 0x20
virtual int getType(); // 0x24
virtual void setLanguage(Language language) override; // 0x28
virtual Language getLanguage() const override; // 0x2C
virtual void onActive() override; // 0x34
virtual void calc(); // 0x38
virtual void draw(); // 0x3C
virtual int getInputMode() const; // 0x40
virtual bool isLocked() const; // 0x44
virtual bool isNumeric() const; // 0x48
virtual bool isNumericWithDot() const; // 0x4C
virtual bool isHoldingButton() const; // 0x50
virtual void doNumericMode(bool); // 0x54
virtual void changeInputMode(InputMode mode); // 0x58
virtual bool isUpperCase(); // 0x5C
virtual void setInputMode(InputMode mode); // 0x60
virtual void setUpperCaseJP(bool); // 0x64
virtual void setLangKeyActive(bool); // 0x68
virtual void onClose(); // 0x6C
virtual void goSignInputMode(); // 0x70
virtual void changePredictLanguage(); // 0x74
virtual void setAbcMode(bool); // 0x78
virtual bool isZiActive(); // 0x7C
virtual bool isAtokActive(); // 0x80
virtual void doInput(); // 0x84
virtual void updateFixMode(); // 0x88
virtual bool isNumeric() const;
void onCtrlKey_(VKeyCode code);
wchar_t convertToZiCellphoneInput_(wchar_t wc);
virtual void vt_0x4C();
virtual void vt_0x50();
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_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();
virtual void vt_0x64();
virtual void vt_0x68(bool);
virtual bool onClose();
#endif
// TODO enum?
int getInputType() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_IMPLEMENTATION)
protected:
Manager* mgr() { return mpManager; }
s32 mTapIndex; // 0x14
s32 mInputMode; // 0x18
u8 mbLocked; // 0x1C
u8 mbNumeric; // 0x1D
u8 mbNumericWithDot; // 0x1E
u8 mbUpperCase; // 0x1F
u8 mbShiftHeld; // 0x20
u8 unk_0x21; // 0x21
const PaneNameToCharCode* mpHoldingPane; // 0x24
const LanguageDependency* mpLanguageDep; // 0x28
MEMAllocator* mpAllocator; // 0x2C
Manager* mpManager; // 0x30
u8 mbLangKeyActive; // 0x34
u8 unk_0x35[3]; // 0x35
#else
private:
#endif
u32 mPreviousInputMode;
u32 mCurrentInputMode;
bool mbInputModeLocked;
bool mbNumericMode;
bool mbNumericWithDotMode;
bool mbUpperCaseMode;
bool mbAbcMode;
bool mbLanguageKeyMode;
#ifdef TI_CELLPHONE_IMPLEMENTATION
const PaneNameToCharCode* mHoldingButton;
#else
u32 mHoldingButton;
#endif
void* mpInputModeTable;
MEMAllocator* mpAllocator;
#ifdef TI_CELLPHONE_IMPLEMENTATION
Manager* mpManager;
bool mInputState;
#elif defined(TIMANAGER_IMPLEMENTATION)
Manager* mpManager;
u32 mInputState;
#else
void* mpInputSettings;
u32 mInputState;
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
void onCtrlKey_(VKeyCode keyCode);
#endif
#endif
};
#ifndef TI_CELLPHONE_MATCH_LAYOUT
#include "tiCellPhoneLayout.h"
#else
class LayoutByNW4R;
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
enum Animation {
ANM_Normal,
ANM_FocusIn,
ANM_FocusOut,
ANM_RollOver,
ANM_Pushed,
ANM_05,
ANM_06,
ANM_ToggleOff,
ANM_Last,
};
enum KeyType {
KT_NormalButton,
KT_ControlButton,
};
#ifdef TI_CELLPHONE_MATCH_LAYOUT
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpLayout(layout) {}
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, TiEventHandler::Input* input); // 0x18
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent* pane, u32 event, Input* input) override;
private:
LayoutByNW4R* mpLayout; // 0x0C
LayoutByNW4R* mpLayoutByNW4R;
};
#endif
class CellPhoneAnmPane : public nw4rmanager::AnmPane {
public:
CellPhoneAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer, u32 keyType)
: nw4rmanager::AnmPane(pane, observer) {
mState = 0;
mKeyType = keyType;
CellPhoneAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
#ifdef TI_CELLPHONE_MATCH_LAYOUT
: nw4rmanager::AnmPane(pane, observer), meState(ANM_Normal), meKeyType(KT_NormalButton) {
init();
changeAnimation(mState);
changeAnimation(meState);
}
#else
: nw4rmanager::AnmPane(pane, observer), meState(ANM_Normal), meKeyType(KT_NormalButton) {}
#endif
virtual void init(); // 0x08
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual void changeAnimation(u32 id); // 0x14
virtual u32 getKeyType() const; // 0x24
virtual void init() override;
virtual void onAnmEvent(AnmPaneEvent event) override;
virtual void changeAnimation(u32 id) override;
virtual KeyType getKeyType() const;
u32 getAnimationState() const { return meState; }
virtual ~CellPhoneAnmPane();
protected:
s32 mState; // 0x2C
u32 mKeyType; // 0x30
Animation meState;
KeyType meKeyType;
};
class CellPhoneControlAnmPane : public CellPhoneAnmPane {
public:
CellPhoneControlAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer, u32 keyType)
: CellPhoneAnmPane(pane, observer, 0) {
mKeyType = keyType;
}
CellPhoneControlAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: CellPhoneAnmPane(pane, observer) { meKeyType = KT_ControlButton; }
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual void onAnmEvent(AnmPaneEvent event) override;
virtual ~CellPhoneControlAnmPane();
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
#ifndef TI_CELLPHONE_MATCH_LAYOUT
class EventHandler : public nw4rmanager::TiEventHandler {
public:
#ifdef TI_CELLPHONE_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, observer),
mpEventHandler(NULL) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
virtual void setLanguage(Language language) override;
virtual void update() override;
virtual void onActive() override;
virtual void calc() override;
virtual void draw() override;
virtual void doNumericMode(bool) override;
virtual void changeInputMode(InputMode mode) override;
virtual void setInputMode(InputMode mode) override;
virtual void setUpperCaseJP(bool) override;
virtual void setLangKeyActive(bool) override;
virtual void onClose() override;
virtual void goSignInputMode() override;
virtual void changePredictLanguage() override;
virtual void setAbcMode(bool) override;
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R*); // 0x104
virtual void setSignWindow(signwindow::LayoutByNW4R*); // 0x108
virtual void doNumericWithDotMode(bool); // 0x10C
virtual void setLineFeedButton(bool); // 0x110
virtual void setPredictLanguageButton(bool); // 0x114
virtual void setSignWindowButton(bool); // 0x118
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x11C
virtual bool updateInput(textinput::input::HKBManager& hkbManager); // 0x120
virtual nw4rmanager::AnmPane* getAnmPane(InputMode mode); // 0x124
virtual void throwReleaseForAll(); // 0x128
virtual void changeAnimationAllToNormal(); // 0x12C
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode); // 0x130
virtual void changeKeyTop(const PaneNameToCharCode* table); // 0x134
virtual void changeSpaceKeyTop(const PaneNameToCharCode* table); // 0x138
void onPressedShift(bool shift);
void onReleasedShift();
void resetHoldingButton();
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent* pane, u32 event, Input* input) override;
private:
bool mbLineFeed; // 0xE0
u8 unk_0xE1[3]; // 0xE1
GXTexObj mSpaceTexObjJP; // 0xE4
GXTexObj mSpaceTexObjCN; // 0x104
GXTexObj mSpaceTexObjKR; // 0x124
EventHandler* mpEventHandler; // 0x144
predictlang::LayoutByNW4R* mpPredictLanguageDialog; // 0x148
signwindow::LayoutByNW4R* mpSignWindow; // 0x14C
LayoutByNW4R* mpLayoutByNW4R;
};
#endif
#ifdef TI_CELLPHONE_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
virtual ~Sample();
};
#else
class Sample {};
#endif
#ifdef TI_CELLPHONE_MATCH_LAYOUT
#include "tiCellPhoneLayout.h"
#endif
} // namespace cellphonetype

View File

@@ -72,10 +72,10 @@ namespace textinput {
virtual ~EventHandler() {} // 0x08
virtual void onEvent(GUIComponent& comp, u32 event, void* data); // 0x0C
virtual void onEvent(GUIComponent& comp, u32 event, void* data) {} // 0x0C
virtual void setLatestEventCtrlNo(int ctrlNo); // 0x10
virtual int getLatestEventCtrlNo(); // 0x14
virtual void setLatestEventCtrlNo(int ctrlNo) { muLatestEventCtrlNo = ctrlNo; } // 0x10
virtual int getLatestEventCtrlNo() { return muLatestEventCtrlNo; } // 0x14
protected:
int muLatestEventCtrlNo; // 0x04
@@ -92,6 +92,9 @@ 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;
@@ -100,19 +103,20 @@ namespace textinput {
mFlightDuration[i] = 0;
}
}
#endif
GUIComponent(u32 id)
: GUIInterface(), mbInitialize(false), mDraggingButton(0xFFFF), mID(id), mbTriggerTarget(false), mpManager(NULL), mpListener(NULL) {
init();
}
virtual ~GUIComponent(); // 0x08
virtual ~GUIComponent() {} // 0x08
virtual u32 getID(); // 0x20
virtual u32 getID() { return mID; } // 0x20
virtual bool isPointed(int point); // 0x24
virtual bool isDragging(int point); // 0x28
virtual bool isPointed(int point) { return mbPointed[point]; } // 0x24
virtual bool isDragging(int point) { return mbDragging[point]; } // 0x28
virtual void setPointed(int point, bool bEnable); // 0x2C
virtual void setPointed(int point, bool bEnable) { mbPointed[point] = bEnable; } // 0x2C
void onEvent(u32 event, void* data) {
if (mpListener) {
@@ -120,30 +124,39 @@ namespace textinput {
}
}
virtual void onPointIn(int point); // 0x30
virtual void onPointOut(int point); // 0x34
virtual void onPointIn(int point) { mFlightDuration[point] = 0; } // 0x30
virtual void onPointOut(int point) { mFlightDuration[point] = 0; } // 0x34
virtual void onDrag(f32 x, f32 y);
virtual void onMove(int point, f32 x, f32 y); // 0x38
virtual void onTrig(int point, u32 trig, Vec& dragPos);
virtual void onDrag(f32 x, f32 y) {}
virtual void onMove(int point, f32 x, f32 y) { mFlightDuration[point]++; } // 0x38
virtual void onTrig(int point, u32 trig, Vec& dragPos) {
if (trig & mDraggingButton) {
mDraggingPos[point] = dragPos;
mbDragging[point] = true;
mFlightDuration[point] = 0;
}
}
virtual void setDraggingButton(u32 dragBtn); // 0x3C
virtual void setDraggingButton(u32 dragBtn) { mDraggingButton = dragBtn; } // 0x3C
virtual u32 updatePointer(const GUIPointer& pointer); // 0x48
virtual u32 updatePointer(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release); // 0x4C
virtual u32 updatePointer(const GUIPointer& pointer) { return updatePointerImpl(pointer); } // 0x40
virtual u32 updatePointer(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release) { // 0x44
GUIPointer pointer(point, x, y, hold, trig, release);
return updatePointerImpl(pointer);
}
virtual bool isTriggerTarget(); // 0x50
virtual void setTriggerTarget(bool bEnable); // 0x54
virtual bool isTriggerTarget() { return mbTriggerTarget; } // 0x48
virtual void setTriggerTarget(bool bEnable) { mbTriggerTarget = bEnable; } // 0x4C
void setParentManager(GUIManager* manager) { mpManager = manager; }
GUIManager* getParentManager() { return mpManager; }
virtual bool isVisible(); // 0x58
virtual bool isVisible() { return true; } // 0x50
virtual u16 getFlightDuration(int point); // 0x5C
virtual void setFlightDuration(int point, u16 flightDir); // 0x60
virtual u16 getFlightDuration(int point) { return mFlightDuration[point]; } // 0x54
virtual void setFlightDuration(int point, u16 flightDir) { mFlightDuration[point] = flightDir; } // 0x58
virtual bool contain(f32 x, f32 y) = 0; // 0x64
virtual bool contain(f32 x, f32 y) = 0; // 0x5C
void setListener(EventHandler* listener) { mpListener = listener; }
@@ -154,9 +167,9 @@ namespace textinput {
bool mbInitialize; // 0x04
bool mbPointed[GUI_POINTS_MAX]; // 0x05
bool mbPointed[GUI_POINTS_MAX]; // 0x08
bool mbDragging[GUI_POINTS_MAX]; // 0x0D
bool mbDragging[GUI_POINTS_MAX]; // 0x10
Vec mDraggingPos[GUI_POINTS_MAX]; // 0x18
int mDraggingButton; // 0x78
@@ -164,10 +177,10 @@ namespace textinput {
u16 mFlightDuration[GUI_POINTS_MAX]; // 0x80
bool mbTriggerTarget; // 0x90
bool mbTriggerTarget; // 0x8A
GUIManager* mpManager; // 0x94
EventHandler* mpListener; // 0x98
GUIManager* mpManager; // 0x8C
EventHandler* mpListener; // 0x90
};
class GUIManager : public GUIInterface {
@@ -187,15 +200,27 @@ namespace textinput {
virtual GUIComponent* getComponent(u32 id); // 0x24
virtual GUIComponent* getComponent(u32 id) const; // 0x28
virtual bool update(int point, const KPADStatus* kpad, f32, f32, void* data); // 0x2C
virtual bool update(int point, const KPADStatus* kpad, f32, f32, void* data) { return false; } // 0x2C
virtual bool update(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x30
virtual void onEvent(GUIComponent& comp, u32 event, int point, void* data); // 0x34
virtual void onEvent(GUIComponent& comp, u32 event, int point, void* data) { // 0x34
if (mpEventHandler) {
mpEventHandler->setLatestEventCtrlNo(point);
mpEventHandler->onEvent(comp, event, data);
}
comp.onEvent(event, data);
}
virtual void setAllComponentTriggerTarget(bool bEnable); // 0x38
virtual void setEventHandler(EventHandler* eventHandler); // 0x3C
virtual EventHandler* changeEventHandler(EventHandler* eventHandler); // 0x40
virtual void setEventHandler(EventHandler* eventHandler) { // 0x3C
mpEventHandler = eventHandler;
}
virtual EventHandler* changeEventHandler(EventHandler* eventHandler) { // 0x40
EventHandler* prevHandler = mpEventHandler;
mpEventHandler = eventHandler;
return prevHandler;
}
virtual void setDraggingButton(u32 dragBtn); // 0x44
@@ -234,7 +259,7 @@ namespace textinput {
virtual PaneComponent* getPaneComponentByPane(nw4r::lyt::Pane* pane); // 0x4C
virtual const nw4r::lyt::DrawInfo* getDrawInfo(); // 0x50
virtual const nw4r::lyt::DrawInfo* getDrawInfo() { return mpDrawInfo; } // 0x50
virtual void setDrawInfo(const nw4r::lyt::DrawInfo* drawInfo) { mpDrawInfo = drawInfo; } // 0x54
virtual void setAllBoundingBoxComponentTriggerTarget(bool bEnable); // 0x58
@@ -273,11 +298,11 @@ namespace textinput {
virtual void draw(); // 0x1C
virtual bool isVisible(); // 0x58
virtual bool isVisible(); // 0x50
virtual bool contain(f32 x, f32 y); // 0x64
virtual bool contain(f32 x, f32 y); // 0x5C
virtual void setPane(nw4r::lyt::Pane* pane); // 0x68
virtual void setPane(nw4r::lyt::Pane* pane) { mpPane = pane; } // 0x60
nw4r::lyt::Pane* getPane() { return mpPane; }
nw4r::lyt::TextBox* getTextPane() { return static_cast<nw4r::lyt::TextBox*>(mpPane); }

View File

@@ -4,158 +4,233 @@
#include <revolution/types.h>
#include <revolution/mem/allocator.h>
#include <revolution/os.h>
#include "keyboard/tiCpData.h"
typedef enum _KBDEc {
KBD_EC_0 = 0,
KBD_EC_1,
KBD_EC_2,
KBD_EC_3,
KBD_EC_4,
KBD_EC_5,
KBD_EC_6,
KBD_EC_OK,
} KBDEc;
typedef struct _KBDDevEvent {
u8 chan;
u8 unk_0x01[0x1F];
} KBDDevEvent;
typedef struct _KBDKeyEvent {
u8 chan;
u8 key;
u8 unk_0x02[2];
u32 mods;
} KBDKeyEvent;
extern "C" {
void KBDInitRegionUS(void);
void KBDInit(void);
void KBDSetAttachCallback(void (*cb)(KBDDevEvent*));
void KBDSetDetachCallback(void (*cb)(KBDDevEvent*));
void KBDSetKeyCallback(void (*cb)(KBDKeyEvent*));
int KBDSetLedsAsync(u8 chan, u8 leds, void (*cb)(KBDEc, void*), void* arg);
int KBDSetLeds(u8 chan, u8 leds);
int KBDSetModState(u8 chan, u32 mods);
int KBDSetCountry(u8 chan, u32 country);
int KBDSetLockProcessing(u8 chan, int lock);
u16 KBDTranslateHidCode(u8 key, u32 country);
}
#ifdef TIHKBMANAGER_IMPLEMENTATION
#include <revolution/kbd.h>
enum _KBDEc { KBD_EC_BUSY = 7 };
#endif
namespace textinput {
namespace input {
#ifdef TIHKBMANAGER_IMPLEMENTATION
class HKBManager {
public:
HKBManager();
class KeyState_ {
public:
void NotifyEvent(u8 down, u8 code);
void Update();
void UpdateModState_();
void Clear() {
held = 0;
triggered = 0;
released = 0;
repeated = 0;
current = 0;
pending = 0;
modifiers &= 0x700;
forceMask = 0;
forceState = 0;
retryLeds = 0;
}
void Initialize(u8 channel) {
held = 0;
triggered = 0;
released = 0;
repeated = 0;
current = 0;
pending = 0;
forceMask = 0;
forceState = 0;
retryLeds = 0;
device = channel;
country = 0xf;
modifiers = 0;
}
u8 device;
u32 held, triggered, released, repeated;
u32 previous, current, pending;
u32 modifiers, forceState, forceMask;
s32 country;
u8 retryLeds;
u8 previousKeys[8], currentKeys[8], pendingKeys[8];
u32 repeatDelay[8];
};
class KeySet {
public:
KeySet() {}
KeySet(const HKBManager* owner, u8 kind)
: manager(owner), type(kind), index(-1), device(0), vcode(0) {}
u8 GetKey() const;
u32 GetWChar() const;
u32 GetVCode() const;
u32 IsValid() const;
bool CheckValidity() const {
if (!manager) return false;
s8 keyIndex = index;
if (keyIndex < 0 || keyIndex >= 8) return false;
u8 keyDevice = device;
if (keyDevice >= 2) return false;
switch (type) {
case 0: return (manager->states[keyDevice].held & (1 << keyIndex)) != 0;
case 1: return (manager->states[keyDevice].triggered & (1 << keyIndex)) != 0;
case 2: return (manager->states[keyDevice].released & (1 << keyIndex)) != 0;
case 3: return (manager->states[keyDevice].repeated & (1 << keyIndex)) != 0;
}
return false;
}
KeySet GetNext() const;
const HKBManager* manager;
u8 type;
s8 index;
u8 device;
mutable u16 vcode;
};
class KBDListenerOwn;
class KBDListenerLinks {
public:
KBDListenerLinks() : previous(0), next(0) {}
virtual ~KBDListenerLinks() {}
virtual void OnAttach(KBDDevEvent*) = 0;
virtual void OnDetach(KBDDevEvent*) = 0;
virtual void OnKeyEvent(KBDKeyEvent*) = 0;
KBDListenerOwn* previous;
KBDListenerOwn* next;
};
class KBDListenerOwn : public KBDListenerLinks {
public:
KBDListenerOwn(HKBManager* owner) : manager(owner) {}
virtual ~KBDListenerOwn();
virtual void OnAttach(KBDDevEvent* event);
virtual void OnDetach(KBDDevEvent* event);
virtual void OnKeyEvent(KBDKeyEvent* event);
HKBManager* manager;
};
HKBManager() __attribute__((never_inline));
~HKBManager();
static HKBManager& getInstance() { return sInstance; }
void Initialize();
void ClearState();
u32 GetModifierState() const;
void SetCountry(u8 country);
void SetModifierState(u32 state, u32 mask);
void SetForceModifierState(u32 state, u32 mask);
void Update();
KeySet GetTriggeredKeySet() const;
KeySet GetReleasedKeySet() const;
KeySet GetRepeatedKeySet() const;
#ifdef TIHWKEYBOARD_IMPLEMENTATION
KeySet GetReleasedKeySet() const;
#endif
static void SetLedCB(_KBDEc result, void* userData);
static void AttachCB(KBDDevEvent* event);
static void DetachCB(KBDDevEvent* event);
static void KeyEventCB(KBDKeyEvent* event);
private:
u8 initialized;
u8 attached[2];
u32 lockState;
u32 retryDevices;
const wchar_t* allowedCharacters;
u32 allowedCharacterCount;
KeyState_ states[2];
KBDListenerOwn listener;
static HKBManager sInstance;
};
#else
class HKBManager {
public:
#ifdef TIMANAGER_IMPLEMENTATION
void ClearState();
#endif
static HKBManager& getInstance() { return sInstance; }
void Initialize();
void Update();
u32 GetModifierState() const;
void SetModifierState(u32 state, u32 mask);
void SetForceModifierState(u32 state, u32 mask);
u32 GetModifierState() const;
void SetCountry(u8 country);
void ClearState();
void SetModifierState(u32, u32);
#if defined(TI_CELLPHONE_HKB_KEYSET)
class KeySet {
public:
KeySet(const HKBManager* manager, u8 type) :
mpManager(manager), mType(type),
mIndex(-1), mSubIndex(0), mVCode(0) {}
u8 GetKey() const;
wchar_t GetWChar() const;
wchar_t GetVCode() const;
bool IsValid() const;
KeySet GetNext() const;
const HKBManager* mpManager; // 0x00
u8 mType; // 0x04
s8 mIndex; // 0x05
u8 mSubIndex; // 0x06
mutable u16 mVCode; // 0x08
u8 GetKey() const;
u32 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 GetReleasedKeySet() const;
KeySet GetRepeatedKeySet() const;
#else
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
class KeySet {
public:
u8 GetKey() const;
#ifdef TIHWKEYBOARD_IMPLEMENTATION
u32 GetWChar() const;
#else
wchar_t GetWChar() const;
#endif
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) {}
#ifdef TIHWKEYBOARD_IMPLEMENTATION
KeySet() : mpManager(NULL), mKind(0), mIndex(-1), mDevice(0), mCharacter(0) {}
#endif
private:
const HKBManager* mpManager;
u8 mKind;
s8 mIndex;
u8 mDevice;
u16 mCharacter;
};
KeySet GetTriggeredKeySet() const;
KeySet GetRepeatedKeySet() const;
#ifdef TIHWKEYBOARD_IMPLEMENTATION
KeySet GetReleasedKeySet() const;
#endif
void SetForceModifierState(u32 mask, u32 state);
#else
class KeySet {
private:
keyboard::cellphonetype::PaneNameToCharCode* pPaneNameToCharCode; // 0x00
wchar_t szKeySetName[17]; // 0x04
u16 uNum; // 0x26
u16 uType; // 0x28
#ifdef TI_CELLPHONE_IMPLEMENTATION
public:
bool IsValid() const;
u32 GetKey() const;
wchar_t GetWChar() const;
KeySet GetNext() const;
#endif
};
#ifdef TI_CELLPHONE_IMPLEMENTATION
KeySet GetTriggeredKeySet() const;
KeySet GetRepeatedKeySet() const;
#endif
#endif
#endif
private:
class KeyState_ {
public:
void NotifyEvent(u8 type, u8 key);
void Update();
void UpdateModState_();
u8 mKbdChan; // 0x00
u8 pad_0x01[3];
u32 mMaskWork; // 0x04
u32 mTrigMask; // 0x08
u32 mRelMask; // 0x0C
u32 mRepMask; // 0x10
u32 mPrevMask; // 0x14
u32 mCurMask; // 0x18
u32 mInputMask; // 0x1C
u32 mModState; // 0x20
u32 mForceMod; // 0x24
u32 mForceMask; // 0x28
s32 mCountry; // 0x2C
u8 mLedOK; // 0x30
u8 mReleasedKeys[8]; // 0x31
u8 mPrevKeys[8]; // 0x39
u8 mCurKeys[8]; // 0x41
u8 pad_0x49[3];
u32 mRepeatCtr[8]; // 0x4C
};
class KBDListener {
public:
KBDListener() : unk_0x04(0), mpNext(NULL) {}
virtual ~KBDListener() {}
virtual void OnAttach(KBDDevEvent* event);
virtual void OnDetach(KBDDevEvent* event);
virtual void OnKeyEvent(KBDKeyEvent* event);
u32 unk_0x04;
KBDListener* mpNext;
};
class KBDListenerOwn : public KBDListener {
public:
KBDListenerOwn(HKBManager* manager) : mpManager(manager) {}
virtual void OnAttach(KBDDevEvent* event);
virtual void OnDetach(KBDDevEvent* event);
virtual void OnKeyEvent(KBDKeyEvent* event);
HKBManager* mpManager; // 0x0C
};
static void SetLedCB(KBDEc result, void* arg);
static void AttachCB(KBDDevEvent* event);
static void DetachCB(KBDDevEvent* event);
static void KeyEventCB(KBDKeyEvent* event);
u8 mInitialized; // 0x00
u8 mAttached[2]; // 0x01
u8 pad_0x03;
u32 mModState; // 0x04
u32 mPendingLeds; // 0x08
const wchar_t* mpKeyTable; // 0x0C
u32 mKeyTableNum; // 0x10
KeyState_ mKeyStates[2]; // 0x14
KBDListenerOwn mListener; // 0xEC
u8 unk_0x00[0xFC];
static HKBManager sInstance;
};
#endif
} // namespace input
} // namespace textinput

View File

@@ -8,39 +8,62 @@ namespace textinput {
class Manager;
namespace keyboard {
namespace hwkey {
#ifdef TIMANAGER_IMPLEMENTATION
class HWKeyboard : public CommandSender {
#else
class HWKeyboard : CommandSender {
#endif
public:
struct AnimationFile {
u32 mAnimationNo;
char mFileName[0x40];
};
static const AnimationFile csAninationFile[8];
HWKeyboard(Manager *);
#ifdef TIMANAGER_IMPLEMENTATION
inline ~HWKeyboard();
#else
~HWKeyboard();
#endif
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
void setLanguage(Destination destination, Language language);
#endif
virtual void init();
virtual ~HWKeyboard();
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_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:
#ifdef TIHWKEYBOARD_IMPLEMENTATION
bool updateRepeatKey_(input::HKBManager&);
bool updateTriggerKey_(input::HKBManager&);
bool updateTappingShift_(input::HKBManager&);
#endif
void updateShift(input::HKBManager& hkbManager);
bool updateRepeatKey_(input::HKBManager& hkbManager);
bool updateTriggerKey_(input::HKBManager& hkbManager);
bool updateTappingShift_(input::HKBManager& hkbManager);
public:
u16 convertWCCode(wchar_t wc) const;
void setLanguage(Destination destination, Language language);
private:
void controlKeyTriggeredHandler(input::HKBManager);
bool controlKeyTriggeredHandler(input::HKBManager&);
Manager *mgr() { return mpManager; }
Manager* mpManager; // 0x10
u8 field_0x14; // 0x14
bool field_0x15; // 0x15
bool field_0x16; // 0x16
#ifdef TIINPUTFORM_IMPLEMENTATION
u8 mbSingleQuoteClosing;
u8 mbDoubleQuoteClosing;
#else
#ifdef TIHWKEYBOARD_IMPLEMENTATION
bool field_0x15;
bool field_0x16;
#else
u8 field_0x15; // 0x15
u8 field_0x16; // 0x16
#endif
#endif
};

View File

@@ -13,17 +13,43 @@
#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:
EditBuffer() : mpString(NULL), mpUnfixString(NULL), mpZiString(NULL), mpAllocator(NULL) {}
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void create(MEMAllocator* allocator);
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
virtual ~EditBuffer();
virtual void create(MEMAllocator* allocator);
void* getString() const { return mpString; }
void* getZiString() const { return mpZiString; }
#else
~EditBuffer();
#endif
private:
void* mpString; // 0x04
@@ -33,10 +59,27 @@ 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 wchar_t ToIndependentClass(wchar_t wc);
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
};
@@ -85,17 +128,61 @@ 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) {}
#ifdef TIINPUTFORM_IMPLEMENTATION
void init() __attribute__((never_inline));
#else
void init();
#endif
~RowInfoManager();
#endif
private:
Info_* mpInfo; // 0x00
u16 mMaxLength; // 0x04
MEMAllocator* mpAllocator; // 0x08
};
#ifdef TISIGNWINDOW_IMPLEMENTATION
bool isAtokActive() const;
#endif
#if defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onCommand(INPUT_COMMAND command, void* data);
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onCommand(INPUT_COMMAND command, void* data);
#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);
@@ -134,7 +221,6 @@ namespace textinput {
virtual void setAtokDictionary(void* atokDict, int atokDictSize, void* apotDict, int apotDictSize, void* nintendoDict, int nintendoDictSize);
virtual void closeAtokDictionary();
virtual bool isAtokDictionaryOpened();
bool isAtokActive() const;
void setZiDictionary(void* ziOemDict, void* ziDict) {
mpZiString->openDictionary(ziDict, ziOemDict);
@@ -144,7 +230,6 @@ namespace textinput {
void initZiString();
void resetContextPredict_();
void dirtyCacheAll();
void notifyChangeMode();
@@ -153,9 +238,12 @@ 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();
void* getCurrentString(bool flag);
#endif
virtual void setString(const wchar_t* string);
@@ -185,6 +273,10 @@ namespace textinput {
virtual void onSE(sound::SE seId);
#ifdef MYTIMANAGER_IMPLEMENTATION
void dirtyCacheAll();
#endif
virtual void clear();
virtual u32 calcCursorPos(f32 x, f32 y);
@@ -201,15 +293,21 @@ namespace textinput {
virtual void makeUpCursorPos(CursorPos* cursorPos, u32 pos, s32 startLine, s32 endLine);
bool isVacancy() const;
bool isPredictOn() const { return mbPredictOn; }
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
protected:
#if !defined(TIINPUTFORM_IMPLEMENTATION) && !defined(TIMANAGER_IMPLEMENTATION)
void setCursorPos(tistring::Decolated* string, u32 pos);
void calcCursorTimer();
#endif
void resetRelation();
nw4r::ut::Rect mRect; // 0x120
#else
private:
#endif
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
nw4r::ut::Rect mRect;
#else
Rect mRect;
#endif
nw4r::math::MTX34 mMtx; // 0x130
Destination meDestination; // 0x160
tistring::Decolated* mpString; // 0x164
@@ -217,6 +315,9 @@ 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
@@ -252,14 +353,18 @@ 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:
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName,
EventObserver* observer, const char* subName);
#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();
virtual void onCommand(INPUT_COMMAND command, void* data);
virtual void onSE(sound::SE seId);
virtual void create(MEMAllocator* allocator, EditBuffer* editBuffer);
@@ -270,6 +375,9 @@ 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);
@@ -280,27 +388,38 @@ namespace textinput {
virtual void setRootPaneScaleFor16x9();
virtual void setRootPaneScaleFor4x3();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual void onSE(sound::SE seId);
#endif
virtual void visibleSeparator(bool flag);
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
protected:
u8 unk_0x2C0[0x0C];
bool mbAbleToUp; // 0x2CC
bool mbAbleToDown; // 0x2CD
bool mbSeparator; // 0x2CE
u8 unk_0x2CF;
nw4rmanager::TiEventHandler* mpInputEventHandler; // 0x2D0
u8 unk_0x2D4[0x34];
};
#ifdef TI_INPUTFORM_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName,
EventObserver* observer, const char* subName)
: LayoutByNW4R(manager, resAccessor, arcName, observer, subName) {}
virtual ~Sample();
};
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;
typedef inputform::Base InputFormBase;

View File

@@ -8,16 +8,50 @@ namespace textinput {
class KeyboardBase : public CommandSender {
public:
#ifdef TIMANAGER_IMPLEMENTATION
KeyboardBase() : meLanguage(JP) {}
#endif
virtual ~KeyboardBase() {}
#if !(defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)) && !defined(TIMANAGER_IMPLEMENTATION) && !defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void create(MEMAllocator* alloc) override;
virtual void init() override;
#ifndef TI_CELLPHONE_MATCH_LAYOUT
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual void sendCommand(u32 command, void*) override;
#endif
#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(TIHWKEYBOARD_IMPLEMENTATION)) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void onKey(u32, void*);
#else
virtual void onKey(u32);
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual u32 getType();
#elif (defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
virtual int getType();
#else
virtual void getType();
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual void setLanguage(Language language) { meLanguage = language; }
#else
virtual void setLanguage(Language language);
#endif
#if (defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_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,12 +19,13 @@ 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(u8 arg) { mbPressedShift = arg; }
void setPressedShiftB(u8 arg) { mbPressedShiftB = arg; }
void clearPressedShift() { mbPressedShift = 0; mbPressedShiftB = 0; }
void setHWPressedShift(const u8& arg) { mbPressedShift = arg; }
class Singleton {
public:

View File

@@ -9,8 +9,6 @@
#include "tiToolBar.h"
#include "tiPcKeyboard.h"
#include "tiCellPhone.h"
#include "tiPredictLang.h"
#include "tiSignWindow.h"
#include <nw4r/lyt/pane.h>
#include <nw4r/lyt/arcResourceAccessor.h>
@@ -25,16 +23,25 @@
namespace textinput {
class EventObserver {
public:
virtual void onInput(CommandReceiver::INPUT_COMMAND command, void* data); // 0x08
virtual void onCommand(CommandReceiver::INPUT_COMMAND command, void* data); // 0x0C
virtual void onEvent(nw4r::lyt::Pane* pane, u32 event); // 0x10
virtual void onInput(CommandReceiver::INPUT_COMMAND command, void* data) {} // 0x08
virtual void onCommand(CommandReceiver::INPUT_COMMAND command, void* data) {} // 0x0C
virtual void onEvent(nw4r::lyt::Pane* pane, u32 event) {} // 0x10
virtual void onSE(sound::SE seId);
virtual void onOK();
virtual void onCancel();
virtual void onOutOfLength();
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);
@@ -57,7 +64,10 @@ namespace textinput {
virtual void setWCString(const wchar_t* string);
virtual void setLanguage(Language language);
virtual Language getLanguage() const;
virtual Language getLanguage() const { return meLanguage; }
#ifdef MYTIMANAGER_IMPLEMENTATION
Language getLanguageForMemo() const { return meLanguage; }
#endif
virtual void setDestination(Destination destination);
@@ -68,49 +78,84 @@ 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);
virtual void setTitleText(wchar_t* titleText);
#ifdef TIMANAGER_IMPLEMENTATION
virtual void setTitleText(wchar_t* titleText);
void initAspect();
#else
virtual void setTitleText(const wchar_t* titleText);
#endif
void setTitleText(const wchar_t* titleText) {
nw4r::lyt::Pane* pane = mpInputForm->getPane("T_title_text");
nw4r::lyt::TextBox* textBox = nw4r::ut::DynamicCast<nw4r::lyt::TextBox*>(pane);
if (textBox != NULL) {
textBox->SetString(titleText, 0);
}
}
virtual void start();
virtual void end();
virtual void start() {}
virtual void end() {}
#ifdef TIHWKEYBOARD_IMPLEMENTATION
EventObserver* getEventObserverForHardware() const { return mpEventObserver; }
#endif
virtual InputForm* getInputForm() { return mpInputForm; }
virtual const InputForm* getInputForm() const;
virtual const InputForm* getInputForm() const { return mpInputForm; }
virtual keyboard::hwkey::HWKeyboard* getHWKeyboard() { return mpHWKeyboard; }
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const;
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const { return mpHWKeyboard; }
virtual keyboard::pctype::LayoutByNW4R* getPCKeyboard();
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const;
virtual keyboard::pctype::LayoutByNW4R* getPCKeyboard() { return mpPCKeyboard; }
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const { return mpPCKeyboard; }
virtual keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() { return mpCellPhoneKeyboard; }
virtual const keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() const;
virtual const keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() const { return mpCellPhoneKeyboard; }
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getSignKeyboard();
virtual const void* getSignKeyboard() const;
#else
virtual void* getSignKeyboard() { return mpSignWindow; }
virtual const void* getSignKeyboard() const { return mpSignWindow; }
#endif
virtual candidatebox::LayoutByNW4R* getCandidateBox();
virtual candidatebox::LayoutByNW4R* getCandidateBox() { return mpCandidateBox; }
virtual const candidatebox::LayoutByNW4R* getCandidateBox() const { return mpCandidateBox; }
virtual toolbar::LayoutByNW4R* getToolBar();
virtual const toolbar::LayoutByNW4R* getToolBar() const;
virtual toolbar::LayoutByNW4R* getToolBar() { return mpToolBar; }
virtual const toolbar::LayoutByNW4R* getToolBar() const { return mpToolBar; }
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getPredictLanguageSelectDialog();
virtual const void* getPredictLanguageSelectDialog() const;
EventObserver* getEventObserver() { return mpEventObserver; }
#else
virtual void* getPredictLanguageSelectDialog() { return mpPredictLanguageDialog; }
virtual const void* getPredictLanguageSelectDialog() const { return mpPredictLanguageDialog; }
#endif
virtual inputform::EditBuffer* createEditBuffer();
virtual keyboard::hwkey::HWKeyboard* createHWKeyboard();
@@ -126,17 +171,14 @@ namespace textinput {
virtual void setLayoutScaleFor4x3();
void enableCompatibleFilter(bool compatibleFilter);
void enableKSXFilter(bool flag);
void startPredictTurnOn(bool flag);
bool isPredictTurning() const;
bool isVacancy() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
bool isPredictTurning() const;
void startPredictTurnOn(bool enabled);
#endif
protected:
void initAspect();
protected:
private:
MEMAllocator* mpAllocator; // 0x04
nw4r::lyt::MultiArcResourceAccessor* mpMultiArcResourceAccessor; // 0x08
@@ -148,9 +190,14 @@ namespace textinput {
InputForm* mpInputForm; // 0x1C
candidatebox::LayoutByNW4R* mpCandidateBox; // 0x20
toolbar::LayoutByNW4R* mpToolBar; // 0x24
predictlang::LayoutByNW4R* mpPredictLanguageDialog; // 0x28
keyboard::signwindow::LayoutByNW4R* mpSignWindow; // 0x2C
#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,20 +14,29 @@ namespace textinput {
class TiEventHandler : public gui::EventHandler {
public:
typedef struct Input {
u32 field_0x00; // 0x00 chan
f32 mfX; // 0x04
f32 mfY; // 0x08
u32 field_0x0C; // 0x0C trigger
u32 field_0x10; // 0x10 hold
u32 field_0x14; // 0x14 release
u8 dummy[8]; // 0x18
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION) || defined(MYTILETTERFORM_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
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, Input* input) = 0; // 0x18
virtual void setEventObserver(EventObserver *event); // 0x1C
virtual void setEventObserver(EventObserver *event) { mpEventObserver = event; } // 0x1C
protected:
EventObserver* mpEventObserver; // 0x08
@@ -81,21 +90,35 @@ namespace textinput {
PE_5,
PE_6,
PE_7,
PE_8,
PE_9,
PE_10,
PE_11,
PE_Last,
} AnmPaneEvent;
virtual void init() {} // 0x08
virtual void calc(); // 0x0C
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void onAnmEvent(AnmPaneEvent) {}
#else
virtual void onAnmEvent(AnmPaneEvent paneEvent);
#endif // 0x10
virtual void changeAnimation(u32 id); // 0x14
virtual bool isInAnimation(); // 0x18
virtual Anim* searchAnimation(u32 id); // 0x1C
#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 ~AnmPane(); // 0x20
@@ -133,11 +156,11 @@ namespace textinput {
class AnimPaneGroup {
public:
AnimPaneGroup() {}
#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
@@ -191,7 +214,11 @@ 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];
}
@@ -220,14 +247,14 @@ namespace textinput {
virtual bool updateInput(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x20
virtual bool updateInput(input::HKBManager& hkbManager); // 0x24
virtual TiLayout* getLayout(); // 0x28
virtual TiLayout* getLayout() { return mpLayout; } // 0x28
virtual nw4r::lyt::Pane* getPane(const char* paneName); // 0x2C
virtual const nw4r::lyt::Pane* getPane(const char* paneName) const; // 0x30
virtual u32 getFlightDuration(int point, const char* paneName); // 0x34
virtual void setAnimOn(bool flag); // 0x38
virtual void setAnimOn(bool flag) { mbAnimOn = flag; } // 0x38
virtual void drawPane(const char* paneName); // 0x3C
@@ -236,8 +263,16 @@ namespace textinput {
virtual void setProjectionMtx(); // 0x48
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* paneLastDraw); // 0x4C
virtual void initPaneLastDrawReceived(); // 0x50
#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 setVisible(const char* paneName, bool flag); // 0x54
virtual bool isVisible(const char* paneName, bool* result) const; // 0x58
@@ -247,8 +282,8 @@ namespace textinput {
virtual AnmPane* searchAnmPane(const char* paneName); // 0x60
virtual AnmPane* searchAnmPane(wchar_t ch); // 0x64
virtual nw4r::ut::List& getAnmPaneList(); // 0x68
virtual gui::PaneManager* getPaneManager(); // 0x6C
virtual nw4r::ut::List& getAnmPaneList() { return mAnmPanes; } // 0x68
virtual gui::PaneManager* getPaneManager() { return mpPaneManager; } // 0x6C
virtual void AdjustPaneMtx(Mtx& mtx, const nw4r::lyt::DrawInfo& drawInfo, const nw4r::math::MTX34& mGlobalMtx); // 0x70

View File

@@ -1,340 +1,210 @@
#ifndef TEXTINPUT_PC_KEYBOARD_H
#define TEXTINPUT_PC_KEYBOARD_H
#include "tiKeyboard.h"
#if (defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION)
#include "tiPcKeyboardImpl.h"
#else
#include "tiNw4rManager.h"
#include "tiGUIManager.h"
#include "tiTextInputBase.h"
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
#include "tiKeyboard.h"
#endif
namespace textinput {
class Manager;
namespace predictlang {
class LayoutByNW4R;
}
namespace keyboard {
namespace signwindow {
class LayoutByNW4R;
}
namespace pctype {
class LayoutByNW4R;
class AnmPane;
class UIObj : public gui::EventHandler {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION)
class UIObj {
public:
class Listener {
public:
virtual void onEvent(UIObj* uiObj, u32, void*) = 0; // 0x08
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
};
UIObj(u32 ctrlNo, LayoutByNW4R* layout, Listener* listener) : mCtrlNo(ctrlNo), mpLayout(layout) {
mpListener = listener;
}
virtual ~UIObj(); // 0x08
virtual void onEvent(gui::GUIComponent& comp, u32 event, void* data); // 0x0C
virtual void onGUIEvent(gui::PaneComponent& pane, u32 event, nw4rmanager::TiEventHandler::Input* input); // 0x18
protected:
u32 mCtrlNo; // 0x08
LayoutByNW4R* mpLayout; // 0x0C
Listener* mpListener; // 0x10
};
class UIModifierButton : public UIObj {
friend class LayoutByNW4R;
public:
UIModifierButton(u32 ctrlNo, LayoutByNW4R* layout, Listener* listener);
virtual ~UIModifierButton();
virtual void onGUIEvent(gui::PaneComponent& pane, u32 event, nw4rmanager::TiEventHandler::Input* input);
private:
gui::PaneComponent* mpPaneComp1; // 0x14
gui::PaneComponent* mpPaneComp2; // 0x18
nw4rmanager::AnmPane* mpAnmPane; // 0x1C
u8 mbFocused; // 0x20
};
class UIModePanel : public UIObj {
friend class LayoutByNW4R;
public:
UIModePanel(u32 ctrlNo, LayoutByNW4R* layout, Listener* listener);
virtual ~UIModePanel();
virtual void onGUIEvent(gui::PaneComponent& pane, u32 event, nw4rmanager::TiEventHandler::Input* input);
void Create(nw4rmanager::Layout* layout);
private:
u32 unk_0x14; // 0x14
gui::PaneComponent* mpComps1[5]; // 0x18
gui::PaneComponent* mpComps2[5]; // 0x2C
nw4rmanager::AnmPane* mpAnmPanes[5]; // 0x40
nw4r::lyt::Pane* mExtraPanes[3]; // 0x54
GXTexObj mTexObjs[4]; // 0x60
};
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: nw4rmanager::AnmPane(pane, observer) {
mState = 0;
}
virtual void init(); // 0x08
virtual void changeAnimation(u32 id); // 0x14
virtual ~AnmPane(); // 0x20
virtual u32 getState() const { return mState; } // 0x24
virtual u32 getKeyType() const { return mKeyType; } // 0x28
protected:
s32 mState; // 0x2C
u32 mKeyType; // 0x30
};
class NormalButtonAnmPane : public AnmPane {
public:
NormalButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) {
mKeyType = 0;
}
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual ~NormalButtonAnmPane();
};
class ShiftCapsAnmPane : public AnmPane {
public:
ShiftCapsAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) {
mKeyType = 1;
mbFocused = false;
}
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual ~ShiftCapsAnmPane();
virtual bool isFocused() const; // 0x2C
private:
u8 mbFocused; // 0x34
};
class ToggleButtonAnmPane : public AnmPane {
public:
ToggleButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) {
mKeyType = 2;
}
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual ~ToggleButtonAnmPane();
};
class OnOffButtonAnmPane : public AnmPane {
public:
OnOffButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) {
mKeyType = 3;
}
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
virtual ~OnOffButtonAnmPane();
};
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpLayout(layout) {}
virtual ~EventHandler(); // 0x08
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, TiEventHandler::Input* input); // 0x18
private:
LayoutByNW4R* mpLayout; // 0x0C
};
class Base : public KeyboardBase {
public:
typedef enum TranslateMode {
TM_00,
TM_01,
TM_02,
TM_03,
} TranslateMode;
typedef enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
IM_05,
IM_06,
IM_07,
IM_08,
} InputMode;
typedef enum InputType {
enum InputType {
IT_00,
IT_01,
IT_02,
IT_03,
IT_04,
} InputType;
struct KeyState {
#ifdef TI_PCTYPE_SAMPLE_CLASS
KeyState() : mFlags(0), mIsABC(0), mAIUFlags(0), mLanguage((Language)1) {}
#endif
void refresh_();
void refreshText(nw4r::lyt::Pane* pane);
void setABCFlag(u32 flag);
wchar_t getWCCode(u32 keyType);
wchar_t getWCCode(char* out);
u32 mFlags; // 0x00
u32 mIsABC; // 0x04
u32 mAIUFlags; // 0x08
Language mLanguage; // 0x0C
const void* mpLanguageDep; // 0x10
Base* mpBase; // 0x14
};
#ifdef TI_PCTYPE_SAMPLE_CLASS
Base(Manager* manager) {
mKeyState.mpLanguageDep = NULL;
mKeyState.mpBase = this;
mpAllocator = NULL;
mbOnlyQwerty = false;
mpManager = manager;
}
#endif
#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; // 0x0C
virtual void init() override; // 0x10
virtual void updateFromReceiver(u32, void*) override; // 0x1C
virtual void onKey(u32, void*); // 0x20
virtual int getType(); // 0x24
virtual void setLanguage(Language language) override; // 0x28
virtual void onActive() override; // 0x34
virtual void inputCharCode(wchar_t wc); // 0x38
virtual void* getState(); // 0x3C
virtual bool isShiftOn() const; // 0x40
virtual bool isCapsOn() const; // 0x44
virtual bool isABC(); // 0x48
virtual void setABC(bool); // 0x4C
virtual int getABCInputMode() const; // 0x50
virtual int getAIUInputMode() const; // 0x54
virtual TranslateMode getTranslateMode() const; // 0x58
virtual void setTranslateMode(TranslateMode mode); // 0x5C
virtual void onlyQwerty(bool); // 0x60
virtual void setLangKeyActive(bool); // 0x64
virtual void setInputModeJP(bool, u32, u32); // 0x68
virtual void setInputModeCK(u32); // 0x6C
virtual void refreshState(); // 0x70
virtual void changeABCInputMode(InputMode mode); // 0x74
virtual void changeAIUInputMode(InputMode mode); // 0x78
virtual void onClose(); // 0x7C
virtual wchar_t getWCCode(char* out); // 0x80
virtual u32 getControlKey(char* out); // 0x84
virtual void sendInputWChar(wchar_t wc, bool flag); // 0x88
virtual void goSignInputMode(); // 0x8C
virtual void changePredictLanguage(); // 0x90
virtual void updateFixMode(); // 0x94
protected:
Manager* mgr() { return mpManager; }
public:
u8 unk_0x14; // 0x14
u8 unk_0x15[3]; // 0x15
u32 unk_0x18; // 0x18
const void* mpLanguageDep; // 0x1C
KeyState mKeyState; // 0x20
MEMAllocator* mpAllocator; // 0x38
u8 mbOnlyQwerty; // 0x3C
u8 mbLangKeyActive; // 0x3D
u8 unk_0x3E[2]; // 0x3E
Manager* mpManager; // 0x40
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
public:
#ifdef TI_PCTYPE_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, observer), mpEventHandler(NULL),
mShiftButton(1, this, this), mCapsButton(0, this, this), mModePanel(2, this, this) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
virtual void setLanguage(Language language) override;
virtual void onActive() override;
virtual void inputCharCode(wchar_t wc) override;
virtual void setABC(bool) override;
virtual void setTranslateMode(TranslateMode mode) override;
virtual void onlyQwerty(bool) override;
virtual void setLangKeyActive(bool) override;
virtual void setInputModeJP(bool, u32, u32) override;
virtual void setInputModeCK(u32) override;
virtual void refreshState() override;
virtual void onClose() override;
virtual void sendInputWChar(wchar_t wc, bool flag) override;
virtual void goSignInputMode() override;
virtual void changePredictLanguage() override;
virtual void draw(); // 0x11C
virtual void calc(); // 0x120
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog); // 0x124
virtual void setSignWindow(signwindow::LayoutByNW4R* window); // 0x128
virtual void setLineFeedButton(bool); // 0x12C
virtual void setPredictLanguageButton(bool); // 0x130
virtual void setSignWindowButton(bool); // 0x134
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x138
virtual bool updateInput(textinput::input::HKBManager& hkbManager); // 0x13C
virtual void changeAnimationAllToNormal(); // 0x140
virtual void throwReleaseForAll(); // 0x144
virtual void cancelStateFocusIn(); // 0x148
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode); // 0x14C
virtual void updateDakuten(); // 0x150
virtual void initLayout(); // 0x154
virtual void onEvent(UIObj* uiObj, u32, void*); // 0x158
void createAnmPane_(MEMAllocator* allocator);
void onPressedCaps();
void onPressedShift(bool);
void onReleasedShift();
private:
EventHandler* mpEventHandler; // 0xF0
predictlang::LayoutByNW4R* mpPredictLanguageDialog; // 0xF4
signwindow::LayoutByNW4R* mpSignWindow; // 0xF8
bool mbLineFeed; // 0xFC
u8 unk_0xFD[3]; // 0xFD
UIModifierButton mShiftButton; // 0x100
UIModifierButton mCapsButton; // 0x124
UIModePanel mModePanel; // 0x148
};
#ifdef TI_PCTYPE_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
virtual ~Sample();
};
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual u32 getType() override;
#else
class Sample {};
virtual void getType() override;
#endif
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();
virtual void setCommandReceiver(textinput::CommandReceiver*);
virtual void updateFromReceiver(u32, void*);
virtual void onKey();
virtual void getType();
virtual void setLanguage();
virtual void getLanguage();
virtual void update();
virtual void onActive();
virtual void inputCharCode();
virtual void getState();
virtual void isShiftOn();
virtual void isCapsOn();
virtual void isABC();
virtual void setABC();
virtual void getABCInputMode();
virtual void getAIUInputMode();
virtual TranslateMode getTranslateMode();
virtual void setTranslateMode(TranslateMode);
virtual void onlyQwerty();
virtual void setLangKeyActive(bool);
virtual void setInputModeJP();
virtual void setInputModeCK();
virtual void refreshState();
virtual void changeABCInputMode();
virtual void changeAIUInputMode();
virtual void onClose();
virtual void getWCCode();
virtual void getControlKey();
virtual void sendInputWChar();
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
{
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
} // namespace keyboard
} // namespace textinput
#endif // TEXTINPUT_PC_KEYBOARD_H
#endif
#endif // TEXTINPUT_HW_KEYBOARD_H

View File

@@ -14,13 +14,17 @@ namespace textinput {
class Base : public CommandSender {
public:
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
#if defined(TI_PREDICTLANG_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
Base(Manager* manager) : mePredictMode(inputform::Base::PM_USEn), mpAllocator(NULL), mpManager(manager) {}
#endif
virtual ~Base() {}
virtual void create(MEMAllocator* allocator) override { mpAllocator = allocator; }
#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:
@@ -34,16 +38,20 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, observer), mbActive(false), mbInput(false),
#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)
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) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void draw() override;
virtual void init() override;
virtual void draw() override;
virtual void open(inputform::Base::PredictMode predictMode, keyboard::KeyboardBase* keyboard);
virtual void endToOpen();
@@ -70,12 +78,21 @@ namespace textinput {
keyboard::KeyboardBase* mpCaller; // 0xD4
};
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
#if defined(TI_PREDICTLANG_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
#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

@@ -7,13 +7,7 @@ namespace textinput {
namespace extend {
namespace savedata {
typedef struct MemoSetting {
union {
u8 uRevisionAndType; // 0x00
struct {
u8 uType : 4; // 0x00:11110000
u8 uRevision : 4; // 0x00:00001111
};
};
u8 uRevisionAndType; // 0x00
union {
struct {

View File

@@ -3,152 +3,132 @@
#include "tiKeyboard.h"
#include "tiNw4rManager.h"
#include "tiTextInputBase.h"
#include "tiSwData.h"
namespace textinput {
class Manager;
class Manager;
namespace keyboard {
namespace keyboard {
namespace signwindow {
struct LanguageDependency {
u8 count;
const PaneNameToCharCodeInSignMode* keys;
};
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;
};
}
}
}
class Base : public KeyboardBase {
public:
#ifdef TI_SIGNWINDOW_SAMPLE_CLASS
Base(Manager* manager) : mpAllocator(NULL), mpManager(manager) {}
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void onKey(u32, void*);
virtual int getType();
virtual void setLanguage(Language language) override;
virtual bool isLocked(); // 0x38
virtual void setPage(u8 page); // 0x3C
virtual u8 getPage(); // 0x40
virtual void movePrevSignPage(); // 0x44
virtual void moveNextSignPage(); // 0x48
virtual void close(); // 0x4C
protected:
u8 mInputFlags; // 0x14
bool mbLocked; // 0x15
bool mbRepeat; // 0x16
u8 muPage; // 0x17
const LanguageDependency* mpLanguageDependency; // 0x18
MEMAllocator* mpAllocator; // 0x1C
Manager* mpManager; // 0x20
};
class AnmPane;
class EventHandler;
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
#ifdef TI_SIGNWINDOW_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, observer), mbActive(false), mbInput(false),
mpEventHandler(NULL), mpKeyboard(NULL) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void onKey(u32, void*) override;
virtual void movePrevSignPage() override; // 0x44
virtual void moveNextSignPage() override; // 0x48
virtual void close() override; // 0x4C
virtual void draw(); // 0xD4
virtual void open(KeyboardBase* keyboard, bool flag); // 0xD8
virtual bool isActive(); // 0xDC
virtual void onChangeAnmState(nw4rmanager::AnmObserver::AnmEvent anmEvent,
nw4rmanager::AnmPane* anmPane, nw4rmanager::Anim* anim); // 0xE0
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0xE4
virtual bool updateInput(textinput::input::HKBManager& hkbManager); // 0xE8
virtual void throwReleaseForAll(); // 0xEC
virtual void resetAnmSignWindow(); // 0xF0
virtual void setSignKeyTop(u16, u16); // 0xF4
virtual void setPageNumber(u16); // 0xF8
virtual void endToClose(); // 0xFC
virtual void startToInput(); // 0x100
virtual void movePrevSignWindow(); // 0x104
virtual void moveNextSignWindow(); // 0x108
private:
bool mbActive; // 0xD0
bool mbInput; // 0xD1
EventHandler* mpEventHandler; // 0xD4
KeyboardBase* mpKeyboard; // 0xD8
};
#ifdef TI_SIGNWINDOW_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
virtual ~Sample();
};
#else
class Sample {};
#endif
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;
};
} // namespace signwindow
} // namespace keyboard
} // namespace textinput
#endif // TEXTINPUT_SIGN_WINDOW_H

View File

@@ -3,7 +3,9 @@
#include <revolution/types.h>
#include <revolution/mem/allocator.h>
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
#include <revolution/kpr.h>
#endif
namespace textinput {
namespace tistring {
@@ -34,15 +36,23 @@ namespace textinput {
virtual void setLength(u16);
virtual wchar_t* getWCString() const;
virtual wchar_t* getWCString() const { return mpszString; }
virtual void setCandidate(wchar_t candidate) { mwcCandidate = candidate; }
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
virtual wchar_t getCandidate() const { return mwcCandidate; }
#else
virtual wchar_t getCandidate() { return mwcCandidate; }
#endif
virtual bool hasCandidate() const;
virtual wchar_t getLastWChar();
#if defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
protected:
#else
private:
#endif
u16 muMaxLength; // 0x04
u16 muLength; // 0x06
@@ -55,41 +65,56 @@ namespace textinput {
};
class KanaStream {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
public:
KPRQueue mQueue;
wchar_t mPending;
wchar_t mOutput[5];
#else
private:
u8 field_0x00[0x24];
#endif
};
class Decolated : public StringBase {
public:
enum TranslateMode { TM_Direct, TM_Kana, TM_Roman, TM_Hangul };
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
Decolated(u16 maxLen) : StringBase(maxLen), mCursorStart(0), mCursorEnd(0), mbSustain(false), mTranslateMode(0) { initKanaConverter(); }
virtual ~Decolated();
#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) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_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);
virtual void inputChar(wchar_t);
virtual void inputString(const wchar_t*);
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*);
virtual void confirm(const wchar_t* string);
virtual bool moveCursorRight();
virtual bool moveCursorLeft();
virtual void setCursorPos(u32);
virtual void setCursorPos(u32 pos);
virtual void onSustain();
virtual void offSustain();
virtual bool isOnSustain();
virtual u32 getCursorPos() const;
virtual void getCursorPos(u32*, u32*);
virtual void getCursorPos(u32* start, u32* end);
virtual bool canBackSpace();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
virtual bool deleteForward();
virtual void getSelected(u32&, u32&);
#else
virtual void deleteForward();
#endif
virtual void getSelected(u32& start, u32& end);
virtual wchar_t getWCharAtCursor();
virtual void replaceAtCursor(wchar_t);
virtual void replaceAtCursor(wchar_t ch);
virtual bool isDakuten();
virtual void converDakuten();
virtual bool isHandaku();
@@ -99,68 +124,123 @@ namespace textinput {
virtual void converSmall();
virtual bool atTheBeginningOfASentence();
virtual void initKanaConverter();
virtual void* getKanaBuffer();
virtual wchar_t* getKanaBuffer();
virtual bool isKanaFix() const;
virtual void confirmKana();
virtual void clearKana();
virtual void EnableKSXFilter(bool);
virtual void EnableKSXFilter(bool enable);
#else
virtual void inputChar();
virtual void inputString();
virtual void deleteChar();
virtual void backSpace();
virtual void confirm();
virtual void moveCursorRight();
virtual void moveCursorLeft();
virtual void setCursorPos();
virtual void onSustain();
virtual void offSustain();
virtual void isOnSustain();
virtual void getCursorPos();
virtual void getCursorPos(u32*, u32*);
virtual void canBackSpace();
virtual void deleteForward();
virtual void getSelected();
virtual void getWCharAtCursor();
virtual void replaceAtCursor();
virtual void isDakuten();
virtual void converDakuten();
virtual void isHandaku();
virtual void converHandaku();
virtual void convertAll();
virtual void isSmall();
virtual void converSmall();
virtual bool atTheBeginningOfASentence();
virtual void initKanaConverter();
virtual void getKanaBuffer();
virtual void isKanaFix();
virtual void confirmKana();
virtual void clearKana();
virtual void EnableKSXFilter();
void setTranslateMode(TranslateMode mode);
TranslateMode getTranslateMode() const { return static_cast<TranslateMode>(mTranslateMode); }
void inputString(const wchar_t* string, TranslateMode mode);
#endif
#if defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
protected:
#else
private:
u32 mCursorStart; // 0x18
u32 mCursorEnd; // 0x1C
u8 mbSustain; // 0x20
s32 mTranslateMode; // 0x24
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
u32 mCursorStart;
u32 mCursorEnd;
#if defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
u8 mbSustain;
s32 mTranslateMode;
#else
bool mbSustain;
u32 mTranslateMode;
#endif
#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) || defined(TISTRING_IMPLEMENTATION) || defined(TIZISTRING_IMPLEMENTATION)
class WithAtok : public Decolated {
public:
struct DrawInfo;
~WithAtok();
WithAtok(u16 maxLength) : Decolated(maxLength) {}
virtual ~WithAtok();
virtual void pushBack(wchar_t ch);
virtual void popBack();
virtual void inputChar(wchar_t);
virtual void inputChar(wchar_t ch);
virtual void backSpace();
virtual void confirm(const wchar_t*);
virtual void confirm(const wchar_t* string);
virtual bool moveCursorRight();
virtual bool moveCursorLeft();
virtual void getCursorPos(u32*, u32*);
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);
virtual void setFix(bool fix);
virtual void initConverting();
virtual bool isConverting();
virtual wchar_t* getConfirmedWCString() const;
virtual int getCurrentNumPredicted();
virtual bool getPredicted(int, wchar_t*);
virtual void commitPredicted(int);
virtual void setSelectedCandidate(long);
virtual void getPredicted(int index, wchar_t* string);
virtual void commitPredicted(int index);
virtual void setSelectedCandidate(s32 index);
virtual bool isCandidateSelected();
virtual int getSelectedCandidate();
virtual s32 getSelectedCandidate();
virtual void init();
virtual void setInputting(wchar_t);
virtual void getDrawString(DrawInfo&);
virtual void openDictionary(void*, int, void*, int, void*, int);
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);
virtual void enableConfirmedString(bool enable);
virtual void startConverting();
virtual bool isDictionaryOpened();
virtual void changeKanaMode(bool);
virtual int getInputStringLength();
virtual void changeKanaMode(bool kana);
virtual wchar_t getInputStringLength();
virtual void resetRelation();
virtual void setFixMode(bool);
virtual void setFixPrediction(int, const char* const*);
virtual void setDefaultPrediction(int, const char* const*);
virtual int getSelectedConverting();
virtual int getFixedPredictionNum();
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,10 +6,17 @@
#include <nw4r/ut/CharWriter.h>
#include <nw4r/ut/Rect.h>
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
#include <string.h>
#endif
namespace textinput {
namespace textdrawer {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
class Base : public nw4r::ut::CharWriter {
#else
class Base : nw4r::ut::CharWriter {
#endif
public:
typedef struct ViewPort {
f32 xOrig; // 0x00
@@ -27,11 +34,23 @@ namespace textinput {
} CursorPos;
typedef struct DrawInfo {
nw4r::ut::Rect rect; // 0x00
wchar_t character; // 0x10
u8 unk_0x12[6]; // 0x12
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_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();
@@ -53,7 +72,7 @@ namespace textinput {
virtual nw4r::math::VEC2 getScale() const = 0;
virtual void setSecretModeOn(bool secretMode);
virtual void setSecretModeOn(bool secretMode) { mbSecretMode = secretMode; }
virtual void doBeforeDrawProcess(const wchar_t*, u32, const DrawInfo& drawInfo);
virtual void doAfterDrawProcess(const wchar_t*, u32, const DrawInfo& drawInfo);
@@ -75,49 +94,116 @@ namespace textinput {
virtual u32 getEndPos() const;
// todo
virtual void setDrawModifyScopeLine(s32, s32);
virtual void setDrawCacheScopeLine(s32, s32);
virtual void modifyCursorCache(s32, u32, f32, f32, f32, f32);
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_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) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual bool isEnableCursorCache() const;
virtual s32 getDrawModifyStartLine() const;
virtual s32 getDrawModifyEndLine() const;
#else
virtual void isEnableCursorCache();
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_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();
#ifdef TITEXTDRAWER_IMPLEMENTATION
protected:
const wchar_t* mpDrawString; // 0x50
ViewPort mSavedViewport; // 0x54
f32 mSavedProjection[7]; // 0x6C
nw4r::ut::Rect mProjectionRect; // 0x88
f32 mfVIWidth; // 0x98
bool mbAspect4x3; // 0x9C
bool mbDrawClipped; // 0x9D
s32 muLine; // 0xA0
f32 mfLineSpacing; // 0xA4
f32 mfCharacterSpacing; // 0xA8
f32 mfFontWidth; // 0xAC
f32 mfFontHeight; // 0xB0
f32 mfModifyStartY; // 0xB4
f32 mfMinScrollY; // 0xB8
u32 muDrawStartPos; // 0xBC
u32 muDrawEndPos; // 0xC0
u32 muDrawCacheStartPos; // 0xC4
bool mbSecretMode; // 0xC8
s32 muDrawModifyStartLine; // 0xCC
s32 muDrawModifyEndLine; // 0xD0
s32 muDrawModifyStartPos; // 0xD4
s32 muDrawModifyEndPos; // 0xD8
u32 muCachedStartPos; // 0xDC
u32 muCachedEndPos; // 0xE0
bool mbDrawCache; // 0xE4
f32 mfCachedCursorX; // 0xE8
f32 mfCachedCursorY; // 0xEC
f32 mfDrawScrollY; // 0xF0
s32 mnCachedCursorLine; // 0xF4
CursorPos mCachedCursor; // 0xF8
bool mbCursorCache; // 0x104
bool mbMaintainCursorCache; // 0x105
const wchar_t* mpDrawString;
ViewPort mSavedViewport;
f32 mSavedProjection[7];
nw4r::ut::Rect mProjectionRect;
f32 mfVIWidth;
bool mbAspect4x3;
bool mbDrawClipped;
s32 muLine;
f32 mfLineSpacing;
f32 mfCharacterSpacing;
f32 mfFontWidth;
f32 mfFontHeight;
f32 mfModifyStartY;
f32 mfMinScrollY;
u32 muDrawStartPos;
u32 muDrawEndPos;
u32 muDrawCacheStartPos;
bool mbSecretMode;
s32 muDrawModifyStartLine;
s32 muDrawModifyEndLine;
s32 muDrawModifyStartPos;
s32 muDrawModifyEndPos;
u32 muCachedStartPos;
u32 muCachedEndPos;
bool mbDrawCache;
f32 mfCachedCursorX;
f32 mfCachedCursorY;
f32 mfDrawScrollY;
s32 mnCachedCursorLine;
CursorPos mCachedCursor;
bool mbCursorCache;
bool mbMaintainCursorCache;
#else
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_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) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_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
#endif
};
}
}

View File

@@ -39,6 +39,10 @@ namespace textinput {
f32 y; // 0x08
} Scroll;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
enum HVKCode { HVK_None = 0 };
#endif
class Base {
public :
virtual ~Base() {}
@@ -50,23 +54,28 @@ namespace textinput {
class CommandSender;
class CommandReceiver : public Base {
public:
#ifdef TI_CELLPHONE_IMPLEMENTATION
struct ChangePredictMode;
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
CommandReceiver() { clearSender(); }
virtual ~CommandReceiver();
#endif
#if defined(MYTIINPUTFORM_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
struct Scroll {
bool absY;
f32 x;
f32 y;
};
#endif
typedef enum INPUT_COMMAND {
IC_TRANSLATE_MODE = 6,
INPUT_COMMAND_0 = 0,
INPUT_COMMAND_37 = 37,
} INPUT_COMMAND;
typedef struct Scroll {
bool absY; // 0x00
f32 x; // 0x04
f32 y; // 0x08
} Scroll;
typedef struct ChangePredictMode {
u32 muLanguage; // 0x00
u8 mbPredictOn; // 0x04
} ChangePredictMode;
#if (defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_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);
@@ -80,7 +89,13 @@ namespace textinput {
CommandSender() : mpCommandReceiver(NULL) {}
virtual void setCommandReceiver(CommandReceiver* cmdRecv);
#if (defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_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:
#ifdef TI_TOOLBAR_SAMPLE_CLASS
#if defined(TI_TOOLBAR_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
Base(Manager* manager) : mQwerty(true), meLanguage(USA), mpAllocator(NULL), mpManager(manager) {}
#endif
@@ -35,16 +35,20 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef TI_TOOLBAR_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, arcName, observer), mpEventHandler(NULL),
#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)
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_VK_toolbar_a.brlyt", observer), mpEventHandler(NULL),
mbIsEnableQwertyChg(false) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void draw() override;
virtual void init() override;
virtual void draw() override;
virtual void setQwerty(bool qwerty) override;
virtual void setLanguage(Language language) override;
@@ -52,10 +56,19 @@ namespace textinput {
virtual void onOK();
virtual void onCancel();
virtual void setQwertyWithSE(bool qwerty);
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual bool isEnableKeytopChange() const { return mbIsEnableQwertyChg; }
#else
virtual bool isEnableKeytopChange() const;
#endif
virtual void enableKeytopChange(bool enable);
#ifdef MYTIMANAGER_MATCHING
virtual nw4r::lyt::Pane* getDownArea();
virtual nw4r::lyt::Pane* getUpArea();
#else
virtual nw4r::lyt::Pane* getUpArea();
virtual nw4r::lyt::Pane* getDownArea();
#endif
virtual void setOKButtonVisible(bool visible);
virtual void setCancelButtonVisible(bool visible);
virtual void setOKButtonCaption(const wchar_t* caption);
@@ -117,12 +130,21 @@ namespace textinput {
KeyType meKeyType; // 0x30
};
#ifdef TI_TOOLBAR_SAMPLE_CLASS
#if defined(TI_TOOLBAR_SAMPLE_CLASS) || defined(TIMANAGER_IMPLEMENTATION)
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, const char* arcName, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, arcName, observer) {}
#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,6 +7,9 @@
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);
@@ -17,9 +20,15 @@ namespace textinput {
wchar_t KBD_ConvertSmall(wchar_t ch);
wchar_t KBD_ConvertAll(wchar_t ch);
#ifdef TISTRING_IMPLEMENTATION
u32 KBD_IsDakuten(wchar_t ch);
u32 KBD_IsHandaku(wchar_t ch);
u32 KBD_IsSmall(wchar_t ch);
#else
bool KBD_IsDakuten(wchar_t ch);
bool KBD_IsHandaku(wchar_t ch);
bool KBD_IsSmall(wchar_t ch);
#endif
bool strcmp(const char* s1, const char* s2);
void replaceChar(char* dest, u32 destLen, const char* src, int replaceIdx, char newCh);
@@ -46,10 +55,11 @@ namespace textinput {
public:
Animation() : mfAnimationTime(0.0f), mbInAnimation(false), mbSE(false), mpAnimObserver(NULL) {}
virtual void startAnm(f32, f32, f32, AnimObserver*, void*); // 0x08
void startAnm(AnimObserver* observer, f32 start, f32 end, f32 frame, void* arg) {
startAnm(start, end, frame, observer, arg);
}
#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 calc(); // 0x0C
virtual f32 getValue(); // 0x10
virtual bool isActive(); // 0x14

View File

@@ -20,7 +20,11 @@ namespace gui {
class Manager;
class EventHandler;
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
class __declspec(novtable) Interface {
#else
class Interface {
#endif
public:
virtual void create() {} // 0x08 (0x02)
@@ -30,14 +34,14 @@ namespace gui {
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
virtual void draw() {} // 0x18 (0x06)
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~Interface(); // 0x1C (0x07)
#else
virtual ~Interface() {} // 0x1C (0x07)
#endif
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
class __declspec(novtable) EventHandler {
#else
class EventHandler {

View File

@@ -24,7 +24,7 @@ namespace ipl {
mbDisableCon(bDisableCon) {}
#endif
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~PaneManager();
#else
virtual ~PaneManager() {}

View File

@@ -69,7 +69,7 @@ namespace ipl {
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const T& start, const T& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
void init(const T& start, const T& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
T get() const {
f32 var_f27 = mFrame;
@@ -81,11 +81,11 @@ namespace ipl {
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(unkVal0 *
(mStartTangent *
(var_f27 +
((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
@@ -101,7 +101,7 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
@@ -109,8 +109,8 @@ namespace ipl {
protected:
T mStart;
T mEnd;
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
template <>
@@ -119,7 +119,7 @@ namespace ipl {
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const f32& start, const f32& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD,
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD,
f32 speed = 1.0f);
f32 get() const {
@@ -132,10 +132,10 @@ namespace ipl {
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(unkVal0 *
(mStartTangent *
(var_f27 + ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
@@ -144,8 +144,8 @@ namespace ipl {
protected:
f32 mStart;
f32 mEnd;
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
#pragma dont_instantiate HermiteIntp<float>
@@ -155,12 +155,12 @@ namespace ipl {
public:
HermiteIntp() {}
void init(const T& start, const T& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f) {
void init(const T& start, const T& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
utility::FrameController::init(playback, maxFrame, 0.0f, speed);
unkVal0 = param_5;
unkVal1 = param_6;
mStartTangent = startTangent;
mEndTangent = endTangent;
}
#ifdef IPL_SD_CHANNEL_SELECT_CPP
@@ -176,9 +176,9 @@ namespace ipl {
inverseDuration * (inverseDuration * (3.0f * frame * frame))));
f32 frameSquared = frame * frame;
f32 cubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangent = unkVal0 * (frame + (cubic -
f32 tangent = mStartTangent * (frame + (cubic -
inverseDuration * (2.0f * frame * frame))) +
unkVal1 * (cubic - inverseDuration * frameSquared);
mEndTangent * (cubic - inverseDuration * frameSquared);
result.x += tangent;
result.y += tangent;
result.z += tangent;
@@ -196,7 +196,7 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
@@ -213,15 +213,55 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
#endif
protected:
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
} // namespace math
} // namespace ipl
#include "math/iplMathTypes.h"
namespace ipl {
namespace math {
template <>
class HermiteIntp<VEC3> : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const VEC3& start, const VEC3& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
VEC3 get() const {
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
VEC3 result =
(mStart * (1.0f + (inverseDuration * (inverseDuration *
(inverseDuration * (frame * (2.0f * frame * frame)))) -
inverseDuration * (inverseDuration * (3.0f * frame * frame))))) -
(mEnd * (inverseDuration * (inverseDuration *
(inverseDuration * (frame * (2.0f * frame * frame)))) -
inverseDuration * (inverseDuration * (3.0f * frame * frame))));
f32 frameSquared = frame * frame;
f32 cubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangent = mStartTangent * (frame + (cubic -
inverseDuration * (2.0f * frame * frame))) +
mEndTangent * (cubic - inverseDuration * frameSquared);
result.x += tangent;
result.y += tangent;
result.z += tangent;
return result;
}
protected:
VEC3 mStart;
VEC3 mEnd;
f32 mStartTangent;
f32 mEndTangent;
};
#endif

View File

@@ -162,14 +162,14 @@ namespace ipl {
class {
public:
void init() {
unk_0x0C = -1;
mAngleIdx = -1;
pos.x = 0.0f;
pos.y = 0.0f;
}
math::VEC2 pos; // pos
int unk_0x08;
int unk_0x0C;
int mStep;
int mAngleIdx;
} mStandData; // 0xE4
picture mPicture; // 0xF4

View File

@@ -309,8 +309,8 @@ namespace ipl {
return mbArrowVisible[i];
}
void setUnk_0x105(bool flag) {
unk_0x105 = flag;
void setSuppressNewMailAnm(bool flag) {
mbSuppressNewMailAnm = flag;
}
protected:
@@ -354,7 +354,7 @@ namespace ipl {
ANIM_MAX,
};
int unk_0x54;
int mAnimWait;
layout::Object* mpLayout; // 0x58
nand::LayoutFile* mpLayoutFile; // 0x5C
@@ -373,8 +373,8 @@ namespace ipl {
BOOL mbHovered[BTN_MAX]; // 0xD8
bool unk_0x104;
bool unk_0x105;
bool mbNewMailAnm;
bool mbSuppressNewMailAnm;
utility::timer mTimer; // 0x108
bool mbEnabled; // 0x110

View File

@@ -95,9 +95,9 @@ namespace ipl {
public:
nw4r::ut::List mDateList; // 0x84
nw4r::ut::List unk_0x90;
nw4r::ut::List mDrawList;
bool mbScrolling; // 0x9C
vBOOL unk_0xA0;
vBOOL mbSearchTaskRunning;
BOOL mbTaskCanceled; // 0xA4
vBOOL mbBackToBoardAlt; // 0xA8
bool mbAsian; // 0xAC

View File

@@ -68,8 +68,8 @@ namespace ipl {
vBOOL mbAppearMsg; // 0x0C
private:
u32 unk_0x10;
int unk_0x14;
u32 mFocusState;
int mPendingFocusCmd;
layout::Object* mpLayout; // 0x18
gui::PaneManager* mpGui; // 0x1C
layout::PaneAnimator* mpCurrentPaneAnim; // 0x20
@@ -77,7 +77,7 @@ namespace ipl {
public:
utility::Date* mpDate; // 0x38
u32 unk_0x3C;
u32 mPointCount;
static const char* mscAnimPanes[ANIM_PANE_MAX];

View File

@@ -293,8 +293,8 @@ namespace ipl {
LOCKED_DIALOG_ANIM_MAX,
};
static void iplChannelTitle_813BA684(void* work);
static void iplChannelTitle_813BA784(void* work);
static void markTmdReadyTask(void* work);
static void deleteTmpTitleContentTask(void* work);
static void getTmdTask(void* work);
static void getTicketLimitTask(void* work);
static BOOL isTimeLimitedTicket(ESTicketView * ticket, u32* remainTime = NULL);

View File

@@ -8,7 +8,7 @@
namespace ipl {
namespace scene {
class GCWindow : public MemoryBase, public MemCardEventHandler {
class GCWindow : public MemoryBase, public MemCardEventListener {
#ifdef IPL_MEMORY_CARD_CPP
friend class MemoryCard;
#endif
@@ -48,6 +48,25 @@ private:
void set_texture(const char*, const GXTexObj&);
public:
virtual void onMemEvent(long, u8);
#ifdef IPL_GC_WINDOW_CPP
virtual void on_wait_anim() = 0;
virtual void on_exit() = 0;
virtual void on_error() = 0;
virtual void on_format() = 0;
virtual void on_dialog_result() = 0;
virtual void on_select_in() = 0;
virtual void on_message_done() = 0;
virtual void on_button_trig() = 0;
#else
virtual void on_wait_anim();
virtual void on_exit();
virtual void on_error();
virtual void on_format();
virtual void on_dialog_result();
virtual void on_select_in();
virtual void on_message_done();
virtual void on_button_trig();
#endif
bool isProcess();
void stop_wait_anim();

View File

@@ -35,7 +35,11 @@ namespace ipl {
MemoryBase* mpBase; // 0x0C
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
class __declspec(novtable) MemoryBase {
#else
class MemoryBase {
#endif
public:
class Anm {
public:

View File

@@ -12,13 +12,61 @@
namespace ipl {
namespace scene {
class MemCardEventHandler {
class __declspec(novtable) MemCardEventListener {
public:
MemCardEventListener() {}
virtual ~MemCardEventListener() {}
virtual void onMemEvent(long event, u8 slot);
};
class MemCardEventHandler : public MemCardEventListener {
public:
MemCardEventHandler() {}
virtual ~MemCardEventHandler();
virtual void onMemEvent(long event, u8 slot);
virtual void onMount(u8 slot) = 0;
virtual void onUnmount(u8 slot) = 0;
virtual void onAttach(u8 slot) = 0;
virtual void onDetach(u8 slot) = 0;
virtual void onCheck(u8 slot) = 0;
virtual void onFormat(u8 slot) = 0;
virtual void onRepair(u8 slot) = 0;
virtual void onRead(u8 slot) = 0;
virtual void onWrite(u8 slot) = 0;
virtual void onOpen(u8 slot) = 0;
virtual void onClose(u8 slot) = 0;
virtual void onCreate(u8 slot) = 0;
virtual void onDelete(u8 slot) = 0;
virtual void onCopy(u8 slot) = 0;
virtual void onMove(u8 slot) = 0;
virtual void onRename(u8 slot) = 0;
virtual void onVerify(u8 slot) = 0;
virtual void onCommit(u8 slot) = 0;
virtual void onProbe(u8 slot) = 0;
virtual void onMountAsync(u8 slot) = 0;
virtual void onUnmountAsync(u8 slot) = 0;
virtual void onCheckAsync(u8 slot) = 0;
virtual void onFormatAsync(u8 slot) = 0;
virtual void onReadAsync(u8 slot) = 0;
virtual void onWriteAsync(u8 slot) = 0;
virtual void onCreateAsync(u8 slot) = 0;
virtual void onDeleteAsync(u8 slot) = 0;
virtual void onCopyAsync(u8 slot) = 0;
virtual void onMoveAsync(u8 slot) = 0;
virtual void onRenameAsync(u8 slot) = 0;
virtual void onVerifyAsync(u8 slot) = 0;
virtual void onCommitAsync(u8 slot) = 0;
virtual void onProbeAsync(u8 slot) = 0;
virtual void onFreeBlocks(u8 slot) = 0;
virtual void onGetLength(u8 slot) = 0;
virtual void onSetAttrib(u8 slot) = 0;
virtual void onGetAttrib(u8 slot) = 0;
virtual void onSlotStatus(u8 slot) = 0;
};
typedef struct MCFile {
@@ -56,6 +104,44 @@ namespace ipl {
}
virtual ~MemoryCardManager();
virtual void onMount(u8 slot) = 0;
virtual void onUnmount(u8 slot) = 0;
virtual void onAttach(u8 slot) = 0;
virtual void onDetach(u8 slot) = 0;
virtual void onCheck(u8 slot) = 0;
virtual void onFormat(u8 slot) = 0;
virtual void onRepair(u8 slot) = 0;
virtual void onRead(u8 slot) = 0;
virtual void onWrite(u8 slot) = 0;
virtual void onOpen(u8 slot) = 0;
virtual void onClose(u8 slot) = 0;
virtual void onCreate(u8 slot) = 0;
virtual void onDelete(u8 slot) = 0;
virtual void onCopy(u8 slot) = 0;
virtual void onMove(u8 slot) = 0;
virtual void onRename(u8 slot) = 0;
virtual void onVerify(u8 slot) = 0;
virtual void onCommit(u8 slot) = 0;
virtual void onProbe(u8 slot) = 0;
virtual void onMountAsync(u8 slot) = 0;
virtual void onUnmountAsync(u8 slot) = 0;
virtual void onCheckAsync(u8 slot) = 0;
virtual void onFormatAsync(u8 slot) = 0;
virtual void onReadAsync(u8 slot) = 0;
virtual void onWriteAsync(u8 slot) = 0;
virtual void onCreateAsync(u8 slot) = 0;
virtual void onDeleteAsync(u8 slot) = 0;
virtual void onCopyAsync(u8 slot) = 0;
virtual void onMoveAsync(u8 slot) = 0;
virtual void onRenameAsync(u8 slot) = 0;
virtual void onVerifyAsync(u8 slot) = 0;
virtual void onCommitAsync(u8 slot) = 0;
virtual void onProbeAsync(u8 slot) = 0;
virtual void onFreeBlocks(u8 slot) = 0;
virtual void onGetLength(u8 slot) = 0;
virtual void onSetAttrib(u8 slot) = 0;
virtual void onGetAttrib(u8 slot) = 0;
void calc();
bool isSlotReady(u8 slot);
@@ -96,7 +182,7 @@ namespace ipl {
u16 getFreeBlocks(u8 slot);
#endif
void setEventHandler(MemCardEventHandler* eventHandler) {
void setEventHandler(MemCardEventListener* eventHandler) {
mpEventHandler = eventHandler;
}
@@ -107,7 +193,7 @@ namespace ipl {
s32 mLastResult; // 0x16930
s32 mLastCmd; // 0x16934
u32 unk_0x16938; // 0x16938
MemCardEventHandler* mpEventHandler; // 0x1693C
MemCardEventListener* mpEventHandler; // 0x1693C
};
} // namespace scene
} // namespace ipl

View File

@@ -81,22 +81,22 @@ namespace ipl {
void* mpThumbnailData;
NandSDWorker::SDAppMetaEntry mAppMeta;
};
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
extern "C" void iplSDChannelObj_activateIfIdle(SDChannelObj* channel);
extern "C" void iplSDChannelObj_setHeaps(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);
extern "C" void iplSDChannelObj_calc(SDChannelObj* channel);
extern "C" void iplSDChannelObj_drawBase(SDChannelObj* channel);
extern "C" void iplSDChannelObj_playPageHide(SDChannelObj* channel);
extern "C" void iplSDChannelObj_setPane(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_setLayoutFile(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_drawPage(SDChannelObj* channel);
extern "C" void iplSDChannelObj_drawDialog(SDChannelObj* channel);
extern "C" void iplSDChannelObj_startAppear(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_startDisappear(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_setSelected(SDChannelObj* channel, bool selected);
extern "C" void iplSDChannelObj_resetPageAnim(SDChannelObj* channel, int enabled);
extern "C" void* iplSDChannelObj_getOrAllocThumbnailData(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_hasAppMeta(SDChannelObj* channel);
union SDChannelSelectCommandArguments {
u32 values[3];
@@ -395,9 +395,9 @@ namespace ipl {
NandSDWorker* mpSDWorker;
ESTitleId32* mpSDTitleIds;
SDChannelSelectTitleInfo* mpSDTitleInfo;
NandSDWorker::TitleUsage* mpNandTitleInfo;
s32 mFirstTitleCount;
s32 mSecondTitleCount;
mutable NandSDWorker::TitleUsage* mpNandTitleInfo;
mutable s32 mFirstTitleCount;
mutable s32 mSecondTitleCount;
SDChannelObj* mpCurrentLoadedChannel;
u32 mSDTitleCount;
u32 mNandTitleCount;

View File

@@ -167,12 +167,12 @@ namespace ipl {
bool is_stopped_all_anm() const;
void fn_81409864();
void calc_exit_sequence();
void fn_814098F4();
void fn_unk_inline();
void fn_81409988();
void fn_814099EC();
void prepare_exit_abort();
void wait_decide_se();
void start_exit_fade();
void finish_exit_reboot();
int mState; // 0x60
int mPrevState; // 0x64

View File

@@ -14,8 +14,8 @@ namespace ipl {
WAIT_UNTIL_FADE_IN = 15
};
TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const ipl::math::VEC3& unk2,
f32 unk3 = 120.0f, f32 unk4 = 30.0f);
TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const ipl::math::VEC3& initialPos,
f32 margin16x9 = 120.0f, f32 margin4x3 = 30.0f);
~TextBalloon();
void calc();
@@ -31,7 +31,7 @@ namespace ipl {
void fadeout();
void fadeoutForce();
void setPos(const math::VEC3& pos, bool unk0, int unk1);
void setPos(const math::VEC3& pos, bool use16x9X, int hAlign);
void updatePos(const math::VEC3& pos);
void set_translate(const math::VEC3& trans);
@@ -50,7 +50,7 @@ namespace ipl {
undefined4 unk_0x00;
undefined4 unk_0x04;
BOOL unk_0x08;
BOOL mbWaitingFadeIn; // 0x08
layout::Object* mpLayout; // 0x0C
@@ -60,10 +60,10 @@ namespace ipl {
u32 mTextLen; // 0x18
math::VEC3 mBalloonPos; // 0x1C
undefined4 unk_0x28;
undefined unk_0x2C;
f32 unk_0x30;
f32 unk_0x34;
undefined4 mHAlign; // 0x28
undefined mbUse16x9X; // 0x2C
f32 mMargin16x9; // 0x30
f32 mMargin4x3; // 0x34
int mWaitUntilFadeIn; // 0x38

View File

@@ -42,7 +42,7 @@ namespace ipl {
};
virtual BOOL isResetAcceptable() const {
return unk_0x7D;
return mbResetAcceptable;
}
virtual void prepare();
@@ -108,7 +108,7 @@ namespace ipl {
static const int mToFace_Duration = 20;
bool mbClosing; // 0x7C
bool unk_0x7D;
bool mbResetAcceptable;
wchar_t* mWCString; // 0x80

View File

@@ -38,21 +38,49 @@ namespace ipl {
int holdSE(const char* sndName);
int holdSEwithPosDis(const char* sndName, f32 x, f32 y);
#ifdef IPL_SOUND_MATCHING
void stopBGM(int unk = 0);
#else
int stopBGM(int unk = 0);
#endif
int stopBGM(nw4r::snd::SoundHandle* handle, int unk = 0);
int stopSE(nw4r::snd::SoundHandle* handle, int unk = 0);
void stopAllSound(int unk = 0);
int resetAllSound();
#ifdef IPL_SOUND_MATCHING
void muteOffBGM(int);
#else
int muteOffBGM(int);
#endif
#ifdef IPL_SOUND_MATCHING
void muteOnBGM(int);
#else
int muteOnBGM(int);
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOnBGM();
#else
int pauseOnBGM();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOffBGM();
#else
int pauseOffBGM();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOnSE();
#else
int pauseOnSE();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOffSE();
#else
int pauseOffSE();
#endif
void setOutputMode(EAudioOutputMode mode);

View File

@@ -39,7 +39,7 @@ namespace ipl {
void stt_wait_fns_msg();
void stt_wait_terminate();
int fn_8135B1C0();
int getProgressPercent();
void error_handling();

View File

@@ -336,19 +336,19 @@ namespace ipl {
BOOL nand_error_handling(int code);
SEntry* fn_8133A4E0(ESTitleId titleId);
u32 fn_8133A57C(ESTitleId titleId);
u32 fn_8133A5B8(ESTitleId titleId);
BOOL fn_8133A5F0(ESTitleId titleId);
BOOL fn_8133A634(ESTitleId titleId);
BOOL fn_8133A678(ESTitleId titleId);
BOOL fn_8133A6B8(ESTitleId titleId);
BOOL fn_8133A73C(ESTitleId titleId);
nand::MetaFile* fn_8133A7A4(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* fn_8133A85C(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* fn_8133A924(EGG::Heap* heap, ESTitleId titleId);
void fn_8133A9F0();
void fn_8133AA50(ESTitleId titleId);
SEntry* findEntryByTitleId(ESTitleId titleId);
u32 getBannerCSIdx(ESTitleId titleId);
u32 getSoundSize(ESTitleId titleId);
BOOL needsNetSetting(ESTitleId titleId);
BOOL usesAltSound(ESTitleId titleId);
BOOL isMissingTicket(ESTitleId titleId);
BOOL isNewsChannelV6Plus(ESTitleId titleId);
BOOL isOperaChannel(ESTitleId titleId);
nand::MetaFile* readBannerMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* readSoundMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* readBannerCSAsync(EGG::Heap* heap, ESTitleId titleId);
void clearTmpChannel();
void unloadBanner(ESTitleId titleId);
BOOL isReady() { return mState == FINISH; }

View File

@@ -16,7 +16,7 @@ namespace ipl {
virtual void onSE(textinput::sound::SE seId);
virtual void onOK();
virtual void onCancel();
virtual void setManager(Manager* manager);
virtual void setManager(Manager* manager) { mpKeyboardMgr = manager; }
private:
Manager* mpKeyboardMgr; // 0x04

View File

@@ -92,7 +92,7 @@ namespace ipl {
void read_sd_app_location_async(ESTitleId32* titleIds);
void check_for_sd_app_to_nand_async(ESTitleId titleId, AppBlocksInfo* usedBlocks, AppBlocksInfo* freeBlocks);
void check_backup_fits_async(TitleIdList* newTitles, TitleIdList* replacingTitles);
void iplNandSD_81348EA8(void* ptrA, void* ptrB, void* ptrC);
void check_sd_app_titles_async(void* ptrA, void* ptrB, void* ptrC);
void list_nand_apps_usage_async(void* ptrA, void* ptr);
@@ -152,7 +152,7 @@ namespace ipl {
BOOL is_working();
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void requestCancel() { unk_0x04 = true; }
void requestCancel() { mbCancel = true; }
#endif
WIISaveBannerFile* get_cached_nand_save_banner(ESTitleId titleId);
@@ -514,7 +514,7 @@ namespace ipl {
void do_check_for_sd_app_to_nand();
void check_backup_fits();
void do_list_nand_apps_usage();
void do_unk_8134C838();
void do_check_sd_app_titles();
void do_move_nand_app_to_sd();
void do_move_sd_app_to_nand();
@@ -531,7 +531,7 @@ namespace ipl {
static void wad_backup_progress_callback(u32 completed, u32 total, BOOL done);
Work* myWork; // 0x00
bool unk_0x04; // 0x04
bool mbCancel; // 0x04
static const char* c_banner_file_name;
static const char* c_nocopy_folder_name;

View File

@@ -24,7 +24,19 @@ namespace ipl {
class Manager;
}
namespace savedata {
extern "C" BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
extern "C" BOOL isTitleCached(void* manager, ESTitleId titleId);
struct ChannelSlot {
u8 valid; // 0x00 (primaryType)
u8 pad[3]; // 0x01
s32 titleId; // 0x04 (sceneID)
u8 rest[8]; // 0x08
};
struct ChannelPage {
u8 pad[0x30];
ChannelSlot slots[MAX_CHANNEL_INDEX]; // 0x30
};
class Manager {
public:
@@ -87,7 +99,7 @@ namespace ipl {
channel::SInfo& getChanInfo(int page, int index) { return mData.chanInfo[page][index]; }
textinput::extend::savedata::MemoSetting getMemoSetting() { return mData.memoSetting; }
void iplSavedata_813596B8(ESTitleId titleId);
void pushTitleCache(ESTitleId titleId);
private:
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
@@ -184,7 +196,7 @@ namespace ipl {
u8 unused_0x504[28];
friend class channel::Manager;
friend BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
friend BOOL isTitleCached(void* manager, ESTitleId titleId);
};
} // namespace savedata
} // namespace ipl

View File

@@ -48,10 +48,14 @@ namespace EGG {
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, u32 id) { return mSoundArchivePlayer.PrepareSound(pHandle, id); } // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, unsigned int id) { return mSoundArchivePlayer.PrepareSound(pHandle, id); } // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, const char* pName) {
#ifdef IPL_SOUND_MATCHING
u32 id = changeNameToId(pName);
#else
u32 id = nw4r::snd::SoundArchive::INVALID_ID;
if (mpArchive != NULL) {
id = changeNameToId(pName);
}
#endif
return mSoundArchivePlayer.PrepareSound(pHandle, id);
} // 0x48

View File

@@ -20,9 +20,13 @@ namespace EGG {
~SoundHeapMgr() { destroySoundHeap(); }
virtual bool loadState(s32 id) {
#ifdef IPL_SOUND_MATCHING
if (id > 0 && mHeap.GetCurrentLevel() >= id) {
#else
s32 level = mHeap.GetCurrentLevel();
if (id > 0 && level >= id) {
#endif
mHeap.LoadState(id);
return true;
}

View File

@@ -17,7 +17,6 @@ namespace nw4r {
class FontRefLink {
public:
FontRefLink();
~FontRefLink();
void Set(const char* name, ut::Font* pFont);

View File

@@ -11,7 +11,11 @@ namespace nw4r {
namespace snd {
class SoundHandle : private ut::NonCopyable {
public:
#ifdef IPL_SOUND_MATCHING
SoundHandle() NO_INLINE;
#else
SoundHandle() NO_INLINE : mSound(NULL) {}
#endif
~SoundHandle() { DetachSound(); }
void detail_AttachSound(detail::BasicSound* sound);

View File

@@ -31,7 +31,14 @@ namespace nw4r {
ut::detail::AutoLock<OSMutex> lock(mMutex);
return mFrameHeap.SaveState();
}
#ifdef IPL_SOUND_MATCHING
void LoadState(int id) {
ut::detail::AutoLock<OSMutex> lock(mMutex);
mFrameHeap.LoadState(id);
}
#else
void LoadState(int id);
#endif
bool IsValid() { return mFrameHeap.IsValid(); }

View File

@@ -20,7 +20,7 @@ namespace nw4r {
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#endif
#ifndef IPL_CONTROLLER_TRIVIAL_RECT_DTOR
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP)
~Rect() {}
#endif

View File

@@ -37,7 +37,7 @@ namespace nw4r {
} // namespace detail
template <typename TDerived, typename TBase>
#ifdef IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST
#if defined(IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST) || defined(IPL_MEMORYCARD_BASE_CPP)
TDerived DynamicCast(TBase* pPtr);
#else
inline TDerived DynamicCast(TBase* pPtr) {

View File

@@ -301,9 +301,9 @@ namespace nw4r {
}
if (error == OS_EXCEPTION_FLOATING_POINT_EXCEPTION) {
u32 uVar1 = sException.FPCSR_COPY;
uVar1 &= (((uVar1 & 0xf8) << 0x16) | 0x01f80700);
if ((uVar1 & 0x20000000) != 0) {
u32 fpcsr = sException.FPCSR_COPY;
fpcsr &= (((fpcsr & 0xf8) << 0x16) | 0x01f80700);
if ((fpcsr & 0x20000000) != 0) {
Exception_Printf_(" FPE: Invalid operation\n");
if ((sException.FPCSR_COPY & 0x1000000) != 0) {
Exception_Printf_(" SNaN\n");
@@ -333,16 +333,16 @@ namespace nw4r {
Exception_Printf_(" Invalid integer convert\n");
}
}
if ((uVar1 & 0x10000000) != 0) {
if ((fpcsr & 0x10000000) != 0) {
Exception_Printf_(" FPE: Overflow\n");
}
if ((uVar1 & 0x8000000) != 0) {
if ((fpcsr & 0x8000000) != 0) {
Exception_Printf_(" FPE: Underflow\n");
}
if ((uVar1 & 0x4000000) != 0) {
if ((fpcsr & 0x4000000) != 0) {
Exception_Printf_(" FPE: Zero division\n");
}
if ((uVar1 & 0x2000000) != 0) {
if ((fpcsr & 0x2000000) != 0) {
Exception_Printf_(" FPE: Inexact result\n");
}
}

View File

@@ -1,19 +1,19 @@
#include <nw4r/db/assert.h>
extern "C" const u8 lbl_81695550 = 255;
extern "C" const u8 lbl_81695551 = 255;
extern "C" const u8 lbl_81695552 = 255;
extern "C" const u8 lbl_81695553 = 0;
extern "C" char lbl_816719DC[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
extern "C" const u8 scLytFatalColorR = 255;
extern "C" const u8 scLytFatalColorG = 255;
extern "C" const u8 scLytFatalColorB = 255;
extern "C" const u8 scLytFatalColorA = 0;
extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
#undef NW4R_ASSERT
#define NW4R_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {*((volatile const u8*)&::lbl_81695550), *((volatile const u8*)&::lbl_81695551), \
*((volatile const u8*)&::lbl_81695552), *((volatile const u8*)&::lbl_81695553)}; \
GXColor front = {*((volatile const u8*)&::scLytFatalColorR), *((volatile const u8*)&::scLytFatalColorG), \
*((volatile const u8*)&::scLytFatalColorB), *((volatile const u8*)&::scLytFatalColorA)}; \
GXColor back = {0, 0, 0, 0}; \
OSFatal((GXColor)front, (GXColor)back, ::lbl_816719DC); \
OSFatal((GXColor)front, (GXColor)back, ::scLytFatalMsg); \
} \
}

View File

@@ -64,8 +64,8 @@ typedef struct {
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 unk_0x14;
u8 unk_0x18;
u8 unk_0x19;
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
u8 scanCompCount; // 0x1B
u8 blockCount[4]; // 0x1C
@@ -143,8 +143,8 @@ struct TMCCJPEGDecWork_t {
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 unk_0x1804;
u8 unk_0x1808;
u8 unk_0x1809;
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A
u8 scanCompCount; // 0x180B
u8 blockCount[4]; // 0x180C

View File

@@ -17,7 +17,96 @@ static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
return limit;
}
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
const TMCHuffmanEntry* entry;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
bitData = work->bitBuf;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry = table + 9;
goto read_entry;
while (1) {
length++;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
bitData = work->bitBuf;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry += 9;
goto read_entry;
while (1) {
length++;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry acEntry;
const TMCHuffmanEntry* ac_fast;
u8* huff_sym;
u32* huff_tbl;
@@ -49,7 +138,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
tmp = bit_pos - 8;
tmp = ((bit_data >> tmp) & 0xFF) << 2;
{
TMCHuffmanEntry dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
@@ -59,68 +148,11 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
work->bitCount = bit_pos;
r = extra;
} else {
s32 dcResult;
u32 code;
unsigned int i;
const TMCHuffmanEntry* entry;
s32 thresh;
s32 offs;
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
if (bit_pos <= 17) {
dcResult = TMCJPEGDEC_load_buff(work);
if (dcResult < 0) {
goto dc_end;
}
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (const TMCHuffmanEntry*)huff_tbl + 9;
goto dc_entry;
while (1) {
i++;
entry++;
if (i > 16) {
dcResult = TMCC_ERROR_OVERFLOW;
goto dc_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
dc_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
thresh = decoded.bitLength;
offs = entry->symbol;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry->bitLength + offs;
dcResult = huff_sym[code & 0xFF];
break;
}
dc_end:
r = dcResult;
if (dcResult < 0) {
return dcResult;
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
}
@@ -132,8 +164,8 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
if (load_ret < 0) {
return load_ret;
}
bit_pos = work->bitCount;
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = 1 << r;
extra = tmp - 1;
@@ -149,7 +181,6 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
TMCHuffmanEntry acEntry;
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
@@ -170,7 +201,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
t = bit_pos - 8;
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
while (idx < 64) {
do {
s32 ac_thresh = acEntry.bitLength;
if (ac_thresh != 0) {
bit_pos = work->bitCount;
@@ -178,62 +209,8 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
work->bitCount = bit_pos;
r = acEntry.symbol;
} else {
u32 code;
unsigned int i;
const TMCHuffmanEntry* entry;
s32 thresh;
s32 offs;
bit_pos = work->bitCount;
if (bit_pos <= 17) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
}
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (const TMCHuffmanEntry*)huff_tbl + 9;
goto ac_entry_huff;
while (1) {
i++;
entry++;
if (i > 16) {
r = TMCC_ERROR_OVERFLOW;
goto ac_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
ac_entry_huff:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
thresh = decoded.bitLength;
offs = entry->symbol;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry->bitLength + offs;
r = huff_sym[code & 0xFF];
break;
}
ac_end:
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
@@ -256,8 +233,8 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
}
bit_pos = work->bitCount;
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
@@ -265,14 +242,14 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
work->bitCount = bit_pos;
t = bit_pos - 8;
extra = extra & (bit_data >> bit_pos);
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
}
q = ((s32*)conv_row_ptr)[zz];
block[zz] = extra * q;
block[(u8)zz] = extra * q;
idx++;
} else {
@@ -294,7 +271,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
idx += 16;
}
}
} while (idx < 64);
if (idx > 64) {
return TMCC_ERROR_OVERFLOW;

View File

@@ -1,7 +1,7 @@
#include <tmc_jpeg_internal.h>
static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work);
static s32 TMCJPEG_814EB108(TMCCJPEGDecWork* work);
static s32 refillJpegBufferAfterFF(TMCCJPEGDecWork* work);
static s32 refillJpegBuffer(TMCCJPEGDecWork* work);
s32 TMCJPEGDEC_init_ptr_buff(TMCCJPEGDecWork* work, void* param) {
u32 readSize;
@@ -52,7 +52,7 @@ s32 TMCJPEGDEC_get_byte(u8* dst, TMCCJPEGDecWork* work) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
s32 r = TMCJPEG_814EB108(work);
s32 r = refillJpegBuffer(work);
if (r < 0) {
return r;
}
@@ -69,7 +69,7 @@ s32 TMCJPEGDEC_get_byte(u8* dst, TMCCJPEGDecWork* work) {
if (cur >= work->pBufEnd) {
if (work->remaining != 0) {
s32 r = TMCJPEG_814EB108(work);
s32 r = refillJpegBuffer(work);
if (r < 0) {
return r;
}
@@ -92,7 +92,7 @@ s32 TMCJPEGDEC_get_wbyte(u16* dst, TMCCJPEGDecWork* work) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0) {
goto br;
} else {
@@ -119,7 +119,7 @@ s32 TMCJPEGDEC_get_wbyte(u16* dst, TMCCJPEGDecWork* work) {
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto o1;
}
@@ -144,7 +144,7 @@ p2:
goto r2;
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0)
goto ez;
else {
@@ -166,7 +166,7 @@ r2:
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0)
goto ez;
else {
@@ -193,7 +193,7 @@ s32 TMCJPEGDEC_get_sbyte(u8* dst, u32 count, TMCCJPEGDecWork* work) {
for (i = 0; i < count; i++) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0) {
goto copy_byte;
} else {
@@ -214,7 +214,7 @@ s32 TMCJPEGDEC_get_sbyte(u8* dst, u32 count, TMCCJPEGDecWork* work) {
goto r0;
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto r0;
}
@@ -251,7 +251,7 @@ lp:
if (work->remaining == 0) {
goto er1;
}
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto lc;
}
@@ -271,7 +271,7 @@ lc:
if (work->remaining == 0) {
goto er2;
}
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto ret0;
}
@@ -320,7 +320,7 @@ s32 TMCJPEGDEC_load_buff(TMCCJPEGDecWork* work) {
if (work->remaining == 0) {
break;
}
r = TMCJPEG_814EAF50(work);
r = refillJpegBufferAfterFF(work);
if (r < 0) {
return r;
}
@@ -345,7 +345,7 @@ s32 TMCJPEGDEC_load_buff(TMCCJPEGDecWork* work) {
if (work->remaining == 0) {
break;
}
r = TMCJPEG_814EAF50(work);
r = refillJpegBufferAfterFF(work);
if (r < 0) {
return r;
}
@@ -364,7 +364,7 @@ s32 TMCJPEGDEC_chk_possible_size(TMCCJPEGDecWork* work) {
return work->pBufEnd - work->pBufCur;
}
static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work) {
static s32 refillJpegBufferAfterFF(TMCCJPEGDecWork* work) {
u8 marker;
u32 readSize;
u8* dest;
@@ -410,7 +410,7 @@ static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work) {
return 0;
}
static s32 TMCJPEG_814EB108(TMCCJPEGDecWork* work) {
static s32 refillJpegBuffer(TMCCJPEGDecWork* work) {
u8* end;
u32 i, j;
s32 readSize;

View File

@@ -1,30 +1,28 @@
#include <string.h>
#include <tmc_jpeg_internal.h>
static u8 clampU8(s32 v) {
static s32 clampU8(s32 v) {
s32 ok;
ok = 0;
if (v < 256 && v > -1) {
ok = 1;
}
return ok ? v : 255 & ~(v >> 31);
return ok ? v : (v < 0 ? 0 : 255);
}
static s8 clampS8(s32 v) {
static s32 clampS8(s32 v) {
s32 inRange = 0;
if (v < 128 && v > -129) {
inRange = 1;
}
return inRange ? (s8)v : (v > 0) ? 127 : -128;
return inRange ? v : (v > 0) ? 127 : -128;
}
static s32 scalingClampU8(s32 val) {
s32 result;
if (val >> 19 != 0)
result = ~(val >> 31) & 0xFF;
else
result = (val >> 11);
return result;
static s32 scalingClampU8(s32 value) {
if ((value >> 19) == 0) {
return value >> 11;
}
return value < 0 ? 0 : 255;
}
void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
@@ -33,13 +31,35 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
s32 done;
s32 iter;
s32 i;
s32 b1, b2, b3, b4, b5, b6, b7;
s32 v, e, a, d, n, o, p, q, t, u, w, x, y;
s32 x_factor, z_factor, m_part, p_part;
s32 r, z, m;
s32 e;
s32 b2;
s32 b3;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 v;
s32 m;
s32 a;
s32 d;
s32 z;
s32 o;
s32 p;
s32 p_part;
s32 t;
s32 u;
s32 r;
s32 n;
s32 y;
s32 x_factor;
s32 z_factor;
s32 m_part;
s32 q;
s32 w;
s32 x;
s32 b1;
r = (zigzag >> 4) * 8;
iter = (u32)(r + 7) >> 3;
dst = tmp;
done = 0;
{
@@ -71,28 +91,41 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
dst[1] = val;
dst[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = block[0] - b4;
d = block[0] + b4;
u = t + (b6 + b2);
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
y = d - u;
z_factor = (b5 - b3) + (b1 - b7);
m_part = (b1 - b7) * 0x14E >> 8;
p_part = (b5 - b3) * 0x8B >> 8;
s32 oddLowSum;
s32 oddHighSum;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
b5 = b5 - b3;
oddHighSum = b1 + b7;
b1 = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = b5 + b1;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = t + u;
v = a + t;
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = b1 * 0x14E >> 8;
e = a - t;
m = m_part - z;
n = (b1 + b7) + ((b5 + b3) + m);
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
p = z + p_part;
q = x + p;
dst[0] = w + n;
p_part = b5 * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;
p = z + p_part;
q = p + x;
dst[6] = v - o;
dst[2] = e + q;
dst[5] = e - q;
@@ -145,25 +178,37 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
out[pitch] = val;
out[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = (*dst + 0x40000) - b4;
d = (*dst + 0x40000) + b4;
u = t + (b6 + b2);
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
s32 oddLowSum;
s32 oddHighSum;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
b5 = b5 - b3;
oddHighSum = b1 + b7;
b1 = b1 - b7;
u = b6 + b2;
b2 = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = b5 + b1;
dcValue = *dst + 0x40000;
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = b2 + u;
v = a + b2;
z_factor = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
z_factor = ((b5 - b3) + (b1 - b7)) * 0x62 >> 8;
m_part = ((b1 - b7) * 0x14E >> 8) - z_factor;
n = (b1 + b7) + ((b5 + b3) + m_part);
m_part = b1 * 0x14E >> 8;
e = a - b2;
m_part = m_part - z_factor;
oddLowSum += m_part;
n = oddHighSum + oddLowSum;
o = x + m_part;
p = ((b5 - b3) * 0x8B >> 8) + z_factor;
q = x + p;
p_part = b5 * 0x8B >> 8;
p = z_factor + p_part;
q = p + x;
out[0] = scalingClampU8(w + n);
out[r] = scalingClampU8(w - n);
out[pitch] = scalingClampU8(v + o);
@@ -182,11 +227,34 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32* dst;
s32 done;
s32 iter;
s32 i;
s32 b1, b2, b3, b4, b5, b6, b7;
s32 v, e, a, d, m, n, o, p, q, t, u, w, x, y, z;
s32 x_factor, z_factor, m_part, p_part;
s32 d;
s32 b1;
s32 b2;
s32 b3;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 v;
s32 r;
s32 a;
s32 i;
s32 m;
s32 n;
s32 o;
s32 x;
s32 q;
s32 y;
s32 u;
s32 w;
s32 p;
s32 t;
s32 z;
s32 x_factor;
s32 z_factor;
s32 m_part;
s32 p_part;
s32 e;
if (zigzag == 0x11) {
s32 val;
@@ -200,90 +268,42 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
goto mode_gt_2;
}
{
s32 inner;
dst = tmp;
done = 0;
for (; done < r; done += 8) {
s32 dcValue;
s32 oddCoefficient;
dst = tmp;
done = 0;
iter = (r + 7) >> 3;
if (r > 0) {
inner = (r + 7) >> 4;
done = iter << 3;
if (inner != 0) {
for (; inner > 0; inner--) {
t = block[1] * 0xB5 >> 8;
v = block[1] * 0x62 >> 8;
u = v + t;
z = (block[1] * 0x14E >> 8) - v;
m = block[1] + z;
n = t + z;
b1 = block[0] + m;
dst[0] = b1;
dst[7] = block[0] - m;
dst[1] = block[0] + n;
dst[6] = block[0] - n;
dst[2] = block[0] + u;
dst[5] = block[0] - u;
dst[3] = block[0] + v;
dst[4] = block[0] - v;
t = block[9] * 0xB5 >> 8;
v = block[9] * 0x62 >> 8;
u = v + t;
z = (block[9] * 0x14E >> 8) - v;
m = block[9] + z;
n = t + z;
b2 = block[8] + m;
dst[8] = b2;
dst[15] = block[8] - m;
dst[9] = block[8] + n;
dst[14] = block[8] - n;
dst[10] = block[8] + u;
dst[13] = block[8] - u;
dst[11] = block[8] + v;
dst[12] = block[8] - v;
dst += 0x10;
block += 0x10;
}
iter = iter & 1;
if (iter == 0) {
goto zero_fill;
}
}
for (; iter > 0; iter--) {
t = block[1] * 0xB5 >> 8;
v = block[1] * 0x62 >> 8;
u = v + t;
z = (block[1] * 0x14E >> 8) - v;
m = block[1] + z;
n = t + z;
b1 = block[0] + m;
dst[0] = b1;
dst[7] = block[0] - m;
dst[1] = block[0] + n;
dst[6] = block[0] - n;
dst[2] = block[0] + u;
dst[5] = block[0] - u;
dst[3] = block[0] + v;
dst[4] = block[0] - v;
dst += 8;
block += 8;
}
}
zero_fill:
dst = tmp + done;
for (; done <= 0x38; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
oddCoefficient = block[1];
dcValue = block[0];
t = oddCoefficient * 0xB5 >> 8;
v = oddCoefficient * 0x62 >> 8;
u = v + t;
z = (oddCoefficient * 0x14E >> 8) - v;
m = oddCoefficient + z;
n = t + z;
dst[0] = dcValue + m;
dst[7] = dcValue - m;
dst[1] = dcValue + n;
dst[6] = dcValue - n;
dst[2] = dcValue + u;
dst[5] = dcValue - u;
dst[3] = dcValue + v;
dst[4] = dcValue - v;
dst += 8;
block += 8;
}
dst = tmp + done;
for (; done <= 0x38; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
goto epilogue;
mode_gt_2:
dst = tmp;
done = 0;
if (r > 0) {
for (iter = (r + 7) >> 3; iter > 0; iter--) {
for (; done < r; done += 8) {
u32 ac;
b4 = block[4];
b6 = block[6];
@@ -312,28 +332,43 @@ mode_gt_2:
dst[1] = val;
dst[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = block[0] - b4;
d = block[0] + b4;
u = t + (b6 + b2);
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
y = d - u;
z_factor = (b5 - b3) + (b1 - b7);
m_part = (b1 - b7) * 0x14E >> 8;
p_part = (b5 - b3) * 0x8B >> 8;
s32 oddLowSum;
s32 oddLowDifference;
s32 oddHighSum;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
oddLowDifference = b5 - b3;
oddHighSum = b1 + b7;
oddHighDifference = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = oddLowDifference + oddHighDifference;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = t + u;
v = a + t;
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = oddHighDifference * 0x14E >> 8;
e = a - t;
m = m_part - z;
n = (b1 + b7) + ((b5 + b3) + m);
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
dst[0] = w + n;
p_part = oddLowDifference * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;
p = z + p_part;
q = p + x;
dst[0] = w + n;
dst[7] = w - n;
dst[1] = v + o;
dst[6] = v - o;
dst[2] = e + q;
dst[5] = e - q;
@@ -342,8 +377,6 @@ mode_gt_2:
}
block += 8;
dst += 8;
done += 8;
}
}
dst = tmp + done;
@@ -357,7 +390,9 @@ epilogue:
dst = tmp + 7;
for (iter = 8, i = 7; iter > 0; iter--, i--) {
u32 ac;
u8* output;
b4 = dst[0x20];
output = conv_row_ptr + i;
b6 = dst[0x30];
b2 = dst[0x10];
b1 = dst[8];
@@ -375,42 +410,56 @@ epilogue:
if (ac == 0) {
s32 val;
val = clampS8(*dst >> 11);
conv_row_ptr[i + 56] = (u8)val;
conv_row_ptr[i + 48] = (u8)val;
conv_row_ptr[i + 40] = (u8)val;
conv_row_ptr[i + 32] = (u8)val;
conv_row_ptr[i + 24] = (u8)val;
conv_row_ptr[i + 16] = (u8)val;
conv_row_ptr[i + 8] = (u8)val;
conv_row_ptr[i] = (u8)val;
output[56] = (u8)val;
output[48] = (u8)val;
output[40] = (u8)val;
output[32] = (u8)val;
output[24] = (u8)val;
output[16] = (u8)val;
output[8] = (u8)val;
output[0] = (u8)val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = *dst - b4;
d = *dst + b4;
u = t + (b6 + b2);
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
s32 oddLowSum;
s32 oddLowDifference;
s32 oddHighSum;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
oddLowDifference = b5 - b3;
oddHighSum = b1 + b7;
oddHighDifference = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = oddLowDifference + oddHighDifference;
dcValue = *dst;
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
y = d - u;
z_factor = (b5 - b3) + (b1 - b7);
d = dcValue + b4;
u = t + u;
v = a + t;
z = z_factor * 0x62 >> 8;
m = ((b1 - b7) * 0x14E >> 8) - z;
n = (b1 + b7) + ((b5 + b3) + m);
w = d + u;
y = d - u;
m_part = oddHighDifference * 0x14E >> 8;
e = a - t;
m = m_part - z;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
p = z + ((b5 - b3) * 0x8B >> 8);
p_part = oddLowDifference * 0x8B >> 8;
p = z + p_part;
q = p + x;
conv_row_ptr[i] = (u8)clampS8((w + n) >> 11);
conv_row_ptr[i + 56] = (u8)clampS8((w - n) >> 11);
conv_row_ptr[i + 8] = (u8)clampS8((v + o) >> 11);
conv_row_ptr[i + 48] = (u8)clampS8((v - o) >> 11);
conv_row_ptr[i + 16] = (u8)clampS8((e + q) >> 11);
conv_row_ptr[i + 40] = (u8)clampS8((e - q) >> 11);
conv_row_ptr[i + 24] = (u8)clampS8((y + p) >> 11);
conv_row_ptr[i + 32] = (u8)clampS8((y - p) >> 11);
output[0] = (u8)clampS8((w + n) >> 11);
output[56] = (u8)clampS8((w - n) >> 11);
output[8] = (u8)clampS8((v + o) >> 11);
output[48] = (u8)clampS8((v - o) >> 11);
output[16] = (u8)clampS8((e + q) >> 11);
output[40] = (u8)clampS8((e - q) >> 11);
output[24] = (u8)clampS8((y + p) >> 11);
output[32] = (u8)clampS8((y - p) >> 11);
}
dst--;
}

View File

@@ -244,6 +244,11 @@ _error:
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo) {
u16 byteOrder;
u32 ifdOffset;
const u8* entries;
u16 remaining;
u16 count;
s32 entriesSize;
u16 index;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -262,11 +267,8 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
@@ -294,11 +296,8 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
@@ -319,11 +318,8 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
@@ -354,7 +350,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x0111:
case 0x0201:
case 0x0202: {
return;
break;
}
case 0x0112: {
pInfo->orientation = readU16(entry + 8, byteOrder);
@@ -474,21 +470,19 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
case 0xA002: {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelXDim = offset;
} else if (type == 3) {
if (type == 3) {
pInfo->pixelXDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelXDim = readU32(entry + 8, byteOrder);
}
return;
}
case 0xA003: {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelYDim = offset;
} else if (type == 3) {
if (type == 3) {
pInfo->pixelYDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelYDim = readU32(entry + 8, byteOrder);
}
return;
}
@@ -508,7 +502,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x9000:
case 0x9101:
case 0xA003: {
return;
break;
}
case 0x011A: {
u32 offset;

View File

@@ -59,8 +59,8 @@ s32 TMCJPEGDEC_Setsize(TMCCJPEGDecWork* work) {
state->stepY = (state->scaleFactor + work->mcuXRem - 1) / state->scaleFactor;
state->jpegWidth = ((s32)(work->frameWidth + state->scaleFactor) - 1) / state->scaleFactor;
state->jpegHeight = (state->scaleFactor + work->frameHeight - 1) / state->scaleFactor;
state->stepXExt = (state->scaleFactor + work->unk_0x1808 - 1) / state->scaleFactor;
state->stepYExt = (state->scaleFactor + work->unk_0x1809 - 1) / state->scaleFactor;
state->stepXExt = (state->scaleFactor + work->remX - 1) / state->scaleFactor;
state->stepYExt = (state->scaleFactor + work->remY - 1) / state->scaleFactor;
state->dataSizeX = (state->stepXExt != 0) ? (state->maxX - 1) * state->stepX : (state->maxX + 1) * state->stepX;
state->dataSizeY = (state->stepYExt != 0) ? (state->maxY - 1) * state->stepY : (state->maxY + 1) * state->stepY;

View File

@@ -2,7 +2,7 @@
extern void* memset(void* dest, s32 val, u32 count);
extern const u32 lbl_8161E080[64] = {
extern const u32 scJpegAanScale[64] = {
0x00000100, 0x000000B9, 0x000000C4, 0x000000DA, 0x00000100, 0x00000146, 0x000001D9, 0x000003A0, 0x000000B9, 0x00000085, 0x0000008D,
0x0000009D, 0x000000B9, 0x000000EB, 0x00000155, 0x0000029D, 0x000000C4, 0x0000008D, 0x00000096, 0x000000A7, 0x000000C4, 0x000000F9,
0x0000016A, 0x000002C6, 0x000000DA, 0x0000009D, 0x000000A7, 0x000000B9, 0x000000DA, 0x00000115, 0x00000192, 0x00000315, 0x00000100,
@@ -562,8 +562,8 @@ s32 TMCJPEGDEC_scan_varinit(TMCCJPEGDecWork* work) {
remX = p->frameWidth % p->mcuXCount;
remY = p->frameHeight % p->mcuXRem;
p->unk_0x18 = remX;
p->unk_0x19 = remY;
p->remX = remX;
p->remY = remY;
p->mcuYCount = p->mcuYCount + ((u8)remX != 0 ? 1 : 0);
p->mcuXCount2 = p->mcuXCount2 + ((u8)remY != 0 ? 1 : 0);
@@ -1411,131 +1411,22 @@ static s32 TMCJPEGDEC_parse_dht(s32 first, TMCCJPEGDecWork* work) {
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_dqt(register TMCCJPEGDecWork* work) {
nofralloc
stwu r1, -0x130(r1)
mflr r0
lis r4, lbl_8161E080@ha
stw r0, 0x134(r1)
addi r4, r4, lbl_8161E080@l
li r0, 0x20
addi r6, r1, 0xc
stmw r24, 0x110(r1)
mr r30, r3
addi r5, r4, -4
mtctr r0
_parse_dqt_copy:
lwz r4, 4(r5)
lwzu r0, 8(r5)
stw r4, 4(r6)
stwu r0, 8(r6)
bdnz _parse_dqt_copy
addi r31, r3, 0x58
mr r4, r30
addi r3, r1, 0xa
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_dqt_have_length
b _parse_dqt_return
_parse_dqt_have_length:
lhz r3, 0xa(r1)
addi r29, r1, 0x10
li r27, 1
lis r28, TMCJPEGDEC_Zigzag_data@ha
addi r0, r3, -2
sth r0, 0xa(r1)
_parse_dqt_table:
lhz r5, 0xa(r1)
mr r4, r30
addi r3, r1, 9
addi r0, r5, -0x41
sth r0, 0xa(r1)
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_dqt_have_qt_info
b _parse_dqt_return
_parse_dqt_have_qt_info:
lbz r0, 9(r1)
cmplwi r0, 4
ble _parse_dqt_valid_qt_info
li r3, -0x41
b _parse_dqt_return
_parse_dqt_valid_qt_info:
add r3, r31, r0
addi r26, r28, TMCJPEGDEC_Zigzag_data@l
stb r27, 0x1790(r3)
li r25, 0
_parse_dqt_coeff:
lbz r24, 0(r26)
cmpwi r24, 0x3f
ble _parse_dqt_valid_coeff
li r3, -0x41
b _parse_dqt_return
_parse_dqt_valid_coeff:
mr r4, r30
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_dqt_have_coeff
b _parse_dqt_return
_parse_dqt_have_coeff:
slwi r4, r24, 2
lbz r3, 9(r1)
add r0, r4, r31
lbz r5, 8(r1)
lwzx r4, r29, r4
slwi r3, r3, 8
mullw. r4, r5, r4
stwx r4, r3, r0
bne _parse_dqt_nonzero
li r3, -0x41
b _parse_dqt_return
_parse_dqt_nonzero:
addi r25, r25, 1
addi r26, r26, 1
cmpwi r25, 0x40
blt _parse_dqt_coeff
lhz r0, 0xa(r1)
cmpwi r0, 0
bne _parse_dqt_table
li r3, 0
_parse_dqt_return:
lmw r24, 0x110(r1)
lwz r0, 0x134(r1)
mtlr r0
addi r1, r1, 0x130
blr
}
#else
static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
typedef struct {
u32 data[64];
} CopyBlock64;
u8* scaleInfo;
u32 tblCopy[65];
u32* tblPtr;
typedef struct { u32 coefficients[4][64]; } QuantizationTables;
QuantizationTables* scaleInfo;
u32 tblCopy[64];
u32* d;
u16 len;
s32 r;
d = tblCopy;
*(CopyBlock64*)(d + 1) = *(CopyBlock64*)lbl_8161E080;
*(CopyBlock64*)d = *(CopyBlock64*)scJpegAanScale;
scaleInfo = (u8*)work + 0x58;
scaleInfo = (QuantizationTables*)&work->scaleFlag;
r = TMCJPEGDEC_get_wbyte(&len, work);
if (r < 0) {
@@ -1543,8 +1434,6 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
}
len -= 2;
tblPtr = &tblCopy[1];
do {
u8 qtInfo;
const u8* zigPtr;
@@ -1563,11 +1452,10 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return -0x41;
}
scaleInfo[qtInfo + 0x1790] = 1; // quantTblFlag[0..3]
((TMCUnknownInfo*)scaleInfo)->quantTblFlag[qtInfo] = 1;
zigPtr = TMCJPEGDEC_Zigzag_data;
for (zzIdx = 0; zzIdx < 64; zzIdx++) {
u32 tmp;
zz = *zigPtr;
if (zz > 0x3F) {
@@ -1579,9 +1467,8 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return r;
}
tmp = (zz << 2) + ((u32)qtInfo << 8);
val = (u32)byte * tblPtr[zz];
*(u32*)(tmp + scaleInfo) = val;
val = (u32)byte * tblCopy[zz];
scaleInfo->coefficients[qtInfo][zz] = val;
if (val == 0) {
return -0x41;
}
@@ -1592,7 +1479,6 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return 0;
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_sof(register TMCCJPEGDecWork* work) {
@@ -2033,8 +1919,8 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
remX = fw - mcuCountX * mcuX;
remY = fh - mcuCountY * mcuY;
work->unk_0x1808 = remX;
work->unk_0x1809 = remY;
work->remX = remX;
work->remY = remY;
{
u16 xr = (remX != 0) ? 1 : 0;

View File

@@ -142,6 +142,9 @@ typedef struct ziFuzzyZYPairs {
int rANDn : 1;
int bANDp : 1;
int gANDk : 1;
int dANDt : 1;
int reserved : 20;
} ziFuzzyZYPairs;
typedef struct _ziGetParam {
@@ -212,9 +215,9 @@ struct __zi8_work_data_s {
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 unk_0x16;
ziU8 cangjieEnabled; // 0x16
ziU8 unk_0x17;
ziU8 unk_0x18;
ziU8 subLanguage; // 0x18
ziU8 unk_0x19;
ziU16 unk_0x1A;
ziU8 unk_0x1C[3];
@@ -255,7 +258,7 @@ struct __zi8_work_data_s {
ziU8 unk_0x330[8];
ziU32 unk_0x338;
ziU8 unk_0x33C[0x1FC];
ziU8 unk_0x538;
ziU8 language; // 0x538
ziU8 unk_0x539;
ziU8 unk_0x53A[0x40];
ziWChar unk_0x57A[0x641];
@@ -357,8 +360,8 @@ typedef struct ziMatchParam {
ziWChar first2; // 0x68
ziWChar comp; // 0x6A
ziU8 nSeg; // 0x6C
ziU8 segs1[0xC0]; // 0x6D
ziU8 segsD[0xC0]; // 0x12D
ziU8 segs1[16][12]; // 0x6D
ziU8 segsD[16][12]; // 0x12D
ziU8 pad_0x1ED; // 0x1ED
} ziMatchParam;

View File

@@ -55,7 +55,7 @@ ziU32 Zi8GetTableData(ziU8 lang, ziU8 tableIdx, ziU8 memberId ZI_NEED_WORK) {
if (langIdx-- != 0) {
tableData = ZI_WORK->langEntries[langIdx].tableData;
if ((lang == ZI8_LANG_ZH) && (tableData[3] >= 4) &&
((ZI_WORK->unk_0x18 == 1) || (ZI_WORK->unk_0x18 == 0x80) || (ZI_WORK->unk_0x18 == 0x40))) {
((ZI_WORK->subLanguage == 1) || (ZI_WORK->subLanguage == 0x80) || (ZI_WORK->subLanguage == 0x40))) {
offset = ((tableData[0x8B] << 0x10) + (tableData[0x8C] << 8) + tableData[0x8D]);
if (offset != 0) {
tableData += offset;

View File

@@ -67,12 +67,11 @@ ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
return mapped[character - defaults->first];
}
ziChar Zi8ConvertWC2UC(ziWChar character, ziU8 language ZI_NEED_WORK) {
ziU16 index, count, first, last, value;
ziU16 index, count, value, first, last;
ziU8* cursor;
ziConversionTable* table;
const ziConversionRangeTable* defaults;
ziConversionRange* ranges;
ziConversionEntry* entry;
ziU8* cursor;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;
@@ -83,94 +82,109 @@ ziChar Zi8ConvertWC2UC(ziWChar character, ziU8 language ZI_NEED_WORK) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
}
entry = table->entries;
count = (ziU16)table->count[0] << 8 | table->count[1];
entry = (ziConversionEntry*)table;
count = (ziU16)entry->first[0] << 8 | entry->first[1];
entry++;
for (index = 0; index < count; index++) {
first = ((ziU16)entry->first[0] << 8 | entry->first[1]);
first = (ziU16)entry->first[0] << 8 | entry->first[1];
last = (ziU16)entry->last[0] << 8 | entry->last[1];
if (first <= character && character <= last) {
value = ((ziU16)entry->value[0] << 8 | entry->value[1]);
if (first == last) {
Zi8LogError(100, __zi8_work_data);
return value & 0xFF;
}
Zi8LogError(100, __zi8_work_data);
return ((ziU8*)table->entries)[character + value - first];
if (character < first || character > last) {
entry++;
continue;
}
entry++;
value = (ziU16)entry->value[0] << 8 | entry->value[1];
if (first == last) {
Zi8LogError(100, __zi8_work_data);
return value & 0xFF;
}
entry = (ziConversionEntry*)((ziU8*)table + value + character - first + 8);
Zi8LogError(100, __zi8_work_data);
return *(ziU8*)entry;
}
Zi8LogError(0x6C2, __zi8_work_data);
return 0;
} else {
defaults = &Zi8CvrtTables.reverse;
if (defaults == 0) {
ranges = Zi8CvrtTables.reverse.entries;
if (ranges == 0) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
}
ranges = defaults->entries;
for (index = 0; index < defaults->count; index++) {
if (ranges[index].first <= character && character <= ranges[index].last) {
count = Zi8CvrtTables.reverse.count;
for (index = 0; index < count; index++) {
if (character >= ranges[index].first && character <= ranges[index].last) {
Zi8LogError(100, __zi8_work_data);
if (ranges[index].first == ranges[index].last) return ranges[index].result.character & 0xFF;
return ((ziU8*)ranges[index].result.table)[character - ranges[index].first];
if (ranges[index].first == ranges[index].last)
return ranges[index].result.character & 0xFF;
cursor = ranges[index].result.table;
return cursor[character - ranges[index].first];
}
}
Zi8LogError(0x6C2, __zi8_work_data);
return 0;
}
Zi8LogError(0x6C2, __zi8_work_data);
return 0;
}
ziWChar Zi8ConvertUC2Key(ziChar character, ziU8 language ZI_NEED_WORK) {
ziU16 count, index, first, last;
ziU32 key = 0;
ziU16 key = 0;
ziU16 index, count, first, last;
ziConversionTable* table;
const ziConversionRangeTable* defaults;
ziWChar* mapped;
ziConversionRange* ranges;
ziConversionEntry* entry;
ziU8* cursor;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;
}
if (ZI_WORK->userKeys[language] != 0) return Zi8ConvertUC2UserKey(character, language, __zi8_work_data);
if (ZI_WORK->userKeys[language] != 0)
return Zi8ConvertUC2UserKey(character, language, __zi8_work_data);
if (Zi8GetTableCount(language, 8, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 8, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;
}
entry = table->entries;
count = (ziU16)table->count[0] << 8 | table->count[1];
entry = (ziConversionEntry*)table;
count = (ziU16)entry->first[0] << 8 | entry->first[1];
entry++;
for (index = 0; index < count; index++) {
first = ((ziU16)entry->first[0] << 8 | entry->first[1]);
first = (ziU16)entry->first[0] << 8 | entry->first[1];
last = (ziU16)entry->last[0] << 8 | entry->last[1];
if (first <= character && character <= last) {
key = ((ziU16)entry->value[0] << 8 | entry->value[1]);
if (first != last) {
cursor = (ziU8*)table->entries + key + (character - first) * 2;
key = (ziU16)cursor[0] << 8 | cursor[1];
}
break;
if (character < first || character > last) {
entry++;
continue;
}
entry++;
key = (ziU16)entry->value[0] << 8 | entry->value[1];
if (first == last) break;
entry = (ziConversionEntry*)((ziU8*)table + key + (character - first) * 2);
entry = (ziConversionEntry*)((ziU8*)entry + 8);
key = (ziU16)entry->first[0] << 8 | entry->first[1];
break;
}
} else {
defaults = &Zi8CvrtTables.keys;
if (defaults == 0) {
ranges = Zi8CvrtTables.keys.entries;
if (ranges == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;
}
ranges = defaults->entries;
for (index = 0; index < defaults->count; index++) {
if (ranges[index].first <= character && character <= ranges[index].last) {
if (ranges[index].first == ranges[index].last) key = ranges[index].result.character & 0xFF;
else key = ((ziWChar*)ranges[index].result.table)[character - ranges[index].first];
count = Zi8CvrtTables.keys.count;
for (index = 0; index < count; index++) {
if (character >= ranges[index].first && character <= ranges[index].last) {
if (ranges[index].first == ranges[index].last) {
key = (ziU8)ranges[index].result.character;
break;
}
mapped = ranges[index].result.table;
key = mapped[character - ranges[index].first];
break;
}
}
}
if (key == 0) {
Zi8LogError(0x6C2, __zi8_work_data);
key = 0xEFF1;
} else Zi8LogError(100, __zi8_work_data);
return key;
return 0xEFF1;
} else {
Zi8LogError(100, __zi8_work_data);
return key;
}
}
ziWChar Zi8ConvertWC2Key(ziWChar character, ziU8 language ZI_NEED_WORK) {
return Zi8ConvertUC2Key(Zi8ConvertWC2UC(character, language, __zi8_work_data), language, __zi8_work_data);

View File

@@ -269,10 +269,10 @@ Zi8UInt Zi8SpellingZY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
Zi8UInt Zi8SpellingPY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
{
Zi8UInt length = 0;
ziU16 initialIndex = (ziU16)(((key & 0xffff) >> 9) & 0x3f);
ziU16 finalIndex = (ziU16)(((key & 0xffff) >> 3) & 0x3f);
ziU16 tone = (ziU16)(key & 7);
Zi8UInt length = 0;
volatile ziU16 tone = (ziU16)(key & 7);
output[0] = zi8PYinitialSpelling[initialIndex][0];
output[1] = zi8PYinitialSpelling[initialIndex][1];
@@ -311,7 +311,7 @@ Zi8UInt Zi8SpellingPY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
return length;
}
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFull,ziU8 usePinyin,Zi8UInt tone)
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
{
ziU16 spelling[16];
Zi8UInt spellingLength;
@@ -330,7 +330,7 @@ ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFul
if ((requireFull != 0) && ((inputLength & 0xff) != (spellingLength & 0xff))) {
return 0;
}
if (((tone & 0xff) == 0) && ((inputLength & 0xff) > (spellingLength & 0xff))) {
if ((tone == 0) && ((inputLength & 0xff) > (spellingLength & 0xff))) {
switch (input[(inputLength & 0xff) - 1]) {
case 0xeff1:
case 0xeff2:
@@ -943,8 +943,7 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
*output |= 0xf300;
output++;
} else {
*output = 0xf360;
output++;
*output++ = 0xf360;
}
}
tableIndex++;

View File

@@ -305,7 +305,7 @@ ziU8 Zi8LangSupported(ziU8 language, ziPtr work);
ziU8 Zi8MatchOEMdata(ziWChar* elements, ziU8 count, ziU8 language, ziWChar* word, ziU16 capacity, ziU8 mode, ziU8 status, ziPtr work);
ziU8 Zi8MatchPUDdata(ziWChar* elements, ziU8 count, ziU8 language, ziWChar* word, ziU16 capacity, ziU8 mode, ziU8 status, ziPtr work);
ziU8 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language, ziWChar* word, ziU16 capacity, ziU8 mode, ziU8 status, ziBool reservedMode, ziBool exactLength, ziPtr work);
ziU8 Zi8MatchUWDdata(ziWChar* elements, ziU8 count, ziWChar* currentWord, ziU8 currentLength, ziU8 language, ziWChar* word, ziU16 capacity, ziU8 mode, ziU8 status, ziPtr work);
ziU8 Zi8MatchUWDdata(ziWChar* elements, ziU8 count, ziWChar* currentWord, ziU16 currentLength, ziU8 language, ziWChar* word, ziU16 capacity, ziU8 mode, ziU8 status, ziPtr work);
void Zi8Memset(ziPtr destination, ziU32 value, ziU32 count);
ziU16 Zi8WCharCount(ziWChar* word, ziPtr work);
ziBool Zi8ZHCheckSpelling(ziWChar* word, ziWChar* elements, ziU8 count, ziPtr work);
@@ -414,7 +414,12 @@ int Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr optionData, ziPtr workDa
phoneticInput = ZI8_TRUE;
for (elementIndex = 0; elementIndex < elementCount; elementIndex++) {
normalizedElements[elementIndex] = elements[elementIndex];
if ((int)elements[elementIndex] < 0xf336 && (int)elements[elementIndex] >= 0xf331) {
switch ((int)elements[elementIndex]) {
case 0xf331:
case 0xf332:
case 0xf333:
case 0xf334:
case 0xf335:
phoneticSeparator = ZI8_TRUE;
phoneticInput = ZI8_FALSE;
if ((language == 0x7d) || ((language == 0x79 || (language == 0x7a)))) {
@@ -887,7 +892,7 @@ selectDictionary:
if ((((matchMode == 0) && (currentVowelRestriction)) &&
((2 < (int)elementCount &&
((((ZiAlphaWork*)workData)->language == language &&
((unsigned int)((ZiAlphaWork*)workData)->prefixCount == elementCount - 1)))))) &&
(((ZiAlphaWork*)workData)->prefixCount == elementCount - 1)))))) &&
(elements[elementCount - 1] == 0xeff1)) {
wordLength = 0;
}
@@ -942,15 +947,15 @@ selectDictionary:
}
if (wordLength != 0) goto filterVowelCandidate;
dictionaryStatus[dictionaryKind] = 1;
if (elements[apostropheIndex] < 0xEFF1) goto finishDictionaryPass;
goto retryDictionary;
if (elements[apostropheIndex] >= 0xEFF1) goto retryDictionary;
goto finishDictionaryPass;
}
filterVowelCandidate:
if ((wordLength != 0) && (prefixVowelRestriction)) {
if ((*wordCursor >= 0x30) && (*wordCursor <= 0x39)) {
wordLength = 0;
} else {
if (((elementCount == 1) && (dictionaryKind != 10)) && (0xeff0 < *wordCursor)) {
if (((elementCount == 1) && (dictionaryKind != 10)) && (*wordCursor >= 0xeff1)) {
punctuationCandidate = ZI8_TRUE;
goto finishDictionaryPass;
}
@@ -1017,67 +1022,59 @@ filterVowelCandidate:
}
break;
case 10:
index = *punctuationCursor;
*wordCursor = index;
if (index == 0) {
if ((*wordCursor = *punctuationCursor) != 0) {
punctuationCursor++;
wordLength = 1;
} else {
wordLength = 0;
}
else {
punctuationCursor = punctuationCursor + 1;
wordLength = 1;
break;
case 11:
if (prefixCount != 0) break;
if (retryPunctuation) {
for (index = 0; index < parameters->elementCount - 1; index++) {
wordCursor[index] = ((ZiAlphaWork*)workData)->prefix[index];
if (wordCursor[index] == 0) break;
}
if (index < parameters->elementCount - 1) {
wordLength = 0;
break;
}
} else {
for (index = 0; index < ((ZiAlphaWork*)workData)->rememberedCount; index++) {
wordCursor[index] = ((ZiAlphaWork*)workData)->rememberedWord[index];
if (wordCursor[index] == 0) break;
}
if (index < ((ZiAlphaWork*)workData)->rememberedCount) {
wordLength = 0;
break;
}
}
if ((wordCursor[index++] = *punctuationCursor) != 0) {
punctuationCursor++;
wordLength = index;
} else {
wordLength = 0;
}
break;
case 0xb:
if (prefixCount == 0) {
if (retryPunctuation) {
for (index = 0;
index < parameters->elementCount - 1; index++) {
wordCursor[index] = ((ZiAlphaWork*)workData)->prefix[index];
if (wordCursor[index] == 0) break;
}
if (index < (int)(parameters->elementCount - 1)) {
wordLength = 0;
}
else {
appendPunctuation:
wordLength = index + 1;
wordCursor[index] = *punctuationCursor;
if (wordCursor[index] == 0) {
wordLength = 0;
}
else {
punctuationCursor = punctuationCursor + 1;
}
}
}
else {
for (index = 0;
index < ((ZiAlphaWork*)workData)->rememberedCount; index++) {
wordCursor[index] = ((ZiAlphaWork*)workData)->rememberedWord[index];
if (wordCursor[index] == 0) break;
}
if ((int)(unsigned int)((ZiAlphaWork*)workData)->rememberedCount <= index) goto appendPunctuation;
wordLength = 0;
}
}
}
dictionaryStatus[dictionaryKind] = 1;
if (wordLength == 0) {
dictionaryStatus[dictionaryKind] = 2;
if ((((((((ZiAlphaWork*)workData)->prefixEnabled != '\0') && (!retryPunctuation)) && (parameters->elementCount != 0)) &&
(((int)(parameters->elementCount - 1) <= (int)(unsigned int)((ZiAlphaWork*)workData)->requiredLength &&
((((ZiAlphaWork*)workData)->requiredLength >= parameters->elementCount - 1 &&
(parameters->elements[parameters->elementCount - 1] == 0xEFF1)))) &&
(((((ZiAlphaWork*)workData)->prefixEnabled != '\x01' ||
(((ZiAlphaWork*)workData)->requiredLength != parameters->elementCount)) &&
(((((ZiAlphaWork*)workData)->prefixLength == '\0' ||
((unsigned int)parameters->elementCount <= ((ZiAlphaWork*)workData)->prefixLength + 1)) && (dictionaryExact != 0)))
(((ZiAlphaWork*)workData)->prefixLength + 1 >= parameters->elementCount)) && (dictionaryExact != 0)))
))) && ((((completionAllowed && (prefixCount == 0)) && (dictionaryKind != 0xb)) &&
((((int)dictionaryIndex < (int)(unsigned int)((ZiAlphaWork*)workData)->dictionaryCount &&
(((ZiAlphaOptions*)optionData)->lookupMode == '\0')) &&
(((ZiAlphaWork*)workData)->dictionaries[language] == 0)))))) {
if (language != ((ZiAlphaWork*)workData)->language) break;
index = ((ZiAlphaWork*)workData)->dictionaryKinds[dictionaryIndex + 1];
if ((index == 0xc) || (((index < 0xc && (index < 9)) && (4 < index)))) {
if (index == 0xc || (index < 9 && index >= 5)) {
if (Zi8getKeyLayout(language,0xeff1,&punctuationBuffer[0],1,workData) == 0) {
punctuationBuffer[0] = 0;
}
@@ -1089,10 +1086,10 @@ appendPunctuation:
}
if ((((((dictionaryExact == 0) || (!completionAllowed)) || (prefixCount != 0)) ||
((dictionaryKind == 0xb ||
((int)(unsigned int)((ZiAlphaWork*)workData)->dictionaryCount <= (int)dictionaryIndex)))) ||
(elements == (ziU16 *)0x0)) ||
(dictionaryIndex >= ((ZiAlphaWork*)workData)->dictionaryCount)))) ||
(elements == 0)) ||
((((elementCount == 0 || (elements[elementCount - 1] != 0xeff1)) ||
(((unsigned int)((ZiAlphaWork*)workData)->rememberedCount != parameters->elementCount - 1 ||
((((ZiAlphaWork*)workData)->rememberedCount != parameters->elementCount - 1 ||
(((((ZiAlphaWork*)workData)->rememberedWord[0] == 0 || (((ZiAlphaOptions*)optionData)->lookupMode != '\0')) ||
(((ZiAlphaWork*)workData)->dictionaries[language] != 0)))))) ||
(languagePassCount == 2)))) break;
@@ -1104,7 +1101,7 @@ appendPunctuation:
punctuationCursor = &punctuationBuffer[0];
dictionaryKind = 0xb;
}
else if ((int)(unsigned int)(ziU8)((ZiAlphaOptions*)optionData)->minWordLength <= (int)wordLength) {
else if (((ZiAlphaOptions*)optionData)->minWordLength <= wordLength) {
if (prefixVowelRestriction) {
if (*wordCursor >= 0x30 && *wordCursor <= 0x39) goto retryDictionary;
if (language == 0x2f) {
@@ -1119,15 +1116,15 @@ appendPunctuation:
{
prepareCandidate:
if (((elementCount == 1) && (dictionaryKind != 10)) &&
((0xeff0 < *wordCursor && (*wordCursor < 0xf011)))) {
((*wordCursor >= 0xeff1 && *wordCursor <= 0xf010))) {
punctuationCandidate = ZI8_TRUE;
break;
}
wordCursor[wordLength] = 0;
if (((exactLengthOnly != 0) && (elementCount != 0)) && ((int)elementCount < (int)wordLength))
if (((exactLengthOnly != 0) && (elementCount != 0)) && ((int)wordLength > (int)elementCount))
{
wordLength = elementCount;
wordCursor[elementCount] = 0;
wordCursor[wordLength] = 0;
}
wordLength = (ziU16)Zi8DeTokenization(wordCursor,wordLength & 0xffff,wordCapacity & 0xffff,language);
if (((phoneticInput) && ((unsigned int)parameters->elementCount < (wordLength & 0xff))) &&
@@ -1139,35 +1136,39 @@ prepareCandidate:
((Zi8ZHCheckSpelling(wordCursor,parameters->elements,parameters->elementCount,
workData)) != '\0')) {
if ((((ZiAlphaWork*)workData)->caseMode != '\0') && ((!phoneticInput && (!phoneticSeparator)))) {
Zi8ChangeWordCase(wordCursor + -prefixCount,language,workData);
Zi8ChangeWordCase(wordCursor - prefixCount,language,workData);
}
if ((((ZiAlphaOptions*)optionData)->suffixOnly != '\0') &&
((int)(unsigned int)(ziU8)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount))) {
wordLength = (ziU8)((ZiAlphaOptions*)optionData)->maxWordLength - prefixCount;
((int)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount))) {
wordLength = ((ZiAlphaOptions*)optionData)->maxWordLength - prefixCount;
wordCursor[wordLength] = 0;
}
if (((int)(unsigned int)(ziU8)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount)) ||
((Zi8IsDupWordW(wordCursor + -prefixCount,wordLength + prefixCount & 0xff,
if (((int)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount)) ||
((Zi8IsDupWordW(wordCursor - prefixCount,wordLength + prefixCount & 0xff,
workData)) != '\0')) {
if ((prefixCount != 0) && ((ziU8)((ZiAlphaOptions*)optionData)->maxWordLength <= prefixCount)) break;
if ((prefixCount != 0) && (((ZiAlphaOptions*)optionData)->maxWordLength <= prefixCount)) break;
}
else {
if ((((keyLayoutCount == 0) || (((ZiAlphaOptions*)optionData)->lookupMode != '\0')) ||
((int)(wordLength + prefixCount) < 2)) ||
((int)(wordLength + prefixCount) <= 1)) ||
(0x40 < (int)(wordLength + prefixCount))) goto emitCandidate;
if (dictionaryKind == 5) {
switch (dictionaryKind) {
case 5:
case 1:
case 9:
checkKeyLayout:
keyLayoutCursor = keyLayout;
candidateCharacterCount = wordLength + prefixCount;
for (index = 0; (int)index < (int)(unsigned int)keyLayoutCount; index = index + 1) {
if (candidateCharacterCount <= *keyLayoutCursor) {
if (candidateCharacterCount < *keyLayoutCursor++) {
if (*keyLayoutCursor < candidateCharacterCount) {
keyLayoutCursor = keyLayoutCursor + *keyLayoutCursor + 1;
} else {
if (*keyLayoutCursor++ > candidateCharacterCount) {
index = (unsigned int)keyLayoutCount;
}
break;
}
keyLayoutCursor = keyLayoutCursor + *keyLayoutCursor + 1;
}
if ((int)index < (int)(unsigned int)keyLayoutCount) {
for (elementIndex = 0; (int)elementIndex < (int)(unsigned int)candidateCharacterCount;
@@ -1175,32 +1176,31 @@ checkKeyLayout:
candidateBytes[elementIndex] = Zi8ConvertWC2UC(wordCursor[elementIndex - prefixCount],language,workData);
}
for (; (int)index < (int)(unsigned int)keyLayoutCount; index = index + 1) {
for (elementIndex = 0;
((int)elementIndex < (int)(unsigned int)candidateCharacterCount &&
(candidateBytes[elementIndex] == keyLayoutCursor[elementIndex]));
elementIndex = elementIndex + 1) {
elementIndex = 0;
while (elementIndex < candidateCharacterCount) {
if (candidateBytes[elementIndex] != keyLayoutCursor[elementIndex]) break;
elementIndex++;
}
if (elementIndex == candidateCharacterCount) {
wordCursor[-prefixCount] = 0;
goto retryDictionary;
}
keyLayoutCursor += candidateCharacterCount;
if (candidateCharacterCount < *keyLayoutCursor++) break;
if (*keyLayoutCursor++ > candidateCharacterCount) break;
}
}
break;
default:
break;
}
else if (dictionaryKind < 5) {
if (dictionaryKind == 1) goto checkKeyLayout;
}
else if (dictionaryKind == 9) goto checkKeyLayout;
emitCandidate:
if (firstCandidate == 0) {
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
if (((ZiAlphaOptions*)optionData)->suffixOnly != '\0') {
if ((int)(wordLength + prefixCount) < (int)(unsigned int)(ziU8)((ZiAlphaOptions*)optionData)->shortestWord) {
if ((int)((ZiAlphaOptions*)optionData)->shortestWord > (int)(wordLength + prefixCount)) {
((ZiAlphaOptions*)optionData)->shortestWord = wordLength + prefixCount;
}
if ((int)(unsigned int)(ziU8)((ZiAlphaOptions*)optionData)->longestWord < (int)(wordLength + prefixCount)) {
if ((int)((ZiAlphaOptions*)optionData)->longestWord < (int)(wordLength + prefixCount)) {
((ZiAlphaOptions*)optionData)->longestWord = wordLength + prefixCount;
}
}
@@ -1224,23 +1224,17 @@ emitCandidate:
} else {
if (((((ZiAlphaWork*)workData)->suffixMode == '\0') && (wordCursor[1] == 0)) &&
(candidateCount == 0)) {
if ((*wordCursor < 0xeff1) || (0xf010 < *wordCursor)) {
((ZiAlphaWork*)workData)->singleCharacter = *wordCursor;
}
else {
if (*wordCursor >= 0xeff1 && *wordCursor <= 0xf010) {
((ZiAlphaWork*)workData)->singleCharacter = 0;
}
}
if (((dictionaryExact == 0) || (parameters->elementCount != ((ZiAlphaWork*)workData)->rememberedCount))
|| ((parameters->maxCandidates != 1 &&
((candidateCount != 0 || (parameters->firstCandidate != 0)))))) {
if (((dictionaryExact == 0) && (parameters->elementCount == ((ZiAlphaWork*)workData)->rememberedCount))
&& ((parameters->maxCandidates == 1 ||
((candidateCount == 0 && (parameters->firstCandidate == 0)))))) {
((ZiAlphaWork*)workData)->rememberedWord[0] = 0;
else {
((ZiAlphaWork*)workData)->singleCharacter = *wordCursor;
}
}
else {
if (dictionaryExact != 0 &&
parameters->elementCount == ((ZiAlphaWork*)workData)->rememberedCount &&
(parameters->maxCandidates == 1 ||
(candidateCount == 0 && parameters->firstCandidate == 0))) {
for (index = 0; (int)index < (int)prefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->rememberedWord[index]
= wordCursor[index - prefixCount];
@@ -1251,6 +1245,13 @@ emitCandidate:
}
((ZiAlphaWork*)workData)->rememberedWord[index + prefixCount] = 0;
}
else {
if (((dictionaryExact == 0) && (parameters->elementCount == ((ZiAlphaWork*)workData)->rememberedCount))
&& ((parameters->maxCandidates == 1 ||
((candidateCount == 0 && (parameters->firstCandidate == 0)))))) {
((ZiAlphaWork*)workData)->rememberedWord[0] = 0;
}
}
if ((((ZiAlphaWork*)workData)->suffixMode == '\0') &&
((((((dictionaryKind == 1 && ((((ZiAlphaWork*)workData)->dictionaryFlags & 1) != 0)) ||
((dictionaryKind == 3 && ((((ZiAlphaWork*)workData)->dictionaryFlags & 2) != 0)))) ||
@@ -1313,7 +1314,7 @@ emitCandidate:
}
else {
if (((ZiAlphaOptions*)optionData)->suffixOnly != '\0') {
wordCursor = wordCursor + -prefixCount;
wordCursor = wordCursor - prefixCount;
wordCapacity = wordCapacity + prefixCount;
wordLength += prefixCount;
for (index = 0; parameters->elementCount + index < wordLength; index++) {
@@ -1435,7 +1436,7 @@ finishDictionaryPass:;
if ((completionAllowed) &&
((((((ZiAlphaWork*)workData)->suffixMode == '\0' && (2 < (int)elementCount)) &&
(elements[elementCount - 2] == 0xeff1)) &&
((unsigned int)((ZiAlphaWork*)workData)->prefixCount == elementCount - 2)))) {
((int)((ZiAlphaWork*)workData)->prefixCount == elementCount - 2)))) {
((ZiAlphaWork*)workData)->prefixElementCount = ((ZiAlphaWork*)workData)->prefixCount + '\x01';
((ZiAlphaWork*)workData)->suffixMode = 1;
}
@@ -1443,19 +1444,58 @@ finishDictionaryPass:;
prefixPrepared = ZI8_TRUE;
goto preparePrefix;
}
if ((((completionAllowed) && (((ZiAlphaWork*)workData)->suffixMode != '\0')) &&
if (!((((completionAllowed) && (((ZiAlphaWork*)workData)->suffixMode != '\0')) &&
((((ZiAlphaWork*)workData)->suffixLocked == '\0' && (2 < (int)elementCount)))) &&
(((elements[elementCount - 2] == 0xeff1 &&
((unsigned int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 2)) ||
(((unsigned int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
((Zi8IsAlphaPunct(elements[elementCount - 1])) != '\0')))))) {
((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 2)) ||
(((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
((Zi8IsAlphaPunct(elements[elementCount - 1])) != '\0'))))))) {
tryAlternatePrefix:
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (completionAllowed) goto checkPrefixPunctuation;
} else {
if ((((ZiAlphaWork*)workData)->prefixEnabled == '\0') || (elements[elementCount - 1] != 0xeff1)) {
if ((!primaryMatched) && (!secondaryMatched)) {
((ZiAlphaWork*)workData)->suffixLocked = 1;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount - 1;
if (prefixCount != 0) {
wordCursor = wordCursor + -prefixCount;
elements = elements + -prefixCount;
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
@@ -1480,8 +1520,8 @@ checkPrefixPunctuation:
((((Zi8GetTableCount(language,0x1f,workData)) & 8) == 0 &&
(parameters->elements[parameters->elementCount - 1] != 0xEFF1)))))) {
if (prefixPrepared) {
wordCursor = wordCursor + -prefixCount;
elements = elements + -prefixCount;
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
@@ -1489,7 +1529,7 @@ checkPrefixPunctuation:
if (((ZiAlphaWork*)workData)->suffixLocked != '\0') {
((ZiAlphaWork*)workData)->previousSuffixCount = ((ZiAlphaWork*)workData)->suffixElementCount;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount;
elementIndex = (unsigned int)((ZiAlphaWork*)workData)->prefixCount + (unsigned int)((ZiAlphaWork*)workData)->suffixCount;
elementIndex = (int)((ZiAlphaWork*)workData)->prefixCount + (int)((ZiAlphaWork*)workData)->suffixCount;
if (elements[elementIndex] != 0xEFF1 && Zi8IsAlphaPunct(elements[elementIndex]) != 0) {
((ZiAlphaWork*)workData)->suffix[((ZiAlphaWork*)workData)->suffixCount++] = elements[elementIndex];
} else {
@@ -1519,46 +1559,6 @@ checkPrefixPunctuation:
goto preparePrefix;
}
}
else {
tryAlternatePrefix:
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
wordCursor = wordCursor + -prefixCount;
elements = elements + -prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (completionAllowed) goto checkPrefixPunctuation;
}
if (!completionAllowed && ((ZiAlphaWork*)workData)->suffixMode == 0 && ((ZiAlphaWork*)workData)->prefixCount != 0 &&
elementCount > 2 && ((ZiAlphaWork*)workData)->prefixCount == elementCount - 1 &&
Zi8IsAlphaPunct(parameters->elements[((ZiAlphaWork*)workData)->prefixCount - 1]) != 0) goto checkPrefixFields;
@@ -1618,7 +1618,7 @@ finishCandidates:
} else {
wordCursor = 0;
}
if (wordCursor != (ziU16 *)0x0) {
if (wordCursor) {
Zi8SetHighlightedWordW(wordCursor,parameters->language,parameters->subLanguage,workData);
}
}
@@ -1634,8 +1634,7 @@ finishCandidates:
countIndex = ((ZiAlphaWork*)workData)->dictionaryCount - 1;
}
for (; countIndex >= 1; countIndex = countIndex - 1) {
((ZiAlphaWork*)workData)->dictionaryCounts[countIndex] =
((ZiAlphaWork*)workData)->dictionaryCounts[countIndex] -
((ZiAlphaWork*)workData)->dictionaryCounts[countIndex] -=
((ZiAlphaWork*)workData)->dictionaryCounts[countIndex - 1];
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -643,7 +643,7 @@ ziU32 Zi8GetSInfo(ziU8* strokes, ziU8* extraStrokes, ziWChar* outputBuffer, ziU8
{
int strokeIndex;
int outputCount;
int extraCount;
volatile int extraCount;
outputCount = 0;
Zi8LogError(100, work);
@@ -660,8 +660,7 @@ ziU32 Zi8GetSInfo(ziU8* strokes, ziU8* extraStrokes, ziWChar* outputBuffer, ziU8
goto lowStroke;
}
badStroke:
outputCount--;
outputBuffer[(ziU8)outputCount] = 0;
outputBuffer[(ziU8)--outputCount] = 0;
return outputCount;
lowStroke:
outputBuffer[(ziU8)outputCount] = zi8StrokeCode(strokes[strokeIndex] & 0xf, work);

View File

@@ -164,7 +164,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
parameters->letters = length;
if ((parameters->getOptions & 0x80) == 0) {
ZI_WORK->unk_0x538 = parameters->language;
ZI_WORK->language = parameters->language;
parameters->candidates[0] = 0xfff0;
output = (ziWChar*)&ZI_WORK->unk_0x338;
}
@@ -490,8 +490,8 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ZI_WORK->unk_0x00 = '\0';
}
}
ZI_WORK->unk_0x18 = parameters->subLanguage;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1,ZI_WORK) & 2;
ZI_WORK->subLanguage = parameters->subLanguage;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1,ZI_WORK) & 2;
options->maxCount = ZI_WORK->unk_0x10;
options->maxWordLength = ZI_WORK->unk_0x0A;
ZI_WORK->unk_0x0A = -1;
@@ -558,7 +558,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
}
else if ((parameters->language == 1) &&
((((parameters->getMode == 7 || (parameters->getMode == 8)) || (parameters->getMode == 10)) || (parameters->getMode == 9)))) {
if (ZI_WORK->unk_0x16 != '\0') {
if (ZI_WORK->cangjieEnabled != '\0') {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
} else {
error = 0x708;
@@ -582,7 +582,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
}
}
else {
ZI_WORK->unk_0x538 = parameters->language;
ZI_WORK->language = parameters->language;
if ((parameters->getOptions & 0x80) == 0) {
saved.restoreCandidates = 1;
saved.savedOptions = parameters->getOptions;

View File

@@ -42,13 +42,13 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
return 0;
}
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->unk_0x538 = 0;
ZI_WORK->language = 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->cangjieEnabled = 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;

View File

@@ -24,17 +24,17 @@ ziU8 Zi8GetZHCharSet(ziPtr 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;
bak = ((struct __zi8_work_data_s*)workData)->subLanguage;
((struct __zi8_work_data_s*)workData)->subLanguage = 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;
((struct __zi8_work_data_s*)workData)->subLanguage = 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;
((struct __zi8_work_data_s*)workData)->subLanguage = bak;
if (v0 != 0) {
if (v0 > 0x4E20) {
charSet |= 8;

View File

@@ -139,7 +139,7 @@ ziU32 Zi8SecMatchChar(ziPtr nodeAddress, ziU8* dictionaryAddress, ziMatchParam*
data = (ziU8*)Zi8GetTableAddress(1, 1, ZI_WORK);
data += ((ziU8*)nodeAddress)[0xB] + (((ziU8*)nodeAddress)[0xA] << 8) + ((((ziU8*)nodeAddress)[9] & 0xF) << 16);
if (ZI_WORK->unk_0x16 != 0) {
if (ZI_WORK->cangjieEnabled != 0) {
switch (data[0] & 7) {
case 2:
data += 2;
@@ -346,7 +346,7 @@ match_code:
traversal.soundIndex = initialCode;
}
sound = (ziU8*)(tableAddress + ((node[9] & 0xF) * 0x10000 + (node[0xB] + node[0xA] * 0x100)));
if (ZI_WORK->unk_0x16 != 0) {
if (ZI_WORK->cangjieEnabled != 0) {
switch (sound[0] & 7) {
case 2:
sound += 2;

View File

@@ -37,7 +37,7 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
p = (ziU8*)(table2 +
(((e[9] & 0xF) << 16) |
(e[0xB] | (e[0xA] << 8))));
if (WORKP->unk_0x16 != 0) {
if (WORKP->cangjieEnabled != 0) {
switch (p[0] & 7) {
case 2:
p += 2;
@@ -65,7 +65,7 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
}
}
e = (ziU8*)table;
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->unk_0x18) {
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->subLanguage) {
if ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
goto map;

View File

@@ -89,7 +89,12 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
ZI_WORK->unk_0x310 = (ziU32)table + section->offset[0] * 0x100 + section->offset[1];
ZI_WORK->unk_0x318 = 0;
}
while ((entry = (ziU8*)ZI_WORK->unk_0x310) != 0) {
for (;;) {
entry = (ziU8*)ZI_WORK->unk_0x310;
if (entry == 0) {
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
word = entry + 1;
wordSize = *entry;
@@ -158,8 +163,6 @@ next:
fallback = 1;
ZI_WORK->unk_0x318 = 0;
}
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziU32 result;
@@ -167,11 +170,12 @@ ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* out
for (;;) {
result = Zi8_8147FD7C(pattern, length, language, output, capacity, complete, continuation, __zi8_work_data);
if ((ziU8)result != 0) break;
if ((ZI_WORK->pudCount = ZI_WORK->pudCount + 1) > 16) {
if (++ZI_WORK->pudCount <= 16) {
continuation = 0;
} else {
ZI_WORK->pudCount = 1;
break;
}
continuation = 0;
}
return result;
}

View File

@@ -45,7 +45,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
if (candidate->length == length) {
position = 0;
while (position < length) {
if ((ziU8)candidate->text[position] != (ziU8)word->text[position]) break;
if (candidate->text[position] != word->text[position]) break;
position++;
}
if (position == length) {
@@ -56,8 +56,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
previous = current;
current = current->next;
}
length = ZI_WORK->uwdCount;
ZI_WORK->uwdCount = length + 1;
length = ZI_WORK->uwdCount++;
added = &ZI_WORK->uwdNodes[length];
if (previous == 0) {
ZI_WORK->uwdList = added;
@@ -91,8 +90,11 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
ziWChar folded;
int fallback = 0;
int visited = 0;
int position, prefixLength, previousOffset;
ziU32 size, entryLanguage, entryLength;
int prefixLength;
int position, previousOffset;
ziU32 size;
ziU8 entryLanguage;
ziU32 entryLength;
ziU8* cursor;
ziU8* begin;
ziU8* boundary;
@@ -103,18 +105,33 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
ziUserDictionary* dictionary;
int firstSegment;
Zi8LogError(100, __zi8_work_data);
if (!(ZI_WORK->unk_0x138 < 3 && ZI_WORK->unk_0x138 != 0 && ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1] != 0)) {
if (!(ZI_WORK->unk_0x138 <= 2 && ZI_WORK->unk_0x138 != 0 && ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1] != 0)) {
Zi8ReplaceLastError(0x19C, __zi8_work_data);
return 0;
}
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
if (continuation == 0) {
if (continuation != 0) {
result = Zi8_814803F4(__zi8_work_data);
entryLength = 0;
if (result != 0) {
entryLanguage = result->language;
entryLength = result->length;
if (entryLength >= capacity) {
Zi8_8148047C(__zi8_work_data);
return 0;
}
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
}
return entryLength;
}
{
Zi8_8148047C(__zi8_work_data);
ZI_WORK->unk_0x13C = 0;
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->unk_0x140 = 0;
else {
prefixLength = 0;
for (position = currentLength - 2; position >= 0 && currentWord[position] != 0x20; position--) prefixLength++;
for (position = currentLength - 2; currentWord[position] != 0x20 && position >= 0; position--) prefixLength++;
position++;
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->unk_0x140 = 0;
else {
ZI_WORK->unk_0x140 = 1;
@@ -123,7 +140,7 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
ZI_WORK->unk_0x141[1] = language;
ZI_WORK->unk_0x141[2] = prefixLength;
previousOffset = 4;
for (; ++position, prefixLength > 0; prefixLength--) {
for (; prefixLength > 0; prefixLength--, position++) {
folded = currentWord[position];
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = 0;
@@ -131,12 +148,10 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data)) Zi8ChangeCharCase(0, &folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
}
if (ZI_WORK->unk_0x141[previousOffset] == 0) {
if (ZI_WORK->unk_0x141[previousOffset++] == 0) {
ZI_WORK->unk_0x140 = 0;
previousOffset++;
break;
}
previousOffset++;
}
}
}
@@ -146,7 +161,8 @@ rescan:
boundary = (ziU8*)dictionary + dictionary->boundary + 7;
end = (ziU8*)dictionary + dictionary->end + 7;
cursor = begin;
firstSegment = begin < boundary;
if (begin < boundary) firstSegment = 1;
else firstSegment = 0;
while (firstSegment ? cursor < boundary : cursor < end) {
size = *cursor;
candidate = (ziUserWord*)cursor;
@@ -185,7 +201,7 @@ next:
visited = 0;
goto rescan;
}
if (complete != 0 && length == 1) {
if (complete == 1 && length != 0 && continuation == 0) {
complete = 0;
fallback = 1;
visited = 0;

View File

@@ -22,7 +22,8 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
node += offset;
if (((ziU32)header & 2) != 0) {
if ((*(ziU8*)node & 0x80) != 0) {
offset = *((ziU8*)node + 2) + ((*(ziU8*)node & 0x7f) * 0x10000 + ((ziU32)*((ziU8*)node + 1) & 0xffff) * 0x100 + 0x8000);
offset = (*(ziU8*)node & 0x7f) * 0x10000 + ((ziU32)*((ziU8*)node + 1) & 0xffff) * 0x100 + 0x8000;
offset += *((ziU8*)node + 2);
} else {
offset = ((ziU32)*(ziU8*)node & 0xffff) * 0x100;
offset += (ziU32)*((ziU8*)node + 1);
@@ -43,7 +44,7 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
ziU8* ZiDAWGGetSibling(ziU8* node) {
ziU16 header;
ziU8* cursor;
ziU8* cursor = node;
ziS32 depth;
ziS32 offset;
@@ -53,29 +54,29 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
if ((header & 4) == 0) {
node = 0;
} else {
cursor = node;
if ((header & 8) != 0) {
if ((node[0] & 0xf) == 0xf) {
cursor = node + 2;
node += 2;
} else {
cursor = node + 1;
node += 1;
}
if ((header & 2) != 0) {
if ((*cursor & 0x80) == 0) {
cursor += 2;
if ((*node & 0x80) == 0) {
node += 2;
} else {
cursor += 3;
node += 3;
}
}
if ((*cursor & 0x80) == 0) {
node += (ziU32)cursor[1] + (ziU32)*cursor * 0x100;
if ((*node & 0x80) != 0) {
node += (*node & 0x7f) * 0x10000 + (ziU32)node[1] * 0x100 +
(ziU32)node[2] + 0x8000;
} else {
node += (*cursor & 0x7f) * 0x10000 + (ziU32)cursor[1] * 0x100 +
0x8000 + (ziU32)cursor[2];
node += (ziU16)*node * 0x100 + (ziU32)node[1];
}
} else {
cursor = node;
do {
header = nodeHeaderTable[cursor[0] >> 4];
if ((cursor[0] & 0xf) == 0xf) {
@@ -89,24 +90,24 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
if ((header & 1) != 0) {
if ((header & 2) == 0) {
depth++;
} else if ((*cursor & 0x80) == 0) {
cursor += 2;
offset += 2;
} else {
} else if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
}
if ((header & 4) == 0) {
depth--;
} else if ((header & 8) != 0) {
if ((*cursor & 0x80) == 0) {
cursor += 2;
offset += 2;
} else {
if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
depth--;
}
@@ -163,16 +164,10 @@ ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
result = 0;
pair = (((ziU16)entry[0] << 8) + entry[1]);
if (pair != 0) {
goto graph_invalid;
return 0;
}
pair = (((ziU16)entry[2] << 8) + entry[3]);
if (pair == 0) {
goto graph_valid;
}
graph_invalid:
result = 0;
goto graph_done;
graph_valid:
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
@@ -182,19 +177,18 @@ graph_valid:
}
while (1) {
if (*keys == (ziU16)(entry[3] + ((ziU16)entry[2] << 8))) {
if (*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8))) {
break;
}
entry += (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10;
if ((end <= (ziU32)entry) ||
(*keys == (ziU16)(entry[3] + ((ziU16)entry[2] << 8)))) {
if (((ziU32)entry >= end) ||
(*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8)))) {
break;
}
}
if (end <= (ziU32)entry) {
result = 0;
break;
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + ((ziU16)entry[5] << 8) +
@@ -215,8 +209,7 @@ graph_valid:
depth++;
keys++;
}
}
graph_done:
return result;
}

View File

@@ -4,7 +4,7 @@
ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx, ziPtr workData);
ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx, ziPtr workData);
ziU8 Zi8_814813FC(ziWChar character, ziU8* result, ziU16* index, ziPtr workData) {
ziU8 Zi8LookupKoreanChar(ziWChar character, ziU8* result, ziU16* index, ziPtr workData) {
ziU16 i;
ziU8* table;
@@ -23,7 +23,7 @@ ziU8 Zi8_814813FC(ziWChar character, ziU8* result, ziU16* index, ziPtr workData)
return 0;
}
ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData);
ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData);
ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
ziPtr workData) {
@@ -97,9 +97,9 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
result = 0;
for (currentCharacter = 0; currentCharacter < state.elementIndex; currentCharacter++) {
if (Zi8_814813FC(buffer[currentCharacter], &state.characterIndex,
if (Zi8LookupKoreanChar(buffer[currentCharacter], &state.characterIndex,
&state.inputIndex, workData) != 0) {
state.matched = Zi8_81481E6C(&state.nextIndex,
state.matched = Zi8MatchKoreanSequence(&state.nextIndex,
buffer + currentCharacter + 1,
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
@@ -235,7 +235,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
return result;
}
ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData) {
ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData) {
ziU16 nestedScratch;
ziU16 nestedIndexStorage;
ziU16 index1;
@@ -375,8 +375,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
}
if ((index3 >= tableCount) || (firstCharacter != (table + index3 * 4)[2]) ||
(input[1] != (table + index3 * 4)[1]) || (input[0] != table[index3 * 4])) {
if ((Zi8_814813FC(input[1], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 2, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[1], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 2, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index1;
return 1;
}
@@ -397,8 +397,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
if ((index4 >= tableCount) || (firstCharacter != (table + index4 * 4)[3]) ||
(input[2] != (table + index4 * 4)[2]) || (input[1] != (table + index4 * 4)[1]) ||
(input[0] != table[index4 * 4])) {
if ((Zi8_814813FC(input[2], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 3, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[2], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 3, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index2;
return 2;
}
@@ -409,8 +409,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
*resultIndex = index4;
return 4;
}
if ((Zi8_814813FC(input[3], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 4, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[3], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 4, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index3;
return 3;
}

View File

@@ -17,7 +17,7 @@ typedef struct ziUserKeys {
typedef struct ziChineseEntry {
ziU8 data[9];
ziU8 offsetHigh;
ziU16 offsetLow;
ziU8 offsetLow[2];
} ziChineseEntry;
ziU8 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
@@ -26,19 +26,22 @@ ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziU8 remaining, group;
ziU16 value = 0;
int count;
int offset;
ziU8 group;
ziU8 remaining;
ziU16 value;
ziWChar* cursor;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziSearchState search;
ziGetParam request;
ziWChar ordinals[65];
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
int length, count, offset;
int length;
int unmatched;
ziChineseEntry* entry;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
search.flags = 0;
search.word = 0;
search.length = 0;
@@ -52,7 +55,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
}
if (language != 1) {
for (length = 0; word[length] != 0; length++) {
if (word[length] > 0xEFF0 || length == 64) return 0;
if (word[length] >= 0xEFF1 || length == 64) return 0;
}
((ziU8*)&search.length)[0] = length;
((ziU8*)&search.flags)[2] = 1;
@@ -91,21 +94,34 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
if (language == 1) {
length = 0;
do {
if (word[length] == 0) {
count = length - 1;
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
if (ordinals[length] == 0xFFFF) return 0;
length++;
if (length == 64) return 0;
} while (word[length] != 0);
{
if (length == 1) return 1;
count = --length;
ordinals[count] |= 0x8000;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
entry = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data) + ordinals[0];
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | entry->offsetLow);
if (ZI_WORK->unk_0x16 != 0) {
group = *data & 7;
if (group == 5) offset = 4;
else if (group < 5) {
if (group == 2) offset = 2;
else if (group < 2) offset = 1;
else offset = 3;
} else offset = 1;
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
if (ZI_WORK->cangjieEnabled != 0) {
switch (*data & 7) {
case 2:
offset = 2;
break;
case 3:
case 4:
offset = 3;
break;
case 5:
offset = 4;
break;
default:
offset = 1;
break;
}
data += offset;
}
if ((*data & 0x80) == 0) return 0;
@@ -134,11 +150,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
}
Zi8LogError(0x2BD, __zi8_work_data);
return 0;
}
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
if (ordinals[length] == 0xFFFF) return 0;
length++;
} while (length != 64);
}
} else Zi8ReplaceLastError(0x26C, __zi8_work_data);
return 0;
}
@@ -156,10 +168,9 @@ ziWChar Zi8ConvertUC2UserKey(ziChar character, ziU8 language ZI_NEED_WORK) {
}
}
found:
if (key < 32) {
if (key == 0) return 0xEFFA;
if (key >= 1 && key <= 9) return key + 0xEFF0;
if (key <= 31) return key + 0xEFF1;
}
if (key >= 32) return 0;
if (key == 0) return 0xEFFA;
if (key >= 1 && key <= 9) return key + 0xEFF0;
if (key <= 31) return key + 0xEFF1;
return 0;
}

View File

@@ -8,7 +8,7 @@ ziU16 Zi8GetTableCount(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU32 Zi8GetTableAddress(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU8 Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, ziPtr __zi8_work_data);
ziBool Zi8_81484484(ziWChar character, ziWChar* output, ziPtr __zi8_work_data) {
ziBool Zi8MapKeyCode(ziWChar character, ziWChar* output, ziPtr __zi8_work_data) {
if (character == 0xeffa) {
*output = 0;
} else if ((character >= 0xeff1) && (character <= 0xeff9)) {
@@ -44,13 +44,12 @@ static ziU8 ziNumKeysWithChars(ziU8 language, ziPtr __zi8_work_data) {
}
ziBool Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, ziPtr __zi8_work_data) {
ziU8 numKeys;
ziU16 tableCount;
ziU8 numKeys;
ziU8* dataAddress;
ziUserKeyMap* customTable;
ziU32 totalCharacters;
ziU16 charCount;
ziU32 keyIndex;
ziU16 keyIndex;
ziWChar* keyChars;
dataAddress = 0;
@@ -59,7 +58,7 @@ ziBool Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, zi
*chars = 0;
if (ZI_WORK->userKeys[language] != 0) {
customTable = ZI_WORK->userKeys[language];
if (!Zi8_81484484(key, &key, __zi8_work_data)) {
if (!Zi8MapKeyCode(key, &key, __zi8_work_data)) {
return 0;
}
keyChars = customTable->lower[key];
@@ -88,20 +87,20 @@ tables_ready:
Zi8ReplaceLastError(0x962, __zi8_work_data);
return 0;
}
if (!Zi8_81484484(key, &key, __zi8_work_data) || (key >= numKeys)) {
if (!Zi8MapKeyCode(key, &key, __zi8_work_data) || (key >= numKeys)) {
Zi8ReplaceLastError(300, __zi8_work_data);
return 0;
}
totalCharacters = 0;
keyIndex = totalCharacters;
tableCount = 0;
keyIndex = tableCount;
for (; (ziU16)keyIndex < key; keyIndex++) {
totalCharacters += dataAddress[(ziU16)keyIndex];
tableCount += dataAddress[(ziU16)keyIndex];
}
if ((charCount = (ziU8)dataAddress[key]) == 0) {
return 0;
}
dataAddress = dataAddress + numKeys + ((totalCharacters & 0xffff) * 2);
dataAddress = dataAddress + numKeys + (tableCount * 2);
keyIndex = 0;
for (; (ziU16)keyIndex < charCount; keyIndex++) {
chars[(ziU16)keyIndex] = (ziU16)dataAddress[(ziU16)keyIndex * 2] |

View File

@@ -23,48 +23,60 @@ ziU8 Zi8DetachOEMdata(ziU8 id ZI_NEED_WORK) {
}
ziU8 Zi8MatchOEMdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* word, ziU16 capacity, ziBool complete, ziBool continuation ZI_NEED_WORK) {
ziWChar folded;
ziU8 fallback = 0;
ziU32 index;
ziS32 index;
ziU32 position;
ziU32 fallback = 0;
if (!continuation) ZI_WORK->oemIdx = 0;
index = ZI_WORK->oemIdx;
if ((ziS32)index >= ZI_WORK->oemLen || ZI_WORK->oemMatch == 0) goto noMatch;
if ((ziS32)index >= ZI_WORK->oemLen) goto failed;
if (ZI_WORK->oemMatch == 0) goto failed;
capacity--;
if (length >= capacity) goto noMatch;
word[capacity] = 0;
word[length] = complete ? 1 : 0;
for (;;) {
if ((ziS32)index >= ZI_WORK->oemLen || !ZI_WORK->oemMatch(index, word, capacity, ZI_WORK->oemData)) {
if (length != 1 || !complete || continuation) goto noMatch;
complete = 0;
fallback = 1;
index = 0;
continue;
}
position = 0;
if ((complete && word[length] == 0) || (!complete && word[length] != 0)) {
for (; (ziS32)position < length; position++) {
if (pattern[position] < 0xEFF1 || pattern[position] > 0xF37F) {
if (word[position] != pattern[position]) {
if (!ZI_WORK->unk_0x1F || language == 1) break;
folded = pattern[position];
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data) || folded != word[position]) break;
}
} else if (pattern[position] != Zi8ConvertWC2Key(word[position], language, __zi8_work_data)) break;
}
}
if ((ziS32)position >= length) {
if (fallback) {
*word = *pattern;
return 1;
}
ZI_WORK->oemIdx = index + 1;
while (word[position] != 0) position++;
return position;
}
word[length] = complete ? 1 : 0;
index++;
if ((ziS32)length >= (ziS32)capacity) {
failed:
return 0;
}
noMatch:
word[capacity] = 0;
if (complete) word[length] = 1; else word[length] = 0;
goto matchRetry;
posEntry:
position = 0;
if ((complete && word[length] == 0) || (!complete && word[length] != 0)) {
for (; (ziS32)position < length; position++) {
if (pattern[position] >= 0xEFF1 && pattern[position] <= 0xF37F) {
if (pattern[position] == Zi8ConvertWC2Key(word[position], language, __zi8_work_data)) continue;
break;
} else if (word[position] != pattern[position]) {
if (!ZI_WORK->unk_0x1F || language == 1) break;
folded = pattern[position];
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data) || folded != word[position]) break;
}
}
}
if ((ziS32)position < length) {
if (complete) word[length] = 1; else word[length] = 0;
index++;
if ((ziS32)index >= ZI_WORK->oemLen) goto oemFailed;
goto matchRetry;
}
if (fallback) {
index = 0;
*word = *pattern;
return 1;
}
index++;
ZI_WORK->oemIdx = index;
while (word[position] != 0) position++;
return position;
matchRetry:
if ((ziS32)index >= ZI_WORK->oemLen) goto oemFailed;
if (!ZI_WORK->oemMatch(index, word, capacity, ZI_WORK->oemData)) goto oemFailed;
goto posEntry;
oemFailed:
if (length != 1 || !complete || continuation) goto tail0;
complete = 0;
fallback = 1;
index = 0;
goto matchRetry;
tail0:
return 0;
}

View File

@@ -457,7 +457,7 @@ void bta_dm_signal_strength(tBTA_DM_MSG *p_data);
void bta_dm_acl_change(tBTA_DM_MSG *p_data);
BOOLEAN bta_sys_check_compress(int, UINT8 app_id, BD_ADDR peer_addr);
BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr);
void bta_dm_keep_acl(tBTA_DM_MSG *p_data);
void bta_dm_immediate_disable(void);

View File

@@ -151,7 +151,7 @@ UINT8 L2CA_SetTraceLevel(UINT8 new_level);
UINT8 L2CA_SetDesireRole(UINT8 new_role);
BOOLEAN L2CA_SetAclPriority(BD_ADDR bd_addr, UINT8 priority);
void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
UINT8 wbits, UINT8 direction, UINT8 param_6,
UINT8 wbits, UINT8 direction, UINT8 config,
UINT8 enable);
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *, signed);
UINT8 L2CA_Flush(UINT16 cid);

View File

@@ -42,7 +42,7 @@ typedef struct UHF_MSC_MESSAGE {
} UHF_MSC_MESSAGE;
extern UHF_MSC_DEVICE uhg_msc_blk_device_tbl[8];
extern s32 uhg_msc_memid_8169971C;
extern s32 uhg_msc_memid;
s32 uhf_ker_set_priority(s32 task_id, s32 priority);
void* uhf_ker_get_memory_block(s32 pool, u32 size, u32 alignment);
s32 uhf_ker_release_memory_block(s32 pool, void* block);

View File

@@ -3,7 +3,7 @@
#include <revolution/types.h>
s32 uhf_ker_create_sem(u32 param_1, int param_2);
s32 uhf_ker_create_sem(u32 initCount, int flags);
s32 uhf_ker_delete_sem(int sem);
s32 uhf_ker_get_sem(int sem);

View File

@@ -16,24 +16,24 @@ typedef s32 CXStreamingResult;
#define CX_STREAMING_ERR_BAD_FILE_TABLE -5
typedef struct CXUncompContextRL {
u8* unk_0x00; // 0x00
int unk_0x04; // 0x04
u8* outData; // 0x00
int outDataLen; // 0x04
u32 size; // 0x08
u16 unk_0x0C; // 0x0C
u8 unk_0x0e; // 0x0E
u8 unk_0x0f; // 0x0F
u16 length; // 0x0C
u8 flags; // 0x0E
u8 hdrLen; // 0x0F
} CXUncompContextRL;
typedef struct CXUncompContextLZ {
u8* unk_0x00; // 0x00
int unk_0x04; // 0x04
u8* outData; // 0x00
int outDataLen; // 0x04
u32 size; // 0x08
int unk_0x0C; // 0x0C
u8 unk_0x10; // 0x10
u8 unk_0x11; // 0x11
u8 unk_0x12; // 0x12
u8 unk_0x13; // 0x13
u8 unk_0x14; // 0x14
int length; // 0x0C
u8 lengthBytesLeft; // 0x10
u8 flags; // 0x11
u8 flagsLeft; // 0x12
u8 hdrLen; // 0x13
u8 lzType; // 0x14
u8 padding[3];
} CXUncompContextLZ;
@@ -52,19 +52,19 @@ typedef struct CXUncompContextHuffman {
u32 size; // 0x08
CXHuffmanDecodeTableEntry* decodeTable; // 0x0C
u32 bits; // 0x10
u32 unk_0x14; // 0x14
u32 wordBuffer; // 0x14
s16 decodeTableSize; // 0x18
u8 bitsLeft; // 0x1A
u8 unk_0x1b; // 0x1B
u8 wordBits; // 0x1B
u8 depth; // 0x1C
u8 hdrLen; // 0x1D
u8 padding[2]; // 0x1E
CXHuffmanDecodeTableEntry decodeTableData[0x200]; // 0x20
} CXUncompContextHuffman;
void CXInitUncompContextRL(CXUncompContextRL* context, u8* param_2);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* param_2);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* param_2);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* data);
CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u32 size);
CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u32 size);

View File

@@ -68,7 +68,7 @@ void KPADInit();
s32 KPADRead(s32 chan, KPADStatus* status, u32 length);
void KPADSetSensorHeight(s32 chan, f32 sensorHeight);
void KPADGetProjectionPos(Vec2* dest, Vec2* src, const Rect* param_3, f32 param_4);
void KPADGetProjectionPos(Vec2* dest, Vec2* src, const Rect* rect, f32 scale);
void KPADSetPosParam(s32 chan, f32 x, f32 y);
void KPADSetBtnRepeat(s32 chan, f32, f32);

View File

@@ -40,7 +40,7 @@ ISD_Error ISD_ProbeCard(u32 slot);
ISD_Error ISD_MountCard(u32 slot, SDDev** dev);
ISD_Error ISD_UnmountCard(SDDev* dev);
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 param_2, u32* param_3, u32 param_4) NO_INLINE;
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 reg, u32* outValue, u32 size) NO_INLINE;
ISD_Error ISD_ReadBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);
ISD_Error ISD_WriteBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);

View File

@@ -20,8 +20,8 @@ typedef void (*USBKBDEventCallback)(void*, char*);
typedef void (*USBKBDCmdLEDCallback)(BOOL success, void* cbarg);
typedef struct USBKBDCmdLED {
vu32 unk_0x00;
vu8 unk_0x04;
vu32 device; // 0x00
vu8 ledBits; // 0x04
} USBKBDCmdLED;
typedef struct USBKBDCmdLEDAsync {
@@ -33,8 +33,8 @@ typedef struct USBKBDCmdLEDAsync {
USBKBDErr USBKBDInitialize(USBKBDAttachCallback attachCb, USBKBDDetachCallback detachCb);
USBKBDErr USBKBDSetLED(u32, u8, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32, u8, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDSetLED(u32 device, u8 ledBits, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32 device, u8 ledBits, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDRegisterEventCallback(USBKBDEventCallback cb);

View File

@@ -80,11 +80,11 @@ typedef struct {
typedef void (*WADProcessCallback)(u32 completed, u32 total, BOOL done);
s32 WADGetTitleVersionEx(char* path, ESTitleId* titleId, u16* titleVersion, WADLocation location, u32 offset);
s32 WADBackupEx(u64 titleId, u32 param_2, MEMAllocator* allocator, char* path, u32* sizeOut, WADLocation location, u32 param_7,
WADProcessCallback processCB);
s32 WADBackupEx(u64 titleId, u32 flags, MEMAllocator* allocator, char* path, u32* sizeOut, WADLocation location, u32 offset,
WADProcessCallback processCallback);
s32 WADImportGetBlocks(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 param_5, WADBlocks* blocks, u32* param_7);
s32 WADImportEx(char* path, MEMAllocator* allocator, WADLocation location, u32 param_4, u32 param_5, WADProcessCallback processCB);
s32 WADImportGetBlocks(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 flags, WADBlocks* blocks, u32* fileListOut);
s32 WADImportEx(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 flags, WADProcessCallback processCallback);
s32 WADGetInstalledVersion(ESTitleId titleID, u16* version);

View File

@@ -67,14 +67,17 @@ BOOL AXFXChorusExpSettings(AXFX_CHORUS_EXP* fx) {
OSRestoreInterrupts(enabled);
return result;
}
void AXFXChorusExpShutdown(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
static void __FreeDelayLine(AXFX_CHORUS_EXP* fx) {
u32 channel;
fx->active |= 1;
for (channel = 0; channel < 3; channel++) {
if (fx->delay.line[channel] != NULL) __AXFXFree(fx->delay.line[channel]);
fx->delay.line[channel] = NULL;
}
}
void AXFXChorusExpShutdown(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
fx->active |= 1;
__FreeDelayLine(fx);
OSRestoreInterrupts(enabled);
}
void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
@@ -118,10 +121,11 @@ void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
fx->history[0][history] = fx->delay.line[0][source];
fx->history[1][history] = fx->delay.line[1][source];
fx->history[2][history] = fx->delay.line[2][source];
history = (history + 1) & 3;
history++;
history &= 3;
source++;
if (source >= fx->delay.size) source = 0;
whole--;
if (source >= fx->delay.size) source = 0;
}
fx->delay.lastPos = position & 0xFFFF0000;
coefficients = __AXFXGetSrcCoef((fraction >> 9) & 0x7F);
@@ -129,14 +133,18 @@ void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
f32 filtered = 0.0f;
f32 dry;
filtered += coefficients[0] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[1] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[2] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[3] * fx->history[channel][history];
history = (history + 1) & 3;
if (fx->busIn != NULL) dry = *input[channel]++ + *output[channel];
history++;
history &= 3;
if (fx->busIn != NULL) dry = *output[channel] + *input[channel]++;
else dry = *output[channel];
fx->delay.line[channel][fx->delay.inPos] = dry + filtered * fx->feedback;
*output[channel]++ = filtered * fx->outGain;

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