some bufstreamnand stuff

src/band3/meta_band/SongSortByRank.cpp

@@ -1,12 +1,8 @@
 #include "meta_band/SongSortByRank.h"
 #include "meta/Sorting.h"
-#include "meta_band/BandSongMgr.h"
 #include "meta_band/MusicLibrary.h"
 #include "meta_band/ProfileMgr.h"
-#include "meta_band/SongSortNode.h"
 #include "net_band/RockCentral.h"
-#include "os/Debug.h"
-#include "stl/pointers/_vector.h"
 
 RankCmp::RankCmp(int val, const char *name, RankCmp::RankType ty)
     : mVal(val), mSongName(name), mType(ty) {}
@@ -80,3 +76,22 @@ void SongSortByRank::CancelSongRankingRequest() {
     TheRockCentral.CancelOutstandingCalls(this);
 }
 
+StoreSongSortNode SongSortByRank::*NewSongNode(StoreOffer *offer) {
+    const char *name = offer->OfferName();
+    //RankCmp *cmp = new 
+}
+
+DataNode SongSortByRank::OnMsg(RockCentralOpCompleteMsg const &msg) {
+    if(msg.Success()) {
+        for(int i = 0; i < mDataResults.mDataResultList.size(); i++) {
+            DataResult *res = mDataResults.GetDataResult(i);
+            //res->GetDataResultValue("SongSortByRank.cpp", );
+        }
+    }
+}
+
+BEGIN_HANDLERS(SongSortByRank)
+HANDLE_MESSAGE(RockCentralOpCompleteMsg)
+HANDLE_SUPERCLASS(SongSort)
+HANDLE_CHECK(0x13E)
+END_HANDLERS

src/band3/meta_band/SongSortByRank.h

@@ -2,6 +2,7 @@
 #include "meta_band/SongSort.h"
 #include "meta_band/SongSortNode.h"
 #include "net_band/DataResults.h"
