コード例 #1
0
ファイル: PROJET.C プロジェクト: gorhill/rayoid
main()
{
	int probleme;

	DataDecrypt();

	if ( DataCheck() != 0 )
		DataClear();

	linea_init();
	hide_mouse();

	probleme = InitTank();

	if ( !probleme ) {
		InitSys();
		_InitSys();
		InitRand((int)*_Hz200 & 0x7FFF);
		ShowLogo();
		MnRoot();
		_TermSys();
		TermSys();
		}

	TermTank(probleme);

	show_mouse(0);

	return (0);
}
コード例 #2
0
ファイル: menu.c プロジェクト: YesWant/HX123S
/*****************************************************************************
** Descriptions:	��ӭ����
** Parameters:    	s32 index
** Returned value:	
** Created By:		������2013.12.09
** Remarks: 		
*****************************************************************************/
SDK_UI_EXIT_VALUE PostShowWelcome(s32 index)
{
    SDK_DISP_PIXEL pixel;
    u8 temp[64] = {0};
    memset(&pixel, 0, sizeof(SDK_DISP_PIXEL));
    
    pgstTradeData->ucTradeId = TRADEID_WELCOME;
    if (pgstAppSetting->stComsetting.uiIdleCntDown > 0 && !sdkSysIsExPower())
    {
        giIdleClockTimer = sdkTimerGetId();
    }

    sdkUISetShowMode(SDK_UI_SHOW_MODE_1_ROW);
    sdkUIClearItems();
    sdkUIAddHideItem((s32)SDK_KEY_ENTER, MainFace);
 
    if (ShowBackground(WELCOMBMP) != SDK_OK) ShowLogo(0, 0);
    pixel = sdkDispGetScreenPixel();
    memset(temp,0,sizeof(temp));
    sdkDispFillRowRam(SDK_DISP_LINE2, pixel.siX / 2, "�����", SDK_DISP_LEFT_DEFAULT);
    memset(temp, 0, sizeof(temp));

#ifdef XGD_SDK_DEBUG
    sdkDispFillRowRam(SDK_DISP_LINE4, 0, "���԰汾,��������", SDK_DISP_DEFAULT);
#endif
    DispIcon();
    DispSysRtc(SDK_DISP_LINE5, false);
    sdkDispBrushScreen();
    return SDK_UI_EXIT_ENTER;
}
コード例 #3
0
BOOL
BLShowLogo(
    )
{
	//  Show the bootloader splashscreen if present on the SDCard
	if (!ShowSDLogo())
	{
		ShowLogo((UINT32)-1, 0);
	}

    return TRUE;
}
コード例 #4
0
ファイル: LicenseWin.c プロジェクト: rn10950/RetroZilla
void
ShowLicenseWin(void)
{
	Str255 		accept;
	Str255 		decline;
	Rect 		sbRect;
	int 		sbWidth;
	
	GrafPtr	oldPort;
	GetPort(&oldPort);
	
	SetPort(gWPtr);

	gCurrWin = kLicenseID; 
	/* gControls->lw = (LicWin *) NewPtrClear(sizeof(LicWin)); */
	
	GetResourcedString(accept, rInstList, sAcceptBtn);
	GetResourcedString(decline, rInstList, sDeclineBtn);
	
	gControls->lw->scrollBar = GetNewControl( rLicScrollBar, gWPtr);
	gControls->lw->licBox = GetNewControl( rLicBox, gWPtr);

	if(gControls->lw->scrollBar && gControls->lw->licBox)
	{
		HLock( (Handle) gControls->lw->scrollBar);
		sbRect = (*(gControls->lw->licBox))->contrlRect;
				
		sbWidth = (*(gControls->lw->scrollBar))->contrlRect.right -
				  (*(gControls->lw->scrollBar))->contrlRect.left;
		
		(*(gControls->lw->scrollBar))->contrlRect.right = sbRect.right + kScrollBarPad;
		(*(gControls->lw->scrollBar))->contrlRect.left = sbRect.right + kScrollBarPad - 
														 sbWidth;
		(*(gControls->lw->scrollBar))->contrlRect.top = sbRect.top - kScrollBarPad;
		(*(gControls->lw->scrollBar))->contrlRect.bottom = sbRect.bottom + kScrollBarPad;
		HUnlock( (Handle) gControls->lw->scrollBar);
	}
	else
	{
		ErrorHandler(eParam, nil);
		return;
	}
	InitLicTxt();

	ShowNavButtons( decline, accept);
	ShowControl( gControls->lw->scrollBar);
	ShowControl( gControls->lw->licBox);
	ShowTxt();
	InitScrollBar( gControls->lw->scrollBar);
	ShowLogo(false);
	
	SetPort(oldPort);
}
コード例 #5
0
ファイル: Stage01.cpp プロジェクト: SZSilence06/THXYY
void Stage01::Update()
{
	Stage::Update();

	auto engine = STGEngine::GetInstance();

	frame++;
	AddEnemy001(1);
	AddEnemy002(5.5 * FPB);
	AddEnemy001(10 * FPB);
	AddEnemy002(14.5 * FPB);
	AddEnemy003(19 * FPB);

	ShowLogo(40.5 * FPB);
}
コード例 #6
0
ファイル: bootos.c プロジェクト: fsebentley/Novo7Tools
int PreBootOS(struct OSImageScript *imgScript, void **bootAddrBuf,
        void **var6, int *logoOff)
{
    int var9;

    var9 = -1;
    *logoOff = imgScript->logoOff;
    ShowLogo(imgScript->logoFileName, imgScript->logoShow,
            imgScript->logoAddress);
    var9 = fnL42801894(imgScript, bootAddrBuf, var6);
    if(var9 >= 0) {
        wlibc_uprintf("start address = %x\n", *bootAddrBuf);
        return 0;
    }
    return -1;
}
コード例 #7
0
ファイル: 06_drturtle_final.c プロジェクト: MarcMDE/raylib
int main()
{
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 1280;
    const int screenHeight = 720;
    
    // Init window
    ShowLogo();
    InitWindow(screenWidth, screenHeight, "Dr. Turtle & Mr. GAMERA");
    
    // Initialize audio device
    InitAudioDevice();      
    
    // Load game resources: textures
    Texture2D sky = LoadTexture("resources/sky.png");
    Texture2D mountains = LoadTexture("resources/mountains.png");
    Texture2D sea = LoadTexture("resources/sea.png");
    Texture2D title = LoadTexture("resources/title.png");
    Texture2D turtle = LoadTexture("resources/turtle.png");
    Texture2D gamera = LoadTexture("resources/gamera.png");
    Texture2D shark = LoadTexture("resources/shark.png");
    Texture2D orca = LoadTexture("resources/orca.png");
    Texture2D swhale = LoadTexture("resources/swhale.png");
    Texture2D fish = LoadTexture("resources/fish.png");
    Texture2D gframe = LoadTexture("resources/gframe.png");
    
    // Load game resources: fonts
    SpriteFont font = LoadSpriteFont("resources/komika.png");
    
    // Load game resources: sounds
    Sound eat = LoadSound("resources/eat.wav");
    Sound die = LoadSound("resources/die.wav");
    Sound growl = LoadSound("resources/gamera.wav");
    
    // Start playing streaming music
    PlayMusicStream("resources/speeding.ogg");

    // Define scrolling variables
    int backScrolling = 0;
    int seaScrolling = 0;
    
    // Define current screen
    GameScreen currentScreen = TITLE;
    
    // Define player variables
    int playerRail = 1;
    Rectangle playerBounds = { 30 + 14, playerRail*120 + 90 + 14, 100, 100 };
    bool gameraMode = false;
    
    // Define enemies variables
    Rectangle enemyBounds[MAX_ENEMIES];
    int enemyRail[MAX_ENEMIES];
    int enemyType[MAX_ENEMIES];
    bool enemyActive[MAX_ENEMIES];
    float enemySpeed = 10;
    
    // Init enemies variables
    for (int i = 0; i < MAX_ENEMIES; i++)
    {
        // Define enemy type (all same probability)
        //enemyType[i] = GetRandomValue(0, 3);
    
        // Probability system for enemies type
        int enemyProb = GetRandomValue(0, 100);
        
        if (enemyProb < 30) enemyType[i] = 0;
        else if (enemyProb < 60) enemyType[i] = 1;
        else if (enemyProb < 90) enemyType[i] = 2;
        else enemyType[i] = 3;

        // define enemy rail
        enemyRail[i] = GetRandomValue(0, 4);

        // Make sure not two consecutive enemies in the same row
        if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4);
        
        enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 };
        enemyActive[i] = false;
    }
    
    // Define additional game variables
    int score = 0;
    float distance = 0.0f;
    int hiscore = 0;
    float hidistance = 0.0f;
    int foodBar = 0;
    int framesCounter = 0;
    
    unsigned char blue = 200;
    float timeCounter = 0;
    
    SetTargetFPS(60);       // Setup game frames per second
    //--------------------------------------------------------------------------------------
    
    // Main game loop
    while (!WindowShouldClose())    // Detect window close button or ESC key
    {
        // Update
        //----------------------------------------------------------------------------------
        framesCounter++;
        
        // Sea color tint effect
        blue = 210 + 25 * sin(timeCounter);
        timeCounter += 0.01;

        // Game screens management
        switch (currentScreen)
        {
            case TITLE:
            {
                // Sea scrolling
                seaScrolling -= 2;
                if (seaScrolling <= -screenWidth) seaScrolling = 0; 
            
                // Press enter to change to gameplay screen
                if (IsKeyPressed(KEY_ENTER))
                {
                    currentScreen = GAMEPLAY;
                    framesCounter = 0;
                }
                
            } break;
            case GAMEPLAY:
            {
                // Background scrolling logic
                backScrolling--;
                if (backScrolling <= -screenWidth) backScrolling = 0; 
                
                // Sea scrolling logic
                seaScrolling -= (enemySpeed - 2);
                if (seaScrolling <= -screenWidth) seaScrolling = 0; 
            
                // Player movement logic
                if (IsKeyPressed(KEY_DOWN)) playerRail++;
                else if (IsKeyPressed(KEY_UP)) playerRail--;
                
                // Check player not out of rails
                if (playerRail > 4) playerRail = 4;
                else if (playerRail < 0) playerRail = 0;
            
                // Update player bounds
                playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 };
                
                // Enemies activation logic (every 40 frames)        
                if (framesCounter > 40)
                {
                    for (int i = 0; i < MAX_ENEMIES; i++)
                    {
                        if (enemyActive[i] == false)
                        {
                            enemyActive[i] = true;
                            i = MAX_ENEMIES;
                        }
                    }
                    
                    framesCounter = 0;
                }
                
                // Enemies logic
                for (int i = 0; i < MAX_ENEMIES; i++)
                {
                    if (enemyActive[i])
                    {
                        enemyBounds[i].x -= enemySpeed;
                    }
                    
                    // Check enemies out of screen
                    if (enemyBounds[i].x <= 0 - 128)
                    {
                        enemyActive[i] = false;
                        enemyType[i] = GetRandomValue(0, 3);
                        enemyRail[i] = GetRandomValue(0, 4);
                        
                        // Make sure not two consecutive enemies in the same row
                        if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4);
                        
                        enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 };
                    }
                }
                
                if (!gameraMode) enemySpeed += 0.005;
                
                // Check collision player vs enemies
                for (int i = 0; i < MAX_ENEMIES; i++)
                {
                    if (enemyActive[i])
                    {
                        if (CheckCollisionRecs(playerBounds, enemyBounds[i]))
                        {                       
                            if (enemyType[i] < 3)   // Bad enemies
                            {
                                if (gameraMode)
                                {
                                    if (enemyType[i] == 0) score += 50;
                                    else if (enemyType[i] == 1) score += 150;
                                    else if (enemyType[i] == 2) score += 300;
                                    
                                    foodBar += 15;
                                
                                    enemyActive[i] = false;
                                    
                                    // After enemy deactivation, reset enemy parameters to be reused
                                    enemyType[i] = GetRandomValue(0, 3);
                                    enemyRail[i] = GetRandomValue(0, 4);
                                    
                                    // Make sure not two consecutive enemies in the same row
                                    if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4);
                                    
                                    enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 };
                                    
                                    PlaySound(eat);
                                }
                                else
                                {
                                    // Player die logic
                                    PlaySound(die);
                                
                                    currentScreen = ENDING;
                                    framesCounter = 0;
                                    
                                    // Save hiscore and hidistance for next game
                                    if (score > hiscore) hiscore = score;
                                    if (distance > hidistance) hidistance = distance;
                                }
                            }
                            else    // Sweet fish
                            {
                                enemyActive[i] = false;
                                enemyType[i] = GetRandomValue(0, 3);
                                enemyRail[i] = GetRandomValue(0, 4);
                                
                                // Make sure not two consecutive enemies in the same row
                                if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4);
                                
                                enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 };
                                
                                if (!gameraMode) foodBar += 80;
                                else foodBar += 25;
                                
                                score += 10;
                                
                                if (foodBar == 400)
                                {
                                    gameraMode = true;
                                    
                                    PlaySound(growl);
                                }
                                
                                PlaySound(eat);
                            }
                        }
                    }
                }
                
                // Gamera mode logic
                if (gameraMode)
                {
                    foodBar--;
                    
                    if (foodBar <= 0) 
                    {
                        gameraMode = false;
                        enemySpeed -= 2;
                        if (enemySpeed < 10) enemySpeed = 10;
                    }
                }
        
                // Update distance counter
                distance += 0.5f;
            
            } break;
            case ENDING:
            {
                // Press enter to play again
                if (IsKeyPressed(KEY_ENTER))
                {
                    currentScreen = GAMEPLAY;
                    
                    // Reset player
                    playerRail = 1;
                    playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 };
                    gameraMode = false;
                    
                    // Reset enemies data
                    for (int i = 0; i < MAX_ENEMIES; i++)
                    {
                        int enemyProb = GetRandomValue(0, 100);
                        
                        if (enemyProb < 30) enemyType[i] = 0;
                        else if (enemyProb < 60) enemyType[i] = 1;
                        else if (enemyProb < 90) enemyType[i] = 2;
                        else enemyType[i] = 3;
                        
                        //enemyType[i] = GetRandomValue(0, 3);
                        enemyRail[i] = GetRandomValue(0, 4);

                        // Make sure not two consecutive enemies in the same row
                        if (i > 0) while (enemyRail[i] == enemyRail[i - 1]) enemyRail[i] = GetRandomValue(0, 4);
                        
                        enemyBounds[i] = (Rectangle){ screenWidth + 14, 120*enemyRail[i] + 90 + 14, 100, 100 };
                        enemyActive[i] = false;
                    }
                    
                    enemySpeed = 10;
                    
                    // Reset game variables
                    score = 0;
                    distance = 0.0;
                    foodBar = 0;
                    framesCounter = 0;
                }
      
            } break;
            default: break;
        }
        //----------------------------------------------------------------------------------
        
        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();
        
            ClearBackground(RAYWHITE);
            
            // Draw background (common to all screens)
            DrawTexture(sky, 0, 0, WHITE);
            
            DrawTexture(mountains, backScrolling, 0, WHITE);
            DrawTexture(mountains, screenWidth + backScrolling, 0, WHITE);
            
            if (!gameraMode)
            {
                DrawTexture(sea, seaScrolling, 0, (Color){ 16, 189, blue, 255});
                DrawTexture(sea, screenWidth + seaScrolling, 0, (Color){ 16, 189, blue, 255});
            }
            else
            {
                DrawTexture(sea, seaScrolling, 0, (Color){ 255, 113, 66, 255});
                DrawTexture(sea, screenWidth + seaScrolling, 0, (Color){ 255, 113, 66, 255});
            }
            
            switch (currentScreen)
            {
                case TITLE:
                {
                    // Draw title
                    DrawTexture(title, screenWidth/2 - title.width/2, screenHeight/2 - title.height/2 - 80, WHITE);
                    
                    // Draw blinking text
                    if ((framesCounter/30) % 2) DrawTextEx(font, "PRESS ENTER", (Vector2){ screenWidth/2 - 150, 480 }, GetFontBaseSize(font), 0, WHITE);
                
                } break;
                case GAMEPLAY:
                {
                    // Draw water lines
                    for (int i = 0; i < 5; i++) DrawRectangle(0, i*120 + 120, screenWidth, 110, Fade(SKYBLUE, 0.1f));
                    
                    // Draw player
                    if (!gameraMode) DrawTexture(turtle, playerBounds.x - 14, playerBounds.y - 14, WHITE);
                    else DrawTexture(gamera, playerBounds.x - 64, playerBounds.y - 64, WHITE);
                    
                    // Draw player bounding box
                    //if (!gameraMode) DrawRectangleRec(playerBounds, Fade(GREEN, 0.4f));
                    //else DrawRectangleRec(playerBounds, Fade(ORANGE, 0.4f));
                    
                    // Draw enemies
                    for (int i = 0; i < MAX_ENEMIES; i++)
                    {
                        if (enemyActive[i]) 
                        {
                            // Draw enemies
                            switch(enemyType[i])
                            {
                                case 0: DrawTexture(shark, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break;
                                case 1: DrawTexture(orca, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break;
                                case 2: DrawTexture(swhale, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break;
                                case 3: DrawTexture(fish, enemyBounds[i].x - 14, enemyBounds[i].y - 14, WHITE); break;
                                default: break;
                            }
                            
                            // Draw enemies bounding boxes
                            /*
                            switch(enemyType[i])
                            {
                                case 0: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break;
                                case 1: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break;
                                case 2: DrawRectangleRec(enemyBounds[i], Fade(RED, 0.5f)); break;
                                case 3: DrawRectangleRec(enemyBounds[i], Fade(GREEN, 0.5f)); break;
                                default: break;
                            }
                            */
                        }
                    }
                    
                    // Draw gameplay interface
                    DrawRectangle(20, 20, 400, 40, Fade(GRAY, 0.4f));
                    DrawRectangle(20, 20, foodBar, 40, ORANGE);
                    DrawRectangleLines(20, 20, 400, 40, BLACK);
                    
                    DrawTextEx(font, FormatText("SCORE: %04i", score), (Vector2){ screenWidth - 300, 20 }, GetFontBaseSize(font), -2, ORANGE);
                    DrawTextEx(font, FormatText("DISTANCE: %04i", (int)distance), (Vector2){ 550, 20 }, GetFontBaseSize(font), -2, ORANGE);
                    
                    if (gameraMode)
                    {
                        DrawText("GAMERA MODE", 60, 22, 40, GRAY);
                        DrawTexture(gframe, 0, 0, Fade(WHITE, 0.5f));
                    }
            
                } break;
                case ENDING:
                {
                    // Draw a transparent black rectangle that covers all screen
                    DrawRectangle(0, 0, screenWidth, screenHeight, Fade(BLACK, 0.4f));
                
                    DrawTextEx(font, "GAME OVER", (Vector2){ 300, 160 }, GetFontBaseSize(font)*3, -2, MAROON);
                    
                    DrawTextEx(font, FormatText("SCORE: %04i", score), (Vector2){ 680, 350 }, GetFontBaseSize(font), -2, GOLD);
                    DrawTextEx(font, FormatText("DISTANCE: %04i", (int)distance), (Vector2){ 290, 350 }, GetFontBaseSize(font), -2, GOLD);
                    DrawTextEx(font, FormatText("HISCORE: %04i", hiscore), (Vector2){ 665, 400 }, GetFontBaseSize(font), -2, ORANGE);
                    DrawTextEx(font, FormatText("HIDISTANCE: %04i", (int)hidistance), (Vector2){ 270, 400 }, GetFontBaseSize(font), -2, ORANGE);
                    
                    // Draw blinking text
                    if ((framesCounter/30) % 2) DrawTextEx(font, "PRESS ENTER to REPLAY", (Vector2){ screenWidth/2 - 250, 520 }, GetFontBaseSize(font), -2, LIGHTGRAY);
                    
                } break;
                default: break;
            }

        EndDrawing();
        //----------------------------------------------------------------------------------
    }

    // De-Initialization
    //--------------------------------------------------------------------------------------
    
    // Unload textures
    UnloadTexture(sky);
    UnloadTexture(mountains);
    UnloadTexture(sea);
    UnloadTexture(gframe);
    UnloadTexture(title);
    UnloadTexture(turtle);
    UnloadTexture(shark);
    UnloadTexture(orca);
    UnloadTexture(swhale);
    UnloadTexture(fish);
    UnloadTexture(gamera);
    
    // Unload font texture
    UnloadSpriteFont(font);
    
    // Unload sounds
    UnloadSound(eat);
    UnloadSound(die);
    UnloadSound(growl);
    
    StopMusicStream();      // Stop music
    CloseAudioDevice();     // Close audio device
    
    CloseWindow();          // Close window and OpenGL context
    //--------------------------------------------------------------------------------------
    
    return 0;
}
コード例 #8
0
ファイル: menu.c プロジェクト: YesWant/HX123S
/*****************************************************************************
** Descriptions:	������
** Parameters:          void
** Returned value:	void
** Created By:		����2012.07.27
** Remarks:
*****************************************************************************/
s32 MainMenu(void) {
//    SDK_DISP_PIXEL pixel;

    u8 btName[68] = {"������: "};
    u8 tmpBtname[68] = {0};
    int retVal = 0;


    Trace("mpos", "go into MainMenu\r\n");
//    memset(&pixel, 0, sizeof(SDK_DISP_PIXEL));
    pgstTradeData->ucTradeId = TRADEID_MAINMENU;

    sdkUIClearItems();
    sdkUISetShowMode(SDK_UI_SHOW_MODE_1_ROW);

    Verify(sdkUIAddHideItem((s32) SDK_KEY_FUNCTION, OnSysSetting) >= 0);

#if 0
    Verify(sdkUIAddHideItem((s32)SDK_KEY_1, TestOnOpenMagCardDevice) >= 0);
    Verify(sdkUIAddHideItem((s32)SDK_KEY_2, TestOnCloseMagCardDevice) >= 0);
    Verify(sdkUIAddHideItem((s32)SDK_KEY_3, TestOnReadMagCard) >= 0);
    Verify(sdkUIAddHideItem((s32)SDK_KEY_4, TestOnReadMagCardEncrypt) >= 0);
    //Verify(sdkUIAddHideItem((s32)SDK_KEY_5, DrawText) >= 0);

    Verify(sdkUIAddHideItem((s32)SDK_KEY_6, TestOnDataEncrypt) >= 0);
    Verify(sdkUIAddHideItem((s32)SDK_KEY_7, TestOnMAC) >= 0);
    //Verify(sdkUIAddHideItem((s32)SDK_KEY_8, TestOnGetDateTime) >= 0);
    //Verify(sdkUIAddHideItem((s32)SDK_KEY_9, TestOnSetDateTime) >= 0);
#endif
//	sdkUIShowMenu();

    //-----------------------------------------------------
    sdkDispClearScreen();
#ifndef DEL_CODE_EXCESS                //ɾ���������: 20150304
    ShowBackground(BACKGROUNDBMP);

//    giAutoRetTimer = sdkTimerGetId();//Xiaox 15-1-12 ���ڽ��յ�ָ��ǰ
    if (ShowBackground(WELCOMBMP) != SDK_OK) ShowLogo(0, 0);
//    pixel = sdkDispGetScreenPixel();
//	sdkDispClearScreen();
#endif	//DEL_CODE_EXCESS	ɾ���������: 20150304

    //sdkDispFillRowRam(SDK_DISP_LINE2-ROW_OFFSET, 0, "���������", gDisplayMode == 0?SDK_DISP_DEFAULT: SDK_DISP_NOFDISP| SDK_DISP_CDISP|SDK_DISP_INCOL);//Xiaox 15-1-14 for test
    sdkDispFillRowRam(SDK_DISP_LINE2 - ROW_OFFSET, 0, "��ӭʹ��ȫ����POS",
                      gDisplayMode == 0 ? SDK_DISP_DEFAULT : SDK_DISP_NOFDISP | SDK_DISP_CDISP |
                                                             SDK_DISP_INCOL);//Xiaox 15-1-14 for test        //20150324 �����滻

    if (BLUETOOTH == gucCurCommMode) {
        retVal = sdkBtGetName(tmpBtname, sizeof(tmpBtname) - 1);

        if (retVal == SDK_OK)//2015-01-08
        {
            strcat(btName, tmpBtname);
            sdkDispFillRowRam(SDK_DISP_LINE3 - ROW_OFFSET, 0, btName,
                              gDisplayMode == 0 ? SDK_DISP_DEFAULT : SDK_DISP_NOFDISP |
                                                                     SDK_DISP_CDISP |
                                                                     SDK_DISP_INCOL);//Xiaox 15-1-14 for test
        }
        else {
            //Trace("Lai","sdkBtGetName error:%d\r\n",retVal);
        }
    }


#ifdef XGD_SDK_DEBUG
    sdkDispFillRowRam(SDK_DISP_LINE4-ROW_OFFSET, 0, "���԰汾,��������", gDisplayMode == 0?SDK_DISP_DEFAULT: SDK_DISP_NOFDISP| SDK_DISP_CDISP|SDK_DISP_INCOL);//Xiaox 15-1-14 for test
#else
    //20150402 ��ʾCSN�ͻ����к�, ���Է��ڰ汾��Ϣ��
    //sdkDispFillRowRam(SDK_DISP_LINE4-ROW_OFFSET, 0, MposDeviceId, gDisplayMode == 0?SDK_DISP_DEFAULT: SDK_DISP_NOFDISP| SDK_DISP_CDISP|SDK_DISP_INCOL);//Xiaox 15-1-14 for test
#endif
    DispIcon();
    DispSysRtc(SDK_DISP_LINE5 - ROW_OFFSET, false);
    sdkDispBrushScreen();
    return SDK_OK;
}