PocketCoreLibraryTest.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/


// PocketCoreLibraryTest.cpp : Defines the entry point for the application.
//

// #include "stdafx.h"
#include "PocketCoreLibraryTest.h"
#include <commctrl.h>

#define MAX_LOADSTRING 100

HWND hMainWnd = NULL;
Collection lines;

bool UpdateLinesOfText(HWND hWnd);
bool DrawLinesOfText(HDC hdc);


// Global Variables:
HINSTANCE                       hInst;                  // The current instance
HWND                            hwndCB;                 // The command bar handle

// Forward declarations of functions included in this code module:
ATOM                            MyRegisterClass (HINSTANCE, LPTSTR);
BOOL                            InitInstance    (HINSTANCE, int);
LRESULT CALLBACK        WndProc                 (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK        About                   (HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(     HINSTANCE hInstance,
                                        HINSTANCE hPrevInstance,
                                        LPTSTR    lpCmdLine,
                                        int       nCmdShow)
{
        MSG msg;
        HACCEL hAccelTable;

        // Perform application initialization:
        if (!InitInstance (hInstance, nCmdShow)) 
        {
                return FALSE;
        }

        hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_POCKETCORELIBRARYTEST);

        JTime now;
/*      JTime total;
        lines.add(JString::format("Testing time 1 %s [%d]", (char*) now.printTime(), (int) total.microDifference(now)));
        now.wait(53);
        now = JTime();
        lines.add(JString::format("Testing time 2 %s [%d]", (char*) now.printTime(), (int) total.microDifference(now)));
        now.wait(53);
        now = JTime();
        lines.add(JString::format("Testing time 3 %s [%d]", (char*) now.printTime(), (int) total.microDifference(now)));
        now.wait(53);
        now = JTime();
        lines.add(JString::format("Testing time 4 %s [%d]", (char*) now.printTime(), (int) total.microDifference(now)));
        now.wait(53);
        now = JTime();
        lines.add(JString::format("Testing time 5 %s [%d]", (char*) now.printTime(), (int) total.microDifference(now)));
        lines.add("");
        UpdateLinesOfText(hMainWnd);
        
        now.wait(5000);
*/      
//      JTime now1 = now+1250;

        lines.add(JString::format("Starting Core Test at %s", (char*) now.printTime()));
        lines.add("");
        UpdateLinesOfText(hMainWnd);

        JString ret;
        Collection col;
        int c = 0;


//      JTime t1;
//      t1.timebuffer.dstflag = 1;
//      lines.add(JString::format("Time: %s", (char*) t1.print()));
//      lines.add(JString::format("GMT:  %s", (char*) t1.toHTTP()));
//      lines.add(JString::format("%d %d %d %d", t1.timebuffer.time, t1.timebuffer.millitm, t1.timebuffer.timezone, t1.timebuffer.dstflag));
//      UpdateLinesOfText(hMainWnd);

//      UpdateLinesOfText(hMainWnd);


/*      HDC hdc = GetDC(hMainWnd);
        JString fontname = "Pica";
        LOGFONT logfont;
        memset ((char *)&logfont, 0, sizeof (logfont));
        logfont.lfQuality = ANTIALIASED_QUALITY;
        logfont.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
        if (fontname.length() < 32)
                 _tcscpy(logfont.lfFaceName, fontname);
        logfont.lfHeight = 12;
        logfont.lfWeight = 700;
        HFONT font = (HFONT) CreateFontIndirect (&logfont);
        if (font != NULL)
                SelectObject(hdc, font);
        ReleaseDC(hMainWnd, hdc);
*/
        try {

                do {
                        ret = runTest(c);
                        col = ret.splitIntoLines();
                        lines.addAll(col);
                        c++;
                        UpdateLinesOfText(hMainWnd);

        //              UpdateWindow(hMainWnd);
        /*              if (GetMessage(&msg, NULL, 0, 0)) 
                        {
                                if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
                                {
                                        TranslateMessage(&msg);
                                        DispatchMessage(&msg);
                                }
                        }*/
                        Sleep(200);
                } while (ret.length() > 0);

                lines.add("");
                now = JTime();
                lines.add(JString::format("Test Complete at %s", (char*) now.printTime()));
                lines.add("");
                UpdateLinesOfText(hMainWnd);


                // Main message loop:
                while (GetMessage(&msg, NULL, 0, 0)) 
                {
                        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
                        {
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                        }
                }

        } catch(...) {
                lines.add("");
                lines.add("Error 1");
                lines.add("");
                UpdateLinesOfText(hMainWnd);
        }

        return msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    It is important to call this function so that the application 
//    will get 'well formed' small icons associated with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
        WNDCLASS        wc;

    wc.style                    = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc              = (WNDPROC) WndProc;
    wc.cbClsExtra               = 0;
    wc.cbWndExtra               = 0;
    wc.hInstance                = hInstance;
    wc.hIcon                    = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_POCKETCORELIBRARYTEST));
    wc.hCursor                  = 0;
    wc.hbrBackground    = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName             = 0;
    wc.lpszClassName    = szWindowClass;

        return RegisterClass(&wc);
}