+#include "net_band/RockCentralMsgs.h"
 #include "utl/Symbols.h"
 
 class RankCmp : public SongSortCmp {
@@ -36,6 +37,7 @@ class SongSortByRank : public SongSort {
     virtual OwnedSongSortNode *NewSongNode(SongRecord *) const;
     virtual StoreSongSortNode *NewSongNode(class StoreOffer *) const;
 
+    DataNode OnMsg(RockCentralOpCompleteMsg const&);
     void RequestSongRankingInfo();
     void CancelSongRankingRequest();
 

src/band3/meta_band/StoreMainPanel.cpp

@@ -1,3 +1,7 @@
 #include "meta/StorePackedMetadata.h"
+#include "StoreMainPanel.h"
 
-DECOMP_FORCEFUNC(StoreMainPanel, StoreMetadataManager, GetString(0))
+DECOMP_FORCEFUNC(StoreMainPanel, StoreMetadataManager, GetString(0))
+
+StoreMainPanel::~StoreMainPanel() {
+};

src/band3/meta_band/StoreMainPanel.h

@@ -0,0 +1,23 @@
+#pragma once 
+
+#include "meta/StoreArtLoaderPanel.h"
+#include "obj/Data.h"
+#include "utl/Str.h"
+
+class StoreMainPanel : StoreArtLoaderPanel {
+    class NewReleaseEntry {
+        public:
+        String mStrName; // 0x0
+        String mText1; // 0xC
+        String mText2; // 0x18
+        Symbol mRequiredOffer; // 0x24
+    };
+
+    public:
+    StoreMainPanel(); 
+    ~StoreMainPanel();
+    //NewReleaseEntry
+
+    DataArray *mPendingConfigData; // 0x6C
+    float mTimeNextEvent; // 
+};

src/system/meta/MemcardMgr_Wii.cpp

@@ -3,7 +3,11 @@
 MemcardMgr TheMemcardMgr;
 
 MemcardMgr::MemcardMgr()
-    : unka4(0), unka8(0), unkac(0), unkb9(0), unkbc(-1), unkc0(0), unkcc(0), unkd0(0),
+    : unka4(0), unka8(0), unkac(0), mIsWriteMode(0), unkbc(-1), unkc0(0), unkcc(0), unkd0(0),
       unkd4(-1), unkd8(-1), unkdc(0) {}
 
-MemcardMgr::~MemcardMgr() {}
+MemcardMgr::~MemcardMgr() {}
+
+bool MemcardMgr::IsWriteMode() {
+  return (mIsWriteMode >> 1) & 1;
+}

src/system/meta/MemcardMgr_Wii.h

@@ -10,6 +10,7 @@ class MemcardMgr : public MsgSource, public ThreadCallback {
     virtual ~MemcardMgr();
     virtual int ThreadStart();
     virtual void ThreadDone(int);
+    bool IsWriteMode();
 
     bool unk20;
     char unk21[64];
@@ -20,7 +21,7 @@ class MemcardMgr : public MsgSource, public ThreadCallback {
     int unkb0;
     int unkb4;
     bool unkb8;
-    bool unkb9;
+    bool mIsWriteMode; // 0xB9
     int unkbc;
     int unkc0; // mState
     int unkc4;

src/system/os/Memcard.h

@@ -8,6 +8,35 @@ enum AccessType {
 };
 enum CreateType {
 };
+enum MCResult {
+    kMCNoError,
+    kMCNoCard,
+    kMCNotFormatted,
+    kMCDifferentCard,
+    kMCReadWriteFailed,
+    kMCCorrupt,
+    kMCNotEnoughSpace,
+    kMCFileExists,
+    kMCFileNotFound,
+    kMCMultipleFilesFound,
+    kMCObsoleteVersion,
+    kMCNewerVersion,
+    kMCGeneralError,
+    kMCUnsupported,
+    kMCAlreadyFormatted,
+    kMCInsufficientInodes,
+    kMCSystemCorrupt,
+    kMCAccessError,
+    kMCMaxedSysMem,
+    kMCSystemMemCorrupt,
+    kMCUnknownError,
+    kMCNoEntriesError,
+    kMCNoFilesError,
+    kMCNoPermission,
+    kMCDeprecated,
+    kMCNotOwner,
+    kMCMax
+};
 
 class MCFile {
 public:

src/system/utl/BufStreamNAND.cpp

@@ -0,0 +1,211 @@
+#include "BufStreamNAND.h"
+#include "meta/MemcardMgr_Wii.h"
+#include "rndwii/Rnd.h"
+
+
+BufStreamNAND::BufStreamNAND(void *v1, int i1, char* buffer, bool b1) 
+    : FixedSizeSaveableStream(v1, i1, b1), mBuffer(buffer), mChecksum(0), mBytesChecksummed(0), mSize(i1), mFilePath(), mFileOpen(0) {
+
+}
+
+BufStreamNAND::~BufStreamNAND() {
+
+}
+
+int BufStreamNAND::Tell() {
+    return mRunningTell;
+}
+
+void BufStreamNAND::SetResult(MCResult result) {
+    mResult = result;
+}
+
+int BufStreamNAND::GetResult() {
+    return mResult;
+}
+
+bool BufStreamNAND::Fail() {
+    return mFail;
+}
+
+EofType BufStreamNAND::Eof() {
+    return (EofType)(mSize == mTell);
+}
+
+void BufStreamNAND::Clear() {
+    mFail = mBuffer == 0;
+    mTell = 0;
+    mRunningTell = 0;
+    mChunkSize = 0x40000;
+    unk80 = 0;
+    mResult = kMCNoError;
+    MILO_ASSERT(fmod(mSize, 4.503601775116288e15 - 4.503601774854144e15), 0x39);
+}
+
+int BufStreamNAND::Open() {
+    s32 file;
+    MCResult result;
+    SetGPHangDetectEnabled(false, "Open");
+    if(!mFileOpen) {
+        file = NANDOpen(mFilePath, mFileInfo, 3);
+        result = HandleResultNAND(file);
+        if(result) 
+            mFail = true;
+        else
+            mFileOpen = true;
+    }
+    SetGPHangDetectEnabled(true, "Open");
+
+    return file;
+}
+
+int BufStreamNAND::Close() {
+    s32 file;
+    MCResult result;
+    SetGPHangDetectEnabled(false, "Close");
+    if(mFileOpen) {
+        //NANDGetLength(mFileInfo, u32 *) // stack variable epic
+        file = NANDClose(mFileInfo);
+        result = HandleResultNAND(file);
+        if(result)
+            mFail = true;
+        else
+         mFileOpen = true;
+    }
+    SetGPHangDetectEnabled(true, "Close");
+    return result;
+}
+
+bool BufStreamNAND::FinishStream() {
+    int result = Close();
+    if(result) {
+        mFail = true;
+    }
+    return result;
+}
+
+void BufStreamNAND::ReadImpl(void *v1, int i1) {
+    // v5 = ui2
+    unsigned int temp;
+    if(!mFail) {
+        if((mTell + i1) > mChunkSize || !mRunningTell)
+            LoadBufferFromNAND();
+
+        if((mRunningTell + i1) > mSize || (mTell + i1) > mChunkSize) {
+            temp = mSize - mTell;
+            mFail = true;
+        }
+        // init_proc(&mBuffer[mTell], temp)
+        mRunningTell += temp;
+        if(mChecksum) {
+            if(!mFail) {
+                mChecksum->Update((unsigned char*)v1, temp);
+                mBytesChecksummed += temp;
+            }
+        }
+    }
+}
+
+int BufStreamNAND::Pad(int size) {
+    MILO_ASSERT(size > mSize, 0x170);
+    int result = 0;
+
+    while(size > mRunningTell) {
+        mTell = size - mRunningTell;
+
+        if(mTell > mChunkSize)
+            mTell = mChunkSize;
+        mRunningTell += mTell;
+
+        result = SaveBufferToNAND(0);
+        if(result) {
+            mFail = true;
+            return result;
+        }
+    }
+    return result;
+}
+
+int BufStreamNAND::PadToEnd() {
+    return Pad(mSize);
+}
+
+void BufStreamNAND::DeleteChecksum() {
+    if(mChecksum) {
+        delete(mChecksum);
+    }
+    mChecksum = 0;
+}
+
+int BufStreamNAND::LoadBufferFromNAND() {
+    SetGPHangDetectEnabled(false, "LoadBufferFromNAND");
+    s32 file = Open();
+    DoSeek(0, kSeekCur);
+    int v3 = mChunkSize;
+    int v4 = mRunningTell;
+    int v5 = mSize;
+
+    if(v4 + v3 > v5)
+        v3 = v5 - v4;
+    s32 res = NANDRead(mFileInfo, mBuffer, v3);
+
+    if(res == v3) {
+        mTell = 0;
+        SetGPHangDetectEnabled(true, "LoadBufferFromNAND");
+        return file;
+    }
+    else {
+        mFail = true;
+        MCResult result = HandleResultNAND(res);
+        SetGPHangDetectEnabled(true, "LoadBufferFromNAND");
+        return result;
+    }
+}
+
+int BufStreamNAND::SaveBufferToNAND(bool b1) {
+    SetGPHangDetectEnabled(false, "SaveBufferToNAND");
+    s32 file = Open();
+    s32 write = NANDWrite(mFileInfo, mBuffer, mTell);
+    if(write == mTell) {
+        memset(mBuffer, 0, mChunkSize);
+        mTell = 0;
+        if(b1 && mRunningTell == mSize && (file = Close()) != 0) {
+            mFail = true;
+            SetGPHangDetectEnabled(true, "SaveBufferToNAND");
+            return file;
+        }
+        else {
+            SetGPHangDetectEnabled(true, "SaveBufferToNAND");
+            return file;
+        }
+    }
+    else {
+        mFail = true;
+        MCResult result = HandleResultNAND(write);
+        SetGPHangDetectEnabled(true, "SaveBufferToNAND");
+        return result;
+    }
+}
+
+bool BufStreamNAND::FinishWrite() {
+    bool result = SaveBufferToNAND(false);
+    if(result)
+        mFail = true;
+    return result;
+}
+
+int BufStreamNAND::DoSeek(int i1, BinStream::SeekType seekType) {
+
+}
+
+void BufStreamNAND::SeekImpl(int i1, BinStream::SeekType seekType) {
+    if(TheMemcardMgr.IsWriteMode() && SaveBufferToNAND(false) != 0)
+        mFail = true;
+    else {
+        DoSeek(i1, seekType);
+        if(!TheMemcardMgr.IsWriteMode() && LoadBufferFromNAND()) {
+            mFail = true;
+        }
+    }
+
+}