ui.c

这个是单片机4200的ui程序

	{
		return(UI_STATUS_COMPLETE);
	}

	/* Scroll setting item */
	if( SELECTION_KEY_NONE != uselKeyState )
	{
		Uint32 uStep;

		// Step unit determination
		if( KEY_PRESSED_MODE_NORMAL == gUIstate.pressedKeyMode )
		{
			uStep = 1;
		}
		else
		{
			uStep = 15;
		}

		// Increase/Decrease scaling value for the selected scaling type
		if( SELECTION_KEY_PREV == uselKeyState )
		{
			if( uStep >= (gSelectionValue - uMinScale[gSelectionNo]) )
			{
				gSelectionValue = uMaxScale[gSelectionNo];
			}
			else
			{
				gSelectionValue -= uStep;
			}
		}
		else
		{
			if( uMaxScale[gSelectionNo] < (uStep + gSelectionValue) )
			{
				gSelectionValue = uMinScale[gSelectionNo];
			}
			else
			{
				gSelectionValue += uStep;
			}
		}

		gUIstate.bUpdateInfo = TRUE;
	}

	// Update LCD panel info.
	if( TRUE == gUIstate.bUpdateInfo )
	{
#ifdef UI_PANEL_ENABLE
		static char* szScaleType[UI_MAX_SCALE_TYPE]={" Normal", "  Min.", "  Max.", 
			" AutoFit", " Poster", "  Clone", " Mirror", " Custom"};
		char szScaleText[20];

		if( scaleAutoFit == gSelectionNo )
		{
			sprintf(szScaleText, "    %s       ", szScaleType[gSelectionNo]);
		}
		else
		{
			sprintf(szScaleText, "  %s %lu%c     ", szScaleType[gSelectionNo], gSelectionValue, '%');
		}

		LcdStr(LCD_ROW_1, LCD_SCALING_COL, "  Scaling Type  "); 
		LcdStr(LCD_ROW_2, LCD_SCALING_COL, szScaleText); 
#endif
		gUIstate.bUpdateInfo = FALSE;
	}

	/* Keep doing scaling until UI_STATUS_COMPLETE */
	*pSubCommand = UI_COMMAND_SCALING;	/* Set new command to be scaling */
	return(UI_STATUS_CONTINUE);
}

