int LPP_UtilsMsgDialogInit(int options, const char *text, ...)
{
char buffer[512];
va_list ap;
va_start(ap, text);
vsnprintf(buffer, 512, text, ap);
va_end(ap);
memset(&lpp_UtilsMsgDialogParams, 0, sizeof(lpp_UtilsMsgDialogParams));
lpp_UtilsMsgDialogParams.base.size = sizeof(lpp_UtilsMsgDialogParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsMsgDialogParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsMsgDialogParams.base.buttonSwap);
lpp_UtilsMsgDialogParams.base.graphicsThread = 17;
lpp_UtilsMsgDialogParams.base.accessThread = 19;
lpp_UtilsMsgDialogParams.base.fontThread = 18;
lpp_UtilsMsgDialogParams.base.soundThread = 16;
lpp_UtilsMsgDialogParams.mode = PSP_UTILITY_MSGDIALOG_MODE_TEXT;
lpp_UtilsMsgDialogParams.options = PSP_UTILITY_MSGDIALOG_OPTION_TEXT;
lpp_UtilsMsgDialogParams.options |= options;
strcpy(lpp_UtilsMsgDialogParams.message, buffer);
int res = sceUtilityMsgDialogInitStart(&lpp_UtilsMsgDialogParams);
if(res == 0) return 1;
return(res);
}
int LPP_UtilsBrowserInit(int memorysize, const char *url)
{
sceHttpInit(0x25800);
memset(&lpp_UtilsBrowserParams, 0, sizeof(lpp_UtilsBrowserParams));
lpp_UtilsBrowserParams.base.size = sizeof(lpp_UtilsBrowserParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsBrowserParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsBrowserParams.base.buttonSwap);
lpp_UtilsBrowserParams.base.graphicsThread = 17;
lpp_UtilsBrowserParams.base.accessThread = 19;
lpp_UtilsBrowserParams.base.fontThread = 18;
lpp_UtilsBrowserParams.base.soundThread = 16;
lpp_UtilsBrowserParams.memsize = memorysize;
lpp_UtilsBrowserParams.initialurl = (char *)url;
lpp_UtilsBrowserParams.numtabs = 3;
lpp_UtilsBrowserParams.textsize = PSP_UTILITY_HTMLVIEWER_TEXTSIZE_SMALL;
lpp_UtilsBrowserParams.connectmode = PSP_UTILITY_HTMLVIEWER_CONNECTMODE_MANUAL_ALL;
lpp_UtilsBrowserParams.textsize = PSP_UTILITY_HTMLVIEWER_TEXTSIZE_NORMAL;
lpp_UtilsBrowserParams.interfacemode = PSP_UTILITY_HTMLVIEWER_INTERFACEMODE_FULL;
lpp_UtilsBrowserParams.displaymode = PSP_UTILITY_HTMLVIEWER_DISPLAYMODE_SMART_FIT;
lpp_UtilsBrowserParams.memaddr = malloc(memorysize);
if(!lpp_UtilsBrowserParams.memaddr) return -1;
int res = sceUtilityHtmlViewerInitStart(&lpp_UtilsBrowserParams);
if(res == 0) return 1;
return res;
}
/**
* localtime_init: Perform initialization required for localtime().
* Called by PSP initialization code at program startup.
*
* [Parameters]
* None
* [Return value]
* None
*/
void localtime_init(void)
{
/* Find the PSP's time zone */
int utc_offset_min;
int32_t result = sceUtilityGetSystemParamInt(
PSP_SYSTEMPARAM_ID_INT_TIMEZONE, &utc_offset_min
);
if (result == 0) {
utc_offset = utc_offset_min * 60;
} else {
DMSG("Failed to get time zone: %s", psp_strerror(result));
utc_offset = 0;
}
/* Check whether daylight saving time is in use */
int dst;
result = sceUtilityGetSystemParamInt(
PSP_SYSTEMPARAM_ID_INT_DAYLIGHTSAVINGS, &dst
);
if (result == 0) {
if (dst) {
utc_offset += 60*60;
}
} else {
DMSG("Failed to get DST status: %s", psp_strerror(result));
}
}
int LPP_UtilsGameShareInit(const char *filepath, const char *name)
{
sceNetAdhocMatchingInit(32*1024);
memset(&lpp_UtilsGameShareParams, 0, sizeof(lpp_UtilsGameShareParams));
lpp_UtilsGameShareParams.base.size = sizeof(lpp_UtilsGameShareParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsGameShareParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsGameShareParams.base.buttonSwap);
lpp_UtilsGameShareParams.base.graphicsThread = 17;
lpp_UtilsGameShareParams.base.accessThread = 19;
lpp_UtilsGameShareParams.base.fontThread = 18;
lpp_UtilsGameShareParams.base.soundThread = 16;
size_t lsize = 0;
SceUID fd = sceIoOpen(filepath, PSP_O_RDONLY, 0777);
if(fd < 0) return -1;
lsize = sceIoLseek32(fd, 0, PSP_SEEK_END);
u8 *buffer = (u8*)malloc(lsize);
if(buffer == null)
{
sceIoClose(fd);
return -1;
}
sceIoLseek32(fd, 0, PSP_SEEK_SET);
int read = sceIoRead(fd, buffer,lsize);
if(read < lsize)
{
sceIoClose(fd);
free(buffer);
return -1;
}
sceIoClose(fd);
buffer[276] = 0x57;
strncpy((char *)&buffer[320], name, 127);
kuKernelMemcpy(&lpp_UtilsGameShareParams.name, "GameShar", 8);
lpp_UtilsGameShareParams.mode = 1;
lpp_UtilsGameShareParams.datatype = 2;
lpp_UtilsGameShareParams.data = buffer;
lpp_UtilsGameShareParams.datasize = lsize;
int res = sceUtilityGameSharingInitStart(&lpp_UtilsGameShareParams);
if(res == 0) return 1;
return (res);
}
int LPP_AdhocDialogInit(int type, char *name)
{
memset(&adhocparam, 0, sizeof(adhocparam));
kuKernelMemcpy(&adhocparam.name, name, sizeof(adhocparam.name));
adhocparam.timeout = 60;
memset(&lpp_UtilsNetconfData, 0, sizeof(lpp_UtilsNetconfData));
lpp_UtilsNetconfData.base.size = sizeof(lpp_UtilsNetconfData);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsNetconfData.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsNetconfData.base.buttonSwap);
lpp_UtilsNetconfData.base.graphicsThread = 17;
lpp_UtilsNetconfData.base.accessThread = 19;
lpp_UtilsNetconfData.base.fontThread = 18;
lpp_UtilsNetconfData.base.soundThread = 16;
lpp_UtilsNetconfData.action = type;
lpp_UtilsNetconfData.adhocparam = &adhocparam;
int res = sceUtilityNetconfInitStart(&lpp_UtilsNetconfData);
if(res == 0) return 1;
return res;
}
static void ConfigureDialog(pspUtilityMsgDialogParams *dialog, size_t dialog_size)
{
memset(dialog, 0, dialog_size);
dialog->base.size = dialog_size;
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE,
&dialog->base.language); // Prompt language
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN,
&dialog->base.buttonSwap); // X/O button swap
dialog->base.graphicsThread = 0x11;
dialog->base.accessThread = 0x13;
dialog->base.fontThread = 0x12;
dialog->base.soundThread = 0x10;
}
static int lua_getLanguage(lua_State *L)
{
if (lua_gettop(L) != 0) return luaL_error(L, "no arguments expected.");
int language;
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &language);
lua_pushnumber(L,language);
return 1;
}
void htmlViewerInit(char *url)
{
int res;
vpl = sceKernelCreateVpl("BrowserVpl", PSP_MEMORY_PARTITION_USER, 0, BROWSER_MEMORY + 256, NULL);
if (vpl < 0)
throwError(6000, "Error 0x%08X creating vpl.\n", vpl);
memset(¶ms, 0, sizeof(pspUtilityHtmlViewerParam));
params.base.size = sizeof(pspUtilityHtmlViewerParam);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, ¶ms.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, ¶ms.base.buttonSwap);
params.base.graphicsThread = 17;
params.base.accessThread = 19;
params.base.fontThread = 18;
params.base.soundThread = 16;
params.memsize = BROWSER_MEMORY;
params.initialurl = url;
params.numtabs = 1;
params.cookiemode = PSP_UTILITY_HTMLVIEWER_COOKIEMODE_DEFAULT;
params.homeurl = url;
params.textsize = PSP_UTILITY_HTMLVIEWER_TEXTSIZE_NORMAL;
params.displaymode = PSP_UTILITY_HTMLVIEWER_DISPLAYMODE_SMART_FIT;
params.options = PSP_UTILITY_HTMLVIEWER_DISABLE_STARTUP_LIMITS|PSP_UTILITY_HTMLVIEWER_ENABLE_FLASH;
params.interfacemode = PSP_UTILITY_HTMLVIEWER_INTERFACEMODE_FULL;
params.connectmode = PSP_UTILITY_HTMLVIEWER_CONNECTMODE_MANUAL_ALL;
// Note the lack of 'ms0:' on the paths
params.dldirname = "/PSP/PHOTO";
res = sceKernelAllocateVpl(vpl, params.memsize, ¶ms.memaddr, NULL);
if (res < 0)
throwError(6000, "Error 0x%08X allocating browser memory.\n", res);
res = sceUtilityHtmlViewerInitStart(¶ms);
if (res < 0)
throwError(6000, "Error 0x%08X initing browser.\n", res);
}
int oslInitNetDialog()
{
memset(&netConf, 0, sizeof(netConf));
netConf.base.size = sizeof(netConf);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &netConf.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &netConf.base.buttonSwap);
netConf.base.graphicsThread = 17;
netConf.base.accessThread = 19;
netConf.base.fontThread = 18;
netConf.base.soundThread = 16;
netConf.action = PSP_NETCONF_ACTION_CONNECTAP;
struct pspUtilityNetconfAdhoc adhocparam;
memset(&adhocparam, 0, sizeof(adhocparam));
netConf.adhocparam = &adhocparam;
int res = sceUtilityNetconfInitStart(&netConf); //<-- STAS: The error code shouldn't be ignored !
if (!res) dialogType = OSL_DIALOG_NETCONF;
return res; //<-- STAS END -->
}
int LPP_UtilsOskInit(const char *description, const char *initialtext)
{
memset(&lpp_UtilsOskDialogParams, 0, sizeof(lpp_UtilsOskDialogParams));
memset(&lpp_UtilsOskDialogData, 0, sizeof(lpp_UtilsOskDialogData));
lpp_UtilsOskDialogData.language = PSP_UTILITY_OSK_LANGUAGE_DEFAULT;
lpp_UtilsOskDialogData.lines = 1;
lpp_UtilsOskDialogData.unk_24 = 1;
lpp_UtilsOskDialogData.inputtype = PSP_UTILITY_OSK_INPUTTYPE_ALL;
if(description != null)
{
lpp_UtilsOskDialogData.desc = LPP_UtilsConvertToUni((char*)description);
}
if(initialtext != null)
{
lpp_UtilsOskDialogData.intext = LPP_UtilsConvertToUni((char*)initialtext);
}
lpp_UtilsOskDialogData.outtextlength = 512;
lpp_UtilsOskDialogData.outtextlimit = 512;
lpp_UtilsOskDialogData.outtext = lpp_UtilsOskOutText;
lpp_UtilsOskDialogParams.base.size = sizeof(lpp_UtilsOskDialogParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsOskDialogParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsOskDialogParams.base.buttonSwap);
lpp_UtilsOskDialogParams.base.graphicsThread = 17;
lpp_UtilsOskDialogParams.base.accessThread = 19;
lpp_UtilsOskDialogParams.base.fontThread = 18;
lpp_UtilsOskDialogParams.base.soundThread = 16;
lpp_UtilsOskDialogParams.datacount = 1;
lpp_UtilsOskDialogParams.data = &lpp_UtilsOskDialogData;
int res = sceUtilityOskInitStart(&lpp_UtilsOskDialogParams);
if(res == 0) return 1;
return(res);
}
int LPP_UtilsNetDialogInit(void)
{
memset(&lpp_UtilsNetconfData, 0, sizeof(lpp_UtilsNetconfData));
lpp_UtilsNetconfData.base.size = sizeof(lpp_UtilsNetconfData);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsNetconfData.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsNetconfData.base.buttonSwap);
lpp_UtilsNetconfData.base.graphicsThread = 17;
lpp_UtilsNetconfData.base.accessThread = 19;
lpp_UtilsNetconfData.base.fontThread = 18;
lpp_UtilsNetconfData.base.soundThread = 16;
lpp_UtilsNetconfData.action = 0;
struct pspUtilityNetconfAdhoc adhocparam;
memset(&adhocparam, 0, sizeof(adhocparam));
lpp_UtilsNetconfData.adhocparam = &adhocparam;
int res = sceUtilityNetconfInitStart(&lpp_UtilsNetconfData);
if(res == 0) return 1;
return res;
}
int LPP_UtilsMsgDialogErrorInit(u32 error)
{
memset(&lpp_UtilsMsgDialogParams, 0, sizeof(lpp_UtilsMsgDialogParams));
lpp_UtilsMsgDialogParams.base.size = sizeof(lpp_UtilsMsgDialogParams);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsMsgDialogParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsMsgDialogParams.base.buttonSwap);
lpp_UtilsMsgDialogParams.base.graphicsThread = 17;
lpp_UtilsMsgDialogParams.base.accessThread = 19;
lpp_UtilsMsgDialogParams.base.fontThread = 18;
lpp_UtilsMsgDialogParams.base.soundThread = 16;
lpp_UtilsMsgDialogParams.mode = PSP_UTILITY_MSGDIALOG_MODE_ERROR;
lpp_UtilsMsgDialogParams.options = PSP_UTILITY_MSGDIALOG_OPTION_ERROR;
lpp_UtilsMsgDialogParams.errorValue = error;
int res = sceUtilityMsgDialogInitStart(&lpp_UtilsMsgDialogParams);
if(res == 0) return 1;
return(res);
}
void get_confirm_button(void)
{
int result = 0;
sceUtilityGetSystemParamInt(9, &result);
if (result == 0) { // Circle?
g_ctrl_OK = PSP_CTRL_CIRCLE;
g_ctrl_CANCEL = PSP_CTRL_CROSS;
} else {
g_ctrl_OK = PSP_CTRL_CROSS;
g_ctrl_CANCEL = PSP_CTRL_CIRCLE;
}
}
//**********************************************************************************
//
//**********************************************************************************
bool CLanguage::Open()
{
s32 val;
if ( sceUtilityGetSystemParamInt( PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &val ) != PSP_SYSTEMPARAM_RETVAL_FAIL )
{
switch ( val )
{
case PSP_SYSTEMPARAM_LANGUAGE_JAPANESE:
s_eLanguage = LANG_JAPANESE;
break;
case PSP_SYSTEMPARAM_LANGUAGE_ENGLISH:
s_eLanguage = LANG_ENGLISH;
break;
case PSP_SYSTEMPARAM_LANGUAGE_FRENCH:
s_eLanguage = LANG_FRENCH;
break;
case PSP_SYSTEMPARAM_LANGUAGE_SPANISH:
s_eLanguage = LANG_SPANISH;
break;
case PSP_SYSTEMPARAM_LANGUAGE_GERMAN:
s_eLanguage = LANG_GERMAN;
break;
case PSP_SYSTEMPARAM_LANGUAGE_ITALIAN:
s_eLanguage = LANG_ITALIAN;
break;
case PSP_SYSTEMPARAM_LANGUAGE_DUTCH:
s_eLanguage = LANG_DUTCH;
break;
case PSP_SYSTEMPARAM_LANGUAGE_PORTUGUESE:
s_eLanguage = LANG_PORTUGESE;
break;
case PSP_SYSTEMPARAM_LANGUAGE_KOREAN:
s_eLanguage = LANG_KOREAN;
break;
default:
break;
}
return true;
}
return false;
}
int sceUtilityGetSystemParamInt_patched( int id, int *value )
{
int ret;
k1 = pspSdkGetK1();
ret = sceUtilityGetSystemParamInt(id, value);
if (ret != 0) goto noPatch_exit;
if (id == 8)
{
*value = languagePatch;
}
noPatch_exit:
pspSdkSetK1(k1);
return ret;
}
/**
* Initialize Networking Components for Adhocctl Emulator
* @param adhoc_id Game Product Code
* @param server_ip Server IP
* @return 0 on success or... -1
*/
int _initNetwork(const SceNetAdhocctlAdhocId * adhoc_id, const char * server_ip)
{
// WLAN Switch Check
if(sceWlanGetSwitchState() == 1)
{
// Initialize Access Point Control
if(sceNetApctlInit(0x1800, 0x30) == 0)
{
// Attempt Counter
int attemptmax = 10;
// Attempt Number
int attempt = 0;
// Attempt Connection Setup
for(; attempt < attemptmax; attempt++)
{
// Start Connection
if(sceNetApctlConnect(_hotspot) == 0)
{
// Wait for Connection
int statebefore = 0;
int state = 0; while(state != 4)
{
// Query State
int getstate = sceNetApctlGetState(&state);
// Log State Change
if(statebefore != state) printk("New Connection State: %d\n", state);
// Query Success
if(getstate == 0 && state != 4)
{
// Wait for Retry
sceKernelDelayThread(1000000);
}
// Query Error
else break;
// Save Before State
statebefore = state;
}
// Connected
if(state == 4)
{
// Create Friend Finder Socket
int socket = sceNetInetSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Created Socket
if(socket > 0)
{
// Enable Port Re-use
sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &_one, sizeof(_one));
sceNetInetSetsockopt(socket, SOL_SOCKET, SO_REUSEPORT, &_one, sizeof(_one));
// Apply Receive Timeout Settings to Socket
// uint32_t timeout = ADHOCCTL_RECV_TIMEOUT;
// sceNetInetSetsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
// Server IP
uint32_t ip = 0;
// Initialize DNS Resolver
if(sceNetResolverInit() == 0)
{
// Create DNS Resolver
unsigned char rbuf[512]; int rid = 0;
if(sceNetResolverCreate(&rid, rbuf, sizeof(rbuf)) == 0)
{
// Resolve Domain
if(sceNetResolverStartNtoA(rid, server_ip, &ip, 500000, 2) != 0)
{
// Attempt IP Conversion
sceNetInetInetAton(server_ip, &ip);
}
// Delete DNS Resolver
sceNetResolverDelete(rid);
}
// Shutdown DNS Resolver
sceNetResolverTerm();
}
// Prepare Server Address
SceNetInetSockaddrIn addr;
addr.sin_len = sizeof(addr);
addr.sin_family = AF_INET;
addr.sin_addr = ip;
addr.sin_port = sceNetHtons(ADHOCCTL_METAPORT);
// Connect to Server
if(sceNetInetConnect(socket, (SceNetInetSockaddr *)&addr, sizeof(addr)) == 0)
{
// Save Meta Socket
_metasocket = socket;
// Save Product Code
_product_code = *adhoc_id;
// Clear Event Handler
memset(_event_handler, 0, sizeof(_event_handler[0]) * ADHOCCTL_MAX_HANDLER);
memset(_event_args, 0, sizeof(_event_args[0]) * ADHOCCTL_MAX_HANDLER);
// Clear Internal Control Status
memset(&_parameter, 0, sizeof(_parameter));
// Read PSP Player Name
sceUtilityGetSystemParamString(PSP_SYSTEMPARAM_ID_STRING_NICKNAME, (char *)_parameter.nickname.data, ADHOCCTL_NICKNAME_LEN);
// Read Adhoc Channel
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_ADHOC_CHANNEL, &_parameter.channel);
// Fake Channel Number 1 on Automatic Channel
if(_parameter.channel == 0) _parameter.channel = 1;
// Read PSP MAC Address
sceWlanGetEtherAddr((void *)&_parameter.bssid.mac_addr.data);
// Prepare Login Packet
SceNetAdhocctlLoginPacketC2S packet;
// Set Packet Opcode
packet.base.opcode = OPCODE_LOGIN;
// Set MAC Address
packet.mac = _parameter.bssid.mac_addr;
// Set Nickname
packet.name = _parameter.nickname;
// Set Game Product ID
memcpy(packet.game.data, adhoc_id->data, ADHOCCTL_ADHOCID_LEN);
// Acquire Network Layer Lock
_acquireNetworkLock();
// Send Login Packet
sceNetInetSend(_metasocket, &packet, sizeof(packet), INET_MSG_DONTWAIT);
// Free Network Layer Lock
_freeNetworkLock();
// Load UPNP Library
_upnp_uid = sceKernelLoadModule("ms0:/kd/pspnet_miniupnc.prx", 0, NULL);
// Start UPNP Library
int status = 0; sceKernelStartModule(_upnp_uid, 0, NULL, &status, NULL);
// Return Success
return 0;
}
// Delete Socket
sceNetInetClose(socket);
}
// Close Hotspot Connection
sceNetApctlDisconnect();
}
}
}
// Terminate Access Point Control
sceNetApctlTerm();
}
}
// Generic Error
return -1;
}
int GetTextOSK(char *buf,int buflen,int mode,const char *title,const char *init)
{
if(buf == NULL)return -1;
u16 *winit,*wtitle,*wresult;
char nulstr[] = "";
if(init == NULL)init = nulstr;
if(title == NULL)title = nulstr;
winit = (u16*)malloc((strlen(init) + 1) * 2);
wtitle = (u16*)malloc((strlen(title) + 1) * 2);
wresult = (u16*)malloc((buflen + 1) * 2);
if(winit == NULL || wtitle == NULL || wresult == NULL)
{
free(winit);
free(wtitle);
free(wresult);
return -1;
}
dxpCpCode_toUcs2(winit,strlen(init) + 1,(const dxpChar*)init,dxpGeneralData.charset);
dxpCpCode_toUcs2(wtitle,strlen(title) + 1,(const dxpChar*)title,dxpGeneralData.charset);
SceUtilityOskData data;
memset(&data, 0, sizeof(SceUtilityOskData));
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &data.language);
data.unk_00 = 1; //ATOK
data.lines = 1;
data.unk_24 = 1;
data.inputtype = mode;
data.desc = wtitle;
data.intext = winit;
data.outtextlength = buflen;
data.outtextlimit = buflen;
data.outtext = wresult;
SceUtilityOskParams params;
memset(¶ms,0x00,sizeof(params));
params.base.size = sizeof(params);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE,¶ms.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN,¶ms.base.buttonSwap);
params.base.graphicsThread = 0x11;
params.base.accessThread = 0x13;
params.base.fontThread = 0x12;
params.base.soundThread = 0x10;
params.datacount = 1;
params.data = &data;
sceUtilityOskInitStart(¶ms);
int done = 0;
while(ProcessMessage() != -1 && !done)
{
ClearDrawScreen();
if ( dxpDialogDrawScene != NULL ) dxpDialogDrawScene();
GUFINISH
switch(sceUtilityOskGetStatus())
{
case PSP_UTILITY_DIALOG_INIT:
break;
case PSP_UTILITY_DIALOG_VISIBLE:
sceUtilityOskUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT:
sceUtilityOskShutdownStart();
break;
case PSP_UTILITY_DIALOG_NONE:
case PSP_UTILITY_DIALOG_FINISHED:
done = 1;
break;
default:
break;
}
ScreenFlip();
}
// dxpCpSJIS_fromUcs2((dxpChar*)buf,buflen,wresult);
dxpCpCode_fromUcs2((dxpChar*)buf,buflen,wresult,dxpGeneralData.charset);
free(winit);
free(wtitle);
free(wresult);
return 0;
}
/*
Returns a string typed through the PSP built-in keyboard.
*/
VALUE Joyau_gets(VALUE self)
{
SceUtilityOskData data;
SceUtilityOskParams params;
unsigned short input[128] = { 'E', 'n', 't', 'e', 'r', ' ',
'y', 'o', 'u', 'r', ' ',
't', 'e','x', 't', 0 };
unsigned short output[128] = { 0 };
memset(&data, 0, sizeof(data));
data.lines = 1;
data.unk_24 = 1;
data.inputtype = PSP_UTILITY_OSK_INPUTTYPE_ALL;
data.desc = input;
data.intext = input;
data.outtextlength = 128;
data.outtextlimit = 128;
data.outtext = output;
memset(¶ms, 0, sizeof(params));
params.base.size = sizeof(params);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE,
¶ms.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN,
¶ms.base.buttonSwap);
params.base.graphicsThread = 17;
params.base.accessThread = 19;
params.base.fontThread = 18;
params.base.soundThread = 16;
params.datacount = 1;
params.data = &data;
sceUtilityOskInitStart(¶ms);
bool done = false;
while (!done)
{
oslStartDrawing();
oslDrawFillRect(0, 0, 480, 272, RGBA(0, 0, 0, 255));
oslEndDrawing();
switch(sceUtilityOskGetStatus())
{
case PSP_UTILITY_DIALOG_INIT:
break;
case PSP_UTILITY_DIALOG_VISIBLE:
sceUtilityOskUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT:
sceUtilityOskShutdownStart();
break;
case PSP_UTILITY_DIALOG_FINISHED:
break;
case PSP_UTILITY_DIALOG_NONE:
done = true;
default :
break;
}
oslEndDrawing();
oslEndFrame();
oslSyncFrame();
}
char *ret = new char[128];
for (int i = 0; i < 128; ++i)
ret[i] = (char)data.outtext[i];
return rb_str_new2(ret);
}
/*
call-seq: run(input_type, language, text, desc, output_size) { ... }
Shows the OSK (Sony's default keyboard), and returns the input text.
Example:
Joyau::OSK.run(Joyau::OSK::ALL, Joyau::OSK::DEFAULT,
"Anonymous", "Enter your nickame", 16) do
Joyau.clearScreen # this is suffisant to avoid glitches,
# Although you might copy the old screen buffer,
# and draw it here.
*/
VALUE Osk_run(VALUE self, VALUE type, VALUE lang, VALUE rb_input,
VALUE rb_desc, VALUE output_size)
{
SceUtilityOskData data;
SceUtilityOskParams params;
char *char_input = StringValuePtr(rb_input);
int char_size = strlen(char_input);
unsigned short *input = new unsigned short[char_size + 1];
for (int i = 0; i < char_size + 1; ++i)
input[i] = char_input[i];
char *char_desc = StringValuePtr(rb_desc);
char_size = strlen(char_desc);
unsigned short *desc = new unsigned short[char_size + 1];
for (int i = 0; i < char_size + 1; ++i)
desc[i] = char_desc[i];
unsigned short *output = new unsigned short[FIX2INT(output_size)];
memset(&data, 0, sizeof(data));
data.lines = 1;
data.unk_24 = 1;
data.inputtype = INT2FIX(type);
data.desc = desc;
data.intext = input;
data.outtextlength = FIX2INT(output_size);
data.outtextlimit = FIX2INT(output_size);
data.outtext = output;
memset(¶ms, 0, sizeof(params));
params.base.size = sizeof(params);
params.base.language = FIX2INT(lang);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN,
¶ms.base.buttonSwap);
params.base.soundThread = 16;
params.base.graphicsThread = 17;
params.base.accessThread = 19;
params.base.fontThread = 18;
params.datacount = 1;
params.data = &data;
sceUtilityOskInitStart(¶ms);
bool done = false;
while (!done)
{
oslStartDrawing();
rb_yield(Qnil);
oslEndDrawing();
switch(sceUtilityOskGetStatus())
{
case PSP_UTILITY_DIALOG_INIT:
break;
case PSP_UTILITY_DIALOG_VISIBLE:
sceUtilityOskUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT:
sceUtilityOskShutdownStart();
break;
case PSP_UTILITY_DIALOG_FINISHED:
break;
case PSP_UTILITY_DIALOG_NONE:
done = true;
default :
break;
}
oslEndDrawing();
oslEndFrame();
oslSyncFrame();
}
char *ret = new char[FIX2INT(output_size)];
for (int i = 0; i < FIX2INT(output_size); ++i)
ret[i] = (char)data.outtext[i];
delete[] input;
delete[] desc;
delete[] output;
return rb_str_new2(ret);
}
int LPP_UtilsSavedataInit(int type, void *data, u32 datasize, const char *cPath, const char *gamename, const char *key, const char *title, const char *subtitle, const char *detail)
{
lpp_UtilsSaveDataData = data;
PspUtilitySavedataListSaveNewData newData;
memset(&newData, 0, sizeof(newData));
memset(&lpp_UtilsSavedataParams, 0, sizeof(lpp_UtilsSavedataParams));
lpp_UtilsSavedataParams.base.size = sizeof(lpp_UtilsSavedataParams);
void *icon0data = null;
size_t icon0size = 0;
void *pic1data = null;
size_t pic1size = 0;
void* snd0data = null;
size_t snd0size = 0;
char *titleshow = "New Save";
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &lpp_UtilsSavedataParams.base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &lpp_UtilsSavedataParams.base.buttonSwap);
lpp_UtilsSavedataParams.base.graphicsThread = 17;
lpp_UtilsSavedataParams.base.accessThread = 19;
lpp_UtilsSavedataParams.base.fontThread = 18;
lpp_UtilsSavedataParams.base.soundThread = 16;
lpp_UtilsSavedataParams.mode = type;
lpp_UtilsSavedataParams.overwrite = 1;
if(type == LPP_UTILS_SAVEDATA_TYPE_LISTLOAD)
{
lpp_UtilsSavedataParams.focus = PSP_UTILITY_SAVEDATA_FOCUS_LATEST;
}
else
{
lpp_UtilsSavedataParams.focus = PSP_UTILITY_SAVEDATA_FOCUS_FIRSTEMPTY;
}
strncpy(lpp_UtilsSavedataParams.key, key, 16);
strncpy(lpp_UtilsSavedataParams.gameName, gamename, 9);
strcpy(lpp_UtilsSavedataParams.saveName, "<>");
if(type == LPP_UTILS_SAVEDATA_TYPE_AUTOLOAD || type == LPP_UTILS_SAVEDATA_TYPE_AUTOSAVE)
{
strcpy(lpp_UtilsSavedataParams.saveName, lpp_UtilsSavedataSaveName);
}
else
{
lpp_UtilsSavedataParams.saveNameList = lpp_UtilsSaveNameMultiple;
}
strcpy(lpp_UtilsSavedataParams.fileName, "DATA.BIN");
lpp_UtilsSavedataParams.dataBuf = malloc(datasize);
lpp_UtilsSavedataParams.dataBufSize = datasize;
lpp_UtilsSavedataParams.dataSize = datasize;
if(type == LPP_UTILS_SAVEDATA_TYPE_AUTOSAVE || type == LPP_UTILS_SAVEDATA_TYPE_LISTSAVE)
{
memset(lpp_UtilsSavedataParams.dataBuf, 0, datasize);
strncpy(lpp_UtilsSavedataParams.dataBuf, data, datasize);
strcpy(lpp_UtilsSavedataParams.sfoParam.title, title);
strcpy(lpp_UtilsSavedataParams.sfoParam.savedataTitle, subtitle);
strcpy(lpp_UtilsSavedataParams.sfoParam.detail, detail);
lpp_UtilsSavedataParams.sfoParam.parentalLevel = 0;
if(type != LPP_UTILS_SAVEDATA_TYPE_AUTOSAVE)
{
if(strcmp(cPath, "EBOOT.PBP") == 0 || strcmp(cPath, "EBOOT.PBP/") == 0 || strcmp(cPath, "EBOOT.PBP\\") == 0)
{
SceUID fd = sceIoOpen(cPath, PSP_O_RDONLY, 0777);
if(fd >= 0)
{
EBOOT_HEADER pbpHeader;
memset(&pbpHeader, 0, sizeof(pbpHeader));
sceIoRead(fd, &pbpHeader, sizeof(pbpHeader));
u32 filesize = pbpHeader.offset[2] - pbpHeader.offset[1];
if(filesize > 0)
{
sceIoLseek32(fd, pbpHeader.offset[1], PSP_SEEK_SET);
icon0data = malloc(filesize);
icon0size = filesize;
sceIoRead(fd, icon0data, filesize);
}
filesize = pbpHeader.offset[5] - pbpHeader.offset[4];
if(filesize)
{
sceIoLseek32(fd, pbpHeader.offset[4], PSP_SEEK_SET);
pic1data = malloc(filesize);
pic1size = filesize;
sceIoRead(fd, pic1data, filesize);
}
filesize = pbpHeader.offset[6] - pbpHeader.offset[5];
if(filesize)
{
sceIoLseek32(fd, pbpHeader.offset[5], PSP_SEEK_SET);
snd0data = malloc(filesize);
snd0size = filesize;
sceIoRead(fd, snd0data, filesize);
}
sceIoClose(fd);
}
} else {
char fname[512];
u8 o = cPath[strlen(cPath) - 1] == '/' || cPath[strlen(cPath) - 1] == '\\';
sprintf(fname, o ? "%sICON0.PNG" : "%s/ICON0.PNG", cPath);
if(LPP_FileExists(fname))
{
SceUID fd = sceIoOpen(fname, PSP_O_RDONLY, 0777);
icon0size = sceIoLseek32(fd, 0, PSP_SEEK_END);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
icon0data = malloc(icon0size);
sceIoRead(fd, icon0data, icon0size);
sceIoClose(fd);
}
sprintf(fname, o ? "%sPIC1.PNG" : "%s/PIC1.PNG", cPath);
if(LPP_FileExists(fname))
{
SceUID fd = sceIoOpen(fname, PSP_O_RDONLY, 0777);
pic1size = sceIoLseek32(fd, 0, PSP_SEEK_END);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
pic1data = malloc(pic1size);
sceIoRead(fd, pic1data, pic1size);
sceIoClose(fd);
}
sprintf(fname, o ? "%sSND0.AT3" : "%s/SND0.AT3", cPath);
if(LPP_FileExists(fname))
{
SceUID fd = sceIoOpen(fname, PSP_O_RDONLY, 0777);
snd0size = sceIoLseek32(fd, 0, PSP_SEEK_END);
sceIoLseek32(fd, 0, PSP_SEEK_SET);
snd0data = malloc(snd0size);
sceIoRead(fd, snd0data, snd0size);
sceIoClose(fd);
}
}
}
lpp_UtilsSavedataParams.icon1FileData.buf = null;
lpp_UtilsSavedataParams.icon1FileData.bufSize = 0;
lpp_UtilsSavedataParams.icon1FileData.size = 0;
lpp_UtilsSavedataParams.pic1FileData.buf = pic1data;
lpp_UtilsSavedataParams.pic1FileData.bufSize = pic1size;
lpp_UtilsSavedataParams.pic1FileData.size = pic1size;
lpp_UtilsSavedataParams.icon0FileData.buf = icon0data;
lpp_UtilsSavedataParams.icon0FileData.bufSize = icon0size;
lpp_UtilsSavedataParams.icon0FileData.size = icon0size;
lpp_UtilsSavedataParams.snd0FileData.buf = snd0data;
lpp_UtilsSavedataParams.snd0FileData.bufSize = snd0size;
lpp_UtilsSavedataParams.snd0FileData.size = snd0size;
newData.title = titleshow;
lpp_UtilsSavedataParams.newData = &newData;
}
int res = sceUtilitySavedataInitStart(&lpp_UtilsSavedataParams);
if(res == 0) return 1;
return(res);
}
char *SonyOSK(int len, const char *_desc, const char *inittext, triImage* img)
{
unsigned short intext[MAX_TEXT_LENGTH];
unsigned short outtext[MAX_TEXT_LENGTH];
unsigned short desc[MAX_TEXT_LENGTH];
memset(intext, 0, MAX_TEXT_LENGTH * sizeof(unsigned short));
memset(outtext, 0, MAX_TEXT_LENGTH * sizeof(unsigned short));
memset(desc, 0, MAX_TEXT_LENGTH * sizeof(unsigned short));
int i;
int txt_len = strlen(_desc);
for(i=0;i<txt_len;i++)
{
desc[i] = _desc[i];
}
desc[txt_len] = 0;
txt_len = strlen(inittext);
for(i=0;i<txt_len;i++)
{
intext[i] = inittext[i];
}
intext[txt_len] = 0;
SceUtilityOskData data;
memset(&data, 0, sizeof(SceUtilityOskData));
data.language = PSP_UTILITY_OSK_LANGUAGE_DEFAULT; // Use system default for text input
data.lines = 1;
data.unk_24 = 1;
data.inputtype = PSP_UTILITY_OSK_INPUTTYPE_ALL; // Allow all input types
data.desc = desc;
data.intext = intext;
data.outtextlength = MAX_TEXT_LENGTH;
data.outtextlimit = len;
data.outtext = outtext;
SceUtilityOskParams params;
memset(¶ms, 0, sizeof(params));
params.base.size = sizeof(params);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, ¶ms.base.language);
//sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, ¶ms.base.buttonSwap);
params.base.buttonSwap = 1;
params.base.graphicsThread = 17;
params.base.accessThread = 19;
params.base.fontThread = 18;
params.base.soundThread = 16;
params.datacount = 1;
params.data = &data;
sceUtilityOskInitStart(¶ms);
int done = 0;
while(!done)
{
triClear( 0 );
if(img)
triDrawImage2( 0.f, 0.f, img );
sceGuFinish();
sceGuSync(0,0);
int stat = sceUtilityOskGetStatus();
switch(stat)
{
case PSP_UTILITY_DIALOG_INIT:
break;
case PSP_UTILITY_DIALOG_VISIBLE:
sceUtilityOskUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT:
sceUtilityOskShutdownStart();
break;
case PSP_UTILITY_DIALOG_FINISHED:
break;
case PSP_UTILITY_DIALOG_NONE:
done = 1;
default :
break;
}
triSwapbuffers();
}
int j;
char buf[sizeof(unsigned)];
char *ret = new char[len+1];
memset(ret, 0, len+1);
for(j = 0; data.outtext[j]; j++)
{
unsigned c = data.outtext[j];
if(32 <= c && c <= 127) // print ascii only
{
sprintf(buf, "%c", data.outtext[j]);
strcat(ret, buf);
}
}
ret[j] = 0;
triLogPrint("ret: %s (%d)\n", ret, strlen(ret));
return ret;
}
static int dxpSaveDialogInit(
/* 格納する構造体 */
SceUtilitySavedataParam * savedata,
/* セーブモード */
int mode,
/* セーブするデータのバッファアドレス */
void * buf,
/* セーブするデータのバッファサイズ */
unsigned int size,
/* ms0:/PSP/SAVEDATA/GameName/って感じ */
const char * GameName,
/* AUTO SAVE時にセーブする場所 */
const char * SaveName,
/* セーブリスト */
char (*nameMultiple)[20],
/* ゲームのタイトル */
const char * GameTitle,
/* セーブデータのタイトル */
const char * SaveTitle,
/* セーブデータの詳細 */
const char * SaveDetail
)
{
memset(savedata, 0, sizeof(SceUtilitySavedataParam));
savedata->base.size = sizeof(SceUtilitySavedataParam);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_LANGUAGE, &savedata->base.language);
sceUtilityGetSystemParamInt(PSP_SYSTEMPARAM_ID_INT_UNKNOWN, &savedata->base.buttonSwap);
savedata->base.graphicsThread = 0x11;
savedata->base.accessThread = 0x13;
savedata->base.fontThread = 0x12;
savedata->base.soundThread = 0x10;
savedata->mode = (PspUtilitySavedataMode)mode;
savedata->overwrite = 1;
//最近セーブしたファイルにフォーカス
savedata->focus = PSP_UTILITY_SAVEDATA_FOCUS_LATEST;
#if _PSP_FW_VERSION >= 200
const char key[] = "ThisIsASampleKey";
strncpy(savedata->key, key, 16);
#endif
strncpy(savedata->gameName, GameName, 13);
savedata->gameName[12] = 0;
strncpy(savedata->saveName, SaveName, 20);
savedata->saveName[19] = 0;
savedata->saveNameList = nameMultiple;
strncpy(savedata->fileName, DXP_SAVE_DATANAME, 13);
savedata->fileName[12] = 0;
if ( size != 0 ) {
savedata->dataBuf = malloc(size);
if (savedata->dataBuf == NULL) return -1;
} else {
savedata->dataBuf = NULL;
}
savedata->dataBufSize = size;
savedata->dataSize = size;
if ( mode == PSP_UTILITY_SAVEDATA_LISTSAVE ||
mode == PSP_UTILITY_SAVEDATA_AUTOSAVE ||
mode == PSP_UTILITY_SAVEDATA_SAVE )
{
//データのコピー
memset(savedata->dataBuf, 0x0, size);
memcpy(savedata->dataBuf, buf, size);
if ( dxpGeneralData.charset == DXP_CP_UTF8 ) {
strncpy(savedata->sfoParam.title, GameTitle, 128);
strncpy(savedata->sfoParam.savedataTitle, SaveTitle, 128);
strncpy(savedata->sfoParam.detail, SaveDetail, 1024);
savedata->sfoParam.title[127] = 0;
savedata->sfoParam.savedataTitle[127] = 0;
savedata->sfoParam.detail[1023] = 0;
savedata->sfoParam.parentalLevel = 1;
} else if ( dxpGeneralData.charset == DXP_CP_SJIS ) {
//128byte
char utf8[1024];
sjis_to_utf8((void*)utf8, (void*)GameTitle);
utf8[127] = '\0';
strncpy(savedata->sfoParam.title, utf8, 128);
sjis_to_utf8((void*)utf8, (void*)SaveTitle);
utf8[127] = '\0';
strncpy(savedata->sfoParam.savedataTitle, utf8, 128);
//1024byte
sjis_to_utf8((void*)utf8, (void*)SaveDetail);
utf8[1023] = '\0';
strncpy(savedata->sfoParam.detail, utf8, 1024);
savedata->sfoParam.parentalLevel = 1;
}
//背景
savedata->pic1FileData.buf = dxp_save_resource[DXP_SAVE_RESOURCE_PIC1].buf;
savedata->pic1FileData.bufSize = dxp_save_resource[DXP_SAVE_RESOURCE_PIC1].size;
savedata->pic1FileData.size = dxp_save_resource[DXP_SAVE_RESOURCE_PIC1].size;
//アイコン
savedata->icon0FileData.buf = dxp_save_resource[DXP_SAVE_RESOURCE_ICON0].buf;
savedata->icon0FileData.bufSize = dxp_save_resource[DXP_SAVE_RESOURCE_ICON0].size;
savedata->icon0FileData.size = dxp_save_resource[DXP_SAVE_RESOURCE_ICON0].size;
//説明
savedata->icon1FileData.buf = dxp_save_resource[DXP_SAVE_RESOURCE_ICON1].buf;
savedata->icon1FileData.bufSize = dxp_save_resource[DXP_SAVE_RESOURCE_ICON1].size;
savedata->icon1FileData.size = dxp_save_resource[DXP_SAVE_RESOURCE_ICON1].size;
//音楽
savedata->snd0FileData.buf = dxp_save_resource[DXP_SAVE_RESOURCE_SND0].buf;
savedata->snd0FileData.bufSize = dxp_save_resource[DXP_SAVE_RESOURCE_SND0].size;
savedata->snd0FileData.size = dxp_save_resource[DXP_SAVE_RESOURCE_SND0].size;
const char* new_title = "新規作成";
char new_title_utf8[20];
sjis_to_utf8((void*)new_title_utf8, (const void*)new_title);
new_title_utf8[19] = '\0';
newData.title = new_title_utf8;
savedata->newData = &newData;
//空のファイルが最初
savedata->focus = PSP_UTILITY_SAVEDATA_FOCUS_FIRSTEMPTY;
}
return 0;
}
