osdvga900.c

LCD Monitor 部分源码

     // Step 1: Clear Old Select
     DrawPen(0,(ucOsdState - _MENU_RESET) * 3 + 5);
     if(ucOsdState == _MENU_MUTE)    CLEAR_OSD_ADJUST();

     // Step 2: Change Select Item
     ucOsdState = ValueInRangeChange(_MENU_RESET,_MENU_MISC_BACK,ucOsdState,LR,1);

     // Step 3: Draw
     DrawPen(1,(ucOsdState - _MENU_RESET) * 3 + 5);
     if(ucOsdState == _MENU_MUTE)    CLEAR_OSD_ADJUST();
}
//------------------------------------------------------------
void MMiscPageMenuOut()
{
     ucOsdState = _MENU_MISC;
     CLEAR_OSD_CLIENT();
     DrawMainPage();
}
//------------------------------------------------------------
void MDrawMuteState()
{
     OSDLine(21, 3, 19, 0x00, BYTE_DISPLAY);
     if(GET_MUTE_STATE() == STATE_MUTEON)
          CenterTextout((unsigned char code *)sOn[GET_LANGUAGE],  11, 21);
     else CenterTextout((unsigned char code *)sOff[GET_LANGUAGE], 11, 21);
}
//------------------------------------------------------------




//------------------------------------------------------------
void MLanguageProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MLanguageMenuOut();     break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MLanguageLR(0);         break;
         case VK_ADJ_INC:       MLanguageLR(1);         break;
         case VK_DO:                                    break;
         case VK_ENTER:         MLanguageMenuOut();     break;
         case VK_LEFT:          MLanguageLR(0);         break;
         case VK_RIGHT:         MLanguageLR(1);         break;
     }
}
//------------------------------------------------------------
void MLanguageLR(unsigned char LR)
{
     unsigned char ucCount = GetLanguegeCount();
     unsigned char ucLanguage = GetCurrLanguagePos();

     DrawPen(0, ucLanguage * 3 + 5);

     ucLanguage = ValueInRangeChange(0,ucCount - 1,ucLanguage,LR,1);
     DrawPen(1,ucLanguage  * 3 + 5);
     
     ucLanguage = IndexofLanuguage(ucLanguage);
     SET_LANGUAGE(ucLanguage);     
}
//------------------------------------------------------------
void MLanguageMenuOut()
{
     ucOsdState = _MENU_LANGUAGE;
     CLEAR_OSD_CLIENT();
     LoadLanguageFont();
     DrawMainPage();
     ucOsdEventMsg = _SAVE_EE_OSDUSERDATA_MSG;
}
//------------------------------------------------------------




//------------------------------------------------------------
void MContrastProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MContrastMenuOut();     break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MContrastLR(1);         break;
         case VK_ADJ_INC:       MContrastLR(0);         break;
         case VK_DO:                                    break;
         case VK_ENTER:         MContrastMenuOut();     break;
         case VK_LEFT:          MContrastLR(1);         break;
         case VK_RIGHT:         MContrastLR(0);         break;
     }
}
//------------------------------------------------------------
void MContrastLR(unsigned char LR)
{
     unsigned int ucContrast = CONTRAST_GUAGE;
     SET_KEYREPEATENABLE();
     ucContrast = ValueInRangeChange(0,100,ucContrast,LR,0);
     ucContrast = ucContrast * (MAX_CONTRAST - MIN_CONTRAST);
//     ucContrast = ucContrast / 100;
     if(ucContrast % 100 == 0)    ucContrast = ucContrast / 100;
     else                         ucContrast = ucContrast / 100 + 1;
     ucContrast += MIN_CONTRAST ;
     stConBriData.Contrast = ucContrast;
     SLIDER(CONTRAST_GUAGE);
     CAdjustContrast();
}
//------------------------------------------------------------
void MContrastMenuOut()
{
     ucOsdState = _MENU_CONTRAST;
     CLEAR_OSD_ADJUST();
     ucOsdEventMsg = _SAVE_EE_COLORPROC0_MSG;
     CLR_KEYREPEATENABLE();
}
//------------------------------------------------------------

void MBrightnessProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MBrightnessMenuOut();   break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MBrightnessLR(1);       break;
         case VK_ADJ_INC:       MBrightnessLR(0);       break;
         case VK_DO:                                    break;
         case VK_ENTER:         MBrightnessMenuOut();   break;
         case VK_LEFT:          MBrightnessLR(1);       break;
         case VK_RIGHT:         MBrightnessLR(0);       break;
     }
}
//------------------------------------------------------------
void MBrightnessLR(unsigned char LR)
{
     unsigned int iBright = BRIGHTNESS_GUAGE;
     SET_KEYREPEATENABLE();
     iBright = ValueInRangeChange(0,100,iBright,LR,0);
     iBright = iBright * (MAX_BRIGHT - MIN_BRIGHT);
     if((iBright % 100) == 0)    iBright /= 100;
     else                        iBright = iBright/100 + 1;
     iBright += MIN_BRIGHT;

     stConBriData.Brightness = iBright;
     SLIDER(BRIGHTNESS_GUAGE);
     CAdjustBrightness();
}
//------------------------------------------------------------
void MBrightnessMenuOut()
{
     ucOsdState = _MENU_BRIGHTNESS;
     CLEAR_OSD_ADJUST();

     ucOsdEventMsg = _SAVE_EE_COLORPROC0_MSG;
     CLR_KEYREPEATENABLE();
}
//------------------------------------------------------------


void MRedProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MRedMenuOut();  break;
         case VK_MENU_IN:                       break;
         case VK_PREV_MENU:                     break;
         case VK_NEXT_MENU:                     break;
         case VK_ADJ_DEC:       MRedLR(1);      break;
         case VK_ADJ_INC:       MRedLR(0);      break;
         case VK_DO:                            break;
         case VK_ENTER:         MRedMenuOut();  break;
         case VK_LEFT:          MRedLR(1);      break;
         case VK_RIGHT:         MRedLR(0);      break;
     }
}
//------------------------------------------------------------
void MRedLR(unsigned char LR)
{
     unsigned int r = USER_R_GUAGE;
     SET_KEYREPEATENABLE();
     r = ValueInRangeChange(0,100,r,LR,0);
     r = r * 255;
     stColorTempData.ColorTemp[_RED] = r / 100;
     if(r % 100 != 0)    stColorTempData.ColorTemp[_RED] = stColorTempData.ColorTemp[_RED] + 1;
     SLIDER1(USER_R_GUAGE,0x20);
     CAdjustContrast();
}
//------------------------------------------------------------
void MRedMenuOut()
{
     ucOsdState = _MENU_RED;
     OSDLine(21, 3, 21, 0x00, BYTE_DISPLAY);
     ucOsdEventMsg = _SAVE_EE_COLORPROC1_MSG;
}
//------------------------------------------------------------





//------------------------------------------------------------
void MGreenProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MGreenMenuOut();        break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MGreenLR(1);            break;
         case VK_ADJ_INC:       MGreenLR(0);            break;
         case VK_DO:                                    break;
         case VK_ENTER:         MGreenMenuOut();        break;
         case VK_LEFT:          MGreenLR(1);            break;
         case VK_RIGHT:         MGreenLR(0);            break;
     }

}
//------------------------------------------------------------
void MGreenLR(unsigned char LR)
{
     unsigned int r = USER_G_GUAGE;
     SET_KEYREPEATENABLE();
     r = ValueInRangeChange(0,100,r,LR,0);
     r = r * 255;
     stColorTempData.ColorTemp[_GREEN] = r / 100;
     if(r % 100 != 0)    stColorTempData.ColorTemp[_GREEN] = stColorTempData.ColorTemp[_GREEN] + 1;
     SLIDER1(USER_G_GUAGE,0x30);
     CAdjustContrast();
}
//------------------------------------------------------------
void MGreenMenuOut()
{
     ucOsdState = _MENU_GREEN;
     OSDLine(21, 3, 21, 0x00, BYTE_DISPLAY);
     ucOsdEventMsg = _SAVE_EE_COLORPROC1_MSG;
}
//------------------------------------------------------------




//------------------------------------------------------------
void MBlueProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MBlueMenuOut();         break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MBlueLR(1);             break;
         case VK_ADJ_INC:       MBlueLR(0);             break;
         case VK_DO:                                    break;
         case VK_ENTER:         MBlueMenuOut();         break;
         case VK_LEFT:          MBlueLR(1);             break;
         case VK_RIGHT:         MBlueLR(0);             break;
     }
}
//------------------------------------------------------------
void MBlueLR(unsigned char LR)
{
     unsigned int r = USER_B_GUAGE;
     SET_KEYREPEATENABLE();
     r = ValueInRangeChange(0,100,r,LR,0);
     r = r * 255;
     stColorTempData.ColorTemp[_BLUE] = r / 100;
     if(r % 100 != 0)    stColorTempData.ColorTemp[_BLUE] = stColorTempData.ColorTemp[_BLUE] + 1;
     SLIDER1(USER_B_GUAGE,0x40);
     CAdjustContrast();
}
//------------------------------------------------------------
void MBlueMenuOut()
{
     ucOsdState = _MENU_BLUE;
     OSDLine(21, 3, 21, 0x00, BYTE_DISPLAY);
     ucOsdEventMsg = _SAVE_EE_COLORPROC1_MSG;
}
//------------------------------------------------------------