//
//  FUNCTION: InitInstance(HANDLE, int)
//
//  PURPOSE: Saves instance handle and creates main window
//
//  COMMENTS:
//
//    In this function, we save the instance handle in a global variable and
//    create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
        HWND    hWnd;
        TCHAR   szTitle[MAX_LOADSTRING];                        // The title bar text
        TCHAR   szWindowClass[MAX_LOADSTRING];          // The window class name

        hInst = hInstance;              // Store instance handle in our global variable
        // Initialize global strings
        LoadString(hInstance, IDC_POCKETCORELIBRARYTEST, szWindowClass, MAX_LOADSTRING);
        MyRegisterClass(hInstance, szWindowClass);

        LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
        hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

        if (!hWnd)
        {       
                return FALSE;
        }

        hMainWnd = hWnd;

        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);
        if (hwndCB)
                CommandBar_Show(hwndCB, TRUE);

        return TRUE;
}

//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
//      HDC hdc;
        int wmId, wmEvent;
        PAINTSTRUCT ps;
//      TCHAR szHello[MAX_LOADSTRING];

        JString mystr;

        switch (message) 
        {
                case WM_COMMAND:
                        wmId    = LOWORD(wParam); 
                        wmEvent = HIWORD(wParam); 
                        // Parse the menu selections:
                        switch (wmId)
                        {
                                case IDM_HELP_ABOUT:
                                   DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
                                   break;
                                case IDM_FILE_EXIT:
                                   DestroyWindow(hWnd);
                                   break;
                                default:
                                   return DefWindowProc(hWnd, message, wParam, lParam);
                        }
                        break;
                case WM_CREATE:
                        hwndCB = CommandBar_Create(hInst, hWnd, 1);                     
                        CommandBar_InsertMenubar(hwndCB, hInst, IDM_MENU, 0);
                        CommandBar_AddAdornments(hwndCB, 0, 0);
                        break;
                case WM_PAINT:
                        DrawLinesOfText(BeginPaint(hMainWnd, &ps));
                        EndPaint(hMainWnd, &ps);
                        break;
                case WM_DESTROY:
                        CommandBar_Destroy(hwndCB);
                        PostQuitMessage(0);
                        break;
                default:
                        return DefWindowProc(hWnd, message, wParam, lParam);
   }
   return 0;
}

// Mesage handler for the About box.
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
        RECT rt, rt1;
        int DlgWidth, DlgHeight;        // dialog width and height in pixel units
        int NewPosX, NewPosY;

        switch (message)
        {
                case WM_INITDIALOG:
                        // trying to center the About dialog
                        if (GetWindowRect(hDlg, &rt1)) {
                                GetClientRect(GetParent(hDlg), &rt);
                                DlgWidth        = rt1.right - rt1.left;
                                DlgHeight       = rt1.bottom - rt1.top ;
                                NewPosX         = (rt.right - rt.left - DlgWidth)/2;
                                NewPosY         = (rt.bottom - rt.top - DlgHeight)/2;
                                
                                // if the About box is larger than the physical screen 
                                if (NewPosX < 0) NewPosX = 0;
                                if (NewPosY < 0) NewPosY = 0;
                                SetWindowPos(hDlg, 0, NewPosX, NewPosY,
                                        0, 0, SWP_NOZORDER | SWP_NOSIZE);
                        }
                        return TRUE;

                case WM_COMMAND:
                        if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
                        {
                                EndDialog(hDlg, LOWORD(wParam));
                                return TRUE;
                        }
                        break;
        }
    return FALSE;
}


bool UpdateLinesOfText(HWND hWnd) {

        HDC hdc = GetDC(hWnd);
        DrawLinesOfText(hdc);
        ReleaseDC(hMainWnd, hdc);
        return true;
}

bool DrawLinesOfText(HDC hdc) {

        RECT rt;
        Color bgColor = Color("White");
        Color fgColor = Color("Blue");
        Color passColor = Color("Green");
        Color failColor = Color("Red");
        JString str, pass;
        GetClientRect(hMainWnd, &rt);
        RECT crt = rt;
        int topMargin = 24;
        int lheight = 14;

        try {
        
        FillRect(hdc, &rt, bgColor);
        Collection tabs;

        for (int n=0; n<lines.getCount(); n++) {
                crt.top = rt.bottom - (n+1)*lheight;
                crt.bottom = rt.bottom - n*lheight;
                if (crt.top < topMargin)
                        break;
                str = lines.get(lines.getCount()-1-n);
                tabs = str.split("\t");

                if (tabs.getCount() == 1) {
                        SetTextColor(hdc, (COLORREF) fgColor);
                        DrawText(hdc, str, str.length(), &crt, 
                                DT_SINGLELINE | DT_TOP | DT_LEFT);
                }
                else {
                        SetTextColor(hdc, (COLORREF) fgColor);
                        DrawText(hdc, tabs.getFirst(), tabs.getFirst().length(), &crt, 
                                DT_SINGLELINE | DT_TOP | DT_LEFT);

                        pass = tabs.getLast();
                        if (pass.equalsIgnoreCase("passed"))
                                SetTextColor(hdc, (COLORREF) passColor);
                        else
                                SetTextColor(hdc, (COLORREF) failColor);
                        DrawText(hdc, pass, pass.length(), &crt, 
                                DT_SINGLELINE | DT_TOP | DT_RIGHT);
                }
        }

        } catch(...) {
                FillRect(hdc, &rt, bgColor);
                crt.top = topMargin+10;
                crt.bottom = crt.top + lheight;
                str = "Error during paint...";
                DrawText(hdc, str, str.length(), &crt, 
                        DT_SINGLELINE | DT_TOP | DT_LEFT | DT_TABSTOP);
        }

        return true;
}

---