ui.h File Reference

---

Detailed Description

UI module C header file.

REVISION

• 09/26/2003 M.GAO
  Initial creation.
• 01/30/2004 M.GAO
  Added various media format string references.
• 03/22/2004 M.GAO
  Added path name defition, fname now points to full path.

Definition in file ui.h.

#include "../feature.h"
#include "../MESSAGE/message.h"
#include "../KEYBOARD/keyboard.h"
#include "../LCD/lcd.h"
#include "../fat/fat.h"
#include "../MENU/menu.h"
#include "../TIMER/timer.h"
#include "../DB/db.h"
#include "../ear/ear.h"

Include dependency graph for ui.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	st_DATETIME
	UI date/time structure definitions. More...
struct	st_UI
	User interface global data structure definition. More...
Defines
#define	WAV_RECQUALITY_INDEX   5
	Indicate the first available WAV record format in VDIM_RECORDQUALITY.
Enumerations
enum	PARENT_STATE
	Parent state enumeration definition. More...
enum	STATE { , S_MENU_STAY = 999 }
	State enumeration definition. More...
enum	CHILD_STATE
	Child state enumeration definition. More...
enum	MENU_STATE
	menu state enumeration definition. More...
enum	PLAY_SRC
	Player source enumeration definition.
Functions
void	UI_child (void)
	Function serves as user interface child task handle.
void	UI_main (void)
	Function serves as user interface task handle.
void	UI_parent (void)
	Function serves as user interface parent task handle.
void	UI_setupTextMenu (ULONG, UINT *, UINT *, ITEMICONCTL)
	Function loads text menu controls into global menu buffer and ready the menu creation function.
CHILD_STATE	UI_CSF_msgbox (st_MSG *)
	Function serves as the child message box state handle.
CHILD_STATE	UI_CSF_null (st_MSG *)
	Function serves as the child NULL state handle.
CHILD_STATE	UI_CSF_xim (st_MSG *)
	Function serves as the child XIM state handle.
CHILD_STATE	UI_CSF_volume (st_MSG *)
	Function serves as the child volume window state handle.
CHILD_STATE	UI_CSF_myfiChannel (st_MSG *)
	Function serves as the child myfi channel window state handle.
PARENT_STATE	UI_PSF_autosync (st_MSG *)
	Function serves as the autosync state handle.
PARENT_STATE	UI_PSF_null (st_MSG *)
	Function serves as the parent null state handle.
PARENT_STATE	UI_PSF_play (st_MSG *)
	Function serves as the parent play state handle.
PARENT_STATE	UI_PSF_sleep (st_MSG *)
	Function serves as the parent sleep state handle.
PARENT_STATE	UI_PSF_radio (st_MSG *)
	Function serves as the parent FM radio state handle.
PARENT_STATE	UI_PSF_record (st_MSG *)
	Function serves as the parent record state handle.
PARENT_STATE	UI_PSF_recorddone (st_MSG *)
	Function serves as the parent record complete state handle.
PARENT_STATE	UI_PSF_hisi (st_MSG *)
	Function serves as the parent hisi state handle.
PARENT_STATE	UI_PSF_hisidone (st_MSG *)
	Function serves as the parent HiSi complete state handle.
STATE	UI_SF_autoscan (st_MSG *)
	Function serves as the autoscan state handle.
STATE	UI_SF_dbmenu (st_MSG *)
	Function serves as the DB menu state handle.
STATE	UI_SF_menu (st_MSG *)
	Function serves as the menu state handle.
STATE	UI_SF_null (st_MSG *)
	Function serves as the NULL state handle.
STATE	UI_SF_powerup (st_MSG *)
	Function serves as the powerup state handle.
STATE	UI_MSF_goup (st_MSG *)
	Function serves as the special go-up menu handle, returns the menu by one level up.
STATE	UI_MSF_stay (st_MSG *)
	Function serves as the special stay menu handle, stays in current menu.
STATE	UI_MSF_autoff (st_MSG *)
	Function serves as the auto off menu state handle.
STATE	UI_MSF_myfi (st_MSG *)
	Function serves as the myfi setup menu handle.
STATE	UI_MSF_shuffle (st_MSG *)
	Function serves as the shuffle menu state handle.
STATE	UI_MSF_repeat (st_MSG *)
	Function serves as the repeat menu state handle.
STATE	UI_MSF_backlight (st_MSG *)
	Function serves as the backlight menu state handle.
STATE	UI_MSF_myfiMode (st_MSG *)
	Function serves as the myfi mode setup menu handle.
STATE	UI_MSF_myfiQuality (st_MSG *)
	Function serves as the myfi quality setup menu handle.
STATE	UI_MSF_hisi (st_MSG *)
	Function serves as the hisi setup menu handle.
STATE	UI_MSF_settings (st_MSG *)
	Function serves as the settings menu state handle.
STATE	UI_MSF_bkpkSwap (st_MSG *)
	Function serves as the backpack swap menu handle.
STATE	UI_MSF_eq (st_MSG *)
	Function serves as the EQ selection menu state handle.
STATE	UI_MSF_main (st_MSG *)
	Function serves as the main menu state handle.
STATE	UI_MSF_dj (st_MSG *)
	Function serves as the DJ selection menu state handle.
STATE	UI_MSF_playQueue (st_MSG *)
	Function serves as the play queue selection menu state handle.
STATE	UI_MSF_audio (st_MSG *)
	Function serves as the audio db menu state handle.
STATE	UI_MSF_xtra (st_MSG *)
	Function serves as the xtra menu state handle.
STATE	UI_MSF_diagnosis (st_MSG *)
	Function serves as the diagnosis menu state handle.
STATE	UI_MSF_diag_nand (st_MSG *)
	Function serves as the NAND diagnosis menu handle.
STATE	UI_MSF_diag_hdd (st_MSG *)
	Function serves as the hard drive diagnosis menu handle.
void	UI_MENU_autoff (void)
	Funciton sets up the auto off setup menu display.
void	UI_MENU_myfi (void)
	Funciton sets up the myfi setup menu display.
void	UI_MENU_shuffle (void)
	Funciton sets up the shuffle setup menu display.
void	UI_MENU_repeat (void)
	Funciton sets up the repeat setup menu display.
void	UI_MENU_backlight (void)
	Funciton sets up the backlight setup menu display.
void	UI_MENU_recordQuality (void)
	Funciton sets up the record quality setup menu display.
void	UI_MENU_myfiGain (void)
	Funciton sets up the myfi gain setup menu display.
void	UI_MENU_myfiMode (void)
	Funciton sets up the myfi mode setup menu display.
void	UI_MENU_myfiQuality (void)
	Funciton sets up the myfi quality setup menu display.
void	UI_MENU_hisi (void)
	Funciton sets up the hisi setup menu display.
void	UI_MENU_settings (void)
	Funciton sets up the SETUP menu display.
void	UI_MENU_bkpkSwap (void)
	Funciton sets up the backpack swap menu display.
void	UI_MENU_bkpkSwapCtls (void)
	Funciton sets up the backpack swap controls menu display.
void	UI_MENU_contrast (void)
	Funciton sets up the LCD contrast setup menu display.
void	UI_MENU_eq (void)
	Funciton sets up the EQ selection menu display.
void	UI_MENU_seteq (void)
	Funciton sets up the EQ value setup menu display.
void	UI_MENU_synclog (void)
	Funciton sets up the synclog view menu display.
void	UI_MENU_presets (void)
	Funciton sets up the presets view menu display.
void	UI_MENU_dateTime (void)
	Funciton sets up the date time setup menu display.
void	UI_MENU_dbRecordInfo (void)
	Funciton sets up the DB record info menu display.
void	UI_MENU_properties (void)
	Funciton sets up the properties setup menu display.
void	UI_MENU_main (void)
	Funciton sets up the main menu display.
void	UI_MENU_dj (void)
	Funciton sets up the DJ selection menu display.
void	UI_MENU_playQueue (void)
	Funciton sets up the play queue selection menu display.
void	UI_MENU_audio (void)
	Funciton sets up the audio db menu display.
void	UI_MENU_xtra (void)
	Function sets up the XTRA menu display.
void	UI_MENU_xtra_mute (void)
	Function sets up the XTRA mute-on-scan menu display.
void	UI_MENU_xtra_hisi (void)
	Function sets up the XTRA HiSi setup menu display.
void	UI_MENU_xtra_backlight (void)
	Function sets up the XTRA backlight setup menu display.
void	UI_MENU_xtra_layout (void)
	Function sets up the XTRA play menu layout display.
void	UI_MENU_xtra_granularity (void)
	Function sets up the XTRA Granularity setup menu display.
void	UI_MENU_xtra_carmode (void)
	Function sets up the car mode options menu display.
void	UI_MENU_xtra_scrollwrap (void)
	Function sets up the scrollwrap options menu display.
void	UI_MENU_diagnosis (void)
	Funciton sets up the diagnosis menu display.
void	UI_MENU_diag_nand (void)
	Funciton sets up the NAND diagnosis menu display.
void	UI_MENU_diag_hdd (void)
	Funciton sets up the hard drive diagnosis menu display.
void	UI_menuBrowse (MSG_DATA, MSG_DATA, MENU_STATE)
	Function kicks off the generic menu browsing.
void	UI_dbBrowse (MSG_DATA, MSG_DATA, DB_ID, DB_ENTRY, DB_ENTRY, DB_FIELDIDX)
	Function kicks off the generic DB browsing.
void	UI_msgbxCreate (MSGBX_ID)
	Function sends out system message to create a message box menu.
BOOL	UI_interpretAudioRecord (st_DBINFO *, USHORT *, char *, char *, char *, char *, char *, char *, char *, ULONG *, ULONG *)
	Funciton interprets audio DB record and sets up player display controls.
BOOL	UI_interpretIdentifiedHisiRecord (st_DBINFO *, USHORT *, char *, char *, char *, char *, char *, char *, char *, ULONG *, ULONG *)
	Funciton interprets identified HiSi record and sets up player display controls.
BOOL	UI_interpretUnidentifiedHisiRecord (st_DBINFO *, USHORT *, char *, char *, char *, char *, char *, char *, char *, ULONG *, ULONG *)
	Funciton interprets unidentified HiSi record and sets up player display controls.
BOOL	UI_interpretFailedHisiRecord (st_DBINFO *, USHORT *, char *, char *, char *, char *, char *, char *, char *, ULONG *, ULONG *)
	Funciton interprets failed HiSi record and sets up player display controls.
BOOL	UI_insertAudioRecord (const char *, const char *, const char *, const char *, const char *, const char *, ULONG, ULONG, const char *)
	Function inserts an audio record from the root of audio DB.
BOOL	UI_insertHisiRecord (const char *, const char *, const char *)
	Function inserts a HiSi clip to unidentified HiSi database.
void	UI_readRTC (st_DATETIME *)
	Function reads back the RTC time in UI format.
UINT	UI_currentTimeString (char *)
	Function creates a string for current RTC date time and returns the string length in words.
BOOL	UI_isPresetValid (int)
	Function checks to see if there is a valid preset corresponding to specific preset index.
int	UI_isPresetStation (USHORT)
	Function checks if specified FM radio station is a preset station or not.
void	UI_presetRadio (int, USHORT)
	Function presets the specified radio station.
void	UI_presetMyFi (int, USHORT)
	Function presets the specified MyFi station.
void	UI_presetAudio (int, DB_ID, DB_ENTRY, DB_ENTRY, DB_FIELDIDX, ULONG)
	Function presets the specified audio playback controls.
void	UI_addXIM (int *, long, int)
	Function adds specified XIM tem to XIM buffer.
void	UI_removeXIM (int *, int)
	Function removes specified XIM item from XIM buffer.
BOOL	UI_earPut (const char *, D2PEAR_ID, PEAR_DATA, USHORT, long)
	Function adds an EAR entry to the EAR file and refresh membar if needed.
long	UI_pendingEarDiskSpace (void)
	Function returns pending device-to-PC EAR disk space in kilobytes.
void	UI_updateMembar (void)
	Functoin sets up to update the memory bar display.
void	UI_rdSynclog (void)
	Function reads back the synclog file and sets up globals.
void	UI_audioPresetUpdate (int)
	Function checks to update the audio preset per to DB changes made.
Variables
PLAY_SRC	playSource
	Global to hold playback source definition.

---

Enumeration Type Documentation

enum CHILD_STATE

Child state enumeration definition. NOTE: State has to be enumed in alphabetically order to comply with the way the child state function handle gets defined. Definition at line 94 of file ui.h. Referenced by UI_child(). { C_NULL = 0, C_MSGBOX = 1, C_XIM = 2, C_VOLUME = 3, C_MYFICHANNEL = 4 } CHILD_STATE;

enum MENU_STATE

