Thread: My Cardiograph

I have a PC that freezes often with no (known) reason. So I decided to write a program which shows something so I can see its working from a distance. I am new to Win32 and GDI+. So I need your comments. My known problem is that rectangle flickers. The good thing is that GDI+ is implemented in C++.

Code:

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

#include "stdafx.h"
#include "Cardiograph.h"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE hInst;        // current instance
HWND hWnd;               // I added this to keep track of window
TCHAR szTitle[MAX_LOADSTRING];      // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];        // the main window class name

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


int APIENTRY _tWinMain(HINSTANCE hInstance,
                                 HINSTANCE hPrevInstance,
                                 LPTSTR    lpCmdLine,
                                 int       nCmdShow)
{
      UNREFERENCED_PARAMETER(hPrevInstance);
      UNREFERENCED_PARAMETER(lpCmdLine);

      MSG msg;
      Gdiplus::GdiplusStartupInput gdiplusStartupInput;
      ULONG_PTR gdiplusToken;

      // Initialize GDI+.
      GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

      // Initialize global strings
      LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
      LoadString(hInstance, IDC_KARDIOGRAPH, szWindowClass, MAX_LOADSTRING);
      MyRegisterClass(hInstance);

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

      // Main message loop that is reorginized:
     do
      {
            PeekMessage(&msg, NULL,  0, 0, PM_REMOVE);
            DispatchMessage(&msg);
            Sleep(250);
            //I made hWnd global so I can use it here
            //I am not so sure about RDW flags
            RedrawWindow(hWnd, NULL, NULL, RDW_UPDATENOW|RDW_ERASE|RDW_INVALIDATE);
      }while (msg.message != WM_QUIT);

      Gdiplus::GdiplusShutdown(gdiplusToken);

      return (int) msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
      WNDCLASSEX wcex;

      wcex.cbSize = sizeof(WNDCLASSEX);

      wcex.style                  = CS_HREDRAW | CS_VREDRAW;
      wcex.lpfnWndProc      = WndProc;
      wcex.cbClsExtra         = 0;
      wcex.cbWndExtra       = 0;
      wcex.hInstance          = hInstance;
      wcex.hIcon                 = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_KARDIOGRAPH));
      wcex.hCursor             = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
      wcex.lpszMenuName  = NULL;
      wcex.lpszClassName  = szWindowClass;
      wcex.hIconSm            = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

      return RegisterClassEx(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, 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; I made it global but not sure if its a good practice

      hInst = hInstance; // Store instance handle in our global variable
      POINT pt = {0,0};
      HMONITOR hMonitor = MonitorFromPoint(pt,MONITOR_DEFAULTTOPRIMARY);
      MONITORINFO mi;
      mi.cbSize = sizeof(MONITORINFO);
      GetMonitorInfo(hMonitor, &mi);


      hWnd = CreateWindow(szWindowClass, szTitle, WS_BORDER|WS_SYSMENU ,
            mi.rcMonitor.right - 270, 0, 270, 80, NULL, NULL, hInstance, NULL);

      if (!hWnd) return FALSE;

      ShowWindow(hWnd, nCmdShow);
      return TRUE;
}

VOID OnPaint(HDC hdc,int a)
{
      Gdiplus::Graphics graphics(hdc);
      Gdiplus::SolidBrush sBrush(Gdiplus::Color(a,255,0,0));
      graphics.FillRectangle(&sBrush, Gdiplus::Rect(0,0,a+15,80));
}


//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu - No menu so code deleted!
//  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)
{
      PAINTSTRUCT ps;
      HDC hdc;

      switch (message)
      {
      case WM_PAINT:
            hdc = BeginPaint(hWnd, &ps);
            OnPaint(hdc,(GetTickCount()/10)%256); //DrawRect
            EndPaint(hWnd, &ps);
            break;
      case WM_DESTROY:
            PostQuitMessage(0);
            break;
      default:
            return DefWindowProc(hWnd, message, wParam, lParam);
      }
      return 0;
}