INT32 UIFlowWndPlay_OnKeyMode(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
//if (KeyScan_IsHDMIPlugIn()==TRUE)
// return NVTEVT_CONSUME;
switch(g_PlbData.State)
{
case PLB_ST_PLAY_MOV:
case PLB_ST_PAUSE_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
// stop movie play
return UIFlowWndPlay_OnMovieFinish(pCtrl, paramNum, paramArray);
default:
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_NEXT);
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnClose(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
// stop SelTimerID/QViewTimerID
if (g_uiSelfTimerID != NULL_TIMER)
{
GxTimer_StopTimer(&g_uiSelfTimerID);
}
if (g_uiQviewTimerID != NULL_TIMER)
{
GxTimer_StopTimer(&g_uiQviewTimerID);
}
/* Once close photo window, reset selftimer to off state */
// SysSetFlag(FL_SELFTIMER, SELFTIMER_OFF);
g_bRedLEDOn = FALSE;
//KeyScan_TurnOffLED(KEYSCAN_LED_RED);
gPhotoData.QuickViewCount = 0;
gPhotoData.SelfTimerCount = 0;
FlowPhoto_InitStartupFuncs();
/* Reset key press/release/continue mask to default */
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Ux_DefaultEvent(pCtrl,NVTEVT_CLOSE_WINDOW,paramNum,paramArray);
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnKeyMode(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UINT32 uiKeyAct=NVTEVT_KEY_PRESS;
if (paramNum==1)
{
uiKeyAct = paramArray[0];
} else {
return NVTEVT_CONSUME;
}
switch(uiKeyAct)
{
case NVTEVT_KEY_PRESS:
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_NEXT);
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnOpen(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UIFlowWndPhoto_InitCfgSetting();
FlowPhoto_InitStartupFuncs();
/* Init window key mask variables & set key press/release/continue mask */
gPhotoData.State = PHOTO_ST_VIEW;
g_uiMaskKeyPress = PHOTO_KEY_PRESS_MASK;
g_uiMaskKeyRelease = PHOTO_KEY_RELEASE_MASK;
g_uiMaskKeyContinue = PHOTO_KEY_CONTINUE_MASK;
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
Input_SetKeyMask(KEY_RELEASE, g_uiMaskKeyRelease);
Input_SetKeyMask(KEY_CONTINUE, g_uiMaskKeyContinue);
gPhotoData.SysTimeCount = 0;
/* Update window info */
FlowPhoto_UpdateIcons(TRUE);
/* set FD/SD feature */
FlowPhoto_SetFdSdProc(TRUE);
Ux_DefaultEvent(pCtrl,NVTEVT_OPEN_WINDOW,paramNum,paramArray);
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_ReverseGear(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
static UINT32 uiLastPipViewStyle = 0;
UINT32 uiReverseGear;
uiReverseGear = paramNum ? paramArray[0] : 0;
if((uiReverseGear==TRUE)&&(bCarGuideLineMode == FALSE))
{
uiLastPipViewStyle = PipView_GetStyle();
//sensor change to sensor2 TV out
debug_msg("-----------sensoer tv out-------\r\n");
PipView_SetStyle(PIP_STYLE_2T2F);
GPIOMap_TurnOnLCDBacklight();
GxCustom_SetControl(GXCUSTOM_CTRL_AUTOLCDOFF_RESET,0);
bCarGuideLineMode = TRUE;
FlowPhoto_UpdateIcons(FALSE);
FlowPhoto_IconDrawGuideLine();
if(GPIOMap_IsLCDBacklightOn()==FALSE)
{
GPIOMap_TurnOnLCDBacklight();
GxCustom_SetControl(GXCUSTOM_CTRL_AUTOLCDOFF_RESET,0);
}
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
/* Init window key mask variables & set key and key released mask */
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
}
else if((uiReverseGear==FALSE)&&(bCarGuideLineMode == TRUE))
{
//PipView_SetStyle(PIP_STYLE_2T1B2S);
PipView_SetStyle(uiLastPipViewStyle);
bCarGuideLineMode = FALSE;
FlowPhoto_UpdateIcons(TRUE);
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
/* Init window key mask variables & set key and key released mask */
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_DEFAULT);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
}
}
static int MenuCustom_SwchToMenu(UINT32 uiMessage, UINT32 uiParam)
{
// mask key while changing primary mode
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
// changing primary mode
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_MOVIE);
return 1;
}
INT32 UIMenuWndPlaySlideShowCB_OnKeyEnter(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
#if SLIDESHOW_JPEG_ONLY
// restore for all legal playback file formats
UIMEnuWndPlaySlideShowCB_SetFileFmt(Playback_FileFmt_ALL);
#endif
Ux_FlushEventByRange(NVTEVT_TIMER, NVTEVT_TIMER);
GxTimer_StopTimer(&gSlideTimerID);
Ux_CloseWindow(&UIMenuWndPlaySlideShowCBCtrl,0);
return NVTEVT_CONSUME;
}
INT32 UIMenuWndCalibration_Item_OnKeyEnter(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
#if 0
if (g_CalItem[g_CalData.SelItem].ItemFunction != NULL)
{
g_CalItem[g_CalData.SelItem].ItemFunction();
}
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
UxCtrl_SetShow(&UIMenuWndCalibrationCtrl, TRUE);
Ux_Redraw();
#endif
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnKeyShutter2(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
#if(_MODEL_DSC_ == _MODEL_DUAL_AONI328_)
// mask key while changing primary mode
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
// changing primary mode
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_MOVIE);
#else
return UIFlowWndPhoto_OnExeCapture(pCtrl,paramNum,paramArray);
#endif
}
INT32 UIMenuWndPlaySlideShowCB_OnTimer(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
NVTEVT event;
event = paramArray[0];
if(event == NVTEVT_DISPTIMER)
{
FlowPB_SetKeyMask(FLGKEY_KEY_MASK_DEFAULT&~(FLGKEY_RIGHT|FLGKEY_LEFT),FLGKEY_KEY_MASK_NULL);
Ux_FlushEventByRange(NVTEVT_TIMER, NVTEVT_TIMER);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_NEXT, 1);
FlowPB_SetKeyMask(FLGKEY_KEY_MASK_DEFAULT,FLGKEY_KEY_MASK_NULL);
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnKeyPlayback(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
switch (gPhotoData.State)
{
case PHOTO_ST_VIEW:
case (PHOTO_ST_VIEW|PHOTO_ST_ZOOM):
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_RELEASE, FLGKEY_KEY_MASK_NULL);
Input_SetKeyMask(KEY_CONTINUE, FLGKEY_KEY_MASK_NULL);
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_FORCETO_PLAYBACK_MODE,0);
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnOpen(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UINT32 uiSoundMask,uiStatus;
g_bUIFlowWndPlayNoImgWndOpened = FALSE;
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYINIT,0);
//After playback ready, point to the last file
// PB_OpenSpecFileBySeq(DCF_GetDBInfo(DCF_INFO_TOL_FILE_COUNT), TRUE);
PB_OpenSpecFileBySeq(AppPlay_GetData(PLAY_FILENUM), TRUE);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_CURR, 1);
uiStatus = AppPlay_GetData(PLAY_PBSTATUS);
if (uiStatus & PB_STA_NOIMAGE)
//if(DCF_GetDBInfo(DCF_INFO_TOL_FILE_COUNT)==0)
{
Ux_OpenWindow(&UIFlowWndWrnMsgCtrl,2,FLOWWRNMSG_ISSUE_NO_IMAGE,FLOWWRNMSG_TIMER_KEEP);
g_bUIFlowWndPlayNoImgWndOpened = TRUE;
}
else
{
g_PlbData.VideoPBSpeed=PLB_FWD_MOV_1x;
g_PlbData.State = PLB_ST_FULL;
UIFlowWndPlay_CheckStatus();
FlowPB_UpdateIcons(1);
}
// enable shutter2 sound
uiSoundMask = Input_GetKeySoundMask(KEY_PRESS);
uiSoundMask |= FLGKEY_SHUTTER2;
Input_SetKeySoundMask(KEY_PRESS, uiSoundMask);
// Set mask key
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, PLAY_KEY_PRESS_MASK);
Input_SetKeyMask(KEY_RELEASE, PLAY_KEY_RELEASE_MASK);
Input_SetKeyMask(KEY_CONTINUE, PLAY_KEY_CONTINUE_MASK);
Ux_DefaultEvent(pCtrl,NVTEVT_OPEN_WINDOW,paramNum,paramArray);
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyPlayback(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
switch(g_PlbData.State)
{
case PLB_ST_FULL:
// Set mask key
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, PLAY_KEY_PRESS_MASK);
Input_SetKeyMask(KEY_RELEASE, PLAY_KEY_RELEASE_MASK);
Input_SetKeyMask(KEY_CONTINUE, PLAY_KEY_CONTINUE_MASK);
Ux_SendEvent(&UISetupObjCtrl,NVTEVT_EXE_CHANGEDSCMODE,1,DSCMODE_CHGTO_NEXT);
break;
case PLB_ST_PLAY_MOV:
case PLB_ST_PAUSE_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
g_PlbData.State = PLB_ST_FULL;
g_PlbData.VideoPBSpeed = PLB_FWD_MOV_1x;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_CLOSE_PLAY_MOVIE, 0);
//#NT#2012/10/23#Philex Lin - begin
// enable auto power off/USB detect timer
// enable key tone flag
KeyScan_EnableMisc(TRUE);
//#NT#2012/10/23#Philex Lin - end
if (gphUIFlowMovPlay_Filehdl)
{
FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
gphUIFlowMovPlay_Filehdl = NULL;
}
FlowPB_UpdateIcons(1);
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnOpen(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UIFlowWndPhoto_InitCfgSetting();
FlowPhoto_InitStartupFuncs();
/* Init window key mask variables & set key press/release/continue mask */
gPhotoData.State = PHOTO_ST_VIEW;
g_uiMaskKeyPress = PHOTO_KEY_PRESS_MASK;
g_uiMaskKeyRelease = PHOTO_KEY_RELEASE_MASK;
g_uiMaskKeyContinue = PHOTO_KEY_CONTINUE_MASK;
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
Input_SetKeyMask(KEY_RELEASE, g_uiMaskKeyRelease);
Input_SetKeyMask(KEY_CONTINUE, g_uiMaskKeyContinue);
gPhotoData.SysTimeCount = 0;
/* Update window info */
FlowPhoto_UpdateIcons(TRUE);
/* set FD/SD feature */
FlowPhoto_SetFdSdProc(TRUE);
#if(LOW_POWER_TIMELAPSE_REC == ENABLE)
debug_err(("rtc_isPWRAlarm() = %d =====\r\n",rtc_isPWRAlarm()));
if(UI_GetData(FL_LOW_POWER_TIMELAPSE_REC)&& rtc_isPWRAlarm())
{
//UIFlowDCF_TimelapseRecUpdateName();
//NH_FileDB_SetRootFolder("TMLPS");
// Wait until AE/AWB are stable.
IPC_WaitVD(FALSE,IPL_ID_1);
IPC_WaitVD(FALSE,IPL_ID_1);
IPC_WaitVD(FALSE,IPL_ID_1);
// press enter key to capture
Ux_PostEvent(NVTEVT_KEY_SHUTTER2, 1, NVTEVT_KEY_PRESS);
}
#endif
Ux_DefaultEvent(pCtrl,NVTEVT_OPEN_WINDOW,paramNum,paramArray);
return NVTEVT_CONSUME;
}
static INT32 UIFlowWndPhoto_OnExeCapture(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UINT32 uiEvtKeyAct = 0;
if(paramNum > 0)
uiEvtKeyAct = paramArray[0];
switch(uiEvtKeyAct)
{
case NVTEVT_KEY_PRESS:
{
switch (gPhotoData.State)
{
case PHOTO_ST_VIEW:
/* Check if in quick review process */
if(SysGetFlag(FL_QUICK_REVIEW) != QUICK_REVIEW_0SEC)
{
if(g_uiQviewTimerID != NULL_TIMER)
{
GxTimer_StopTimer(&g_uiQviewTimerID);
//g_bQviewTimerStart = FALSE;
// unloce AE/AWB
FlowPhoto_InitStartupFuncs();
/* Set to preview mode */
UI_Show(UI_SHOW_PREVIEW, TRUE);
/* close quick view image */
UI_Show(UI_SHOW_QUICKVIEW, FALSE);
/* Resume key after quick view completed */
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
/* Update window info */
FlowPhoto_UpdateIcons(TRUE);
return NVTEVT_CONSUME;
}
}
/* Check capture prerequisite */
if(FlowPhoto_IsStorageErr() == TRUE)
{
debug_err(("UIFlowWndPhoto_OnKeyShutter2: Card or memory full!\r\n"));
gPhotoData.State= PHOTO_ST_WARNING_MENU;
return NVTEVT_CONSUME;
}
if (GetBatteryLevel() == BATTERY_EXHAUSTED)
{
debug_err(("UIFlowWndPhoto_OnKeyShutter2: Battery is too low!\r\n"));
return NVTEVT_CONSUME;
}
// check free pic number
if (SysGetFlag(FL_CONTINUE_SHOT) == CONTINUE_SHOT_ON) {
if(FlowPhoto_GetFreePicNum() < 2)
{
UINT32 uiMsg = 0;
#if (_DUAL_CARD_FUNC_ == ENABLE)
uiMsg = ((UI_GetData(FL_CardStatus) == CARD_REMOVED) && (UI_GetData(FL_Card2Status) == CARD_REMOVED))? UIFlowWndWrnMsg_StatusTXT_Msg_STRID_PLEASE_INSERT_SD : UIFlowWndWrnMsg_StatusTXT_Msg_STRID_CARD_FULL;
#else
uiMsg = (UI_GetData(FL_CardStatus) == CARD_REMOVED)? UIFlowWndWrnMsg_StatusTXT_Msg_STRID_PLEASE_INSERT_SD : UIFlowWndWrnMsg_StatusTXT_Msg_STRID_CARD_FULL;
#endif
gPhotoData.State= PHOTO_ST_WARNING_MENU;
Ux_OpenWindow(&UIFlowWndWrnMsgCtrl,2,uiMsg,FLOWWRNMSG_TIMER_2SEC);
return NVTEVT_CONSUME;
}
}
switch (SysGetFlag(FL_SELFTIMER)) // set capture mode by system flag
{
case SELFTIMER_2SEC:
/* Suspend all keys, except S2 key while selftimer started */
Input_SetKeyMask(KEY_PRESS, FLGKEY_ENTER);
FlowPhoto_IconDrawSelftimerTime(&UIFlowWndPhoto_StaticTXT_SelftimerCntCtrl,2);
gPhotoData.SelfTimerCount = 20; // set time counter
gPhotoData.State = PHOTO_ST_SELFTIMER; // set working state to self-timer state
//KeyScan_EnableLEDToggle(KEYSCAN_LED_GREEN, TRUE);
UISound_Play(DEMOSOUND_SOUND_KEY_TONE);
if (g_uiSelfTimerID == NULL_TIMER)
{
g_uiSelfTimerID = GxTimer_StartTimer(100, NVTEVT_01SEC_TIMER, CONTINUE);
}
break;
case SELFTIMER_5SEC:
/* Suspend all keys, except S2 key while selftimer started */
Input_SetKeyMask(KEY_PRESS, FLGKEY_ENTER);
FlowPhoto_IconDrawSelftimerTime(&UIFlowWndPhoto_StaticTXT_SelftimerCntCtrl,5);
gPhotoData.SelfTimerCount = 50; // set time counter
gPhotoData.State = PHOTO_ST_SELFTIMER; // set working state to self-timer state
//KeyScan_EnableLEDToggle(KEYSCAN_LED_GREEN, TRUE);
UISound_Play(DEMOSOUND_SOUND_KEY_TONE);
if (g_uiSelfTimerID == NULL_TIMER)
{
g_uiSelfTimerID = GxTimer_StartTimer(100, NVTEVT_01SEC_TIMER, CONTINUE);
}
break;
case SELFTIMER_10SEC:
/* Suspend all keys, except S2 key while selftimer started */
Input_SetKeyMask(KEY_PRESS, FLGKEY_ENTER);
FlowPhoto_IconDrawSelftimerTime(&UIFlowWndPhoto_StaticTXT_SelftimerCntCtrl,10);
gPhotoData.SelfTimerCount = 100; // set time counter
gPhotoData.State = PHOTO_ST_SELFTIMER; // set working state to self-timer state
//#NT#2012/8/1#Philex - begin
//KeyScan_EnableLEDToggle(KEYSCAN_LED_GREEN, TRUE);
UISound_Play(DEMOSOUND_SOUND_KEY_TONE);
//#NT#2012/8/1#Philex - begin
if (g_uiSelfTimerID == NULL_TIMER)
{
g_uiSelfTimerID = GxTimer_StartTimer(100, NVTEVT_01SEC_TIMER, CONTINUE);
}
break;
default:
/* Suspend all keys before sending capture command */
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
/* Clear the whole OSD screen */
UxCtrl_SetAllChildShow(pCtrl,FALSE);
gPhotoData.State = PHOTO_ST_CAPTURE; // enter capture state
FlowPhoto_DoCapture(); // do capture directly
break;
}
break;
case PHOTO_ST_SELFTIMER:
gPhotoData.State = PHOTO_ST_VIEW;
gPhotoData.SelfTimerCount = 0;
//KeyScan_EnableLEDToggle(KEYSCAN_LED_GREEN, FALSE);
FlowPhoto_IconHideSelftimer(&UIFlowWndPhoto_StaticTXT_SelftimerCntCtrl);
// resume press mask to default
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
break;
}
break;
}
case NVTEVT_KEY_RELEASE:
{
//Rsvd
break;
}
default:
debug_err(("UIFlowWndPhoto_OnKeyShutter2: Unknown evt 0x%x\r\n", uiEvtKeyAct));
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyRight(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
switch(g_PlbData.State)
{
case PLB_ST_FULL:
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_NEXT, 1);
FlowPB_UpdateIcons(1);
UIFlowWndPlay_CheckStatus();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
break;
case PLB_ST_PLAY_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
#if(_MODEL_DSC_== _MODEL_DUAL_NAZHIDA_)
//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_8x)
{
g_PlbData.VideoPBSpeed --;
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_FWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_BWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
{
g_PlbData.State = PLB_ST_PLAY_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
FlowPB_IconDrawMovSpeed();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
}
break;
#else
//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
{
g_PlbData.VideoPBSpeed ++;
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_FWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_BWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
{
g_PlbData.State = PLB_ST_PLAY_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
FlowPB_IconDrawMovSpeed();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
}
break;
//#NT#2012/08/31#Calvin Chang -end
#endif
//#NT#2012/7/6#Philex mark temp
#if 0
if (KeyScan_IsHDMIPlugIn()==FALSE) {
if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
{
g_PlbData.VideoPBSpeed ++;
Ux_FlushEvent();
KeyScan_SetKeyMask(KEYSCAN_KEYMODE_PRESS, FLGKEY_KEY_MASK_NULL);
if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWD,1,g_PlbData.VideoPBSpeed);
g_PlbData.State = PLB_ST_FWD_MOV;
// set mute in FWD playing
hdmitx_setAudMute(TRUE);
}
else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVBWD,1,g_PlbData.VideoPBSpeed);
g_PlbData.State = PLB_ST_BWD_MOV;
// set mute in BWD playing
hdmitx_setAudMute(TRUE);
}
else //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWDSTOP,0);
g_PlbData.State = PLB_ST_PLAY_MOV;
/* Since Media FWD/BWD will set volume mute, we should restore current volume. */
hdmitx_setAudMute(FALSE);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_AUD_VOLUME,1,g_uiUIFlowWndPlayCurrentVolume);
}
FlowPB_IconDrawMovSpeed();
KeyScan_SetKeyMask(KEYSCAN_KEYMODE_PRESS, FLGKEY_KEY_MASK_DEFAULT);
}
}
break;
#endif
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyEnter(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
//UINT32 uiCurindex;
UINT32 uiPoolAddr;
char pFilePath[FULL_FILE_PATH_LEN];
UINT32 fileType = DCF_FILE_TYPE_JPG;
UINT32 uiPBFileFmt;
switch(g_PlbData.State)
{
case PLB_ST_PLAY_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_PAUSE_PLAY_MOVIE, 0);
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PAUSE_MOV;
//#NT#2012/10/23#Philex Lin - begin
// enable auto power off/USB detect timer
// enable sound key tone flag
KeyScan_EnableMisc(TRUE);
//#NT#2012/10/23#Philex Lin - end
break;
case PLB_ST_PAUSE_MOV:
//#NT#2012/10/23#Philex Lin - begin
// disable auto power off/USB detect timer
// disable key tone flag
KeyScan_EnableMisc(FALSE);
//#NT#2012/10/23#Philex Lin - end
// Start to Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PLAY_MOV;
break;
default:
case PLB_ST_FULL:
uiPBFileFmt = AppPlay_GetData(PLAY_FILEFMT);
if (uiPBFileFmt & PBFMT_AVI ||
uiPBFileFmt & PBFMT_MOVMJPG ||
uiPBFileFmt & PBFMT_MP4)
{
// Open Video File
if (gphUIFlowMovPlay_Filehdl)
{
FileSys_CloseFile(gphUIFlowMovPlay_Filehdl);
gphUIFlowMovPlay_Filehdl = NULL;
}
if (uiPBFileFmt & PBFMT_AVI)
fileType = DCF_FILE_TYPE_AVI;
else if (uiPBFileFmt & PBFMT_MOVMJPG)
fileType = DCF_FILE_TYPE_MOV;
else if (uiPBFileFmt & PBFMT_MP4)
fileType = DCF_FILE_TYPE_MOV;
else
{
debug_msg("Wrong video file format!! \r\n");
break;
}
// Get Current index
PB_GetParam(PBPRMID_CURR_FILEPATH, (UINT32 *)pFilePath);
#if 0
uiCurindex = DCF_GetCurIndex();
DCF_GetObjPath(uiCurindex,fileType,pFilePath);
#endif
// Open Test Media File
gphUIFlowMovPlay_Filehdl = FileSys_OpenFile(pFilePath, FST_OPEN_READ);
if (!gphUIFlowMovPlay_Filehdl)
{
debug_msg("UIFlowWndPlay_OnKeyEnter: Can't open Video file!\r\n");
break;
}
//#NT#2012/10/23#Philex Lin - begin
// disable auto power off/USB detect timer
// disable key tone flag
KeyScan_EnableMisc(FALSE);
//#NT#2012/10/23#Philex Lin - end
// Buffer Allocation
get_blf((VP*)&(uiPoolAddr), POOL_ID_APP);
rel_blf(POOL_ID_APP, (VP)uiPoolAddr);
g_UIPlayMediaObj.hActMediafilehdl = gphUIFlowMovPlay_Filehdl;
g_UIPlayMediaObj.CallBackFunc = Play_MovieCB;
// g_UIPlayMediaObj.uiMemAddr = uiPoolAddr;
g_UIPlayMediaObj.uiMemAddr = (UINT32)OS_GetMempoolAddr(POOL_ID_APP);
g_UIPlayMediaObj.uiMemSize = POOL_SIZE_APP;
//g_UIPlayMediaObj.iAudioType = AUDIO_OUTPUT_HP;
g_UIPlayMediaObj.bDisableAudio = FALSE;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
//flush event first
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
//stop scan
//SxTimer_SetFuncActive(SX_TIMER_DET_STRG_ID, FALSE);
SxTimer_SetFuncActive(SX_TIMER_DET_SYSTEM_BUSY_ID, FALSE);
Ux_SendEvent(&UIMoviePlayObjCtrl, NVTEVT_INIT_PLAY_MOVIE, 1, &g_UIPlayMediaObj);
// Start to Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
if (KeyScan_GetPlugDev()!=PLUG_HDMI)
{
//FlowPB_IconDrawMovPlayVolumn(g_uiUIFlowWndPlayCurrentVolume);
}
FlowPB_IconDrawMovPlay(TRUE);
g_PlbData.State = PLB_ST_PLAY_MOV;
}
break;
}
//#NT#2012/08/31#Calvin Chang -end
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnChildClose(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
UINT32 uiSoundMask;
/* Set key mask to self-original state */
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
Input_SetKeyMask(KEY_RELEASE, g_uiMaskKeyRelease);
Input_SetKeyMask(KEY_CONTINUE, g_uiMaskKeyContinue);
switch (gPhotoData.State)
{
case PHOTO_ST_WARNING_MENU:
if(paramNum > 0)
{
if(paramArray[0] == NVTRET_ENTER_MENU)
{
/* Force to lock FD/SD functions before opening Menu */
FlowPhoto_ForceLockFdSd();
/* Create Menu window */
gPhotoData.State = PHOTO_ST_MENU;
TM_SetMenu(&gPhotoMenu);
Ux_OpenWindow(&MenuCommonItemCtrl, 0);
return NVTEVT_CONSUME;
}
}
gPhotoData.State = PHOTO_ST_VIEW;
break;
case PHOTO_ST_MENU:
// disable shutter2 sound
uiSoundMask = Input_GetKeySoundMask(KEY_PRESS);
uiSoundMask &= ~FLGKEY_SHUTTER2;
Input_SetKeySoundMask(KEY_PRESS, uiSoundMask);
gPhotoData.State = PHOTO_ST_VIEW;
// set image ratio here
UIFlowWndPhoto_OnExeSetImageRatio();
// unloce AE/AWB
FlowPhoto_InitStartupFuncs();
/* Set to preview mode */
UI_Show(UI_SHOW_PREVIEW, TRUE);
/* close quick view image */
UI_Show(UI_SHOW_QUICKVIEW, FALSE);
/* Resume key after normal capture completed */
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
/* Set FD/SD functions againg after exiting Menu */
FlowPhoto_SetFdSdProc(TRUE);
/* Update window info */
FlowPhoto_UpdateIcons(TRUE);
break;
}
Ux_DefaultEvent(pCtrl,NVTEVT_CHILD_CLOSE,paramNum,paramArray);
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPhoto_OnTimer(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
NVTEVT event;
if(paramNum > 0)
{
event = paramArray[0];
} else {
return NVTEVT_CONSUME;
}
switch(event)
{
case NVTEVT_01SEC_TIMER:
if (gPhotoData.QuickViewCount !=0)
{
gPhotoData.QuickViewCount--;
if (gPhotoData.QuickViewCount == 0)
{
if (g_uiQviewTimerID != NULL_TIMER)
{
GxTimer_StopTimer(&g_uiQviewTimerID);
}
/* reset state to PHOTO_ST_VIEW */
gPhotoData.State = PHOTO_ST_VIEW;
/* set FD/SD feature */
FlowPhoto_SetFdSdProc(FALSE);
/* Set to preview mode */
UI_Show(UI_SHOW_PREVIEW, TRUE);
/* close quick view image */
UI_Show(UI_SHOW_QUICKVIEW, FALSE);
/* Update window info */
//FlowPhoto_UpdateIcons(TRUE);
/* Resume key after normal capture completed */
Input_SetKeyMask(KEY_PRESS, g_uiMaskKeyPress);
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
/* set DirID/FileID */
{
UINT32 uhFilesysDirNum, uhFilesysFileNum;
DCF_GetNextID(&uhFilesysDirNum, &uhFilesysFileNum);
SysSetFlag(FL_DCF_DIR_ID, uhFilesysDirNum);
SysSetFlag(FL_DCF_FILE_ID, uhFilesysFileNum);
}
}
}
if (gPhotoData.SelfTimerCount != 0)
{
gPhotoData.SelfTimerCount--;
if (gPhotoData.SelfTimerCount == 0)
{
if (g_uiSelfTimerID != NULL_TIMER)
{
GxTimer_StopTimer(&g_uiSelfTimerID);
}
// stopping LED toggle
//KeyScan_EnableLEDToggle(KEYSCAN_LED_GREEN, FALSE);
}
FlowPhoto_OnTimer01SecIndex();
}
break;
}
return NVTEVT_CONSUME;
}
INT32 UIFlowWndPlay_OnKeyLeft(VControl *pCtrl, UINT32 paramNum, UINT32 *paramArray)
{
switch(g_PlbData.State)
{
case PLB_ST_FULL:
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_PLAYSINGLE, 2, PB_SINGLE_PREV, 1);
FlowPB_UpdateIcons(1);
UIFlowWndPlay_CheckStatus();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
break;
case PLB_ST_PLAY_MOV:
case PLB_ST_FWD_MOV:
case PLB_ST_BWD_MOV:
//#NT#2012/08/31#Calvin Chang#Porting Media Flow -begin
//if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_8x)
if(g_PlbData.VideoPBSpeed > PLB_BWD_MOV_4x)
{
g_PlbData.VideoPBSpeed --;
Ux_FlushEventByRange(NVTEVT_KEY_EVT_START,NVTEVT_KEY_EVT_END);
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_FWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
UxState_SetData(&UIFlowWndPlay_StatusICN_MovFwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovFwd_ICON_FF_RIGHT_BLUE);
UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovFwdCtrl, TRUE);
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
{
g_PlbData.State = PLB_ST_BWD_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_BACKWARD;
UxState_SetData(&UIFlowWndPlay_StatusICN_MovBwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovBwd_ICON_FB_LEFT_BLUE);
UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovBwdCtrl, TRUE);
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
else //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
{
g_PlbData.State = PLB_ST_PLAY_MOV;
UIFlowMoviePlay_SetSpeed(g_PlbData.VideoPBSpeed);
g_uiUIFlowWndPlayCurrenDirection = MEDIAPLAY_DIR_FORWARD;
UxState_SetData(&UIFlowWndPlay_StatusICN_MovBwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovBwd_ICON_FB_LEFT);
UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovBwdCtrl, TRUE);
UxState_SetData(&UIFlowWndPlay_StatusICN_MovFwdCtrl,STATE_CURITEM,UIFlowWndPlay_StatusICN_MovFwd_ICON_FF_RIGHT);
UxCtrl_SetShow(&UIFlowWndPlay_StatusICN_MovFwdCtrl, TRUE);
// Play
Ux_SendEvent(&UIMoviePlayObjCtrl,
NVTEVT_PLAY_PLAY_MOVIE,
2,
g_uiUIFlowWndPlayCurrenSpeed,
g_uiUIFlowWndPlayCurrenDirection);
}
FlowPB_IconDrawMovSpeed();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
}
//#NT#2012/08/31#Calvin Chang -end
#if 0
if (KeyScan_IsHDMIPlugIn()==FALSE) {
if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_8x)
{
g_PlbData.VideoPBSpeed ++;
Ux_FlushEvent();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_NULL);
if(g_PlbData.VideoPBSpeed > PLB_FWD_MOV_1x)
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWD,1,g_PlbData.VideoPBSpeed);
g_PlbData.State = PLB_ST_FWD_MOV;
// set mute in FWD playing
hdmitx_setAudMute(TRUE);
}
else if(g_PlbData.VideoPBSpeed < PLB_FWD_MOV_1x)
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVBWD,1,g_PlbData.VideoPBSpeed);
g_PlbData.State = PLB_ST_BWD_MOV;
// set mute in BWD playing
hdmitx_setAudMute(TRUE);
}
else //uiCurrSpeedIndex == PLAYMOV_SPEED_FWD_1X
{
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_MOVFWDSTOP,0);
g_PlbData.State = PLB_ST_PLAY_MOV;
/* Since Media FWD/BWD will set volume mute, we should restore current volume. */
hdmitx_setAudMute(FALSE);
Ux_SendEvent(&UIPlayObjCtrl,NVTEVT_AUD_VOLUME,1,g_uiUIFlowWndPlayCurrentVolume);
}
FlowPB_IconDrawMovSpeed();
Input_SetKeyMask(KEY_PRESS, FLGKEY_KEY_MASK_DEFAULT);
}
}
#endif
break;
}
return NVTEVT_CONSUME;
}