menu state enumeration definition. NOTE: definition has to be complied with the way the menu state function handle gets defined. Definition at line 108 of file ui.h. Referenced by UI_SF_null(). { MENU_AUTOFF = 0, MENU_BACKLIGHT = 1, MENU_BKPKSWAP = 2, MENU_BKPKSWAPCTLS = 3, MENU_CONTRAST = 4, MENU_DATETIME = 5, MENU_DBRECORDINFO = 6, MENU_EQ = 7, MENU_HISI = 8, MENU_MAIN = 9, MENU_MYFI = 10, MENU_MYFI_GAIN = 11, MENU_MYFI_MODE = 12, MENU_MYFI_QUALITY = 13, MENU_PRESETREVIEW = 14, MENU_PROPERTIES = 15, MENU_RECORDQUALITY = 16, MENU_REPEAT = 17, MENU_SETEQ = 18, MENU_SETTINGS = 19, //DeepB MENU_XTRA = 20, MENU_XTRA_MUTE = 21, MENU_XTRA_HISI = 22, MENU_XTRA_BACKLIGHT = 23, MENU_XTRA_LAYOUT = 24, MENU_XTRA_GRANULARITY = 25, MENU_XTRA_CARMODE = 26, MENU_XTRA_SCROLLWRAP = 27, MENU_SHUFFLE = 28, MENU_SYNCLOG = 29, #ifdef DJ_SUPPORT MENU_DJ, #endif #ifdef M3U_SUPPORT MENU_PLAYQ, #endif #ifdef SP_SUPPORT MENU_AUDIO, #endif MENU_DIAGNOSIS, MENU_DIAG_HDD, MENU_DIAG_NAND, MENU_NULL = 0x7FFF } MENU_STATE;

enum PARENT_STATE

Parent state enumeration definition. NOTE: State has to be enumed in alphabetically order to comply with the way the parent state function handle gets defined. Definition at line 57 of file ui.h. Referenced by UI_parent(). { P_NULL = 0, P_SLEEP = 1, P_AUTOSYNC = 2, P_PLAY = 3, P_RADIO = 4, P_RECORD = 5, P_RECORDDONE = 6, P_HISI = 7, P_HISIDONE = 8 } PARENT_STATE;

enum STATE

State enumeration definition. NOTE: State has to be enumed in alphabetically order to comply with the way the state function handle gets defined. Enumeration values: S_MENU_STAY  stay in current menu state, do not close window. Definition at line 77 of file ui.h. Referenced by UI_main(), UI_SF_menu(), and UI_SF_null(). { S_NULL = 0, S_MENU = 1, S_AUTOSCAN = 2, S_DBMENU = 3, S_POWERUP = 4, S_MENU_STAY = 999 } STATE;

---

Function Documentation

void UI_addXIM (  int *  pXIMbuf, long  pXIM_DEF, int  position )

Function adds specified XIM tem to XIM buffer. It is the caller's responsibility to make sure XIM buffer is big enough. Parameters: pXIMbuf  XIM data buffer. pXIM_DEF  XIM definition data pointer. position  position specifier, if == -1, add it one item before EXIT. Definition at line 266 of file UI_CSF_xim.c. { int * pData; int * pStart; int len, tmp, itemNum; ULONG dptr; len = *pXIMbuf; if(len == 0) pStart = pXIMbuf; else { /* Get itemNum. */ itemNum = pXIMbuf[1] & 0x007F; /* Increase item number. */ pXIMbuf[1] = itemNum + 1; if(position == -1) { position = itemNum - 1; } /* Adjustify pDspData and pActionData for all items */ /* Points to first XIM item data pointer. */ pData = pXIMbuf + 4; for( tmp = 0; tmp < itemNum; tmp++ ) { dptr = ((unsigned long)(*pData)<<16)|((unsigned short)*(pData+1)); /* If NULL, no data associated. */ if(dptr) { dptr += XIM_ITEM_HEADER_LEN; *pData++ = dptr >> 16; *pData++ = dptr & 0xFFFF; } else pData += 2; dptr = ((unsigned long)(*pData)<<16)|((unsigned short)*(pData+1)); /* If NULL, no data associated. */ if(dptr) { dptr += XIM_ITEM_HEADER_LEN; *pData++ = dptr >> 16; *pData++ = dptr & 0xFFFF; } else pData += 2; /* Points to next XIM item. */ pData += 2; } /* Make room for new item header. */ pStart = pData = pXIMbuf + 2 + (position*XIM_ITEM_HEADER_LEN); memmove( pData + XIM_ITEM_HEADER_LEN, pData, len - (position*XIM_ITEM_HEADER_LEN) - 2 ); } /* Set up pointer to where dspData starts. */ pData = pXIMbuf + len + XIM_ITEM_HEADER_LEN; /* Insert new header. */ GEN_readXdata(pXIM_DEF, (USHORT *)pStart, XIM_ITEM_HEADER_LEN); /* Preserve pDspData, then modify it. */ dptr = (((unsigned long)pStart[2])<<16)|(unsigned short)pStart[3]; pStart[2] = 0; //pStart[3] = (int)pData; pStart[3] = (int)(pData - pXIMbuf); /* Load dspData. */ GEN_readXdata(dptr, (USHORT *)&tmp, 1); GEN_readXdata(dptr, (USHORT *)pData, tmp + 1); /* Set up pointer to where actionData starts. */ pData += (tmp + 1); len += (tmp + 1); /* Preserve pActionData, then modify it. */ dptr = ((unsigned long)pStart[4]<<16)|(unsigned short)pStart[5]; if(dptr) { pStart[4] = 0; //pStart[5] = (int)pData; pStart[5] = (int)(pData - pXIMbuf); /* Load actionData. */ GEN_readXdata(dptr, (USHORT *)&tmp, 1); GEN_readXdata(dptr, (USHORT *)pData, tmp + 1); len += (tmp + 1); } /* Update XIM data len. */ pXIMbuf[0] = len + XIM_ITEM_HEADER_LEN; }

void UI_audioPresetUpdate (  int  dbChange  )

Function checks to update the audio preset per to DB changes made. Parameters: dbChange  DB change mode, 1, record insertion, -1, record deletion. Definition at line 218 of file UI_presetMgmt.c. References st_PRESET::audio, st_NDSYSPARAM::audioPresetChksum, st_PRESET::chksum, DB_queryClose(), DB_queryFirst(), GEN_checksum(), st_NDSYSPARAM::preset, st_PRESET::share, and st_PRESET::type. Referenced by UI_insertAudioRecord(), and UI_PSF_play(). { int ii; st_PRESET * pPreset = &nandSysParam.preset[1]; st_AUDIOPRESET * pAP; USHORT buf[DB_MAXRECLEN]; DB_HDL hdl; unsigned int check; unsigned int fldEntry; unsigned int dbEntry; for(ii = 1; ii < 6; ii++ ) { if( (pPreset->type >= PRESET_AUDIO)&&(pPreset->type <= PRESET_RECORDINGS) ) { pAP = &pPreset->share.audio; fldEntry = pAP->fldEntry; dbEntry = pAP->dbEntry; check = 0; while(check < 3) { //if(pPreset->type == PRESET_SONGS) hdl = DB_queryFirst(pAP->dbId, pAP->fldIdx, fldEntry, dbEntry, buf); //else // hdl = DB_queryFirst(DB_childID(pAP->dbId, pAP->fldIdx), 0, 0, fldEntry, buf); if(hdl != DB_INVALID_HDL) { DB_queryClose(hdl); if(nandSysParam.audioPresetChksum[ii] == GEN_checksum(buf+3, strlen((const char*)buf+3))) { //pPreset->type = PRESET_AUDIO; pAP->dbEntry = dbEntry; pAP->fldEntry = fldEntry; pPreset->chksum = GEN_checksum((USHORT*)pPreset, 7); break; } } switch(check) { case 0: dbEntry += dbChange; check++; break; case 1: dbEntry = pAP->dbEntry; fldEntry++; check++; break; case 2: pPreset->type = PRESET_Invalid; check++; break; } } } pPreset++; } }

Here is the call graph for this function:

void UI_child (  void   )

Function serves as user interface child task handle. This task handle all pop-up windows. Definition at line 43 of file UI_child.c. References CHILD_STATE, st_MSG::d1, st_MSG::d2, st_MSG::id, SBATLEVEL_UPDT, SINITSTATUSBAR, SMEMBAR_UPDT, SRTC_UPDT, SSTATE_END, SSTATE_END_ACK, SYS_autoffReset(), and UI_CSF_myfiChannel(). Referenced by SYS_createResidentTask(). { st_MSG msgIN; st_MSG msgOUT; CHILD_STATE c_curstate = C_NULL; CHILD_STATE c_oldstate = C_NULL; MSG_ID id; MSG_DATA d1; MSG_DATA d2; CSFHDL CSFHDL_TABLE[] = { UI_CSF_null, UI_CSF_msgbox, UI_CSF_xim, UI_CSF_volume, UI_CSF_myfiChannel }; _init(); while(1) { BOOL processed = FALSE; mMSG_get(uiChildMsgQ, &msgIN, SYS_FOREVER); id = msgIN.id; d1 = msgIN.d1; d2 = msgIN.d2; if(KBD_MSG_ID == id) { SYS_autoffReset(); SYS_autoResumePlayReset(); } if( TMR_MSG_ID == id ) { if(THDDPOWEROFF == d1) { HDD_shutdown(); continue; } else if(TSYSBUSY == d1) { mMENU_statusBar(STBAR_SYSBUSY, NULL); processed = TRUE; } else if(TSYSNOTBUSY == d1) { mMENU_statusBar(STBAR_SYSIDLE, NULL); processed = TRUE; } } else if( SYS_MSG_ID == id ) { if(SMEMBAR_UPDT == d1) { mMENU_statusBar(STBAR_MEMORY, d2); processed = TRUE; } else if(SBATLEVEL_UPDT == d1) { mMENU_statusBar(STBAR_BATTERY, d2); processed = TRUE; } else if(SRTC_UPDT == d1) { mMENU_statusBar(STBAR_TIME, d2); processed = TRUE; } else if(SINITSTATUSBAR == d1) { mMENU_statusBar(STBAR_CREATE, 0); // Display full battery bar. mMENU_statusBar(STBAR_BATTERY, 3); // Display current time. mMENU_statusBar(STBAR_TIME, 0); processed = TRUE; } } if(FALSE == processed) { c_curstate = UI_getChildSFhdl(c_oldstate)(&msgIN); while(c_curstate != c_oldstate) { c_oldstate = c_curstate; _loadCurStateCode(c_curstate); msgOUT.id = SYS_MSG_ID; msgOUT.d1 = SSTATE_START; // msgIN.d2 is carried over here. msgOUT.d2 = msgIN.d2; c_curstate = UI_getChildSFhdl(c_oldstate)(&msgOUT); } } // Report to system the following message status. if( (SYS_MSG_ID == id)&&(SSTATE_END == d1) ) { mMSG_send(sysMsgQ, SYS_MSG_ID, SSTATE_END_ACK, DONTCARE, SYS_FOREVER); } UI_stackassert(UI_CHILD); } }

Here is the call graph for this function:

CHILD_STATE UI_CSF_msgbox (  st_MSG *  msgIN  )

Function serves as the child message box state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 48 of file UI_CSF_msgbox.c. References BTN_CANCEL, BTN_NO, BTN_PCDELETE, st_MSGBOX::button, MENU_2NEXT, MENU_2PREV, MENU_buf, MENU_CLOSE, MSG_send(), SAUDIOTIME_UPDT, SBROWSE, SDISKDBREADY, SENDOFMUSIC, SMSGBOX_EXIT, SSTATE_END, SSTATE_START, TMR_delete(), TMR_MSGBOXCANCEL, and st_MSGBOX::value. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; st_MSGBOX * pMbx; if(SYS_MSG_ID == id) { switch(d1) { case SSTATE_START: { g_curMSGBX = d2; MENU_buf[0] = DP_MSGBOX; MENU_buf[1] = d2; menu = mMENU_create((void*)&MENU_buf[0]); return C_MSGBOX; } case SBROWSE: case SAUDIOTIME_UPDT: return C_MSGBOX; case SSTATE_END: case SDISKDBREADY: { _msgboxCancel(); return C_NULL; } case SENDOFMUSIC: { _msgboxCancel(); MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_NULL; } } } else if(KBD_MSG_ID == id) { switch(d1) { //DeepB case KEY_PLAY: case KEY_SELECT: { TMR_delete(TMR_MSGBOXCANCEL); pMbx = (st_MSGBOX *)mMENU_getObj(menu); //UI_assert((UINT)pMbx, UI_CSF_MSGBOX2); if(!pMbx) d2 = BTN_CANCEL; else { switch(pMbx->button) { case MBX_BTN_NULL: d2 = BTN_NULL; break; case MBX_BTN_OK: d2 = BTN_OK; break; case MBX_BTN_OKCANCEL: d2 = (pMbx->value)? BTN_CANCEL:BTN_OK; break; case MBX_BTN_YESNO: d2 = (pMbx->value)? BTN_NO:BTN_YES; break; case MBX_BTN_PCCANCEL: d2 = (pMbx->value)? BTN_PCDELETE:BTN_NO;break; case MBX_BTN_NEUROSCANCELPC: if(pMbx->value == 0) d2 = BTN_NEUROS; else if(pMbx->value == 1) d2 = BTN_CANCEL; else d2 = BTN_PCDELETE; break; } } mMENU_action(menu, MENU_CLOSE); mMSG_send(uiMsgQ, SYS_MSG_ID, SMSGBOX_EXIT, d2, SYS_FOREVER); return C_NULL; } case KEY_UP: case KEY_HUP: case KEY_RUP: { mMENU_action(menu, MENU_2PREV); return C_MSGBOX; } case KEY_DOWN: case KEY_HDOWN: case KEY_RDOWN: { mMENU_action(menu, MENU_2NEXT); return C_MSGBOX; } case KEY_BACK: case KEY_REWIND: case KEY_FORWARD: { _msgboxCancel(); return C_NULL; } } } else if(TMR_MSG_ID == id) { switch(d1) { case THISIANIMATION: case TRECANIMATION: case TRECVUMETER: case TTXTSCROLL: return C_MSGBOX; case TMSGBOX_CANCEL: case TRESUMEPLAY: { _msgboxCancel(); return C_NULL; } } } // Pass the rest of the message to UI_main. MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_MSGBOX; }

Here is the call graph for this function:

CHILD_STATE UI_CSF_myfiChannel (  st_MSG *  msgIN  )

Function serves as the child myfi channel window state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 50 of file UI_CSF_myfiChannel.c. References AI_PAUSE, AUDIO_setInterface(), MENU_2BOTTOM, MENU_2NEXT, MENU_2PREV, MENU_2TOP, MENU_buf, MENU_RECALL, MENU_STORE, MSG_send(), st_SYSPARAM::myfiChannel, SAUDIOTIME_UPDT, SBROWSE, SENDOFMUSIC, SMYFICHANNELCHANGED, SSTATE_END, SSTATE_START, TMR_create(), TMR_MYFICHANNELWINDOW, TMR_reset(), UI_msgbxCreate(), and UI_presetMyFi(). Referenced by UI_child(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( SYS_MSG_ID == id) { switch(d1) { case SSTATE_START: { MENU_buf[0] = DP_MYFICHANNEL; MENU_buf[1] = (UINT)&sysParam.myfiChannel;// current fm out channel. MENU_buf[2] = MAX_CHANNEL; // max fm out channel. MENU_buf[3] = MIN_CHANNEL; // min fm out channel. menu = mMENU_create((void *)&MENU_buf[0]); TMR_create(TMR_MYFICHANNELWINDOW, 600, TMYFICHANNELWINDOW, 0, NO_RELOAD); return C_MYFICHANNEL; } case SBROWSE: case SAUDIOTIME_UPDT: return C_MYFICHANNEL; case SSTATE_END: { _exit(); return C_NULL; } case SENDOFMUSIC: { _exit(); MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_NULL; } } } else if(KBD_MSG_ID == id) { switch(d1) { case KEY_SELECT: case KEY_BACK: case KEY_REWIND: case KEY_FORWARD: { _exit(); return C_NULL; } case KEY_UP: case KEY_HUP: case KEY_RUP: { AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_2PREV); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } case KEY_DOWN: case KEY_HDOWN: case KEY_RDOWN: { AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_2NEXT); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } //DeepB // Handle MyFi Presets // Store them case KEY_HPRESET1: case KEY_HPRESET2: case KEY_HPRESET3: case KEY_HPRESET4: case KEY_HPRESET5: { int ii = d1-KEY_PRESET0; // Store preset Here AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_STORE); UI_presetMyFi(ii, sysParam.myfiChannel); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } // Recall preset case KEY_PRESET1: case KEY_PRESET2: case KEY_PRESET3: case KEY_PRESET4: case KEY_PRESET5: { int ii = d1-KEY_PRESET0; // Recall preset Here AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_RECALL); // sysParam.myfiChannel = nandSysParam.myfi[ii]; XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } //To top of the freq case KEY_HSELECT: { AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_2TOP); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } //To bottom of the freq case KEY_HBACK: { AUDIO_setInterface(AI_PAUSE); TMR_reset(TMR_MYFICHANNELWINDOW); mMENU_action(menu, MENU_2BOTTOM); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMYFICHANNELCHANGED,DONTCARE, SYS_FOREVER); return C_MYFICHANNEL; } } } else if(TMR_MSG_ID == id) { switch(d1) { case TTXTSCROLL: return C_MYFICHANNEL; case TMYFICHANNELWINDOW: { _exit(); return C_NULL; } } } // Pass the rest of the message to UI_main. MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_MYFICHANNEL; }

Here is the call graph for this function:

CHILD_STATE UI_CSF_null (  st_MSG *  msgIN  )

Function serves as the child NULL state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 42 of file UI_CSF_null.c. References MSG_send(), SBATLOW_SHUTDOWN, SCSF_NULL, SMSGBOX_CREATE, SMYFICHANNELWIN_CREATE, SSTATE_END, SSTATE_START, SVOLWIN_CREATE, SXIM_CREATE, TMR_create(), and TMR_LOWBAT_AUTOFF. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: return C_NULL; case SMSGBOX_CREATE: return C_MSGBOX; case SXIM_CREATE: return C_XIM; case SVOLWIN_CREATE: return C_VOLUME; case SMYFICHANNELWIN_CREATE: return C_MYFICHANNEL; case SBATLOW_SHUTDOWN: { msgIN->d2 = MSGBX_BATTERYLOW; TMR_create(TMR_LOWBAT_AUTOFF, 250, TSHUTDOWN, 0, NO_RELOAD); return C_MSGBOX; } case SSTATE_END: { mMSG_send(sysMsgQ, SYS_MSG_ID, SCSF_NULL, DONTCARE, SYS_FOREVER); return C_NULL; } } break; case TMR_MSG_ID: break; } // Route the rest of the messages to parent UI. MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_NULL; }

Here is the call graph for this function:

CHILD_STATE UI_CSF_volume (  st_MSG *  msgIN  )

Function serves as the child volume window state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 45 of file UI_CSF_volume.c. References CODEC_hpVolume(), MENU_2NEXT, MENU_2PREV, MENU_buf, MENU_CLOSE, MSG_send(), SAUDIOTIME_UPDT, SBROWSE, SENDOFMUSIC, SSTATE_END, SSTATE_START, TMR_create(), TMR_delete(), TMR_reset(), TMR_VOLUMEWINDOW, and st_SYSPARAM::volume. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if(SYS_MSG_ID == id) { switch(d1) { case SSTATE_START: { MENU_buf[0] = DP_VOLUME; MENU_buf[1] = (UINT)&sysParam.volume; MENU_buf[2] = MAX_VOLUME; menu = mMENU_create((void*)&MENU_buf[0]); TMR_create(TMR_VOLUMEWINDOW, 200, TVOLUMEWINDOW, 0, NO_RELOAD); return C_VOLUME; } case SBROWSE: case SAUDIOTIME_UPDT: return C_VOLUME; case SSTATE_END: { TMR_delete(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_CLOSE); return C_NULL; } case SENDOFMUSIC: { TMR_delete(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_CLOSE); MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_NULL; } } } else if(KBD_MSG_ID == id) { switch(d1) { case KEY_BACK: case KEY_FORWARD: case KEY_REWIND: case KEY_SELECT: { TMR_delete(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_CLOSE); return C_NULL; } case KEY_UP: case KEY_HUP: case KEY_RUP: { TMR_reset(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_2PREV); CODEC_hpVolume(sysParam.volume); return C_VOLUME; } case KEY_DOWN: case KEY_HDOWN: case KEY_RDOWN: { TMR_reset(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_2NEXT); CODEC_hpVolume(sysParam.volume); return C_VOLUME; } } } else if(TMR_MSG_ID == id) { switch(d1) { case TTXTSCROLL: return C_VOLUME; case TVOLUMEWINDOW: { TMR_delete(TMR_VOLUMEWINDOW); mMENU_action(menu, MENU_CLOSE); return C_NULL; } } } // Pass the rest of the message to UI_main. MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_VOLUME; }

Here is the call graph for this function:

CHILD_STATE UI_CSF_xim (  st_MSG *  msgIN  )

Function serves as the child XIM state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 57 of file UI_CSF_xim.c. References MENU_2NEXT, MENU_2PREV, MENU_buf, MENU_CLOSE, MENU_SELECT, MSG_send(), SAUDIOTIME_UPDT, SBROWSE, SENDOFMUSIC, SSTATE_END, SSTATE_START, and SXIM_EXIT. { ULONG dptr = 0L; MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; st_XIMENU * pXim; if(SYS_MSG_ID == id) { switch(d1) { case SSTATE_START: { switch(d2&0xff00) { case XIMWIN_DB: dptr = DB_SRAM_BUF; break; case XIMWIN_HISIDONE: dptr = (ULONG)XIM_HISI_DONE; break; case XIMWIN_RADIO: dptr = (ULONG)XIM_RADIO; break; case XIMWIN_PLAYER: dptr = (ULONG)XIM_PLAYER; break; case XIMWIN_PLAYERQ: dptr = (ULONG)XIM_PLAYERQ; break; case XIMWIN_PLAYER_ADD2MYMIX: dptr = (ULONG)XIM_PLAYER_ADD2MYMIX; break; case XIMWIN_PLAYER_MYFI_ADD2MYMIX: dptr = (ULONG)XIM_PLAYER_MYFI_ADD2MYMIX; break; case XIMWIN_PLAYER_MYFI: dptr = (ULONG)XIM_PLAYER_MYFI; break; case XIMWIN_PLAYER_MYFIQ: dptr = (ULONG)XIM_PLAYER_MYFIQ; break; case XIMWIN_RECORDDONE: dptr = (ULONG)XIM_RECORD_DONE; break; #ifdef M3U_SUPPORT case XIMWIN_PLAYQ: dptr = (ULONG)XIM_PLAYQ; break; #endif } if(dptr == 0L) { mMSG_send(uiMsgQ, SYS_MSG_ID, SXIM_EXIT, 0xffff, SYS_FOREVER); return C_NULL; } if( (d2&0xff00) != prevXIM ) { prevXIM = (d2&0xff00); actvItem = 0; } _loadXIMmenu(dptr); menu = mMENU_create((void*)&MENU_buf[0]); return C_XIM; } case SBROWSE: case SAUDIOTIME_UPDT: return C_XIM; case SSTATE_END: { mMENU_action(menu, MENU_CLOSE); mMSG_send(uiMsgQ, SYS_MSG_ID, SXIM_EXIT, 0xffff, SYS_FOREVER); return C_NULL; } case SENDOFMUSIC: { mMENU_action(menu, MENU_CLOSE); mMSG_send(uiMsgQ, SYS_MSG_ID, SXIM_EXIT, 0xffff, SYS_FOREVER); MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_NULL; } } } else if(KBD_MSG_ID == id) { switch(d1) { case KEY_SELECT: mMENU_action(menu, MENU_SELECT); pXim = (st_XIMENU*)mMENU_getObj(menu); if(pXim) _ximAction(actvItem, pXim); mMENU_action(menu, MENU_CLOSE); return C_NULL; // Catch also holding buttons, to avoid a lockup // Patch by Bernard Cafarelli case KEY_UP: case KEY_HUP: case KEY_RUP: mMENU_action(menu, MENU_2PREV); return C_XIM; // Catch also holding buttons, to avoid a lockup // Patch by Bernard Cafarelli case KEY_DOWN: case KEY_HDOWN: case KEY_RDOWN: mMENU_action(menu, MENU_2NEXT); return C_XIM; case KEY_FORWARD: case KEY_REWIND: case KEY_BACK: mMENU_action(menu, MENU_CLOSE); mMSG_send(uiMsgQ, SYS_MSG_ID, SXIM_EXIT, 0xffff, SYS_FOREVER); return C_NULL; } } else if (TMR_MSG_ID == id) { switch(d1) { case TTXTSCROLL: return C_XIM; } } // Pass the rest of the message to UI_main. MSG_send(uiMsgQ, msgIN, SYS_FOREVER); return C_XIM; }

Here is the call graph for this function:

UINT UI_currentTimeString (  char *  str  )

Function creates a string for current RTC date time and returns the string length in words. String takes the following format, MO-DY-YR HR-MI-SE AM/PM It is the caller's responsibility to make sure string buffer is big enough to hold the entire time string. Parameters: str  Time string buffer. Returns: Time string length in words. Definition at line 90 of file UI_rtc.c. References RTC_readTime(). { st_TIME t; int length = 0; RTC_readTime(&t); t.Month &= 0x1F; *str++ = (t.Month >> 4) + 0x30; *str++ = (t.Month & 0x0F) + 0x30; *str++ = '-'; length += 3; t.Day &= 0x3F; *str++ = (t.Day >> 4) + 0x30; *str++ = (t.Day & 0x0F) + 0x30; *str++ = '-'; length += 3; *str++ = (t.Year >> 4) + 0x30; *str++ = (t.Year & 0x0F) + 0x30; *str++ = ' '; length += 3; t.Hour &= 0x3F; *str++ = (t.Hour >> 4) + 0x30; *str++ = (t.Hour & 0x0F) + 0x30; *str++ = '-'; length += 3; t.Minute &= 0x7F; *str++ = (t.Minute >> 4) + 0x30; *str++ = (t.Minute & 0x0F) + 0x30; *str++ = '-'; length += 3; t.Second &= 0x7F; *str++ = (t.Second >> 4) + 0x30; *str = (t.Second & 0x0F) + 0x30; length += 2; return length; }

Here is the call graph for this function:

void UI_dbBrowse (  MSG_DATA  msgD1, MSG_DATA  msgD2, DB_ID  db, DB_ENTRY  dbEntry, DB_ENTRY  fldEntry, DB_FIELDIDX  fldIdx )

Function kicks off the generic DB browsing. DB menu system maintains its own history and returns the specified system message when browsing back to what it was started. NOTE: 1) It is the caller's responsibility to make sure request is NOT cascaded, in other words, do not send another browse request before current request reaches its root. 2) This API can NOT be called from UI task, it can be called from parent UI, child UI, system etc. Parameters: msgD1  Returning system message data1. msgD2  Returning system message data2 db  Browsing DB ID. dbEntry  DB record entry. fldEntry  DB field entry. fldIdx  DB field index. Definition at line 84 of file UI_browse.c. References SDBBROWSE. { static UINT dbREQUEST[6]; UINT * pD = &dbREQUEST[0]; *pD++ = (UINT)msgD2; *pD++ = (UINT)msgD1; *pD++ = (UINT)dbEntry; *pD++ = (UINT)fldEntry; *pD++ = (UINT)fldIdx; *pD++ = (UINT)db; mMSG_send(uiMsgQ, SYS_MSG_ID, SDBBROWSE, (int)&dbREQUEST[0], SYS_FOREVER); }

BOOL UI_earPut (  const char *  drive, D2PEAR_ID  id, PEAR_DATA  pData, USHORT  dataLen, long  diskSpace )

Function adds an EAR entry to the EAR file and refresh membar if needed. Parameters: drive  Drive letter string. id  device to PC EAR id. pData  EAR request support data pointer. dataLen  EAR support data length in words. diskSpace  EAR disk space usage in kilo bytes. (1024). Returns: TRUE if request successfully added, otherwise FALSE. Definition at line 144 of file UI_ear.c. References D2PEAR_ID, EAR_put(), FAT_freeSpace(), PEAR_DATA, and UI_updateMembar(). Referenced by UI_PSF_play(). { if(diskSpace < 0) { if(-diskSpace > FAT_freeSpace((drive == strDISKD)?DISK_D:DISK_C) ) { // Disk full. return FALSE; } } EAR_put(drive,id,pData,dataLen,diskSpace); //if(diskSpace) { UI_updateMembar(); } if( (SYS_isHDDpresent())&&(!SYS_isPlayActive())) { HDD_setPowerMode( HDD_POWEROFF, 0 ); } return TRUE; }

Here is the call graph for this function:

BOOL UI_insertAudioRecord (  const char *  pTitle, const char *  pPlaylist, const char *  pArtist, const char *  pAlbum, const char *  pGenre, const char *  pRecordings, ULONG  timeLen, ULONG  size, const char *  pPath )

Function inserts an audio record from the root of audio DB. Note that in case the audio DB is updated future, this funciton needs to be rewritten. NOTE: pTitle and pPath are mandatory and must NOT be null pointers. Parameters: pTitle  Audio record time. pPlaylist  Audio record playlist string. pArtist  Audio record artist string. pAlbum  Audio record album string. pGenre  Audio record genre string. pRecordings  Audio record recording source string. timeLen  Audio record duration. size  Audio file size in kilo-bytes. pPath  Audio record full path. Returns: TRUE if successfully inserted, otherwise FALSE. Definition at line 129 of file UI_insertRecord.c. References st_DBNAV::audio, DB_insertRecord(), GEN_strPack(), SYS_die(), and UI_audioPresetUpdate(). { char * title; char * playlist; char * artist; char * album; char * genre; char * recordings; char * pC; char emptyRecord[] = {0x8000, DB_RECDLMT}; //char * record[6] = { title, playlist, artist, album, genre, recordings }; char * record[6]; int ii; int len1, len2; BOOL ret; BOOL bPlaylistAllocated = TRUE; BOOL bArtistAllocated = TRUE; BOOL bAlbumAllocated = TRUE; BOOL bGenreAllocated = TRUE; BOOL bRecordingsAllocated = TRUE; UI_assert (pTitle != NULL , UI_INSERTAUDIORECORD); UI_assert (pPath != NULL , UI_INSERTAUDIORECORD2); /* Construct the primary data entry. */ len1 = strlen(pTitle); len2 = strlen(pPath); ii = ( (len1 + len2)/2 ) + 30; // 2 extra NULL holder + 15 child DB entry holder. // + 1 record flag + 4 timeLen + 4 size // + 4 reserved for safe. title = (char *)calloc(ii, sizeof(char)); if(NULL == title) SYS_die(UI_INSERTAUDIORECORD3); pC = title; *pC++= 0x8000; // Record flag. pC += GEN_strPack(pC, pTitle, len1); *pC++ = DB_FLDDLMT; // end of title field. *pC++ = 0; *pC++ = 0; *pC++ = DB_FLDDLMT; // playlist entry holder. *pC++ = 0; *pC++ = 0; *pC++ = DB_FLDDLMT; // artist entry holder. *pC++ = 0; *pC++ = 0; *pC++ = DB_FLDDLMT; // album entry holder. *pC++ = 0; *pC++ = 0; *pC++ = DB_FLDDLMT; // genre entry holder. *pC++ = 0; *pC++ = 0; *pC++ = DB_FLDDLMT; // recordings entry holder. // Let's handle the special characters. pC += _processDBchar(timeLen, pC); pC += _processDBchar(size, pC); pC += GEN_strPack(pC, pPath, len2); *pC = DB_RECDLMT; // Contruct playlist record entry. if( (playlist = _constructRecord(pPlaylist)) == NULL ) { playlist = emptyRecord; bPlaylistAllocated = FALSE; } // Contruct playlist record entry. if( (artist = _constructRecord(pArtist)) == NULL ) { artist = emptyRecord; bArtistAllocated = FALSE; } // Contruct Album record entry. if( (album = _constructRecord(pAlbum)) == NULL ) { album = emptyRecord; bAlbumAllocated = FALSE; } // Contruct Genre record entry. if( (genre = _constructRecord(pGenre)) == NULL ) { genre = emptyRecord; bGenreAllocated = FALSE; } // Contruct recordings record entry. if( (recordings = _constructRecord(pRecordings)) == NULL ) { recordings = emptyRecord; bRecordingsAllocated = FALSE; } // Initialize record. record[0] = title; record[1] = playlist; record[2] = artist; record[3] = album; record[4] = genre; record[5] = recordings; // Insert to audio DB. ret = DB_insertRecord(DBnav.audio, (DB_DATA *)record); free(title); if(bPlaylistAllocated == TRUE) free(playlist); if(bArtistAllocated == TRUE) free(artist); if(bAlbumAllocated == TRUE) free(album); if(bGenreAllocated == TRUE) free(genre); if(bRecordingsAllocated == TRUE) free(recordings); UI_audioPresetUpdate(1); return ret; }

Here is the call graph for this function:

BOOL UI_insertHisiRecord (  const char *  pTitle, const char *  pSrc, const char *  pPath )

Function inserts a HiSi clip to unidentified HiSi database. Parameters: pTitle  Title string. pSrc  HiSi source string embedded with hisi source identifier. pPath  HiSi clip full path. Returns: TRUE if record successfully inserted, otherwise FALSE. 3 delimiter + 2 reserved for safe. Definition at line 51 of file UI_insertRecord.c. References DB_insertRecord(), GEN_strPack(), SYS_die(), and st_DBNAV::unidedhisi. { char * record; char * pC; int len1; int len2; int len3; int ii; BOOL ret; /* Construct the primary data entry. */ len1 = strlen(pTitle); len2 = strlen(pSrc); len3 = strlen(pPath); // 3 extra NULL holder + 1 record flag + ii = ( (len1 + len2 + len3)/2 ) + 9; record = (char *)calloc(ii, sizeof(char)); if(NULL == record) SYS_die(UI_INSERTRECORD); pC = record; *pC++= 0x8000; // Record flag. pC += GEN_strPack(pC, pTitle, len1); *pC++ = DB_FLDDLMT; pC += GEN_strPack(pC, pSrc, len2); *pC++ = DB_FLDDLMT; pC += GEN_strPack(pC, pPath, len3); *pC = DB_RECDLMT; /* Insert to unidentified HiSi DB. */ ret = DB_insertRecord(DBnav.unidedhisi, (DB_DATA *)&record); free(record); return ret; }

Here is the call graph for this function:

BOOL UI_interpretAudioRecord (  st_DBINFO *  pInfo, USHORT *  buf, char *  fname, char *  artist, char *  title, char *  album, char *  genre, char *  playlist, char *  recordings, ULONG *  pDuration, ULONG *  pSize )

Funciton interprets audio DB record and sets up player display controls. Parameters: pInfo  Audio database info. buf  DB record data buffer. fname  File path name. artist  Artist name. title  Title name. album  Album name genre  Genre name playlist  Playlist name. recordings  Recordings category name. pDuration  Duration in seconds of current audio record. pSize  Size in bytes of current audio track file. Returns: TRUE if successfully interpreted, otherwise FALSE. NOTE: 1) DB field are currently all hard-coded. 2) NULL pointer is checked to support buffer allocation one at a time. Definition at line 66 of file UI_interpretRecord.c. References DB_getField(), and GEN_strUnpack(). Referenced by MENU__createDbRecordInfoMenu(). { int len; // Fetch title. if(title) { if(0 == DB_getField((DB_DATA *)buf, 0, (DB_DATA*)title, pInfo)) { *title = 0; } } // Fetch playlist. if(playlist) { if(0 == DB_getField((DB_DATA *)buf, 1, (DB_DATA*)playlist, pInfo)) { *playlist = 0; } } // Fetch artist. if(artist) { if(0 == DB_getField((DB_DATA *)buf, 2, (DB_DATA*)artist, pInfo)) { //*artist = 0; GEN_readXstr((ULONG)text_unknownArtist, (USHORT*)artist, 16); } } // Fetch album. if(album) { if(0 == DB_getField((DB_DATA *)buf, 3, (DB_DATA*)album, pInfo)) { *album = 0; } } // Fetch genre. if(genre) { if(0 == DB_getField((DB_DATA *)buf, 4, (DB_DATA*)genre, pInfo)) { *genre = 0; } } // Fetch recording category. if(recordings) { if(0 == DB_getField((DB_DATA *)buf, 5, (DB_DATA*)recordings, pInfo)) { *recordings = 0; } } // Extract time length. if(pDuration) { DB_getField((DB_DATA *)buf, 6, (DB_DATA *)pDuration, pInfo); } // Extract size. if(pSize) { DB_getField((DB_DATA *)buf, 7, (DB_DATA *)pSize, pInfo); } // Extract path info. if(fname) { len = DB_getField((DB_DATA *)buf, AUDIO_PATH_DBFLDIDX, (DB_DATA *)fname, pInfo); GEN_strUnpack((UINT16*)fname, len); } return TRUE; }

Here is the call graph for this function:

BOOL UI_interpretFailedHisiRecord (  st_DBINFO *  pInfo, USHORT *  buf, char *  fname, char *  artist, char *  title, char *  album, char *  genre, char *  playlist, char *  recordings, ULONG *  pDuration, ULONG *  pSize )

Funciton interprets failed HiSi record and sets up player display controls. Parameters: pInfo  Failed HiSi database info. buf  DB record data buffer. fname  File path name. artist  Artist name. title  Title name. album  Album name genre  Genre name playlist  Playlist name. recordings  Recordings category name. pDuration  Duration in seconds of current audio record. pSize  Size in bytes of current audio track file. Returns: TRUE if successfully interpreted, otherwise FALSE. NOTE: 1) DB field are currently all hard-coded. 2) NULL pointer is checked to support buffer allocation one at a time. Definition at line 391 of file UI_interpretRecord.c. References DB_getField(), and GEN_strUnpack(). { int len; // Fetch title. if(title) { if(0 == DB_getField((DB_DATA *)buf, 0, (DB_DATA*)title, pInfo)) { *title = 0; } } // Fetch artist. //if(artist) *artist = 0; if(artist) GEN_readXstr((ULONG)text_unIdedArtist, (USHORT*)artist, 16); // Fetch album. if(album) *album = 0; // Fetch playlist. if(playlist) *playlist = 0; // Fetch genre. if(genre) *genre = 0; // Fetch recording category. if(recordings) *recordings = 0; // Extract time length. if(pDuration) { DB_getField((DB_DATA *)buf, 6, (DB_DATA *)pDuration, pInfo); } // Extract size. if(pSize) { DB_getField((DB_DATA *)buf, 7, (DB_DATA *)pSize, pInfo); } // Extract path info. if(fname) { len = DB_getField((DB_DATA *)buf, HISI_PATH_DBFLDIDX, (DB_DATA *)fname, pInfo); GEN_strUnpack((UINT16*)fname, len); } return TRUE; }

Here is the call graph for this function:

BOOL UI_interpretIdentifiedHisiRecord (  st_DBINFO *  pInfo, USHORT *  buf, char *  fname, char *  artist, char *  title, char *  album, char *  genre, char *  playlist, char *  recordings, ULONG *  pDuration, ULONG *  pSize )

Funciton interprets identified HiSi record and sets up player display controls. Parameters: pInfo  Identified HiSi database info. buf  DB record data buffer. fname  File path name. artist  Artist name. title  Title name. album  Album name genre  Genre name playlist  Playlist name. recordings  Recordings category name. pDuration  Duration in seconds of current audio record. pSize  Size in bytes of current audio track file. Returns: TRUE if successfully interpreted, otherwise FALSE. NOTE: 1) DB field are currently all hard-coded. 2) NULL pointer is checked to support buffer allocation one at a time. Definition at line 193 of file UI_interpretRecord.c. References DB_getField(), and GEN_strUnpack(). Referenced by MENU__createDbRecordInfoMenu(). { int len; // Fetch title. 0, points to clip name, 5, identified track name. if(title) { if(0 == DB_getField((DB_DATA *)buf, 5, (DB_DATA*)title, pInfo)) { *title = 0; } } // Fetch artist. if(artist) { if(0 == DB_getField((DB_DATA *)buf, 2, (DB_DATA*)artist, pInfo)) { //*artist = 0; GEN_readXstr((ULONG)text_unknownArtist, (USHORT*)artist, 16); } } // Fetch album. if(album) { if(0 == DB_getField((DB_DATA *)buf, 3, (DB_DATA*)album, pInfo)) { *album = 0; } } // Fetch playlist. if(playlist) *playlist = 0; // Fetch genre. if(genre) *genre = 0; // Fetch recording category. if(recordings) *recordings = 0; // Extract time length. if(pDuration) { DB_getField((DB_DATA *)buf, 6, (DB_DATA *)pDuration, pInfo); } // Extract size. if(pSize) { DB_getField((DB_DATA *)buf, 7, (DB_DATA *)pSize, pInfo); } // Extract path info. if(fname) { len = DB_getField((DB_DATA *)buf, AUDIO_PATH_DBFLDIDX, (DB_DATA *)fname, pInfo); GEN_strUnpack((UINT16*)fname, len); } return TRUE; }

Here is the call graph for this function:

BOOL UI_interpretUnidentifiedHisiRecord (  st_DBINFO *  pInfo, USHORT *  buf, char *  fname, char *  artist, char *  title, char *  album, char *  genre, char *  playlist, char *  recordings, ULONG *  pDuration, ULONG *  pSize )

Funciton interprets unidentified HiSi record and sets up player display controls. Parameters: pInfo  Unidentified HiSi database info. buf  DB record data buffer. fname  File path name. artist  Artist name. title  Title name. album  Album name genre  Genre name playlist  Playlist name. recordings  Recordings category name. pDuration  Duration in seconds of current audio record. pSize  Size in bytes of current audio track file. Returns: TRUE if successfully interpreted, otherwise FALSE. NOTE: 1) DB field are currently all hard-coded. 2) NULL pointer is checked to support buffer allocation one at a time. Definition at line 299 of file UI_interpretRecord.c. References DB_getField(), and GEN_strUnpack(). { int len; // Fetch title. if(title) { if(0 == DB_getField((DB_DATA *)buf, 0, (DB_DATA*)title, pInfo)) { *title = 0; } } // Fetch artist. //if(artist) *artist = 0; if(artist) GEN_readXstr((ULONG)text_toBeIdedArtist, (USHORT*)artist, 16); // Fetch album. if(album) *album = 0; // Fetch playlist. if(playlist) *playlist = 0; // Fetch genre. if(genre) *genre = 0; // Fetch recording category. if(recordings) *recordings = 0; // Extract time length. if(pDuration) { DB_getField((DB_DATA *)buf, 6, (DB_DATA *)pDuration, pInfo); } // Extract size. if(pSize) { DB_getField((DB_DATA *)buf, 7, (DB_DATA *)pSize, pInfo); } // Extract path info. if(fname) { len = DB_getField((DB_DATA *)buf, HISI_PATH_DBFLDIDX, (DB_DATA *)fname, pInfo); GEN_strUnpack((UINT16*)fname, len); } return TRUE; }

Here is the call graph for this function:

int UI_isPresetStation (  USHORT  station  )

Function checks if specified FM radio station is a preset station or not. If true, funciton returns the preset index. Parameters: station  FM channel in 100KHz. Returns: preset index starting from 1. -1 indicates station is not a valid preset one. Definition at line 80 of file UI_presetMgmt.c. References st_NDSYSPARAM::preset, st_PRESET::radio, st_PRESET::share, and st_PRESET::type. { int ii; st_PRESET * pPreset; pPreset = &nandSysParam.preset[1]; for( ii = 1; ii <= MAX_PRESET; ii++) { if(pPreset->type == PRESET_RADIO) { if(pPreset->share.radio.station == station) return ii; } pPreset++; } return -1; }

BOOL UI_isPresetValid (  int  presetIdx  )

Function checks to see if there is a valid preset corresponding to specific preset index. Function also marks corresponding preset to be invalid if it detects a corrupted one. Parameters: presetIdx  preset index starting from 1. Returns: TRUE if a valid preset is detected. Definition at line 53 of file UI_presetMgmt.c. References st_PRESET::chksum, GEN_checksum(), st_NDSYSPARAM::preset, and st_PRESET::type. Referenced by MENU__createPresetMenu(), SYS_SF_idle(), UI_SF_dbmenu(), and UI_SF_menu(). { st_PRESET * pPreset = &nandSysParam.preset[presetIdx]; if(pPreset->type < PRESET_Invalid) { if(pPreset->chksum == GEN_checksum((USHORT*)pPreset, 7)) { return TRUE; } } pPreset->type = PRESET_Invalid; return FALSE; }

Here is the call graph for this function:

void UI_main (  void   )

Function serves as user interface task handle. This task is responsible to handle all menu browsing. Definition at line 37 of file UI_main.c. References st_MSG::d1, st_MSG::d2, st_MSG::id, MSG_createQ(), SSTATE_END, SSTATE_END_ACK, STATE, and UI_SF_powerup(). Referenced by SYS_createResidentTask(). { st_MSG msgIN; st_MSG msgOUT; MSG_ID id; MSG_DATA d1; MSG_DATA d2; STATE curstate = S_NULL; STATE oldstate = S_NULL; SFHDL SFHDL_TABLE[] = { UI_SF_null, UI_SF_menu, UI_SF_autoscan, UI_SF_dbmenu, UI_SF_powerup }; uiMsgQ = MSG_createQ(UI_MSG_Q_LENGTH); while(1) { mMSG_get(uiMsgQ, &msgIN, SYS_FOREVER); id = msgIN.id; d1 = msgIN.d1; d2 = msgIN.d2; curstate = UI_getSFhdl(oldstate)(&msgIN); while(curstate != oldstate) { oldstate = curstate; _loadCurStateCode(curstate); msgOUT.id = SYS_MSG_ID; msgOUT.d1 = SSTATE_START; // msgIN.d2 is carried over here. msgOUT.d2 = msgIN.d2; curstate = UI_getSFhdl(oldstate)(&msgOUT); } // Report to system the following message status. if( (SYS_MSG_ID == id)&&(SSTATE_END == d1) ) { mMSG_send(sysMsgQ, SYS_MSG_ID, SSTATE_END_ACK, DONTCARE, SYS_FOREVER); } UI_stackassert(UI_MAIN); } }

Here is the call graph for this function:

void UI_menuBrowse (  MSG_DATA  msgD1, MSG_DATA  msgD2, MENU_STATE  menu )

Function kicks off the generic menu browsing. Menu system maintains its own history and returns the specified system message when browsing to where it was started. NOTE: 1) It is the caller's responsibility to make sure request is NOT cascaded, in other words, do not send another browse request before current request reaches its root. 2) This API can NOT be called from UI task, it can be called from parent UI, child UI, system etc. Parameters: msgD1  Returning system message data1. msgD2  Returning system message data2 menu  Browsing menu ID. Definition at line 49 of file UI_browse.c. References SMENUBROWSE. Referenced by SYS_kickoff(). { static UINT mbREQUEST[3]; UINT * pD = &mbREQUEST[0]; *pD++ = (UINT)msgD2; *pD++ = (UINT)msgD1; *pD++ = (UINT)menu; mMSG_send(uiMsgQ, SYS_MSG_ID, SMENUBROWSE, (int)&mbREQUEST[0], SYS_FOREVER); }

STATE UI_MSF_audio (  st_MSG *  msgIN  )

Function serves as the audio db menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 41 of file UI_MSF_audio.c. { return S_MENU_STAY; }

STATE UI_MSF_autoff (  st_MSG *  msgIN  )

Function serves as the auto off menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 38 of file UI_MSF_autoff.c. References st_SYSPARAM::autoOffTime, SYS_autoffDisable(), and SYS_autoffEnable(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if(sysParam.autoOffTime == 1) SYS_autoffDisable(); else if(!SYS_isPlayActive()) SYS_autoffEnable(); } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_backlight (  st_MSG *  msgIN  )

Function serves as the backlight menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 41 of file UI_MSF_backlight.c. References st_SYSPARAM::backlight, KBD_LED, LED_OFF, LED_ON, SYS_onOffLEDs(), TMR_BACKLIGHT, TMR_create(), TMR_delete(), and st_SYSPARAM::x_backlight. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { // Check to apply backlight control. if(!( (SYS_isPowerPlugged()) && (sysParam.x_backlight == XTRA_OFF) )) // if(!SYS_isPowerPlugged()) { if(sysParam.backlight != 1) { ULONG backlite[2] = {500, 1500}; SYS_onOffLEDs(KBD_LED, LED_ON); TMR_create(TMR_BACKLIGHT, backlite[sysParam.backlight-2], TBACKLIGHTOFF, 0, NO_RELOAD); } else { TMR_delete(TMR_BACKLIGHT); SYS_onOffLEDs(KBD_LED, LED_OFF); } } else { TMR_delete(TMR_BACKLIGHT); SYS_onOffLEDs(KBD_LED, LED_ON); // if(sysParam.backlight != 1) SYS_onOffLEDs(KBD_LED, LED_ON); // else SYS_onOffLEDs(KBD_LED, LED_OFF); } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_bkpkSwap (  st_MSG *  msgIN  )

Function serves as the backpack swap menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 40 of file UI_MSF_bkpkSwap.c. References BTN_NULL, BTN_YES, SMSGBOX_EXIT, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { switch(actvItem) { case 1: // Controls. GEN_pushStack(MENU_BKPKSWAP); GEN_pushStack(MENU_BKPKSWAPCTLS); return S_MENU; case 2: // Restore flash. if( (SYS_isHDDpresent())&&(!(SYS_isNandRestoreFailed())) ) { // Wait till disk/DB is ready. if(FALSE == SYS_deleteDiskDbTask(0)) UI_msgbxCreate(MSGBX_SYSBUSY); else UI_msgbxCreate(MSGBX_NANDRESTOREQUERY); } break; } } else if( (SYS_MSG_ID == id)&&(SMSGBOX_EXIT == d1) ) { if( (BTN_YES == d2)&&(MENU_curMsgbx() == MSGBX_NANDRESTOREQUERY) ) { UI_msgbxCreate(MSGBX_NANDRESTOREWAIT); SYS_createDiskDbTask(DDT_RESTORENAND); } else if( (BTN_NULL == d2)&&(MENU_curMsgbx() == MSGBX_NANDRESTOREWAIT) ) { if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_NANDRESTOREWAIT); } else { if(SYS_isNandRestoreFailed()) { UI_msgbxCreate(MSGBX_NONANDBAKFILE); if(SYS_isSyncDbNeeded()) { MENU_voidMsgbx(); SYS_deleteDiskDbTask(SYS_FOREVER); SYS_createDiskDbTask(DDT_SYNCDB); } } else { mMSG_send(sysMsgQ, KBD_MSG_ID, KEY_HPLAY, DONTCARE, SYS_FOREVER); } } } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_diag_hdd (  st_MSG *  msgIN  )

Function serves as the hard drive diagnosis menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 40 of file UI_MSF_diag_hdd.c. References BTN_NULL, BTN_YES, SMSGBOX_EXIT, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { switch(actvItem) { case 1: // format. case 2: // media format UI_msgbxCreate(MSGBX_DIAG_FORMATDISK); break; } } else if((SYS_MSG_ID == id)&&(SMSGBOX_EXIT == d1)) { if(BTN_YES == d2) { UI_msgbxCreate(MSGBX_DIAG_FORMATWAIT); switch(actvItem) { case 2: // media format SYS_forceMediaFormat(); case 1: // format. SYS_createDiskDbTask(DDT_DIAG_FORMATHDD); break; } } else if(BTN_NULL == d2) { if(MENU_curMsgbx() == MSGBX_DIAG_FORMATWAIT) { if(FALSE == SYS_deleteDiskDbTask(0)) UI_msgbxCreate(MSGBX_DIAG_FORMATWAIT); } } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_diag_nand (  st_MSG *  msgIN  )

Function serves as the NAND diagnosis menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 40 of file UI_MSF_diag_nand.c. References BTN_NULL, BTN_YES, SMSGBOX_EXIT, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { switch(actvItem) { case 1: // format. case 2: // revive. UI_msgbxCreate(MSGBX_DIAG_FORMATDISK); break; } } else if((SYS_MSG_ID == id)&&(SMSGBOX_EXIT == d1)) { if(BTN_YES == d2) { UI_msgbxCreate(MSGBX_DIAG_FORMATWAIT); switch(actvItem) { case 1: // format. SYS_createDiskDbTask(DDT_DIAG_FORMATNAND); break; case 2: // revive. SYS_createDiskDbTask(DDT_DIAG_REVIVENAND); break; } } else if(BTN_NULL == d2) { if(MENU_curMsgbx() == MSGBX_DIAG_FORMATWAIT) { if(FALSE == SYS_deleteDiskDbTask(0)) UI_msgbxCreate(MSGBX_DIAG_FORMATWAIT); } } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_diagnosis (  st_MSG *  msgIN  )

Function serves as the diagnosis menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 41 of file UI_MSF_diagnosis.c. References BOOT_MAIN. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { switch(actvItem) { case 1: // nand GEN_pushStack(MENU_DIAGNOSIS); GEN_pushStack(MENU_DIAG_NAND); return S_MENU; case 2: // hdd if(SYS_isHDDpresent()) { GEN_pushStack(MENU_DIAGNOSIS); GEN_pushStack(MENU_DIAG_HDD); return S_MENU; } break; case 3: // Exit SYS_reboot(BOOT_MAIN); } } return S_MENU_STAY; }

STATE UI_MSF_dj (  st_MSG *  msgIN  )

Function serves as the DJ selection menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 41 of file UI_MSF_dj.c. { return S_MENU_STAY; }

STATE UI_MSF_eq (  st_MSG *  msgIN  )

Function serves as the EQ selection menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 43 of file UI_MSF_eq.c. References AUDIO_setEQ(), st_EQ::curEqIdx, st_NDSYSPARAM::eq, st_EQ::eqBands, and SYS_loadDefaultEq(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if(1 == nandSysParam.eq.curEqIdx ) { // Off if(SYS_isAudioActive()) { AUDIO_setEQ(NULL); } } else if(8 == nandSysParam.eq.curEqIdx) { GEN_pushStack(MENU_EQ); hiliteItem = 0; SYS_loadDefaultEq(); if(SYS_isAudioActive()) { AUDIO_setEQ(nandSysParam.eq.eqBands[nandSysParam.eq.curEqIdx-2]); } return S_MENU; } else { GEN_pushStack(MENU_EQ); GEN_pushStack(MENU_SETEQ); if(SYS_isAudioActive()) { AUDIO_setEQ(nandSysParam.eq.eqBands[nandSysParam.eq.curEqIdx-2]); } return S_MENU; } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_goup (  st_MSG *  msgIN  )

Function serves as the special go-up menu handle, returns the menu by one level up. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 212 of file UI_globals.c. {return S_MENU;}

STATE UI_MSF_hisi (  st_MSG *  msgIN  )

Function serves as the hisi setup menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 39 of file UI_MSF_hisi.c. References st_DBNAV::failedhisi, st_DBNAV::idedhisi, SYS_deleteDiskDbTask(), UI_msgbxCreate(), and st_DBNAV::unidedhisi. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; DB_ID dbID; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { // Wait till disk/DB is ready. if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SYSBUSY); } else { GEN_pushStack(MENU_HISI); switch(actvItem) { case 1: // ided. dbID = DBnav.idedhisi; break; case 2: // unided. dbID = DBnav.unidedhisi; break; case 3: // failed. dbID = DBnav.failedhisi; break; } GEN_pushStack(S_MENU); GEN_pushStack(DB_INVALID_ID); GEN_pushStack(1); // actvItem GEN_pushStack(0); // fldEntry GEN_pushStack(-1); // fldIdx GEN_pushStack(dbID); return S_DBMENU; } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_main (  st_MSG *  msgIN  )

Function serves as the main menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 52 of file UI_MSF_main.c. References st_DBNAV::audio, KBD_isKeyDown(), KREWIND, st_DBNAV::pcaudio, SPOWERUP, SSTARTRADIO, SYS_deleteDiskDbTask(), UI_m3uEntryNum(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; USHORT ii; if( (SYS_MSG_ID == id)&&(SPOWERUP == d1) ) { GEN_pushStack(MENU_MAIN); return S_POWERUP; } else if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { switch(actvItem) { case 4+_Q: // PC audio collection #ifdef SP_SUPPORT { if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SYSBUSY); break; } GEN_pushStack(MENU_MAIN); GEN_pushStack(MENU_AUDIO); return S_MENU; } #endif case 1: // Audio. { DB_ID dbID; // Wait till disk/DB is ready. if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SYSBUSY); break; } dbID = (actvItem == 1)? DBnav.audio:DBnav.pcaudio; GEN_pushStack(MENU_MAIN); GEN_pushStack(S_MENU); GEN_pushStack(DB_INVALID_ID); GEN_pushStack(1); // dbEntry GEN_pushStack(0); // fldEntry GEN_pushStack(-1);// fldIdx GEN_pushStack(dbID); return S_DBMENU; } case 2+_Q: // FM Radio. { // Will eventually return to current menu. GEN_pushStack(MENU_MAIN); GEN_pushStack(S_MENU); // This simply yields, don't send messages. GEN_pushStack(DONTCARE); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTARTRADIO, DONTCARE, SYS_FOREVER); if(KBD_isKeyDown(KREWIND)) SYS_HF_linkitEnable(); return S_NULL; } case 3+_Q: // HiSi. GEN_pushStack(MENU_MAIN); GEN_pushStack(MENU_HISI); return S_MENU; case 5+_Q: // Settings. GEN_pushStack(MENU_MAIN); GEN_pushStack(MENU_SETTINGS); return S_MENU; #ifdef M3U_SUPPORT case 2: // Play Queue // Wait till disk/DB is ready. if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SYSBUSY); break; } if(0 == UI_m3uEntryNum(0)) { UI_msgbxCreate(MSGBX_EMPTYQ); break; } else { GEN_pushStack(MENU_MAIN); GEN_pushStack(MENU_PLAYQ); return S_MENU; } #endif //case 6: // Now playing. } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_myfi (  st_MSG *  msgIN  )

Function serves as the myfi setup menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 42 of file UI_MSF_myfi.c. References st_SYSPARAM::myfiMode, st_SYSPARAM::myfiQuality, and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { GEN_pushStack(MENU_MYFI); switch(actvItem) { case 1: /* mode. */ oldMyfiMode = sysParam.myfiMode; GEN_pushStack(MENU_MYFI_MODE); return S_MENU; case 2: /* myfi quality. */ oldMyfiQuality = sysParam.myfiQuality; GEN_pushStack(MENU_MYFI_QUALITY); return S_MENU; case 3: /* myfi gain. */ GEN_pushStack(MENU_MYFI_GAIN); return S_MENU; case 4: /* Auto scan. */ if(SYS_isHPpresent()) return S_AUTOSCAN; else { UI_msgbxCreate(MSGBX_HEADPHONEPLUG); GEN_popStack(); } break; } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_myfiMode (  st_MSG *  msgIN  )

Function serves as the myfi mode setup menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 90 of file UI_MSF_myfi.c. References st_SYSPARAM::myfiMode, and SMIFIMODECHANGED. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if( (SYS_isPlayActive())&&(oldMyfiMode != sysParam.myfiMode) ) { oldMyfiMode = sysParam.myfiMode; mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMIFIMODECHANGED, DONTCARE, SYS_FOREVER); } } return S_MENU_STAY; }

STATE UI_MSF_myfiQuality (  st_MSG *  msgIN  )

Function serves as the myfi quality setup menu handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 116 of file UI_MSF_myfi.c. References st_SYSPARAM::myfiQuality, and SMIFIQUALITYCHANGED. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if( (SYS_isPlayActive())&&(oldMyfiQuality != sysParam.myfiQuality) ) { oldMyfiQuality = sysParam.myfiQuality; mMSG_send(uiParentMsgQ, SYS_MSG_ID, SMIFIQUALITYCHANGED, DONTCARE, SYS_FOREVER); } } return S_MENU_STAY; }

STATE UI_MSF_playQueue (  st_MSG *  msgIN  )

Function serves as the play queue selection menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 44 of file UI_MSF_playQueue.c. References BTN_YES, SMSGBOX_EXIT, SPLAYQCHANGED, SXIM_CREATE, SXIM_EXIT, UI_m3uActvItem(), UI_m3uClear(), UI_m3uEntryNum(), and UI_m3uRemove(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; USHORT ii; if( (SYS_MSG_ID == id)&&(SXIM_EXIT == d1) ) { return(_ximAction(d2)); } else if( (SYS_MSG_ID == id)&&(SMSGBOX_EXIT == d1) ) { switch(MENU_curMsgbx()) { case MSGBX_REMOVEQALL: { if(BTN_YES == d2) { UI_m3uClear(0); if( SYS_isPlayActive() ) { mMSG_send(uiParentMsgQ, SYS_MSG_ID, SPLAYQCHANGED, 2, SYS_FOREVER); } return S_MENU; } break; } case MSGBX_REMOVEQRECORD: { if(BTN_YES == d2) { UI_m3uRemove(0, UI_m3uActvItem(0)); if(UI_m3uEntryNum(0)) GEN_pushStack(MENU_PLAYQ); if( SYS_isPlayActive() ) { mMSG_send(uiParentMsgQ, SYS_MSG_ID, SPLAYQCHANGED, 1, SYS_FOREVER); } return S_MENU; } break; } } } else if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_PLAYQ, SYS_FOREVER); } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_repeat (  st_MSG *  msgIN  )

Function serves as the repeat menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 38 of file UI_MSF_repeat.c. References SREPEATCHANGED. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if(SYS_isPlayActive()) { mMSG_send(uiParentMsgQ, SYS_MSG_ID, SREPEATCHANGED, DONTCARE, SYS_FOREVER); } } return S_MENU_STAY; }

STATE UI_MSF_settings (  st_MSG *  msgIN  )

Function serves as the settings menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 39 of file UI_MSF_settings.c. References BTN_YES, SMSGBOX_EXIT, SYS_defaultParams(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { GEN_pushStack(MENU_SETTINGS); switch(actvItem){ case 1: // Auto OFF. GEN_pushStack(MENU_AUTOFF); return S_MENU; case 2: // FM out GEN_pushStack(MENU_MYFI); return S_MENU; case 3: // Shuffle. GEN_pushStack(MENU_SHUFFLE); return S_MENU; case 4: // Repeat. GEN_pushStack(MENU_REPEAT); return S_MENU; case 5: // EQ GEN_pushStack(MENU_EQ); return S_MENU; case 6: // Backpack Swap. GEN_pushStack(MENU_BKPKSWAP); return S_MENU; case 7: // Presets. GEN_pushStack(MENU_PRESETREVIEW); return S_MENU; case 8: // Backlight. GEN_pushStack(MENU_BACKLIGHT); return S_MENU; case 9: // Contrast. GEN_pushStack(MENU_CONTRAST); return S_MENU; case 10: // Synclog. GEN_pushStack(MENU_SYNCLOG); return S_MENU; case 11: // Record quality. GEN_pushStack(MENU_RECORDQUALITY); return S_MENU; case 12: // Date time GEN_pushStack(MENU_DATETIME); return S_MENU; case 13: // Restore default UI_msgbxCreate(MSGBX_RESTOREDEFAULT); break; case 14: // Properties. GEN_pushStack(MENU_PROPERTIES); return S_MENU; //DeepB case 15: // Xtra. GEN_pushStack(MENU_XTRA); return S_MENU; } GEN_popStack(); } else if((SYS_MSG_ID == id)&&(SMSGBOX_EXIT == d1)) { if(MENU_curMsgbx() == MSGBX_RESTOREDEFAULT) { if(BTN_YES == d2) { SYS_defaultParams(); } } } return S_MENU_STAY; }

Here is the call graph for this function:

STATE UI_MSF_shuffle (  st_MSG *  msgIN  )

Function serves as the shuffle menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 41 of file UI_MSF_shuffle.c. References st_SYSPARAM::shuffle, and SSHUFFLECHANGED. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { if(SYS_isPlayActive()) { if(oldShuffleMode != sysParam.shuffle) { oldShuffleMode = sysParam.shuffle; mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSHUFFLECHANGED, DONTCARE, SYS_FOREVER); } } } return S_MENU_STAY; }

STATE UI_MSF_stay (  st_MSG *  msgIN  )

Function serves as the special stay menu handle, stays in current menu. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 223 of file UI_globals.c. {return S_MENU_STAY;}

STATE UI_MSF_xtra (  st_MSG *  msgIN  )

Function serves as the xtra menu state handle. Parameters: msgIN  Input message from UI. Returns: Next UI state. Definition at line 63 of file UI_MSF_xtra.c. References UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (KBD_MSG_ID == id)&&(KEY_SELECT == d1) ) { GEN_pushStack(MENU_XTRA); switch(actvItem){ case 1: // Layout // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_LAYOUT); return S_MENU; case 2: // Mute button. // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_MUTE); return S_MENU; case 3: // Hisi // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_HISI); return S_MENU; case 4: // Backlight // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_BACKLIGHT); return S_MENU; case 5: // Frequency Steps // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_GRANULARITY); return S_MENU; case 6: // Car Mode // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_CARMODE); return S_MENU; case 7: // Scrollwrap // Not Implemented warning // UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // break; GEN_pushStack(MENU_XTRA_SCROLLWRAP); return S_MENU; default: // Not Implemented warning UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); break; } GEN_popStack(); } return S_MENU_STAY; }

Here is the call graph for this function:

void UI_msgbxCreate (  MSGBX_ID  msgbx  )

Function sends out system message to create a message box menu. Parameters: msgbx  Message box ID. Definition at line 38 of file UI_msgbxCreate.c. References SMSGBOX_CREATE. Referenced by SYS_SF_idle(), UI_CSF_myfiChannel(), UI_MSF_bkpkSwap(), UI_MSF_diag_hdd(), UI_MSF_diag_nand(), UI_MSF_hisi(), UI_MSF_main(), UI_MSF_myfi(), UI_MSF_settings(), UI_MSF_xtra(), UI_PSF_hisi(), UI_PSF_null(), UI_PSF_play(), UI_PSF_record(), UI_SF_dbmenu(), UI_SF_menu(), and UI_SF_powerup(). { mMSG_send(uiChildMsgQ, SYS_MSG_ID, SMSGBOX_CREATE, msgbx, SYSTEM_TICK_SECOND*5); }

void UI_parent (  void   )

Function serves as user interface parent task handle. Parent task is responsible to handle macro level states, such as USB, playback, recording, radio etc. Definition at line 62 of file UI_parent.c. References st_MSG::d1, st_MSG::d2, st_MSG::id, MSG_createQ(), PARENT_STATE, SPOWERUP_SEQUENCEDONE, SSTART2HISI, SSTATE_END, SSTATE_END_ACK, SYS_autoffEnable(), SYS_deleteDiskDbTask(), UI_m3uInit(), UI_PSF_hisidone(), and USB_isCablePlugged(). Referenced by SYS_createResidentTask(). { st_MSG msgIN; st_MSG msgOUT; MSG_ID id; MSG_DATA d1; MSG_DATA d2; PARENT_STATE p_oldstate = P_NULL; PARENT_STATE p_curstate = P_NULL; PSFHDL PSFHDL_TABLE[] = { UI_PSF_null, UI_PSF_sleep, UI_PSF_autosync, UI_PSF_play, UI_PSF_radio, UI_PSF_record, UI_PSF_recorddone, UI_PSF_hisi, UI_PSF_hisidone }; uiParentMsgQ = MSG_createQ(UI_MSG_Q_LENGTH); while(1) { mMSG_get(uiParentMsgQ, &msgIN, SYS_FOREVER); id = msgIN.id; d1 = msgIN.d1; d2 = msgIN.d2; if( (SYS_MSG_ID == id)&&(SPOWERUP_SEQUENCEDONE == d1) ) { SYS_deleteDiskDbTask(SYS_FOREVER); #ifdef M3U_SUPPORT UI_m3uInit(); #endif // System has been fully powered up, check to auto-resume // if USB is not plugged and it is not hisi powerup. if(SYS_isHisiPowerup()) { SYS_powerupSequenceDone(); mMSG_send(sysMsgQ, SYS_MSG_ID, SSTART2HISI, DONTCARE, SYS_FOREVER); continue; } if( (!USB_isCablePlugged())&&(!SYS_isLowBattery()) ) { if(FALSE == _autoResume()) { SYS_autoffEnable(); } } SYS_usbEnabled(); SYS_powerupSequenceDone(); continue; } p_curstate = UI_getParentSFhdl(p_oldstate)(&msgIN); while(p_curstate != p_oldstate) { p_oldstate = p_curstate; _loadCurStateCode(p_curstate); msgOUT.id = SYS_MSG_ID; msgOUT.d1 = SSTATE_START; // msgIN.d2 is carried over here. msgOUT.d2 = msgIN.d2; p_curstate = UI_getParentSFhdl(p_oldstate)(&msgOUT); } // Report to system the following message status. if( (SYS_MSG_ID == id)&&(SSTATE_END == d1) ) { mMSG_send(sysMsgQ, SYS_MSG_ID, SSTATE_END_ACK, DONTCARE, SYS_FOREVER); } UI_stackassert(UI_PARENT); } }

Here is the call graph for this function:

void UI_presetAudio (  int  presetIdx, DB_ID  dbID, DB_ENTRY  dbEntry, DB_ENTRY  fldEntry, DB_FIELDIDX  fldIdx, ULONG  fptr )

Function presets the specified audio playback controls. Parameters: presetIdx  preset index starting from 1. dbID  Audio DB ID. dbEntry  NEUROS audio database record entry. fldEntry  NEUROS audio database field entry. fldIdx  NEUROS audio database field index. fptr  Bookmark file pointer. Definition at line 152 of file UI_presetMgmt.c. References st_PRESET::audio, st_NDSYSPARAM::audioPresetChksum, st_PRESET::chksum, DB_queryClose(), DB_queryFirst(), GEN_checksum(), st_NDSYSPARAM::preset, st_PRESET::share, and st_PRESET::type. Referenced by UI_PSF_play(), UI_SF_dbmenu(), and UI_SF_menu(). { st_PRESET * pPreset = &nandSysParam.preset[presetIdx]; st_AUDIOPRESET * pAP; USHORT buf[DB_MAXRECLEN]; DB_HDL hdl; pAP = &pPreset->share.audio; if(0x1234 == dbID) { // Play queue support. pPreset->type = PRESET_PLAYQ; pAP->dbId = 0x1234; pAP->dbEntry = dbEntry; pAP->fptr = fptr; pPreset->chksum = GEN_checksum((USHORT*)pPreset, 7); return; } // Hard-coded to check preset category. switch(fldIdx) { case 1: pPreset->type = PRESET_PLAYLIST; break; case 2: pPreset->type = PRESET_ARTIST; break; case 3: pPreset->type = PRESET_ALBUM; break; case 4: pPreset->type = PRESET_GENRE; break; case 5: pPreset->type = PRESET_RECORDINGS; break; default: pPreset->type = PRESET_SONGS; break; } //pPreset->type = PRESET_AUDIO; pAP->dbId = dbID; pAP->dbEntry = dbEntry; pAP->fldEntry = fldEntry; pAP->fldIdx = fldIdx; pAP->fptr = fptr; pPreset->chksum = GEN_checksum((USHORT*)pPreset, 7); // Apply checksum logic only to formal presets. if(0 != presetIdx) { // Calculate record checksum. //if(pPreset->type == PRESET_SONGS) hdl = DB_queryFirst(pAP->dbId, pAP->fldIdx, pAP->fldEntry, pAP->dbEntry, buf); //else // hdl = DB_queryFirst(DB_childID(pAP->dbId, pAP->fldIdx), 0, 0, pAP->fldEntry, buf); if(hdl != DB_INVALID_HDL) { nandSysParam.audioPresetChksum[presetIdx] = GEN_checksum(buf+3, strlen((const char*)buf+3)); DB_queryClose(hdl); } } }

Here is the call graph for this function:

void UI_presetMyFi (  int  presetIdx, USHORT  station )

Function presets the specified MyFi station. Parameters: presetIdx  preset index starting from 1. station  MyFi channel in 100KHz. Definition at line 127 of file UI_presetMgmt.c. References st_NDSYSPARAM::myfi. Referenced by UI_CSF_myfiChannel(). { st_RADIOPRESET * pPreset = &nandSysParam.myfi[presetIdx]; pPreset->station = station; }

void UI_presetRadio (  int  presetIdx, USHORT  station )

Function presets the specified radio station. Parameters: presetIdx  preset index starting from 1. station  FM channel in 100KHz. Definition at line 108 of file UI_presetMgmt.c. References st_PRESET::chksum, GEN_checksum(), st_NDSYSPARAM::preset, st_PRESET::radio, st_PRESET::share, and st_PRESET::type. Referenced by UI_PSF_radio(). { st_PRESET * pPreset = &nandSysParam.preset[presetIdx]; pPreset->type = PRESET_RADIO; pPreset->share.radio.station = station; pPreset->chksum = GEN_checksum((USHORT*)pPreset, 7); }

Here is the call graph for this function:

PARENT_STATE UI_PSF_autosync (  st_MSG *  msgIN  )

Function serves as the autosync state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 83 of file UI_PSF_autosync.c. References MENU_buf, MENU_CLOSE, SSTATE_START, SUSB_START, SUSB_STOP, SUSB_UNPLUG, SYS_createDiskDbTask(), TMR_AUTOSYNC, TMR_create(), TMR_delete(), TMR_ZEROTRAFFIC, USB_is20active(), and USB_isCableRemoved(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; ULONG dptr; switch(id) { case SYS_MSG_ID: if(SSTATE_START == d1) { // Make sure the cable is still plugged. if(USB_isCableRemoved()) { SYS_createDiskDbTask(DDT_AFTERSYNC); return P_NULL; } // Create GUI. MENU_buf[0] = DP_AUTOSYNC; menu = mMENU_create((void *)&MENU_buf[0]); // Tell system to start USB interface. mMSG_send(sysMsgQ, SYS_MSG_ID, SUSB_START, d2, SYS_FOREVER); TMR_create(TMR_AUTOSYNC, 4, TSYNCDISPLAY, 0, AUTO_RELOAD); bZero = FALSE; return P_AUTOSYNC; } if(SUSB_UNPLUG == d1) { SYS_createDiskDbTask(DDT_AFTERSYNC); mMSG_send(sysMsgQ, SYS_MSG_ID, SUSB_STOP, DONTCARE, SYS_FOREVER); TMR_delete(TMR_AUTOSYNC); mMENU_action(menu, MENU_CLOSE); return P_NULL; } break; case TMR_MSG_ID: if(TSYNCDISPLAY == d1) { #ifdef USB20_SUPPORT if(TRUE == USB_is20active()) { if(USB20_isTrafficPresent()) { bZero = FALSE; TMR_create(TMR_ZEROTRAFFIC, 320, TZEROTRAFFIC, 0, NO_RELOAD); } } else #endif { BOOL removeAllowed; ULONG txRate; ULONG rxRate; USB_isRemoveAllowed(&removeAllowed); USB_getTxRate(&txRate); USB_getRxRate(&rxRate); if( (FALSE == removeAllowed) || (txRate+rxRate > 300) ) { bZero = FALSE; TMR_create(TMR_ZEROTRAFFIC, 320, TZEROTRAFFIC, 0, NO_RELOAD); } } if(bZero == FALSE) { //DeepB // dptr = syncIconList[counter]; // mMENU_update(menu, 1, dptr, FALSE); mMENU_update(menu, 2, 0, FALSE); mMENU_update(menu, 4, 0, FALSE); mMENU_refresh(menu); } // if(++counter == 33) counter = 1; return P_AUTOSYNC; } if(TZEROTRAFFIC == d1) { bZero = TRUE; //DeepB // dptr = syncIconList[0]; // mMENU_update(menu, 1, dptr, FALSE); mMENU_update(menu, 3, 0, FALSE); mMENU_update(menu, 5, 0, FALSE); mMENU_refresh(menu); return P_AUTOSYNC; } } return P_AUTOSYNC; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_hisi (  st_MSG *  msgIN  )

Function serves as the parent hisi state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 68 of file UI_PSF_hisi.c. References AF_MP3, AI_START, Audio, AUDIO_initInterface(), AUDIO_MODE, AUDIO_setInterface(), BTN_YES, CLOCK_MP3RECORD, ENCODER_getAudioMode(), ENCODER_setSource(), ES_SOURCE, FAT_freeSpace(), st_UI::fname, st_AUDIO::freeSpace, MENU_buf, st_AUDIO::mode, st_UI::path, SAUDIOTIME_UPDT, SMSGBOX_EXIT, SSTATE_END, SSTATE_START, SYS_clockSetup(), TMR_create(), TMR_HISI, and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; //DeepB /* ULONG hisiIconList[12] = { (ULONG)graf_icon_hisi1, (ULONG)graf_icon_hisi2, (ULONG)graf_icon_hisi3, (ULONG)graf_icon_hisi4, (ULONG)graf_icon_hisi5, (ULONG)graf_icon_hisi6, (ULONG)graf_icon_hisi7, (ULONG)graf_icon_hisi8, (ULONG)graf_icon_hisi9, (ULONG)graf_icon_hisi10, (ULONG)graf_icon_hisi11, (ULONG)graf_icon_hisi12}; */ switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { SYS_clockSetup(CLOCK_MP3RECORD); BAT_setLowThreshold(0x3A66); //3.65V*4096. ENCODER_setSource((ES_SOURCE)d2); Audio.freeSpace = FAT_freeSpace(SYS_isHDDpresent()?DISK_C:DISK_D); if(Audio.freeSpace < DISK_RESERVED_SPACE) { UI_msgbxCreate(MSGBX_DISKFULL); return P_HISI; } if(HFC_SUCCESS != _createHisiFile(Ui.path, (ES_SOURCE)d2)) { return P_NULL; } AUDIO_initInterface((AUDIO_MODE)ENCODER_getAudioMode((USHORT)d2), AF_MP3, 0, 0); AUDIO_setInterface(AI_START); _loadHisiTmplt(Ui.fname, (int)d2); menu = mMENU_create((void *)&MENU_buf[0]); _updateHisiTime(30); TMR_create(TMR_HISI, 10, THISIANIMATION, 0, AUTO_RELOAD); //DeepB // iconCount = 0; return P_HISI; } case SSTATE_END: { _cancelHisi(); return P_NULL; } case SAUDIOTIME_UPDT: { if(30 < SYS_getCurRecordDuration()) { _stopHisi(); return P_HISIDONE; } _updateHisiTime(30-SYS_getCurRecordDuration()); return P_HISI; } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_CANCELHISI) { if(BTN_YES == d2) { _cancelHisi(); return P_NULL; } } else if(MENU_curMsgbx() == MSGBX_DISKFULL) { SYS_usbEnabled(); SYS_recordNotActive(); return (Audio.mode == AM_RECFM) ? P_RADIO: P_NULL; } break; } } break; case TMR_MSG_ID: switch(d1) { case THISIANIMATION: { ULONG dptr; // Update recorder icon display if not paused. //DeepB // if(++iconCount >= 12) iconCount = 0; // dptr = hisiIconList[iconCount]; // mMENU_update(menu, 3, dptr, FALSE); mMENU_refresh(menu); break; } } break; case KBD_MSG_ID: switch(d1) { case KEY_BACK: case KEY_HBACK: case KEY_HISI: UI_msgbxCreate(MSGBX_CANCELHISI); return P_HISI; } break; } return P_HISI; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_hisidone (  st_MSG *  msgIN  )

Function serves as the parent HiSi complete state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 60 of file UI_PSF_hisidone.c. References AI_SHUTDOWN, AUDIO_setInterface(), BTN_YES, ENCODER_getSource(), FAT_delete(), st_UI::fname, MENU_buf, MENU_CLOSE, st_UI::path, SMSGBOX_EXIT, SSTATE_END, SSTATE_START, SXIM_CREATE, SXIM_EXIT, TMR_create(), TMR_delete(), and TMR_HISIDONE. Referenced by UI_parent(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { _loadHisiDoneTmplt(Ui.fname, (int)ENCODER_getSource()); menu = mMENU_create((void *)&MENU_buf[0]); TMR_create(TMR_HISIDONE, 250, THISIDONE, 0, NO_RELOAD); return P_HISIDONE; } case SSTATE_END: { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_HISIDONE); _addHisi2Db(); if(SYS_isRadioActive()) { AUDIO_setInterface(AI_SHUTDOWN); } return P_NULL; } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_DELETEHISICLIP) { if(BTN_YES == d2) { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_HISIDONE); FAT_delete(Ui.path); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; } else TMR_create(TMR_HISIDONE, 250, THISIDONE, 0, NO_RELOAD); } } case SXIM_EXIT: return _ximAction(msgIN); } break; case TMR_MSG_ID: switch(d1) { case THISIDONE: { mMENU_action(menu, MENU_CLOSE); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SSTATE_END, DONTCARE, SYS_FOREVER); _addHisi2Db(); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; } } break; case KBD_MSG_ID: switch(d1) { case KEY_BACK: TMR_delete(TMR_HISIDONE); mMENU_action(menu, MENU_CLOSE); _addHisi2Db(); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; case KEY_PLAY: _playHisi(msgIN); return P_PLAY; case KEY_SELECT: TMR_delete(TMR_HISIDONE); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_HISIDONE, SYS_FOREVER); break; } break; } return P_HISIDONE; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_null (  st_MSG *  msgIN  )

Function serves as the parent null state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 56 of file UI_PSF_null.c. References BAT_calibrate(), HISI_LED, KBD_isKeyDown(), KFORWARD, LED_OFF, LED_ON, SBROWSE, SDIAGNOSIS, SENDOFMENU, SFORCEOFF, SGO2PRESET, SHIDDENFEATURE, SMSGBOX_EXIT, SPSF_NULL, SSHUT_DOWN, SSTART2HISI, SSTART2PLAY, SSTART2RECORD, SSTARTRADIO, SSTATE_END, SSTATE_START, st_SYSPARAM::station, SUSB_PLUG, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), SYS_onOffLEDs(), SYS_serialNumber(), UI_m3uClose(), and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: case SDIAGNOSIS: case SENDOFMENU: { mMSG_send(uiMsgQ, SYS_MSG_ID, SBROWSE, DONTCARE, SYS_FOREVER); break; } case SSTATE_END: { mMSG_send(sysMsgQ, SYS_MSG_ID, SPSF_NULL, DONTCARE, SYS_FOREVER); break; } case SUSB_PLUG: { // GUI level clean up before switching to USB mode. #ifdef M3U_SUPPORT UI_m3uClose(0); #endif SYS_createDiskDbTask(DDT_2SYNC); // Ready the disk. SYS_deleteDiskDbTask(SYS_FOREVER); return P_AUTOSYNC; } case SSHUT_DOWN: { // GUI level clean up before shutting down. #ifdef M3U_SUPPORT UI_m3uClose(0); #endif UI_msgbxCreate(MSGBX_SHUTDOWN); SYS_deleteDiskDbTask(SYS_FOREVER); SYS_createDiskDbTask(DDT_SHUTDOWN); break; } case SSTARTRADIO: return P_RADIO; case SSTART2PLAY: return P_PLAY; case SSTART2RECORD: case SSTART2HISI: { // Ready the disk. SYS_deleteDiskDbTask(SYS_FOREVER); return((SSTART2RECORD == d1)? P_RECORD:P_HISI); } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_SHUTDOWN) { if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SHUTDOWN); } else return P_SLEEP; } break; } case SGO2PRESET: { if(UI_presetType(d2) == PRESET_RADIO) { sysParam.station = UI_presetStation(d2); return P_RADIO; } else { SYS_deleteDiskDbTask(SYS_FOREVER); return P_PLAY; } } case SHIDDENFEATURE: { if(1 == d2) { SYS_serialNumber(SN_FILEREAD, NULL); SYS_onOffLEDs(HISI_LED, LED_ON); SYS_HF_batCaliEnable(); BAT_caliEnable(); } break; } case SFORCEOFF: return P_SLEEP; } break; case KBD_MSG_ID: switch(d1) { case KEY_PLAY: { // Prepare for playback, properly shut down any msgbox, xim, ready // the data etc. if(!SYS_isDiagnosisMode()) { if(KBD_isKeyDown(KFORWARD)) { mMSG_send(sysMsgQ, SYS_MSG_ID, SSTART2PLAY, 0xA5A5, SYS_FOREVER); } else mMSG_send(sysMsgQ, SYS_MSG_ID, SSTART2PLAY, DONTCARE, SYS_FOREVER); } break; } case KEY_HBACK: { if(SYS_HF_batCalibration()) _batCalibrate(); break; } case KEY_HHISI: { if(SYS_HF_batCalibration()) { BAT_calibrate(); SYS_HF_batCaliDisable(); BAT_caliDisable(); SYS_onOffLEDs(HISI_LED, LED_OFF); } break; } } break; case TMR_MSG_ID: break; } return P_NULL; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_play (  st_MSG *  msgIN  )

Function serves as the parent play state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 126 of file UI_PSF_play.c. References st_UI::abMode, st_UI::abStart, AF_ILINK, AI_PAUSE, AI_START, AI_UNMUTE, st_PLAYQ::album, AM_ILINK, AM_MYFI, st_UI::aPtr, st_PLAYQ::artist, st_PRESET::audio, st_DBNAV::audio, Audio, AUDIO_getCacheTrackFile(), AUDIO_getFilePtr(), AUDIO_initInterface(), AUDIO_resetMyfiQuality(), AUDIO_setCurrentTrack(), AUDIO_setFilePtr(), AUDIO_setInterface(), BTN_CANCEL, BTN_NEUROS, BTN_PCDELETE, BTN_YES, CLOCK_PLAY, D2PEAR_ID, DB_deleteRecordByMdb(), DECODER_cacheDepthReset(), st_PLAYQ::duration, st_DBNAV::failedhisi, FAT_delete(), st_PLAYQ::fname, st_PLAYQ::genre, st_DBNAV::idedhisi, st_PLAYQ::mdb, MENU_buf, MENU_CLOSE, MENU_isValid(), MENU_TXTSCROLL, st_AUDIO::mode, st_SYSPARAM::myfiChannel, st_SYSPARAM::myfiMode, PEAR_DATA, st_AUDIO::playtime, st_NDSYSPARAM::preset, SAUDIOTIME_UPDT, SBROWSE, SCURRENTAUDIOFILE, SENDOFMENU, SENDOFMUSIC, st_PRESET::share, st_PLAYQ::size, SMIFIMODECHANGED, SMIFIQUALITYCHANGED, SMSGBOX_EXIT, SMYFICHANNELCHANGED, SMYMIXCHANGED, SNEXTAUDIOFILE, SPLAYQCHANGED, SPRESET, SRESUMEPLAY, SSHUFFLECHANGED, SSTARTRADIO, SSTATE_END, SSTATE_START, SXIM_CREATE, SXIM_EXIT, SYS_clockSetup(), SYS_die(), st_PLAYQ::title, UI_audioPresetUpdate(), UI_earPut(), UI_m3uActvItemPtr(), UI_m3uChgOrder(), UI_m3uPut(), UI_m3uRemove(), UI_msgbxCreate(), UI_playQcurrent(), UI_playQreset(), UI_presetAudio(), UI_updateMembar(), st_DBNAV::unidedhisi, and st_SYSPARAM::x_granularity. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { SYS_clockSetup(CLOCK_PLAY); if(SYS_HF_linkit()) { AUDIO_initInterface(AM_ILINK, AF_ILINK, 0, 0); AUDIO_setInterface(AI_START); SYS_audioNotPaused(); _linkitGUIon(TRUE); return P_PLAY; } #ifdef DJ_SUPPORT _abInit(); #endif return _startPlay(d2, TRUE); } case SSTATE_END: { if(SYS_HF_linkit()) { _stopPlay(); return P_NULL; } return(_stateEnd()); } case SSTARTRADIO: _stopPlay(); return P_RADIO; case SRESUMEPLAY: case SENDOFMENU: { if(MENU_isValid(menu) == FALSE ) { _setupPlayMenu(UI_playQcurrent()); menu = mMENU_create((void*)&MENU_buf[0]); _displayMyfiChannel(); if(SYS_isAudioPaused()) { mMENU_update(menu, 5, (ULONG)graf_icon_pause, FALSE); } else { mMENU_update(menu, 5, (ULONG)graf_icon_play, FALSE); } _updatePlayTime(); } return P_PLAY; } case SPRESET: { if(SYS_isPresetable()) { ULONG fptr; //DeepB // Bugzilla #213 // Only get file pointer while paused if (SYS_isAudioPaused()) fptr = AUDIO_getFilePtr(); else fptr = 0; UI_presetAudio(d2, UI_presetDbId(0), UI_playQcurrent()->actvTrack, UI_presetFldEntry(0), UI_presetFldIdx(0), fptr); switch(UI_presetFldIdx(0)) { case 1: UI_msgbxCreate(MSGBX_PLAYLIST_PRESETDONE); break; case 2: UI_msgbxCreate(MSGBX_ARTIST_PRESETDONE); break; case 3: UI_msgbxCreate(MSGBX_ALBUM_PRESETDONE); break; case 4: UI_msgbxCreate(MSGBX_GENRE_PRESETDONE); break; case 5: UI_msgbxCreate(MSGBX_RECORDING_PRESETDONE);break; default: UI_msgbxCreate(MSGBX_SONGS_PRESETDONE); break; } } return P_PLAY; } case SAUDIOTIME_UPDT: { #ifdef DJ_SUPPORT _abCheck(); #endif _updatePlayTime(); return P_PLAY; } case SENDOFMUSIC: { #ifdef DJ_SUPPORT if( (Ui.abMode)&&(2 == Ui.abStart) ) return _prevNextMusic(0); #endif DECODER_cacheDepthReset(1); return _prevNextMusic(1); } case SPLAYQCHANGED: { #ifdef M3U_SUPPORT if( UI_getPlaySource() != PLAY_FROM_PLAYQ ) { st_PLAYQ * q = UI_playQcurrent(); UI_presetAudio(0, 0x1234, 1, DONTCARE, DONTCARE, 0); DB_LOCK(SYS_FOREVER); UI_m3uPut(0, q->fname, q->artist, q->title, q->album, q->genre, q->duration, q->size); *UI_m3uActvItemPtr(0) = 2; UI_m3uChgOrder(0, 0); DB_UNLOCK(); UI_playQreset(0x1234); return P_PLAY; } #endif } case SMYMIXCHANGED: { if(FALSE == UI_playQreset(d2)) { // No playable contents. _stopPlay(); UI_msgbxCreate(MSGBX_CONTENTSNA); return P_NULL; } return P_PLAY; } case SSHUFFLECHANGED: { UI_playQreset(DONTCARE); return P_PLAY; } case SMIFIQUALITYCHANGED: { AUDIO_resetMyfiQuality(); return P_PLAY; } case SMIFIMODECHANGED: { // Check new myfi mode. if( ((sysParam.myfiMode == 1) // off. &&(AUDIO_isMyfiActive())) || //DeepB ((sysParam.myfiMode == 2) // on && (!AUDIO_isMyfiActive())) || //Auto detectar ((sysParam.myfiMode == 3) // auto-detect. &&((AUDIO_isMyfiActive()) == (SYS_isHPpresent()))) ) { // Restart. UI_presetAudio(0, UI_presetDbId(0), UI_playQcurrent()->actvTrack, UI_presetFldEntry(0), UI_presetFldIdx(0), AUDIO_getFilePtr()); _stopPlay(); return _startPlay(0, FALSE); } break; } case SMYFICHANNELCHANGED: { _displayMyfiChannel(); return P_PLAY; } case SXIM_EXIT: { return(_ximAction(d2)); } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_CONTENTSNA) { return P_NULL; } else if(MENU_curMsgbx() == MSGBX_REMOVEQRECORD) { if(BTN_YES == d2) { _stateEnd(); UI_m3uRemove(0, UI_playQcurrent()->actvTrack); // Start next track from the very beginning. nandSysParam.preset[0].share.audio.fptr = 0L; return _startPlay(0, TRUE); } else return P_PLAY; } else if(MENU_curMsgbx() == MSGBX_DELETERECORD) { D2PEAR_ID earID; st_PLAYQ * q = UI_playQcurrent(); if( BTN_CANCEL == d2 ) return P_PLAY; if( (BTN_NEUROS == d2)||(BTN_PCDELETE == d2) ) { _stateEnd(); FAT_delete(q->fname); switch(UI_getPlaySource()) { case PLAY_FROM_IDEDHISI: DB_deleteRecordByMdb(DBnav.idedhisi, q->mdb); break; case PLAY_FROM_FAILEDHISI: DB_deleteRecordByMdb(DBnav.failedhisi, q->mdb); break; case PLAY_FROM_AUDIODB: DB_deleteRecordByMdb(DBnav.audio, q->mdb); UI_audioPresetUpdate(-1); break; default: SYS_die(UI_PSF_PLAY); } } earID = (BTN_NEUROS == d2)? DELETE_NEUROS_AUDIO: DELETE_PC_AUDIO; if(SYS_isHDDpresent()) { UI_earPut(strDISKC, earID,(PEAR_DATA)q->fname,strlen(q->fname)+1, 0); SYS_NAND_DBMOD_2HDD_PENDING(); } else { UI_earPut(strDISKD, earID,(PEAR_DATA)q->fname,strlen(q->fname)+1, 0); SYS_NAND_CONTENTS_CHANGED(); } // Start next track from the very beginning. nandSysParam.preset[0].share.audio.fptr = 0L; return _startPlay(0, TRUE); } else if(MENU_curMsgbx() == MSGBX_DELETERECORDFILE) { if(BTN_YES == d2) { st_PLAYQ * q = UI_playQcurrent(); _stateEnd(); FAT_delete(q->fname); UI_updateMembar(); return P_NULL; } } else if(MENU_curMsgbx() == MSGBX_DELETEHISICLIP) { if(BTN_YES == d2) { st_PLAYQ * q = UI_playQcurrent(); _stateEnd(); FAT_delete(q->fname); if(UI_getPlaySource() == PLAY_FROM_UNIDEDHISI) { DB_deleteRecordByMdb(DBnav.unidedhisi, q->mdb); UI_earPut(SYS_isHDDpresent()? strDISKC:strDISKD, HISI_DELETE_UNIDED_CLIP,(PEAR_DATA)q->fname, strlen(q->fname)+1, 0); if(SYS_isHDDpresent()) { SYS_NAND_DBMOD_2HDD_PENDING(); } else { SYS_NAND_CONTENTS_CHANGED(); } } return P_NULL; } } return P_PLAY; } case SCURRENTAUDIOFILE: { AUDIO_setCurrentTrack(); return P_PLAY; } case SNEXTAUDIOFILE: { AUDIO_getCacheTrackFile(d2); return P_PLAY; } } break; case TMR_MSG_ID: switch(d1) { case TTXTSCROLL: mMENU_action(menu, MENU_TXTSCROLL); return P_PLAY; } break; case KBD_MSG_ID: switch(d1) { case KEY_BACK: if(SYS_HF_linkit()) { _stopPlay(); return P_NULL; } if(!PLAY_isFromDb()) { _stopPlay(); return (SYS_wasFromHisi())? P_HISIDONE:P_RECORDDONE; } mMENU_action(menu, MENU_CLOSE); // Auto resume play window. SYS_autoResumePlayEnable(); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SBROWSE, DONTCARE, SYS_FOREVER); return P_PLAY; case KEY_HREWIND: if(SYS_HF_myfiTest()) { //sysParam.myfiChannel = 911; sysParam.myfiChannel = 875; _updateLinkitDisplay(sysParam.myfiChannel, menu); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); } case KEY_RREWIND: if(SYS_HF_linkit()) return P_PLAY; DECODER_frwd(); return P_PLAY; case KEY_REWIND: if(SYS_HF_linkit()) return P_PLAY; DECODER_cacheDepthReset(0); #ifdef DJ_SUPPORT if(Ui.abStart == 2) { AUDIO_setFilePtr(Ui.aPtr); return P_PLAY; } #endif //DeepB // To previous song // if on first 5 seconds // of non-paused song if((Audio.playtime < 5) && !(SYS_isAudioPaused())) return _prevNextMusic(-1); else return _prevNextMusic(0); case KEY_FORWARD: if(SYS_HF_linkit()) return P_PLAY; DECODER_cacheDepthReset(0); #ifdef DJ_SUPPORT if(Ui.abStart == 2) { AUDIO_setFilePtr(Ui.aPtr); return P_PLAY; } #endif return _prevNextMusic(1); case KEY_HFORWARD: if(SYS_HF_myfiTest()) { //sysParam.myfiChannel = 1049; sysParam.myfiChannel = 1041; _updateLinkitDisplay(sysParam.myfiChannel, menu); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); } case KEY_RFORWARD: if(SYS_HF_linkit()) return P_PLAY; DECODER_ffwd(); return P_PLAY; case KEY_PLAY: SYS_toggleAudioPaused(); if(SYS_isAudioPaused()) { PLAY_setPaused(); AUDIO_setInterface(AI_PAUSE); if(SYS_HF_linkit()) mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE); else mMENU_update(menu, 5, (ULONG)graf_icon_pause, FALSE); } else { PLAY_unsetPaused(); AUDIO_setInterface(AI_START); AUDIO_setInterface(AI_UNMUTE); if(SYS_HF_linkit()) mMENU_update(menu, 7, (ULONG)text_null, FALSE); else mMENU_update(menu, 5, (ULONG)graf_icon_play, FALSE); } mMENU_refresh(menu); return P_PLAY; case KEY_HUP: case KEY_UP: case KEY_RUP: if(SYS_HF_linkit()) { if(sysParam.myfiChannel < MAX_CHANNEL) { sysParam.myfiChannel+=sysParam.x_granularity; _updateLinkitDisplay(sysParam.myfiChannel, menu); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); } return P_PLAY; } case KEY_HDOWN: case KEY_DOWN: case KEY_RDOWN: if(SYS_HF_linkit()) { if(sysParam.myfiChannel > MIN_CHANNEL) { sysParam.myfiChannel-=sysParam.x_granularity; _updateLinkitDisplay(sysParam.myfiChannel, menu); XMIT_SetFreq(XMIT_SET, (MAX_CHANNEL-sysParam.myfiChannel)/2); } return P_PLAY; } mMSG_send(uiChildMsgQ, SYS_MSG_ID, (AM_MYFI == Audio.mode)? SMYFICHANNELWIN_CREATE:SVOLWIN_CREATE, DONTCARE, SYS_FOREVER); return P_PLAY; case KEY_SELECT: { int ximPtr; if(SYS_HF_linkit()) return P_PLAY; SYS_autoResumePlayEnable(); if(PLAY_FROM_PLAYQ == UI_getPlaySource()) { ximPtr = (AM_MYFI == Audio.mode)? XIMWIN_PLAYER_MYFIQ:XIMWIN_PLAYERQ; } else { ximPtr = (AM_MYFI == Audio.mode)? XIMWIN_PLAYER_MYFI:XIMWIN_PLAYER; if(PLAY_FROM_AUDIODB == UI_getPlaySource()) { if(FALSE == _playFromMymix()) { ximPtr = (AM_MYFI == Audio.mode)? XIMWIN_PLAYER_MYFI_ADD2MYMIX:XIMWIN_PLAYER_ADD2MYMIX; } } } mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, ximPtr, SYS_FOREVER); return P_PLAY; } } break; } return P_PLAY; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_radio (  st_MSG *  msgIN  )

Function serves as the parent FM radio state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 82 of file UI_PSF_radio.c. References AF_PCM, AI_SHUTDOWN, AI_START, AM_FMRADIO, AUDIO_initInterface(), AUDIO_setInterface(), CLOCK_FMTUNER, CODEC_hpVolume(), st_SYSPARAM::myfiChannel, SBROWSE, SENDOFMENU, SGO2PRESET, SHIDDENFEATURE, SPRESET, SRESUMEPLAY, SSTART2HISI, SSTART2PLAY, SSTART2RECORD, SSTARTRADIO, SSTATE_END, SSTATE_START, st_SYSPARAM::station, SVOLWIN_CREATE, SXIM_CREATE, SXIM_EXIT, SYS_clockSetup(), SYS_delayMicrosecond(), SYS_deleteDiskDbTask(), TMR_delete(), TMR_TUNERSEEK, TUNER_control(), TUNER_initFIR(), TUNER_tune(), UI_presetRadio(), and st_SYSPARAM::volume. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { SYS_clockSetup(CLOCK_FMTUNER); SYS_presetable(); if(!SYS_isRadioActive()) { SYS_radioActive(); TUNER_control(ON); TUNER_initFIR(); SYS_delayMicrosecond(300000); AUDIO_initInterface(AM_FMRADIO, AF_PCM, 0, 0); AUDIO_setInterface(AI_START); TUNER_tune(TUNER_SET, sysParam.station); CODEC_hpVolume(sysParam.volume); SYS_audioNotPaused(); HDD_shutdown(); } _radioGUIon(TRUE, d2); return P_RADIO; } case SHIDDENFEATURE: { if(1 != d2) break; _stateEnd(); SYS_HF_myfiTestEnable(); sysParam.myfiChannel = 963; mMSG_send(sysMsgQ, SYS_MSG_ID, SSTART2PLAY, 0xA5A5, SYS_FOREVER); return P_NULL; } case SSTATE_END: { return _stateEnd(); } case SGO2PRESET: { if(UI_presetType(d2) == PRESET_RADIO) { int station = UI_presetStation(d2); if(sysParam.station != station) { sysParam.station = station; TUNER_tune(TUNER_SET, station); } _radioGUIon(TRUE, d2); } else { _radioGUIon(FALSE, d2); AUDIO_setInterface(AI_SHUTDOWN); return P_PLAY; } return P_RADIO; } case SSTARTRADIO: case SRESUMEPLAY: case SENDOFMENU: { _radioGUIon(TRUE, curPresetIdx); return P_RADIO; } case SPRESET: { UI_presetRadio(d2, sysParam.station); _updateRadioDisplay(sysParam.station, menu, d2); return P_RADIO; } case SSTART2RECORD: case SSTART2HISI: { SYS_deleteDiskDbTask(SYS_FOREVER); // Bugzilla #157 Pt. 2b if(SYS_isAudioPaused()) { SYS_toggleAudioPaused(); mMENU_update(menu, 7, (ULONG)text_null, FALSE); CODEC_hpVolume(sysParam.volume); } mMENU_refresh(menu); _radioGUIon(FALSE, DONTCARE); return((SSTART2RECORD == d1)? P_RECORD:P_HISI); } case SXIM_EXIT: { return(_ximAction(d2)); } } break; case KBD_MSG_ID: switch(d1) { case KEY_HSELECT: sysParam.station = TUNER_tune(TUNER_SET, TUN_MAX_REAL_FREQ); _updateRadioDisplay(sysParam.station, menu, DONTCARE); return P_RADIO; case KEY_HBACK: sysParam.station = TUNER_tune(TUNER_SET, TUN_MIN_REAL_FREQ); _updateRadioDisplay(sysParam.station, menu, DONTCARE); return P_RADIO; case KEY_BACK: // Auto resume play window. SYS_autoResumePlayEnable(); _radioGUIon(FALSE, DONTCARE); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SBROWSE, DONTCARE, SYS_FOREVER); return P_RADIO; case KEY_HREWIND: case KEY_RREWIND: sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station); _updateRadioDisplay(sysParam.station, menu, DONTCARE); return P_RADIO; case KEY_REWIND: _seeksetup(TUNER_SEEK_DOWN); return P_RADIO; case KEY_FORWARD: _seeksetup(TUNER_SEEK_UP); return P_RADIO; case KEY_HFORWARD: case KEY_RFORWARD: sysParam.station = TUNER_tune(TUNER_INC, sysParam.station); _updateRadioDisplay(sysParam.station, menu, DONTCARE); return P_RADIO; case KEY_PLAY: SYS_toggleAudioPaused(); if(SYS_isAudioPaused()) { mMENU_update(menu, 7, (ULONG)text_tunermuted, FALSE); CODEC_hpVolume(0); } else { mMENU_update(menu, 7, (ULONG)text_null, FALSE); CODEC_hpVolume(sysParam.volume); } mMENU_refresh(menu); return P_RADIO; case KEY_UP: case KEY_HUP: case KEY_DOWN: case KEY_HDOWN: mMSG_send(uiChildMsgQ, SYS_MSG_ID, SVOLWIN_CREATE, DONTCARE, SYS_FOREVER); return P_RADIO; case KEY_SELECT: SYS_autoResumePlayEnable(); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_RADIO, SYS_FOREVER); return P_RADIO; } break; case TMR_MSG_ID: switch(d1) { case TFRWD_DOUBLECLICK: if(TUNER_SEEK_DOWN == d2) sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station); else sysParam.station = TUNER_tune(TUNER_INC, sysParam.station); _updateRadioDisplay(sysParam.station, menu, DONTCARE); break; case TTUNERSEEK: if( _SEEK_DONE != _seektest()) { unsigned int oldStation; oldStation = sysParam.station; if(TUNER_SEEK_DOWN == d2) { sysParam.station = TUNER_tune(TUNER_DEC, sysParam.station); if(oldStation < sysParam.station) {_seekdone(oldStation);} else _seekcontinue(); } else { sysParam.station = TUNER_tune(TUNER_INC, sysParam.station); if(oldStation > sysParam.station) {_seekdone(oldStation);} else _seekcontinue(); } } else { TMR_delete(TMR_TUNERSEEK); // Bugzilla #157 Pt. 2a if(SYS_isAudioPaused()) { SYS_toggleAudioPaused(); mMENU_update(menu, 7, (ULONG)text_null, FALSE); CODEC_hpVolume(sysParam.volume); } mMENU_refresh(menu); } _updateRadioDisplay(sysParam.station, menu, DONTCARE); break; } break; } return P_RADIO; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_record (  st_MSG *  msgIN  )

Function serves as the parent record state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 83 of file UI_PSF_record.c. References AI_START, Audio, AUDIO_initInterface(), AUDIO_setInterface(), CLOCK_MP3RECORD, ENCODER_getAudioFormat(), ENCODER_getAudioMode(), ENCODER_setSource(), ES_SOURCE, st_AUDIOENERGY::FastPeak, st_AUDIOENERGY::FastPeakdB, FAT_delete(), FAT_freeSpace(), st_UI::fname, st_AUDIO::freeSpace, GEN_int2ASCII(), MENU_buf, st_AUDIO::mode, st_UI::path, st_SYSPARAM::recordTime, SAUDIOTIME_UPDT, st_AUDIOENERGY::SlowPeak, st_AUDIOENERGY::SlowPeakdB, SMEDIAFULL, SMSGBOX_EXIT, SSTATE_END, SSTATE_START, SYS_clockSetup(), TMR_create(), TMR_RECORDER, TMR_RECORDER_VU, and UI_msgbxCreate(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; //DeepB /* ULONG recordIconList[4] = { (ULONG)graf_icon_record1, (ULONG)graf_icon_record2, (ULONG)graf_icon_record3, (ULONG)graf_icon_record4}; */ switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { SYS_clockSetup(CLOCK_MP3RECORD); BAT_setLowThreshold(0x3a66); //3.65V*4096. ENCODER_setSource((ES_SOURCE)d2); Audio.freeSpace = FAT_freeSpace(SYS_isHDDpresent()?DISK_C:DISK_D); if(Audio.freeSpace < DISK_RESERVED_SPACE) { UI_msgbxCreate(MSGBX_DISKFULL); return P_RECORD; } if(RFC_SUCCESS != _createRecFile(Ui.path, (ES_SOURCE)d2)) { return P_NULL; } AUDIO_initInterface(ENCODER_getAudioMode((USHORT)d2), ENCODER_getAudioFormat(), 0, 0); AUDIO_setInterface(AI_START); _loadRecorderTmplt(Ui.fname, (int)d2); menu = mMENU_create((void *)&MENU_buf[0]); _gainDisplay(); _updateRecordTime(0); mMENU_update(menu, 11, 0, FALSE); TMR_create(TMR_RECORDER_VU, 10, TRECVUMETER, 0, AUTO_RELOAD); if (sysParam.recordTime > 0) TMR_create(TMR_RECORDER, 39, TRECANIMATION, 0, AUTO_RELOAD); // iconCount = 0; if (sysParam.recordTime > 0) _togglePause(); return P_RECORD; } case SSTATE_END: { _stopRecord(); return P_RECORDDONE; } case SAUDIOTIME_UPDT: { _updateRecordTime(SYS_getCurRecordDuration()); return P_RECORD; } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_DISKFULL) { SYS_usbEnabled(); SYS_recordNotActive(); return (Audio.mode == AM_RECFM) ? P_RADIO: P_NULL; } break; } case SMEDIAFULL: { } } break; case TMR_MSG_ID: switch(d1) { case TRECVUMETER: { unsigned short i; char strLevel[8]; LeftInputEnergy.SlowPeakdB = AUDIO_Convert2dB(&LeftInputEnergy.SlowPeak); RightInputEnergy.SlowPeakdB = AUDIO_Convert2dB(&RightInputEnergy.SlowPeak); LeftInputEnergy.FastPeakdB = AUDIO_Convert2dB(&LeftInputEnergy.FastPeak); RightInputEnergy.FastPeakdB = AUDIO_Convert2dB(&RightInputEnergy.FastPeak); LeftInputEnergy.FastPeakdB = (LeftInputEnergy.FastPeakdB > 60)? 60 : LeftInputEnergy.FastPeakdB; RightInputEnergy.FastPeakdB = (RightInputEnergy.FastPeakdB > 60)? 60 : RightInputEnergy.FastPeakdB; lpeak = (lpeak < LeftInputEnergy.SlowPeakdB) ? lpeak : LeftInputEnergy.SlowPeakdB; rpeak = (rpeak < RightInputEnergy.SlowPeakdB) ? rpeak : RightInputEnergy.SlowPeakdB; // Do Left Level i = 0; if (LeftInputEnergy.SlowPeakdB != 0) strLevel[i++] = '-'; i += GEN_int2ASCII( LeftInputEnergy.SlowPeakdB, &strLevel[i], FALSE, 0); strLevel[i++] = 'd'; strLevel[i++] = 'B'; strLevel[i++] = '\0'; mMENU_update(menu, 5, (ULONG)strLevel, FALSE); i = 0; if (lpeak != 0) strLevel[i++] = '-'; i += GEN_int2ASCII( lpeak, &strLevel[i], FALSE, 0); strLevel[i++] = '\0'; mMENU_update(menu, 8, (ULONG)strLevel, FALSE); // Do Right Level i = 0; if (RightInputEnergy.SlowPeakdB != 0) strLevel[i++] = '-'; i += GEN_int2ASCII( RightInputEnergy.SlowPeakdB, &strLevel[i], FALSE, 0); strLevel[i++] = 'd'; strLevel[i++] = 'B'; strLevel[i++] = '\0'; mMENU_update(menu, 6, (ULONG)strLevel, FALSE); i = 0; if (rpeak != 0) strLevel[i++] = '-'; i += GEN_int2ASCII( rpeak, &strLevel[i], FALSE, 0); strLevel[i++] = '\0'; mMENU_update(menu, 9, (ULONG)strLevel, FALSE); _updateLevelBarGraphs(); mMENU_refresh(menu); break; } case TRECANIMATION: { if ((SYS_getCurRecordDuration()) >= (sysParam.recordTime * 60) && (sysParam.recordTime != 0) ) { _stopRecord(); return P_RECORDDONE; } break; } } break; case KBD_MSG_ID: switch(d1) { case KEY_HSELECT: lpeak = 255; rpeak = lpeak; break; //DeepB // Stop recordings only with the HiSi button // case KEY_BACK: case KEY_HISI: _stopRecord(); if( 5 > SYS_getCurRecordDuration()) { FAT_delete(Ui.path); if (SYS_isHDDpresent()) HDD_setPowerMode(HDD_POWEROFF, 0); return (SYS_isRadioActive())? P_RADIO: P_NULL; } return P_RECORDDONE; case KEY_PLAY: _togglePause(); return P_RECORD; case KEY_FORWARD: case KEY_RFORWARD: case KEY_HFORWARD: _timeUp(); return P_RECORD; case KEY_REWIND: case KEY_RREWIND: case KEY_HREWIND: _timeDown(); return P_RECORD; case KEY_HUP: case KEY_UP: case KEY_RUP: _gainUp(); return P_RECORD; case KEY_HDOWN: case KEY_DOWN: case KEY_RDOWN: _gainDown(); return P_RECORD; } break; } return P_RECORD; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_recorddone (  st_MSG *  msgIN  )

Function serves as the parent record complete state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 56 of file UI_PSF_recorddone.c. References AI_SHUTDOWN, AUDIO_setInterface(), BTN_YES, ENCODER_getSource(), FAT_delete(), st_UI::fname, GEN_createTimeString(), MENU_buf, MENU_CLOSE, st_UI::path, SMSGBOX_EXIT, SSTATE_END, SSTATE_START, SXIM_CREATE, SXIM_EXIT, TMR_create(), TMR_delete(), and TMR_RECORDDONE. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { char strDuration[16]; _loadRecorderDoneTmplt(Ui.fname, (int)ENCODER_getSource()); menu = mMENU_create((void *)&MENU_buf[0]); GEN_createTimeString(SYS_getCurRecordDuration(), strDuration); mMENU_update(menu, 4, (ULONG)strDuration, FALSE); mMENU_refresh(menu); TMR_create(TMR_RECORDDONE, 250, TRECORDDONE, 0, NO_RELOAD); return P_RECORDDONE; } case SSTATE_END: { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_RECORDDONE); _addRecord2Db(); if(SYS_isRadioActive()) { AUDIO_setInterface(AI_SHUTDOWN); } return P_NULL; } case SMSGBOX_EXIT: { if(MENU_curMsgbx() == MSGBX_DELETERECORDFILE) { if(BTN_YES == d2) { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_RECORDDONE); FAT_delete(Ui.path); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; } else TMR_create(TMR_RECORDDONE, 250, TRECORDDONE, 0, NO_RELOAD); } } case SXIM_EXIT: return _ximAction(msgIN); } break; case TMR_MSG_ID: switch(d1) { case TRECORDDONE: { mMENU_action(menu, MENU_CLOSE); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SSTATE_END, DONTCARE, SYS_FOREVER); _addRecord2Db(); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; } } break; case KBD_MSG_ID: switch(d1) { case KEY_BACK: TMR_delete(TMR_RECORDDONE); mMENU_action(menu, MENU_CLOSE); _addRecord2Db(); if(SYS_isRadioActive()) return P_RADIO; return P_NULL; case KEY_PLAY: _playRecord(msgIN); return P_PLAY; case KEY_SELECT: TMR_delete(TMR_RECORDDONE); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_RECORDDONE, SYS_FOREVER); break; } break; } return P_RECORDDONE; }

Here is the call graph for this function:

PARENT_STATE UI_PSF_sleep (  st_MSG *  msgIN  )

Function serves as the parent sleep state handle. This is where system gets shutdown with the power cable plugged in. When coming here, only following 4 messages can possibly wake system up, 1), PLAY press; 2), HiSi press; 3), USB plug; 4), Alarm fired. and 5) Unplug of power cabe or hold key-back will completely shut down system. Parameters: msgIN  Input message. Returns: Next state. Definition at line 65 of file UI_PSF_sleep.c. References ALL_LED, BOOT_AUTOLAUNCH1, BOOT_HHISI, BOOT_MAIN, KBD_isKeyDown(), KDOWN, LCD_power(), LED_OFF, SPOWER_UNPLUG, SPSF_NULL, SSHUT_DOWN, SSTART2HISI, SSTART2RECORD, SSTATE_END, SSTATE_START, SUSB_PLUG, SYS_autoffDisable(), SYS_delayMicrosecond(), SYS_onOffLEDs(), USB_cableStatusInit(), and st_SYSPARAM::x_hisibutton. { st_MSG msgOUT; MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if( (SYS_MSG_ID == id)&&(SSTATE_START == d1) ) { // Wait till system status is stable. SYS_delayMicrosecond(300000); if( (!SYS_isPowerPlugged()) || (SYS_isBatDead()) || !( (HDD_ID == 0xA017) || (HDD_ID == 0xA018) ) ) // is a usb 2.0 backpack? -wk { LCD_power(LCD_POWER_OFF, 0); SYS_onOffLEDs(ALL_LED, LED_OFF); // Wait till LCD stably shuts down. SYS_delayMicrosecond(1000000); _shutDown(); } else { //SYS_clockSetup(CLOCK_SLEEP); SYS_autoffDisable(); USB_cableStatusInit(); SYS_usbEnabled(); // Tell system to do the charge animation. SYS_batteryAnimation(); // Reenble keyboard routine here. SYS_kbdEnabled(); } } else if( ((KBD_MSG_ID == id)&&((KEY_PPLAY == d1)||(KEY_PLAY == d1)))|| ((SYS_MSG_ID == id)&&((SUSB_PLUG == d1)||(SSHUT_DOWN == d1))) ) //DeepB // Disable USB Cable detection // else if( ((KBD_MSG_ID == id)&&((KEY_PPLAY == d1)||(KEY_PLAY == d1)))|| // ((SYS_MSG_ID == id)&&(SSHUT_DOWN == d1)) ) { if(TRUE == KBD_isKeyDown(KDOWN)) { SYS_reboot(BOOT_AUTOLAUNCH1); } SYS_reboot(BOOT_MAIN); } //DeepB else if( (((SYS_MSG_ID == id)&&(SSTART2RECORD == d1))|| ((SYS_MSG_ID == id)&&(SSTART2HISI == d1)) ) && (sysParam.x_hisibutton < XTRA_HISI_OFF)) { SYS_reboot(BOOT_HHISI); } else if( ( (SYS_MSG_ID == id) && (SPOWER_UNPLUG == d1) ) || ( (KBD_MSG_ID == id) && (KEY_HBACK == d1) ) // check for key-left -wk ) { _shutDown(); } else if( (SYS_MSG_ID == id)&&(SSTATE_END == d1) ) { mMSG_send(sysMsgQ, SYS_MSG_ID, SPSF_NULL, DONTCARE, SYS_FOREVER); return P_SLEEP; } //else if alarm here... return P_SLEEP; }

Here is the call graph for this function:

void UI_readRTC (  st_DATETIME *  pDateTime  )

Function reads back the RTC time in UI format. Parameters: pDateTime  GUI date time structure pointer. Definition at line 38 of file UI_rtc.c. References RTC_BCD2INT(), RTC_readTime(), and st_SYSPARAM::year. Referenced by UI_MENU_dateTime(). { st_TIME t; RTC_readTime(&t); pDateTime->month = RTC_BCD2INT(MONTH, t.Month); pDateTime->day = RTC_BCD2INT(DAY, t.Day); /* High bits of year are stored away in E2ROM. */ pDateTime->year = (sysParam.year/100)*100 + RTC_BCD2INT(YEAR, t.Year); pDateTime->hour = RTC_BCD2INT(HOUR, t.Hour); // be careful at the boundry if(pDateTime->hour > 12 ) { pDateTime->am = 0; pDateTime->hour -= 12; } else { // 12:00 in 24 hr is 12:00pm in 12 hr if ( pDateTime->hour == 12 ) pDateTime->am = 0; else { // 00:00 is 12:00am in 12 hr if ( pDateTime->hour == 0 ) pDateTime->hour = 12; pDateTime->am = 1; } } pDateTime->minute = RTC_BCD2INT(MINUTE, t.Minute); }

Here is the call graph for this function:

void UI_removeXIM (  int *  pXIMbuf, int  item )

Function removes specified XIM item from XIM buffer. Parameters: pXIMbuf  XIM data buffer. item  item specifier. Definition at line 179 of file UI_CSF_xim.c. { int * pData; int len, tmp, itemNum; ULONG dptr; len = *pXIMbuf; if(len == 0) return; else { /* Get itemNum. */ itemNum = pXIMbuf[1] & 0x007F; if(itemNum <= item) return; /* Decrease item number. */ pXIMbuf[1] = itemNum - 1; if(pXIMbuf[1] == 0) { pXIMbuf[0] = 0; return; } /* Adjustify pDspData and pActionData for all items */ /* Points to first XIM item data pointer. */ pData = pXIMbuf + 4; for( tmp = 0; tmp < itemNum; tmp++ ) { dptr = ((unsigned long)(*pData)<<16)|((unsigned short)*(pData+1)); /* If NULL, no data associated. */ if(dptr) { dptr -= XIM_ITEM_HEADER_LEN; *pData++ = dptr >> 16; *pData++ = dptr & 0xFFFF; } else pData += 2; dptr = ((unsigned long)(*pData)<<16)|((unsigned short)*(pData+1)); /* If NULL, no data associated. */ if(dptr) { dptr -= XIM_ITEM_HEADER_LEN; *pData++ = dptr >> 16; *pData++ = dptr & 0xFFFF; } else pData += 2; /* Points to next XIM item. */ pData += 2; } /* Release removed item header. */ pData = pXIMbuf + 2 + (item*XIM_ITEM_HEADER_LEN); memmove( pData, pData + XIM_ITEM_HEADER_LEN, len - ((item+1)*XIM_ITEM_HEADER_LEN) - 2 ); } /* Update XIM data len. */ pXIMbuf[0] = len - XIM_ITEM_HEADER_LEN; }

void UI_setupTextMenu (  ULONG  tmpltStart, UINT *  pValue, UINT *  pActvItem, ITEMICONCTL  icon )

Function loads text menu controls into global menu buffer and ready the menu creation function. Parameters: tmpltStart  Text menu template data pointer. pValue  Selected item value pointer. pActvItem  Active item value pointer if not NULL. icon  Associated item icon ID. Definition at line 43 of file UI_setupTextMenu.c. References ITEMICONCTL, and MENU_buf. Referenced by UI_MENU_audio(), UI_MENU_autoff(), UI_MENU_backlight(), UI_MENU_bkpkSwap(), UI_MENU_bkpkSwapCtls(), UI_MENU_diag_hdd(), UI_MENU_diag_nand(), UI_MENU_diagnosis(), UI_MENU_eq(), UI_MENU_hisi(), UI_MENU_main(), UI_MENU_myfi(), UI_MENU_myfiMode(), UI_MENU_myfiQuality(), UI_MENU_recordQuality(), UI_MENU_repeat(), UI_MENU_settings(), UI_MENU_shuffle(), UI_MENU_xtra(), UI_MENU_xtra_backlight(), UI_MENU_xtra_carmode(), UI_MENU_xtra_granularity(), UI_MENU_xtra_hisi(), UI_MENU_xtra_layout(), UI_MENU_xtra_mute(), and UI_MENU_xtra_scrollwrap(). { UINT topItem; UINT actvItem; USHORT * pD; UI_assert((USHORT)pValue, UI_SETUPTEXTMENU); //UI_assert((USHORT)pActvItem, UI_SETUPTEXTMENU2); if(pActvItem) actvItem = *pActvItem; else actvItem = *pValue; /* Calculate top item and adjust active item. */ topItem = (actvItem>MENU_MAXITEMPERSCREEN)? actvItem-MENU_MAXITEMPERSCREEN+1 : 1; actvItem -= topItem; pD = (USHORT *)&MENU_buf[0]; *pD++ = DP_LISTMENU; GEN_readXdata(tmpltStart, pD++, 1); // itemNum *pD++ = actvItem; // actvItem *pD++ = topItem; // topItem *pD++ = icon; // itemicon. *pD++ = ((ULONG)_getRomDptr>>16); *pD++ = ((ULONG)_getRomDptr) & 0xFFFF; *pD++ = (USHORT)(tmpltStart>>16); // getdptr controls *pD++ = (USHORT)(tmpltStart & 0xFFFF); *pD++ = (USHORT)pValue; // pValue *pD = (USHORT)pActvItem; // pActvItem }

STATE UI_SF_autoscan (  st_MSG *  msgIN  )

Function serves as the autoscan state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 50 of file UI_SF_autoscan.c. References MENU_buf, MENU_CLOSE, MSG_send(), st_SYSPARAM::myfiChannel, SBROWSE, SDBBROWSE, SMENUBROWSE, SSTART2PLAY, SSTATE_END, SSTATE_START, SYS_autoffDisable(), TMR_AUTOSCAN, TMR_create(), and TMR_delete(). { ULONG dptr; MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; //DeepB /* ULONG scanIconList[12] = { (ULONG)graf_icon_seek1, (ULONG)graf_icon_seek2, (ULONG)graf_icon_seek3, (ULONG)graf_icon_seek4, (ULONG)graf_icon_seek5, (ULONG)graf_icon_seek6, (ULONG)graf_icon_seek7, (ULONG)graf_icon_seek8, (ULONG)graf_icon_seek9, (ULONG)graf_icon_seek10, (ULONG)graf_icon_seek11, (ULONG)graf_icon_seek12 }; */ switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { SYS_autoffDisable(); AUTOSCAN_init(); TMR_create(TMR_AUTOSCAN, BASETIMER, TAUTOSCAN, 0, AUTO_RELOAD); //DeepB // animation = 0; // iconCount = 0; MENU_buf[0] = DP_AUTOSCAN; menu = mMENU_create((void*)&MENU_buf[0]); return S_AUTOSCAN; } case SSTATE_END: { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_AUTOSCAN); AUTOSCAN_stop(); return S_MENU; } case SBROWSE: case SMENUBROWSE: case SDBBROWSE: case SSTART2PLAY: return S_AUTOSCAN; } break; case KBD_MSG_ID: switch(d1) { case KEY_BACK: mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_AUTOSCAN); AUTOSCAN_stop(); return S_MENU; } break; case TMR_MSG_ID: if(TAUTOSCAN == d1) { BOOL ret; int channel; if(!SYS_isHPpresent()) { mMENU_action(menu, MENU_CLOSE); TMR_delete(TMR_AUTOSCAN); AUTOSCAN_stop(); return S_MENU; } ret = AUTOSCAN_scan(&channel); // if((++animation == ANIMATIONTIMER)||(TRUE == ret)) // { //DeepB // animation = 0; // _displayMyfiChannel(channel); // // dptr = scanIconList[iconCount++]; // mMENU_update(menu, 1, dptr, FALSE); // if(iconCount == 12) iconCount = 0; if(TRUE == ret) { sysParam.myfiChannel = MAX_CHANNEL-(2*(channel)); mMENU_update(menu, 5, 0, FALSE); TMR_delete(TMR_AUTOSCAN); } mMENU_refresh(menu); // } return S_AUTOSCAN; } break; } MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_AUTOSCAN; }

Here is the call graph for this function:

STATE UI_SF_dbmenu (  st_MSG *  msgIN  )

Function serves as the DB menu state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 104 of file UI_SF_dbmenu.c. References st_DBNAV::audio, BTN_NEUROS, BTN_PCDELETE, BTN_YES, DB_getSaiByMdb(), MENU_2NEXT, MENU_2PREV, MENU_action(), MENU_buf, MENU_CLOSE, MENU_JUMPDN, MENU_JUMPUP, MENU_SELECT, MENU_TNEXT, MENU_TPREV, MENU_TSELECT, MENU_TXTSCROLL, MSG_send(), st_DBNAV::pcaudio, SMENUBROWSE, SMSGBOX_EXIT, SRESUMEPLAY, SSTART2PLAY, SSTATE_END, SSTATE_START, SXIM_CREATE, SXIM_EXIT, UI_isPresetValid(), UI_m3uActvItem(), UI_m3uEntryNum(), UI_msgbxCreate(), and UI_presetAudio(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; USHORT ii; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { // +-------------+ // | dbID | // +-------------+ // | fldIdx | // +-------------+ // | fldEntry | // +-------------+ // | actvItem | // +-------------+ // +-------------+ // | Invalid dbID| // +-------------+ // | Caller State| // +-------------+ DB_id = GEN_popStack(); DB_fldIdx = GEN_popStack(); DB_fldEntry = GEN_popStack(); DB_actvItem = GEN_popStack(); if(_validateDB() == 0 ) { UI_msgbxCreate(MSGBX_DBRECORDNA); return(_dbStateEnd()); } else menu = mMENU_create((void*)&MENU_buf[0]); return S_DBMENU; } case SSTATE_END: { return(_dbStateEnd()); } case SXIM_EXIT: { return(_ximAction(d2)); } case SMSGBOX_EXIT: { switch(MENU_curMsgbx()) { case MSGBX_DELETEHISICLIP: { if(BTN_YES == d2) { mMENU_action(menu, MENU_CLOSE); _deleteHisiClip(); if(_validateDB() == 0 ) { return(_dbStateEnd()); } menu = mMENU_create((void*)&MENU_buf[0]); } break; } case MSGBX_DELETERECORD: { if(BTN_NEUROS == d2) { mMENU_action(menu, MENU_CLOSE); _deleteRecord(); if(_validateDB() == 0 ) { return(_dbStateEnd()); } menu = mMENU_create((void*)&MENU_buf[0]); } else if(BTN_PCDELETE == d2) { mMENU_action(menu, MENU_CLOSE); _pcdeleteRecord(); if(_validateDB() == 0 ) { return(_dbStateEnd()); } menu = mMENU_create((void*)&MENU_buf[0]); } break; } case MSGBX_DELETEONSYNC: { if(BTN_YES == d2) { _deleteOnsync(); } break; } case MSGBX_REMOVERECORD: { if(BTN_YES == d2) { mMENU_action(menu, MENU_CLOSE); _removeRecord(); if(_validateDB() == 0 ) { return(_dbStateEnd()); } menu = mMENU_create((void*)&MENU_buf[0]); } break; } } return S_DBMENU; } //DeepB #ifdef USE_DATABASE_HACKS case SSTART2PLAY: { mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); GEN_pushStack(DB_actvItem); // actvItem GEN_pushStack(DB_fldEntry); // fldEntry GEN_pushStack(DB_fldIdx); // fldIdx GEN_pushStack(DB_id); GEN_pushStack(S_DBMENU); SYS_notUseSavedRandomPattern(); // Set up to play. if( (DB_rootID(DB_id) == DBnav.pcaudio) ) { // Play all if no history available and queue is empty. if( (FALSE == UI_isPresetValid(0))||(PRESET_RADIO == UI_presetType(0)) ) { #ifdef M3U_SUPPORT if(UI_m3uEntryNum(0)) { UI_presetAudio(0, 0x1234, UI_m3uActvItem(0), DONTCARE, DONTCARE, 0); } else #endif { UI_presetAudio(0, DBnav.audio, DONTCARE, 0, -1, 0); } } else { SYS_useSavedRandomPattern(); } } else { // If nothing is specifically selected here, play all instead. if(0 == DB_selected) { UI_presetAudio(0, DBnav.audio, DONTCARE, 0, -1, 0); } else { if(DB_id == DB_rootID(DB_id)) { UI_presetAudio(0, DB_id, DB_actvItem, DB_fldEntry, DB_fldIdx, 0); } else { DB_ENTRY fldEntry; // Hard-coded to support artist under album, in which case always play // the first available album. if(6 == DB_id) { _navDB(); { menu = mMENU_create((void*)&MENU_buf[0]); mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); } } fldEntry = DB_getSaiByMdb(((ULONG)dbBUF[0]<<16)|dbBUF[1], DB_id); //UI_presetAudio(0, DB_rootID(DB_id), DONTCARE, DB_actvItem, DB_fieldIndex(DB_id), 0); UI_presetAudio(0, DB_rootID(DB_id), DONTCARE, fldEntry, DB_fieldIndex(DB_id), 0); } } } GEN_pushStack(DONTCARE); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTART2PLAY, 0, SYS_FOREVER); return S_NULL; } #else // #ifdef USE_DATABASE_HACKS // I like this KISS approach better case SSTART2PLAY: { mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); GEN_pushStack(DB_actvItem); // actvItem GEN_pushStack(DB_fldEntry); // fldEntry GEN_pushStack(DB_fldIdx); // fldIdx GEN_pushStack(DB_id); GEN_pushStack(S_DBMENU); if (_navDB()) UI_presetAudio(0, DB_id, DB_actvItem, DB_fldEntry, DB_fldIdx, 0); else UI_presetAudio(0, DBnav.audio, DONTCARE, 0, -1, 0); GEN_pushStack(DONTCARE); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTART2PLAY, 0, SYS_FOREVER); return S_NULL; } #endif // #ifdef USE_DATABASE_HACKS case SRESUMEPLAY: { mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); GEN_pushStack(DB_actvItem); // actvItem GEN_pushStack(DB_fldEntry); // fldEntry GEN_pushStack(DB_fldIdx); // fldIdx GEN_pushStack(DB_id); GEN_pushStack(S_DBMENU); GEN_pushStack(DONTCARE); MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_NULL; } case SMENUBROWSE: { UINT * pD = (UINT*)d2; GEN_pushStack(S_NULL); GEN_pushStack(*pD++); if(*pD != DONTCARE) GEN_pushStack(*pD); pD++; GEN_pushStack(S_NULL); GEN_pushStack(MENU_NULL); GEN_pushStack(*pD); return S_MENU; } } break; case KBD_MSG_ID: switch(d1) { case KEY_PLAY: if(SYS_isAudioActive()) { mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTATE_END, DONTCARE, SYS_FOREVER); } MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_DBMENU; case KEY_DOWN: case KEY_HDOWN: mMENU_action(menu, MENU_2NEXT); return S_DBMENU; case KEY_RDOWN: ii = (d2/(KDOWN_HOLD_TIME>>1)) - 2; ii = (ii > 6)? 6 : ii; mMENU_action(menu, MENU_JUMPDN|(2<<ii)); return S_DBMENU; case KEY_UP: case KEY_HUP: mMENU_action(menu, MENU_2PREV); return S_DBMENU; case KEY_RUP: ii = (d2/(KDOWN_HOLD_TIME>>1)) - 2; ii = (ii > 6)? 6 : ii; mMENU_action(menu, MENU_JUMPUP|(2<<ii)); return S_DBMENU; case KEY_FORWARD: { //DeepB // Here is where i should check // if the leading char is not a letter. unsigned char curLeadCh = toupper(dbBUF[3]>>8); unsigned short curItem; mMENU_action(menu, MENU_2NEXT); mMENU_action(menu, MENU_SELECT); curItem = DB_actvItem; while(1) { if(toupper(dbBUF[3]>>8) != curLeadCh) break; mMENU_action(menu, MENU_TNEXT); mMENU_action(menu, MENU_TSELECT); if(DB_actvItem == curItem) break; } MENU_action(menu, MENU_JUMPDN); return S_DBMENU; } case KEY_REWIND: { unsigned char curLeadCh = toupper(dbBUF[3]>>8); unsigned short curItem; mMENU_action(menu, MENU_2PREV); mMENU_action(menu, MENU_SELECT); curItem = DB_actvItem; while(1) { if(toupper(dbBUF[3]>>8) != curLeadCh) break; mMENU_action(menu, MENU_TPREV); mMENU_action(menu, MENU_TSELECT); if(DB_actvItem == curItem) break; } MENU_action(menu, MENU_JUMPUP); return S_DBMENU; } //DeepB // Creates Xi Menu for folders too. // Broken right now. case KEY_HSELECT: { UI_msgbxCreate(MSGBX_NOTIMPLEMENTED); // mMENU_action(menu, MENU_SELECT); // _navDB(); // _setupDBxim(dbHdl); // mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_DB|dbHdl, SYS_FOREVER); // return S_DBMENU; } break; case KEY_SELECT: { int navRet; DB_ID _id; int _fldIdx; int _actvItem; int _fldEntry; mMENU_action(menu, MENU_SELECT); // Save a copy of controls. _actvItem = DB_actvItem; _fldEntry = DB_fldEntry; _fldIdx = DB_fldIdx; _id = DB_id; navRet =_navDB(); if( 0 == navRet ) { // No record available, restore the original DB controls. DB_id = _id; DB_fldIdx = _fldIdx; DB_fldEntry = _fldEntry; DB_actvItem = _actvItem; _validateDB(); UI_msgbxCreate(MSGBX_DBRECORDNA); } else if( -1 == navRet ) { mMENU_action(menu, MENU_CLOSE); // Nav forward, save history on stack. GEN_pushStack(_actvItem); // actvItem GEN_pushStack(_fldEntry); // fldEntry GEN_pushStack(_fldIdx); // fldIdx GEN_pushStack(_id); menu = mMENU_create((void*)&MENU_buf[0]); } else { _setupDBxim(dbHdl); mMSG_send(uiChildMsgQ, SYS_MSG_ID, SXIM_CREATE, XIMWIN_DB|dbHdl, SYS_FOREVER); } return S_DBMENU; } case KEY_BACK: return(_dbStateEnd()); } break; case TMR_MSG_ID: switch(d1) { case TTXTSCROLL: mMENU_action(menu, MENU_TXTSCROLL); return S_DBMENU; } break; } MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_DBMENU; }

Here is the call graph for this function:

STATE UI_SF_menu (  st_MSG *  msgIN  )

Function serves as the menu state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 67 of file UI_SF_menu.c. References st_DBNAV::audio, CODE_CONST, MENU_2NEXT, MENU_2PREV, MENU_buf, MENU_CLOSE, MENU_FWD, MENU_JUMPDN, MENU_JUMPUP, MENU_RWD, MENU_SELECT, MENU_TIME_UPDT, MENU_TXTSCROLL, MSG_send(), SAUDIOTIME_UPDT, st_SYSPARAM::sleepCount, st_SYSPARAM::sleepTimer, SMSGBOX_EXIT, SPOWERUP, SRESUMEPLAY, SRTC_UPDT, SSTART2PLAY, SSTATE_END, SSTATE_START, STATE, SXIM_EXIT, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), UI_isPresetValid(), UI_m3uActvItem(), UI_m3uEntryNum(), UI_msgbxCreate(), and UI_presetAudio(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; STATE retState; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { // | curMenu | // +-------------+ // | ParentMenu | // +-------------+ // | Caller State| // +-------------+ // If parentMenu == MENU_NULL, return to caller state. // What menu needs to be displayed? curMenu = (MENU_STATE)GEN_popStack(); GEN_load((CODE_CONST)UI_getMenuCode(curMenu)); UI_getMenuHdl(curMenu)(); menu = mMENU_create((void*)&MENU_buf[0]); return S_MENU; } case SSTATE_END: return _menuStateEnd(); case SXIM_EXIT: case SPOWERUP: case SMSGBOX_EXIT: return _menuHdl(msgIN); case SSTART2PLAY: { // Wait till disk/DB is ready. if(FALSE == SYS_deleteDiskDbTask(0)) { UI_msgbxCreate(MSGBX_SYSBUSY); return S_MENU; } mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); // Specially handle DB Record Info menu, make sure it shutdown // before playback window is set active. This is due to a // potential DB access conflict. if(MENU_DBRECORDINFO == curMenu) { // Throw away MENU_NULL, and directly browse to S_DBMENU. GEN_popStack(); } else { GEN_pushStack(curMenu); GEN_pushStack(S_MENU); } // Play history if available. // Play from queue if not empty // Play all else. SYS_notUseSavedRandomPattern(); if( (FALSE == UI_isPresetValid(0))|| (PRESET_RADIO == UI_presetType(0))|| (MENU_PLAYQ == curMenu) ) { #ifdef M3U_SUPPORT if(UI_m3uEntryNum(0)) { // play from queue. UI_presetAudio(0, 0x1234, UI_m3uActvItem(0), DONTCARE, DONTCARE, 0); } else #endif { // play all. UI_presetAudio(0, DBnav.audio, DONTCARE, 0, -1, 0); } } else { SYS_useSavedRandomPattern(); } GEN_pushStack(DONTCARE); mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTART2PLAY, 0, SYS_FOREVER); if(0xA5A5 == d2) SYS_HF_linkitEnable(); return S_NULL; } case SRESUMEPLAY: { mMENU_action(menu, MENU_SELECT); mMENU_action(menu, MENU_CLOSE); // Specially handle DB Record Info menu, make sure it shutdown // before playback window is set active. This is due to a // potential DB access conflict. if(MENU_DBRECORDINFO == curMenu) { // Throw away MENU_NULL, and directly browse to S_DBMENU. GEN_popStack(); } else { GEN_pushStack(curMenu); GEN_pushStack(S_MENU); } GEN_pushStack(DONTCARE); MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_NULL; } #ifdef DJ_SUPPORT case SAUDIOTIME_UPDT: { if(MENU_DJ == curMenu) mMENU_action(menu, MENU_TIME_UPDT); break; } #endif } break; case KBD_MSG_ID: switch(d1) { case KEY_RDOWN: { unsigned short ii; ii = (d2/(KDOWN_HOLD_TIME>>1)) - 2; ii = (ii > 6)? 6 : ii; mMENU_action(menu, MENU_JUMPDN|(2*ii)); } // Run through. case KEY_DOWN: case KEY_HDOWN: mMENU_action(menu, MENU_2NEXT); if(SYS_HF_sleepTimer()) { if(sysParam.sleepTimer>1) sysParam.sleepTimer--; sysParam.sleepCount = sysParam.sleepTimer; mMSG_send(sysMsgQ, SYS_MSG_ID, SRTC_UPDT, 0, 0); } return S_MENU; case KEY_RUP: { unsigned short ii; ii = (d2/(KDOWN_HOLD_TIME>>1)) - 2; ii = (ii > 6)? 6 : ii; mMENU_action(menu, MENU_JUMPUP|(2*ii)); } // Run through. case KEY_UP: case KEY_HUP: mMENU_action(menu, MENU_2PREV); if(SYS_HF_sleepTimer()) { if(sysParam.sleepTimer<480)sysParam.sleepTimer++; sysParam.sleepCount = sysParam.sleepTimer; mMSG_send(sysMsgQ, SYS_MSG_ID, SRTC_UPDT, 0, 0); } return S_MENU; case KEY_SELECT: mMENU_action(menu, MENU_SELECT); return _menuHdl(msgIN); #ifdef M3U_SUPPORT case KEY_PLAY: if( (SYS_isAudioActive())&&(MENU_PLAYQ == curMenu) ) { mMSG_send(uiParentMsgQ, SYS_MSG_ID, SSTATE_END, DONTCARE, SYS_FOREVER); } break; #endif case KEY_BACK: return(_menuStateEnd()); #ifdef DJ_SUPPORT case KEY_REWIND: if(MENU_DJ == curMenu) { mMENU_action(menu, MENU_RWD); return S_MENU; } break; case KEY_FORWARD: if(MENU_DJ == curMenu) { mMENU_action(menu, MENU_FWD); return S_MENU; } break; #endif #ifdef SP_SUPPORT case KEY_HBACK: { SYS_deleteDiskDbTask(SYS_FOREVER); SYS_createDiskDbTask(DDT_PROFILER); return S_MENU; } #endif } break; case TMR_MSG_ID: switch(d1) { case TTXTSCROLL: mMENU_action(menu, MENU_TXTSCROLL); return S_MENU; } break; } MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_MENU; }

Here is the call graph for this function:

STATE UI_SF_null (  st_MSG *  msgIN  )

Function serves as the NULL state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 42 of file UI_SF_null.c. References MENU_STATE, MSG_send(), SBROWSE, SDBBROWSE, SENDOFMENU, SMENUBROWSE, SSF_NULL, SSTATE_END, SSTATE_START, and STATE. { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; switch(id) { case SYS_MSG_ID: switch(d1) { case SSTATE_START: { // End of browsing, send system the message being // waiting for. MSG_DATA mD1 = (MSG_DATA)(GEN_popStack()); if(DONTCARE != mD1) { MSG_DATA mD2 = (MSG_DATA)(GEN_popStack()); mMSG_send(sysMsgQ, SYS_MSG_ID, mD1, mD2, SYS_FOREVER); } return S_NULL; } case SSTATE_END: { mMSG_send(sysMsgQ, SYS_MSG_ID, SSF_NULL, DONTCARE, SYS_FOREVER); return S_NULL; } case SBROWSE: { STATE retstate = S_NULL; if(GEN_stackDepth()) retstate = (STATE)GEN_popStack(); if(S_NULL == retstate) { MENU_STATE ms; ms = (SYS_isDiagnosisMode())? MENU_DIAGNOSIS:MENU_MAIN; GEN_pushStack(DONTCARE); GEN_pushStack(SENDOFMENU); GEN_pushStack(S_NULL); GEN_pushStack(MENU_NULL); GEN_pushStack(ms); retstate = S_MENU; } return retstate; } case SMENUBROWSE: { UINT * pD = (UINT*)d2; //GEN_pushStack(S_NULL); GEN_pushStack(*pD++); if(*pD != DONTCARE) GEN_pushStack(*pD); pD++; GEN_pushStack(S_NULL); GEN_pushStack(MENU_NULL); GEN_pushStack(*pD); return S_MENU; } case SDBBROWSE: { UINT * pD = (UINT*)d2; //GEN_pushStack(S_NULL); GEN_pushStack(*pD++); if(*pD != DONTCARE) GEN_pushStack(*pD); pD++; GEN_pushStack(S_NULL); GEN_pushStack(DB_INVALID_ID); GEN_pushStack(*pD++); GEN_pushStack(*pD++); GEN_pushStack(*pD++); GEN_pushStack(*pD); return S_DBMENU; } } break; case TMR_MSG_ID: break; } // Route the rest of the messages to parent UI. MSG_send(uiParentMsgQ, msgIN, SYS_FOREVER); return S_NULL; }

Here is the call graph for this function:

STATE UI_SF_powerup (  st_MSG *  msgIN  )

Function serves as the powerup state handle. Parameters: msgIN  Input message. Returns: Next state. Definition at line 41 of file UI_SF_powerup.c. References st_SYSPARAM::bkpkSwap, BTN_NO, BTN_OK, BTN_YES, SCREATETASK, SDIAGNOSIS, SMSGBOX_EXIT, SSTATE_START, SYS_createDiskDbTask(), SYS_deleteDiskDbTask(), and UI_msgbxCreate(). Referenced by UI_main(). { MSG_ID id = msgIN->id; MSG_DATA d1 = msgIN->d1; MSG_DATA d2 = msgIN->d2; if(SYS_MSG_ID == id) { if( SSTATE_START == d1) { SYS_createDiskDbTask(DDT_STARTUP); SYS_deleteDiskDbTask(SYS_FOREVER); if(SYS_isUnable2MountHDD()) { UI_msgbxCreate(MSGBX_HDDMOUNTFAILURE); } else if((SYS_isBkpkSwapPending())&&(1 == sysParam.bkpkSwap)) { UI_msgbxCreate(MSGBX_BKPKSWAPQUERY); } else { mMSG_send(sysMsgQ, SYS_MSG_ID, SCREATETASK, DDT_SYNCDB, SYS_FOREVER); return S_MENU; } return S_POWERUP; } else if(SMSGBOX_EXIT == d1) { if(BTN_YES == d2) { if(MENU_curMsgbx() == MSGBX_BKPKSWAPQUERY) { UI_msgbxCreate(MSGBX_NANDBAKWAIT); SYS_createDiskDbTask(DDT_SAVENAND); } else if(MENU_curMsgbx() == MSGBX_NANDSAVEFAILED) { mMSG_send(sysMsgQ, SYS_MSG_ID, SCREATETASK, DDT_SYNCDB, SYS_FOREVER); return S_MENU; } return S_POWERUP; } else if(BTN_NO == d2) { if(MENU_curMsgbx() == MSGBX_BKPKSWAPQUERY) { mMSG_send(sysMsgQ, SYS_MSG_ID, SCREATETASK, DDT_SYNCDB, SYS_FOREVER); return S_MENU; } else if(MENU_curMsgbx() == MSGBX_NANDSAVEFAILED) { mMSG_send(sysMsgQ, KBD_MSG_ID, KEY_HPLAY, DONTCARE, SYS_FOREVER); return S_MENU; } return S_POWERUP; } else if(BTN_OK == d2) { if(MENU_curMsgbx() == MSGBX_HDDMOUNTFAILURE) { GEN_flushStack(0); GEN_pushStack(DONTCARE); GEN_pushStack(SDIAGNOSIS); GEN_pushStack(S_NULL); GEN_pushStack(MENU_NULL); GEN_pushStack(MENU_DIAGNOSIS); SYS_diagnosisMode(); return S_MENU; } } } } if(MENU_curMsgbx() == MSGBX_NANDBAKWAIT) { if(FALSE == SYS_deleteDiskDbTask(0)) UI_msgbxCreate(MSGBX_NANDBAKWAIT); else { if(!SYS_isNandBakDone()) { UI_msgbxCreate(MSGBX_NANDSAVEFAILED); } else { mMSG_send(sysMsgQ, SYS_MSG_ID, SCREATETASK, DDT_SYNCDB, SYS_FOREVER); return S_MENU; } } } return S_POWERUP; }

Here is the call graph for this function:

---