bool Menu_Delete(){
WPAD_Rumble(0,0);
self.rumbleAmt = 0;
struct discHdr *header = NULL;
char gameName[31];
/* No game list */
if (!self.gameCnt)
return false;
/* Selected game */
header = &self.gameList[self.gameSelected];
char title[MAX_TITLE_LEN];
if(self.usingTitlesTxt){
sprintf(title, "%s", header->title);
getTitle(titleList, (char*)header->id, title);
}
else
sprintf(title, "%s", (header->title));
if(strlen(title) < 30) {
sprintf(gameName, "%s", title);
}
else
{
strncpy(gameName, title, 27);
gameName[27] = '\0';
strncat(gameName, "...", 3);
}
//if(WindowPrompt(TX.askDelete, gameName, &yesButton, &noButton))
if(WindowPromptInstall((char*)header->id, gameName, TX.askDelete, &yesButton, &noButton, 1))
{
BUFFER_KillBuffer();
if(0 > WBFS_RemoveGame(header->id))
{
InitializeBuffer(self.gameList,self.gameCnt,BUFFER_WINDOW,COVER_COUNT/2.0 +self.shift,(settings.covers3d+settings.hq));
BUFFER_InitBuffer();
WindowPrompt(TX.errorDelete, TX.cantDelete, &okButton, 0);
}
else
{
GetEntries();
InitializeBuffer(self.gameList,self.gameCnt,BUFFER_WINDOW,COVER_COUNT/2.0 +self.shift,(settings.covers3d+settings.hq));
BUFFER_InitBuffer();
WindowPrompt(TX.successDelete, TX.pressOkContinue, &okButton, 0);
WBFS_DiskSpace(&self.usedSpace, &self.freeSpace);
return true;
}
}
return false;
}
/*!
*******************************************************************************
** \brief Initializes the USART hardware as a UART interface.
**
** \param id UART identifier. UART 0 is the first UART interface.
** \param baudRate Baud rate setting, indicates the speed in bps.
** \param parityMode Indicates whether a parity bit will be transmitted
** (transceiver) and expected (receiver). It can be
** switched off, odd or even.
** \param stopBitMode Indicates whether one or two stop bits will be sent
** when transmitting data.
** \param charSizeMode
** Indicates the number of bits per transmission.
** \param transceiveMode
** Indicates whether the receiver, the transmitter or
** both will be enabled.
** \param ledParamsPtr
** Optional pointer. Specifies setup for activity LEDs.
**
** \return
** - A valid UART_HandleT handle on success.
** - NULL if a bad parameter has been passed.
**
*******************************************************************************
*/
UART_HandleT UART_Init (UART_InterfaceIdT id,
UART_BaudT baudRate,
UART_ParityT parityMode,
UART_StopBitT stopBitMode,
UART_CharSizeT charSizeMode,
UART_TransceiveT transceiveMode,
UART_LedParamsT* ledParamsPtr)
{
uartHandleT* handlePtr = NULL;
uint8_t sreg_save = 0;
uint8_t ucsra = 0;
uint8_t ucsrb = 0;
uint8_t ucsrc = 0;
// no need to store these in the handle:
volatile uint8_t* ucsrc_ptr;
volatile uint8_t* ubrrh_ptr;
volatile uint8_t* ubrrl_ptr;
// Get the handle for the identified port:
if ((id) < (sizeof(uartHandleArr) / sizeof(uartHandleArr[0])))
{
handlePtr = &uartHandleArr[id];
}
else
{
return (NULL);
}
// Reset handle:
memset(handlePtr, 0, sizeof(uartHandleT));
// Initialize register addresses for specified port:
#if (UART_PORT_FACTOR == UART_SINGLEPORT)
handlePtr->udrPtr = &UDR;
handlePtr->ucsraPtr = &UCSRA;
handlePtr->ucsrbPtr = &UCSRB;
ucsrc_ptr = &UCSRC;
ubrrh_ptr = &UBRRH;
ubrrl_ptr = &UBRRL;
#endif
#if (UART_PORT_FACTOR == UART_MULTIPORT_1)
handlePtr->udrPtr = &UDR0;
handlePtr->ucsraPtr = &UCSR0A;
handlePtr->ucsrbPtr = &UCSR0B;
ucsrc_ptr = &UCSR0C;
ubrrh_ptr = &UBRR0H;
ubrrl_ptr = &UBRR0L;
#endif
#if (UART_PORT_FACTOR == UART_MULTIPORT_2)
if(id == UART_InterfaceId0)
{
handlePtr->udrPtr = &UDR0;
handlePtr->ucsraPtr = &UCSR0A;
handlePtr->ucsrbPtr = &UCSR0B;
ucsrc_ptr = &UCSR0C;
ubrrh_ptr = &UBRR0H;
ubrrl_ptr = &UBRR0L;
}
if(id == UART_InterfaceId1)
{
handlePtr->udrPtr = &UDR1;
handlePtr->ucsraPtr = &UCSR1A;
handlePtr->ucsrbPtr = &UCSR1B;
ucsrc_ptr = &UCSR1C;
ubrrh_ptr = &UBRR1H;
ubrrl_ptr = &UBRR1L;
}
#endif
// Disable interrupts temporarily:
sreg_save = SREG;
cli();
/* normal transmission speed, no MPCM */
*handlePtr->ucsraPtr = 0x00;
// init UCSRB and UCSRC with 0 first:
*handlePtr->ucsrbPtr = 0x00;
#if (UART_PORT_FACTOR == UART_SINGLEPORT)
// select UCSRC register and clear
*ucsrc_ptr = (1 << URSEL);
#else
// clear UCSRC, also: UMSEL0 1:0 = b00 => asynchronous UART
*ucsrc_ptr = 0x00;
#endif
// set up the register configuration:
uartSetBaudRate(ubrrh_ptr, ubrrl_ptr, baudRate);
// parity setup
switch (parityMode)
{
case UART_Parity_off: // UPM1:0 = 00
break;
case UART_Parity_odd: // UPM1:0 = 11
ucsrc |= (1 << UPM1) | (1 << UPM0);
break;
case UART_Parity_even: // UPM1:0 = 10
ucsrc |= (1 << UPM1);
break;
default:
SREG = sreg_save;
return (NULL);
}
// stop bit setup
switch (stopBitMode)
{
case UART_StopBit_1: // USBS = 0
break;
case UART_StopBit_2: // USBS = 1
ucsrc |= (1 << USBS);
break;
default:
SREG = sreg_save;
return (NULL);
}
// character size setup
// avoid 9-bit setting: UCSZ2 in ucsrb is already cleared.
// UCSZ1:0 settings:
switch (charSizeMode)
{
case UART_CharSize_5: // UCSZ1:0 = 00
break;
case UART_CharSize_6: // UCSZ1:0 = 01
ucsrc |= (1 << UCSZ0);
break;
case UART_CharSize_7: // UCSZ1:0 = 10
ucsrc |= (1 << UCSZ1);
break;
case UART_CharSize_8: // UCSZ1:0 = 11
ucsrc |= ((1 << UCSZ1) | (1 << UCSZ0));
break;
default:
SREG = sreg_save;
return (NULL);
}
// receiver/transmitter setup
switch (transceiveMode)
{
case UART_Transceive_Rx:
// also enable receive interrupt:
ucsrb |= (1 << RXCIE) | (1 << RXEN);
break;
case UART_Transceive_Tx:
// transmit interrupt will be enabled automatically when sending
ucsrb |= (1 << TXEN);
break;
case UART_Transceive_RxTx:
// also enable receive interrupt:
ucsrb |= (1 << RXCIE) | (1 << RXEN) | (1 << TXEN);
break;
default:
SREG = sreg_save;
return (NULL);
}
// apply configuration register settings
*handlePtr->ucsraPtr = ucsra;
*handlePtr->ucsrbPtr = ucsrb;
#if (UART_PORT_FACTOR == UART_SINGLEPORT)
*ucsrc_ptr = (1 << URSEL) | ucsrc;
#else
*ucsrc_ptr = ucsrc;
#endif
// initialize the buffers:
// realize as static arrays to avoid allocation from heap:
BUFFER_InitBuffer(&handlePtr->rxBuffer,
handlePtr->rxBufferArray,
UART_BUFFER_LENGTH_RX);
BUFFER_InitBuffer(&handlePtr->txBuffer,
handlePtr->txBufferArray,
UART_BUFFER_LENGTH_TX);
// set up LEDs:
if (ledParamsPtr)
{
if (ledParamsPtr->txLedPortPtr && ledParamsPtr->txLedDdrPtr)
{
handlePtr->txLedPortPtr = ledParamsPtr->txLedPortPtr;
handlePtr->txLedIdx = ledParamsPtr->txLedIdx;
handlePtr->txLedActive = 1;
UART_TX_LED_OFF;
// finally set pin as output:
*ledParamsPtr->txLedDdrPtr |= (1 << ledParamsPtr->txLedIdx);
}
if (ledParamsPtr->rxLedPortPtr && ledParamsPtr->rxLedDdrPtr)
{
handlePtr->rxLedPortPtr = ledParamsPtr->rxLedPortPtr;
handlePtr->rxLedIdx = ledParamsPtr->rxLedIdx;
handlePtr->rxLedActive = 1;
UART_RX_LED_OFF;
// finally set pin as output:
*ledParamsPtr->rxLedDdrPtr |= (1 << ledParamsPtr->rxLedIdx);
}
}
// initialize local variables:
#if UART_RX_CALLBACK_COUNT
memset(handlePtr->rxCallbackArray, 0,
UART_RX_CALLBACK_COUNT * sizeof(uartRxCallbackT));
#endif
handlePtr->rxWaiting = 0;
handlePtr->initialized = 1;
// restore SREG:
SREG = sreg_save;
return ((UART_HandleT)handlePtr);
}