/******************************************************************************
* Name:        UIDoSettingSelection
*
* Description: Do sub-menu function selection  
*
* Parameters:  UICommandType* pSubCommand
*
* Return:      UI_STATUS_COMPLETE - Finish the command
*              UI_STATUS_CONTINUE - Need more operations
*
* Notes:      
******************************************************************************/
API_RET UIDoSettingSelection(UICommandType* pSubCommand)
{
	Uint8 uselKeyState;
	SettingType selSetType;
	e_PaperSize paperSize;


	selSetType = (SettingType)gSelectionNo;
	uselKeyState = UIPassSelectionKey(PANEL_KEY_SETTING, TRUE);
	// Sub-menu type changed
	if( SELECTION_KEY_SPECIFY == uselKeyState )
	{
		gSelectionNo++;
		if( UI_MAX_SETTING_TYPE == gSelectionNo )
		{
			gSelectionNo = 0;
		}

		selSetType = (SettingType)gSelectionNo;
#if ENABLE_FIREPULSE_SETTING
		if( setBKPreFireWidth == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.uBKPreFireWidth[gUIstate.imageQuality];
		}
		else if( setCLRPreFireWidth == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.uCLRPreFireWidth[gUIstate.imageQuality];
		}
		else if( setBKFireWidth == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.uBKFireWidth[gUIstate.imageQuality];
		}
		else if( setCLRFireWidth == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.uCLRFireWidth[gUIstate.imageQuality];
		}
		else
#endif
			if( setOutputPaperSize == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.paperSize;
		}
#if PHOTO_PRINT_ENABLED
		else if( setPhotoSize == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.ePhotoSize;
		}
#endif
#ifdef ADF_SUPPORTED
		else if( setgScanSource == selSetType )
		{
			gSelectionValue = (Uint32)gUIstate.ScanWithADF;
		}
#endif
#ifdef UI_PANEL_ENABLE
		LcdClrScreen();
#endif

		gUIstate.bUpdateInfo = TRUE;
	}
	// Finish the sub-menu setting
	else if( SELECTION_KEY_OK == uselKeyState )
	{
		switch( selSetType )
		{
			case setAutoAlignCartridge:
				*pSubCommand = UI_COMMAND_AUTO_ALIGN_CAR;
				break;

			case setAlignCartridge:
				*pSubCommand = UI_COMMAND_ALIGN_CARTRIDGE;
				break;

			case setCleanCartridge:
				*pSubCommand = UI_COMMAND_CLEAN_CARTRIDGE;
				break;

			case setOutputPaperSize:

				gUIstate.paperSize = (PaperSize)gSelectionValue;

				if( paperA4 == gUIstate.paperSize )
					paperSize = PSA4;
				else if( paperLetter == gUIstate.paperSize )
					paperSize = PS8p5x11;
				else
					paperSize = PSA4;

				PSPRINTF("setOutputPaperSize = %d\n",paperSize);

				/*	Set for all of the print sizes... 
				  #define omPRINTPRINTSIZE
				  #define omCOPYPRINTSIZE
				  #define omPHOTOPRINTSIZE
				  #define omPBPHOTOPRINTSIZE
				*/
				OMsetEnum(omPRINTPRINTSIZE, OMDEFAULT, (Uint32)paperSize);
				OMsetEnum(omCOPYPRINTSIZE, OMDEFAULT, (Uint32)paperSize);

				// Leave the photo paper size alone for now
				//OMsetEnum(omPHOTOPRINTSIZE, OMDEFAULT, (Uint32)paperSize);
				//OMsetEnum(omPBPHOTOPRINTSIZE, OMDEFAULT, (Uint32)paperSize);


				break;

#if PHOTO_PRINT_ENABLED
			case setPhotoSize:
				gUIstate.ePhotoSize = (e_PhotoSize)gSelectionValue; 
				break;
#endif
#ifdef ADF_SUPPORTED
			case setgScanSource:
				gUIstate.ScanWithADF = gSelectionValue;
				break;
#endif
#if ENABLE_FIREPULSE_SETTING
			case setBKPreFireWidth:
				gUIstate.uBKPreFireWidth[gUIstate.imageQuality] = gSelectionValue;
				DB_Write(DBPARAM_PREFIRE_PULSE_B_WIDTH + gUIstate.imageQuality, (void*)&gSelectionValue);
				break;

			case setCLRPreFireWidth:
				gUIstate.uCLRPreFireWidth[gUIstate.imageQuality] = gSelectionValue; 
				DB_Write(DBPARAM_PREFIRE_PULSE_C_WIDTH + gUIstate.imageQuality, (void*)&gSelectionValue);
				break;

			case setBKFireWidth:
				gUIstate.uBKFireWidth[gUIstate.imageQuality] = gSelectionValue; 
				DB_Write(DBPARAM_FIRE_PULSE_B_WIDTH + gUIstate.imageQuality,(void*)&gSelectionValue);
				break;

			case setCLRFireWidth:
				gUIstate.uCLRFireWidth[gUIstate.imageQuality] = gSelectionValue; 
				DB_Write(DBPARAM_FIRE_PULSE_C_WIDTH + gUIstate.imageQuality,(void*)&gSelectionValue);
				break;
#endif

			case setVopuMode:
				*pSubCommand = UI_COMMAND_SET_VOPU_MODE;
                if (vopuMode != vopuDisplayMode) {
                  vopuMode = vopuDisplayMode;
                  switch (vopuMode) {
                  case eVopuOff:
//                    VopuIFDisable();
                    break;
                  case eVopuLCD:
//                    VopuIFEnableLCD();
                    break;
                  case eVopuNTSC:
//                    VopuIFEnableNTSC();
                    break;
                  case eVopuPAL:
 //                   VopuIFEnablePAL();
                    break;
                  default:
                    break;      /* ignore unknown values */
                  }
                }
				break;

			case setDefault:
				*pSubCommand = UI_COMMAND_SET_DEFAULT;
				break;

			default:
				break;
		}    

		return(UI_STATUS_COMPLETE);
	}
	// cancel the setting
	else if( SELECTION_KEY_CANCEL == uselKeyState )
	{
		return(UI_STATUS_COMPLETE);
	}

#if ENABLE_FIREPULSE_SETTING
	/* Do sub-menu function setting */
	if( (setBKPreFireWidth == selSetType) || (setCLRPreFireWidth == selSetType) )
	{
		// Do PreFire pulse withd selection
		UIDoFirePulseWidthSelection(uselKeyState);
	}
	else if( (setBKFireWidth == selSetType) || (setCLRFireWidth == selSetType) )
	{
		// Do PreFire pulse withd selection
		UIDoFirePulseWidthSelection(uselKeyState);
	}
	else
#endif
      if( setOutputPaperSize == selSetType )
      {
        // Do paper type selection
		UIDoPaperSizeSelection(uselKeyState);
      }
#if PHOTO_PRINT_ENABLED
	else if( setPhotoSize == selSetType )
	{
		// Do photo size selection
		UIDoPhotoSizeSelection(uselKeyState);
	}
#endif
#ifdef ADF_SUPPORTED
	else if( setgScanSource == selSetType )
	{
		// Do scan source selection
		UIDogScanSourceSelection(uselKeyState);
	}
#endif

    else if ( selSetType == setVopuMode) {
      // Do vopu mode selection
      UIDoVopuModeSelection(uselKeyState);
    }
	// other sub function, just show current selection info 
	else if( TRUE == gUIstate.bUpdateInfo )
	{
#ifdef UI_PANEL_ENABLE
		static char* szSettingType[UI_MAX_SETTING_TYPE]={" Auto Align Car.", 
			" Align Cartridge", " Clean Cartridge",  "   Paper Size   ", 
#if PHOTO_PRINT_ENABLED
			"   Photo Size   ", 
#endif
#ifdef ADF_SUPPORTED
			"   Scan Source  ",
#endif
#if ENABLE_FIREPULSE_SETTING
			"    Default     ", "   VOPU Mode:    ", "  PreFire Width  ", "    Fire Width   "};
#else
			"    Default     ", "   VOPU Mode:    "};
#endif

		LcdStr(LCD_ROW_1, LCD_SETTING_TYPE_COL, szSettingType[gSelectionNo]); 
#endif
		gUIstate.bUpdateInfo = FALSE;
	}

	/* Keep doing setting until UI_STATUS_COMPLETE */
	*pSubCommand = UI_COMMAND_SETTING;	/* Set new command to be setting */
	return(UI_STATUS_CONTINUE);
}
#endif
#if ENABLE_FIREPULSE_SETTING
/******************************************************************************
* Name:        UIDoFirePulseWidthSelection
*
* Description: Prefire/Fire pulse width setting  
*
* Parameters:  uselKeyState - Pressed Key state
*
* Return:      None
*
* Notes:      
******************************************************************************/
void UIDoFirePulseWidthSelection(Uint32 uselKeyState)
{
	Uint32 uStep;
	Uint32 uPulseWidthMin, uPulseWidthMax;

	if( (setBKPreFireWidth == gSelectionNo) || (setCLRPreFireWidth == gSelectionNo) )
	{
		uPulseWidthMin = UI_PREFIRE_PULSE_WIDTH_MIN;
		uPulseWidthMax = UI_PREFIRE_PULSE_WIDTH_MAX;
	}
	else
	{
		uPulseWidthMin = UI_FIRE_PULSE_WIDTH_MIN;
		uPulseWidthMax = UI_FIRE_PULSE_WIDTH_MAX;
	}

	// Determine Inc/Dec step unit 
	if( KEY_PRESSED_MODE_NORMAL == gUIstate.pressedKeyMode )
	{
		uStep = 10;
	}
	else
	{
		uStep = 100;
	}

	if( SELECTION_KEY_PREV == uselKeyState )
	{
		if( uPulseWidthMin > (gSelectionValue - uStep) )
		{
			gSelectionValue = uPulseWidthMax;
		}
		else
		{
			gSelectionValue -= uStep;
		}

		gUIstate.bUpdateInfo = TRUE;
	}
	else if( SELECTION_KEY_NEXT == uselKeyState )
	{
		if( uPulseWidthMax < (uStep + gSelectionValue) )
		{
			gSelectionValue = uPulseWidthMin;
		}
		else
		{
			gSelectionValue += uStep;
		}

		gUIstate.bUpdateInfo = TRUE;
	}

	if( TRUE == gUIstate.bUpdateInfo )
	{
#ifdef UI_PANEL_ENABLE
		char szTextOut[20];

		if( setBKPreFireWidth == gSelectionNo )
		{
			LcdStr(LCD_ROW_1, 0, "BK PreFire Width"); 
		}
		else if( setCLRPreFireWidth == gSelectionNo )
		{
			LcdStr(LCD_ROW_1, 0, "CLR PreFireWidth"); 
		}
		else if( setBKFireWidth == gSelectionNo )
		{
			LcdStr(LCD_ROW_1, 0, " BK Fire Width  "); 
		}
		else
		{
			LcdStr(LCD_ROW_1, 0, " CLR Fire Width "); 
		}

		sprintf(szTextOut, " Pulse ==> %lu   ", gSelectionValue);
		LcdStr(LCD_ROW_2, 0, szTextOut); 
#endif
		gUIstate.bUpdateInfo = FALSE;
	}
}
#endif
#if 0
/******************************************************************************
* Name:        UIDoPaperSizeSelection
*
* Description: Paper size setting  
*
* Parameters:  uselKeyState - Pressed Key state
*
* Return:      None
*
* Notes:      
******************************************************************************/
void UIDoPaperSizeSelection(Uint32 uselKeyState)
{
	if( SELECTION_KEY_PREV == uselKeyState )
	{
		if( 0 == gSelectionValue )
		{
			gSelectionValue = UI_MAX_PAPER_SIZE - 1;
		}
		else
		{
			gSelectionValue--;
		}

		gUIstate.bUpdateInfo = TRUE;
	}
	else if( SELECTION_KEY_NEXT == uselKeyState )
	{
		gSelectionValue++;
		if( UI_MAX_PAPER_SIZE == gSelectionValue )
		{
			gSelectionValue = 0;
		}

		gUIstate.bUpdateInfo = TRUE;
	}

	if( TRUE == gUIstate.bUpdateInfo )
	{
#ifdef UI_PANEL_ENABLE
		static char* szPaperSize[UI_MAX_PAPER_SIZE]={"     A4 ", "   Letter"};

		LcdStr(LCD_ROW_1, LCD_SETTING_TYPE_COL, "   Paper Size   "); /* !!! text */
		LcdClrLine(LCD_ROW_2);
		LcdStr(LCD_ROW_2, LCD_SETTING_ITEM_COL, szPaperSize[gSelectionValue]); 
#endif
		gUIstate.bUpdateInfo = FALSE;
	}
}

/******************************************************************************
* Name:        UIDoVopuModeSelection
*
* Description: Video Output Unit mode selection
*
* Parameters:  uselKeyState - Pressed Key state
*
* Return:      None
*
* Notes:      
******************************************************************************/
void UIDoVopuModeSelection(Uint32 uselKeyState)
{
  eVopuMode newMode;
  newMode = vopuDisplayMode;
  if ( uselKeyState == SELECTION_KEY_PREV ) {
    // previous value
    newMode--;
    gUIstate.bUpdateInfo = TRUE;
  } else if ( uselKeyState == SELECTION_KEY_NEXT ) {
    // next value
    newMode++;
    gUIstate.bUpdateInfo = TRUE;
  }
  // Make values wrap around
  if (newMode >= eVopuMax) {
    newMode = (eVopuMode)(eVopuMin + 1);
  }
  if (newMode <= eVopuMin) {
    newMode = (eVopuMode)(eVopuMax - 1);
  }
  if (vopuDisplayMode != newMode) {
    vopuDisplayMode = newMode;
  }
#ifdef UI_PANEL_ENABLE
  if (gUIstate.bUpdateInfo) {
    LcdStr(LCD_ROW_1, LCD_SETTING_TYPE_COL, "