//------------------------------------------------------------
void MClockProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MClockMenuOut();        break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MClockLR(1);            break;
         case VK_ADJ_INC:       MClockLR(0);            break;
         case VK_DO:                                    break;
         case VK_ENTER:         MClockMenuOut();        break;
         case VK_LEFT:          MClockLR(1);            break;
         case VK_RIGHT:         MClockLR(0);            break;
     }
}
//------------------------------------------------------------
void MClockLR(unsigned char LR)
{
     SET_KEYREPEATENABLE();
     stModeUserData.Clock = ValueInRangeChange(COsdFxGetAdcClockRange(_GET_CLOCKRANGE_MIN),
                                          COsdFxGetAdcClockRange(_GET_CLOCKRANGE_MAX),
                                          stModeUserData.Clock,LR,0);
     SLIDER(ClockGuage());
     CAdjustAdcClock(stModeUserData.Clock);
}
//------------------------------------------------------------
void MClockMenuOut()
{
     ucOsdState = _MENU_CLOCK;
     CLEAR_OSD_ADJUST();

     ucOsdEventMsg = _SAVE_EE_MODEUSERDATA_MSG;
     CLR_KEYREPEATENABLE();
}
//------------------------------------------------------------





//------------------------------------------------------------
void MPhaseProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MPhaseMenuOut();        break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MPhaseLR(1);            break;
         case VK_ADJ_INC:       MPhaseLR(0);            break;
         case VK_DO:                                    break;
         case VK_ENTER:         MPhaseMenuOut();        break;
         case VK_LEFT:          MPhaseLR(1);            break;
         case VK_RIGHT:         MPhaseLR(0);            break;
     }
}
//------------------------------------------------------------
void MPhaseLR(unsigned char LR)
{
     SET_KEYREPEATENABLE();
     stModeUserData.Phase = ValueInRangeChange(0,63,stModeUserData.Phase,LR,0);
     SLIDER(PHASE_GUAGE);
     CAdjustPhase(stModeUserData.Phase);
}
//------------------------------------------------------------
void MPhaseMenuOut()
{
     ucOsdState = _MENU_PHASE;
     CLEAR_OSD_ADJUST();

     ucOsdEventMsg = _SAVE_EE_MODEUSERDATA_MSG;
     CLR_KEYREPEATENABLE();
}
//------------------------------------------------------------



//------------------------------------------------------------
void MGammaProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MGammaMenuOut();        break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MGammaLR(0);            break;
         case VK_ADJ_INC:       MGammaLR(1);            break;
         case VK_DO:                                    break;
         case VK_ENTER:         MGammaMenuOut();        break;
         case VK_LEFT:          MGammaLR(0);            break;
         case VK_RIGHT:         MGammaLR(1);            break;
     }
}
//------------------------------------------------------------
void MGammaLR(unsigned char LR)
{
     unsigned char ucGamma = GET_GAMMA();

     //SET_KEYREPEATENABLE();
     MDrawGammaSelState(ucGamma,0);
     ucGamma = ValueInRangeChange(0,3,ucGamma,LR,0);
     SET_GAMMA(ucGamma);
     MDrawGammaSelState(GET_GAMMA(),1);
}
//------------------------------------------------------------
void MGammaMenuOut()
{
     ucOsdState = _MENU_GAMMA;
     CLEAR_OSD_ADJUST();

     ucOsdEventMsg = _SAVE_EE_SYSTEMDATA_MSG;
}
//------------------------------------------------------------

void MSharpnessProc()
{
     switch(ucKeyMessage)
     {
         case VK_MENU_OUT:      MSharpnessMenuOut();    break;
         case VK_MENU_IN:                               break;
         case VK_PREV_MENU:                             break;
         case VK_NEXT_MENU:                             break;
         case VK_ADJ_DEC:       MSharpnessLR(0);        break;
         case VK_ADJ_INC:       MSharpnessLR(1);        break;
         case VK_DO:                                    break;
         case VK_ENTER:         MSharpnessMenuOut();    break;
         case VK_LEFT:          MSharpnessLR(0);        break;
         case VK_RIGHT:         MSharpnessLR(1);        break;
     }
}
//------------------------------------------------------------
void MSharpnessLR(unsigned char LR)
{
     unsigned char ucSharpness = GET_SHARPNESS();

     //SET_KEYREPEATENABLE();
     MDrawSharpnessSelState(ucSharpness,0);
     ucSharpness = ValueInRangeChange(0,4,ucSharpness,LR,0);
     SET_SHARPNESS(ucSharpness);
     MDrawSharpnessSelState(GET_SHARPNESS(),1);
     CAdjustSharpness();