title: VS 2013 errorC3861 PeekMessage etc and errorC2065 WNDCLASSEX
body: <p>I am attempting a new user graphics tutorial but I am very stuck. I am a very new programmer...I was under the impression that most of these definitions would be included in  I included. My message handler is missing an identifier 'DefWindowProcess', WINDCLASSEX is also not being identified, GetModuleHandle function, PeekMessage/TranslateMessage etc. The Microsoft dev center says that all these definitions should be in windows.h.</p>
  
  <pre><code>#ifndef _SYSTEMCLASS_H_
  #define _SYSTEMCLASS_H_
  
  #define WIN32_LEAN_AND_MEAN
  
  #include &lt;windows.h&gt;
  
  #include "inputclass.h"
  #include "graphicsclass.h"
  
  
  class SystemClass
  {
  public:
  SystemClass();
  SystemClass(const SystemClass&amp;);
  ~SystemClass();
  
  bool Initialize();
  void Shutdown();
  void Run();
  
  LRESULT CALLBACK MessageHandler(HWND, UINT, WPARAM, LPARAM);
  
  private:
  bool Frame();
  void InitializeWindows(int&amp;, int&amp;);
  void ShutdownWindows();
  
  private:
  LPCWSTR m_applicationName;
  HINSTANCE m_hinstance;
  HWND m_hwnd;
  
  InputClass* m_Input;
  GraphicsClass* m_Graphics;
  
  };
  
  static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
  
  static SystemClass* ApplicationHandle = 0;
  
  #endif
  </code></pre>
  
  <p>my systemclass.cpp is as follows</p>
  
  <pre><code>#include "pch.h"
  #include "systemclass.h"
  
  SystemClass::SystemClass()
  {
  m_Input = 0;
  m_Graphics = 0;
  }
  
  
  bool SystemClass::Initialize()
  {
  int screenWidth, screenHeight;
  bool result;
  
  screenWidth = 0;
  screenHeight = 0;
  
  // Initialize the windows api.
  InitializeWindows(screenWidth, screenHeight);
  
  m_Input = new InputClass;
  if (!m_Input)
  {
      return false;
  }
  
  // Initialize the input object.
  m_Input-&gt;Initialize();
  
  // Create the graphics object.  This object will handle rendering all the graphics for this application.
  m_Graphics = new GraphicsClass;
  if (!m_Graphics)
  {
      return false;
  }
  
  // Initialize the graphics object.
  result = m_Graphics-&gt;Initialize(screenWidth, screenHeight, m_hwnd);
  if (!result)
  {
      return false;
  }
  
  return true;
  }
  
  
  void SystemClass::Shutdown()
  {
  // Release the graphics object.
  if (m_Graphics)
  {
      m_Graphics-&gt;Shutdown();
      delete m_Graphics;
      m_Graphics = 0;
  }
  
  // Release the input object.
  if (m_Input)
  {
      delete m_Input;
      m_Input = 0;
  }
  
  // Shutdown the window.
  ShutdownWindows();
  
  return;
  }
  
  
  void SystemClass::Run()
  {
  MSG msg;
  bool done, result;
  
  
  // Initialize the message structure.
  ZeroMemory(&amp;msg, sizeof(MSG));
  
  // Loop until there is a quit message from the window or the user.
  done = false;
  while (!done)
  {
      // Handle the windows messages.
      if ( PeekMessage(&amp;msg, NULL, 0, 0, PM_REMOVE))
      {
          TranslateMessage(&amp;msg);
          DispatchMessage(&amp;msg);
      }
  
      // If windows signals to end the application then exit out.
      if (msg.message == WM_QUIT)
      {
          done = true;
      }
      else
      {
          // Otherwise do the frame processing.
          result = Frame();
          if (!result)
          {
              done = true;
          }
      }
  
  }
  
  return;
  }
  
  
  bool SystemClass::Frame()
  {
  bool result;
  
  
  // Check if the user pressed escape and wants to exit the application.
  if (m_Input-&gt;IsKeyDown(VK_ESCAPE))
  {
      return false;
  }
  
  // Do the frame processing for the graphics object.
  result = m_Graphics-&gt;Frame();
  if (!result)
  {
      return false;
  }
  
  return true;
  }
  
  
  LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM   wparam, LPARAM lparam)
  {
  switch (umsg)
  {
      // Check if a key has been pressed on the keyboard.
  case WM_KEYDOWN:
  {
  
      m_Input-&gt;KeyDown((unsigned int)wparam);
      return 0;
  }
  
  // Check if a key has been released on the keyboard.
  case WM_KEYUP:
  {
      m_Input-&gt;KeyUp((unsigned int)wparam);
      return 0;
  }
  
  default:
  {
      return DefWindowProc(hwnd, umsg, wparam, lparam);
  }
  }
  }
  
  
  void SystemClass::InitializeWindows(int&amp; screenWidth, int&amp; screenHeight)
  {
  WNDCLASSEX wc; //THIS IS THE PROBLEM
  DEVMODE dmScreenSettings;
  int posX, posY;
  
  
  // Get an external pointer to this object.  
  ApplicationHandle = this;
  
  // Get the instance of this application.
  m_hinstance = GetModuleHandle(NULL);
  
  // Give the application a name.
  m_applicationName = L"Engine";
  
  // Setup the windows class with default settings.
  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  wc.lpfnWndProc = WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = m_hinstance;
  wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
  wc.hIconSm = wc.hIcon;
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  wc.lpszMenuName = NULL;
  wc.lpszClassName = m_applicationName;
  wc.cbSize = sizeof(WNDCLASSEX);
  
  // Register the window class.
  RegisterClassEx(&amp;wc);
  
  // Determine the resolution of the clients desktop screen.
  screenWidth = GetSystemMetrics(SM_CXSCREEN);
  screenHeight = GetSystemMetrics(SM_CYSCREEN);
  
      if (FULL_SCREEN)
  {
              memset(&amp;dmScreenSettings, 0, sizeof(dmScreenSettings));
      dmScreenSettings.dmSize = sizeof(dmScreenSettings);
      dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth;
      dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
      dmScreenSettings.dmBitsPerPel = 32;
      dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
  
      // Change the display settings to full screen.
      ChangeDisplaySettings(&amp;dmScreenSettings, CDS_FULLSCREEN);
  
      // Set the position of the window to the top left corner.
      posX = posY = 0;
  }
  else
  {
      // If windowed then set it to 800x600 resolution.
      screenWidth = 800;
      screenHeight = 600;
  
      // Place the window in the middle of the screen.
      posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2;
      posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
  }
  
  // Create the window with the screen settings and get the handle to it.
  m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName,
      WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
      posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL);
  
  // Bring the window up on the screen and set it as main focus.
  ShowWindow(m_hwnd, SW_SHOW);
  SetForegroundWindow(m_hwnd);
  SetFocus(m_hwnd);
  
  // Hide the mouse cursor.
  ShowCursor(false);
  
  return;
  }
  
  
  void SystemClass::ShutdownWindows()
  {
  // Show the mouse cursor.
  ShowCursor(true);
  
  // Fix the display settings if leaving full screen mode.
  if (FULL_SCREEN)
  {
      ChangeDisplaySettings(NULL, 0);
  }
  
  // Remove the window.
  DestroyWindow(m_hwnd);
  m_hwnd = NULL;
  
  // Remove the application instance.
  UnregisterClass(m_applicationName, m_hinstance);
  m_hinstance = NULL;
  
  // Release the pointer to this class.
  ApplicationHandle = NULL;
  
  return;
  }
  
  
  LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
  {
  switch (umessage)
  {
      // Check if the window is being destroyed.
  case WM_DESTROY:
  {
      PostQuitMessage(0);
      return 0;
  }
  
  // Check if the window is being closed.
  case WM_CLOSE:
  {
      PostQuitMessage(0);
      return 0;
  }
  
  // All other messages pass to the message handler in the system class.
  default:
  {
      return ApplicationHandle-&gt;MessageHandler(hwnd, umessage, wparam, lparam);
  }
  }
  }
  </code></pre>