Jump to content

Like
0Likes
Dislike
Setting up a window


window hinstance windows return program title hwnd simple
Provides a basic Win32 framework.

4: Adsense

updated: 2/12/00

Notes:
This program creates a very simple window. It should look like a blank, white, with no title, no text, and default cursor/icons window. I set it up so that VK_ESCAPE (the escape button) will exit the window. I made this window because it give you a visual look at what you have created. I created it in VC++ 6.0 and I'm sure if I ran across a tutorial like this back when I was really new to windows programming it would help very much, I hope it help y'all. Good luck.

//////////////////////////////////////
// A Simple Window Tutorial

////////////////////////////
// By Jesse King
// 11/13/99
////////////

/////////////
// #includes
// You will use this for all of your Windows applications
#include <windows.h>

////////////
// #defines
#ifndef  WIN32_LEAN_AND_MEAN  	// This cleans out rarely used stuff
#define  WIN32_LEAN_AND_MEAN
#endif
#define  MAX_LOADSTRING  100 

///////////////////
// Global Variables
HINSTANCE  	hInst;                           		// the Instance
TCHAR      	szWindowClass[] = "I'M A TITLE!!!" ; 	// Title Bar

//////////////////////////////////////////////////
// Prototypes: beforehand declaration of functions
ATOM            	MyRegisterClass(HINSTANCE hInstance);
BOOL            	InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);

///////////////////////////////////////
// WinMain() is what applies everthing
int APIENTRY WinMain(HINSTANCE hInstance,
  HINSTANCE hPrevInstance,
  LPSTR lpCmdLine,
  int nCmdShow)
{
   MSG msg;

   /////////////////////////
   // Set up the windows class
   MyRegisterClass(hInstance);

   /////////////////////////
   // Create the window. If it doesn't work, return FALSE.
   if (!InitInstance (hInstance, nCmdShow)) 
  	return FALSE;

   ////////////////////////
   // This is a good place to use accelerations and whatnot,
   // you should load them in the program from the resources (the whatever.rc)
   ////////////////////////

   ////////////////////////
   // The main message loop is run under here,
   // it pretty much explains itself. It just gets and handelse messages.
   while (GetMessage(&msg, NULL, 0, 0)) 
   {
  	if (!TranslateAccelerator(msg.hwnd, 0, &msg)) 
  	{
 		TranslateMessage(&msg);
 		DispatchMessage(&msg);
  	}
   }

   return msg.wParam;
}

/////////////////////
// the function MyRegisterClass()
// this is used to create a WIN32 application,
// if you have Microsoft Visual C++ and the documentation
// it explains this really well. All the wc.xxxxxxx are variables in the
// WNDCLASSEX structure, it took me a while to figure it out, just look at 
// help files and tutorials, it's easier then it seems.
ATOM MyRegisterClass(HINSTANCE hInstance)
{
   //////////////
   // This allows you to use the structure
   // WNDCLASSEX as wc.whatevervariable
   WNDCLASSEX wc ;
   wc.cbSize 		= sizeof(WNDCLASSEX) ;
   //////////////
   // Class Style described here.
   wc.style    	= CS_HREDRAW | CS_VREDRAW ;
   //////////////
   // This is the functions that is called when a message is sent to the window (like a PAINT msg).
   wc.lpfnWndProc    	= (WNDPROC)WndProc ;
   ///////////////
   // This is a simple window, so this isn't needed.
   wc.cbClsExtra    	= 0 ;
   ///////////////
   // Same as above
   wc.cbWndExtra    	= 0 ;
   ///////////////
   // The instance of the window.
   wc.hInstance    	= hInstance ;
   ///////////////
   // A declaration of the icon, in the resources, or from file, but
   // this one is from the resources.
   wc.hIcon    	= 0 ;
   ///////////////
   // Loads the pointer, or cursor your window application will use
   wc.hCursor    	= 0 ;
   ///////////////
   // The background color can change through color_window+whatever
   wc.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1) ;
   ///////////////
   // Name of the menu system, but we don't have a menu here
   // because this is a simple window.
   wc.lpszMenuName	= 0 ;
   ///////////////
   // The title of the used windows classes, or
   // the title of the program.
   wc.lpszClassName	= szWindowClass ;
   ///////////////
   // This is the small icon, like when your windows options is to list all the
   // icons, then it will display the small icons, this is the declaration of the 
   // icon used for this occasion
   wc.hIconSm    	= 0 ;

   ///////////////
   // This returns a registered structure,
   // which is the windows classes, to the window.
   return RegisterClassEx(&wc) ;
}

/////////////////////
// the function InitInstance(HANDLE, int)
// creates the main window or parent window, and 
// describes the style (such as WS_OVERLAPPEDWINDOW, WS means 
// Windows Style) and many other characteristics of the 
// Parent Window.

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd ;
   hInst = hInstance ;          	// Store instance handle on global hInst
   hWnd = CreateWindow( szWindowClass,
                    	0, 
                    	WS_OVERLAPPEDWINDOW,
                    	CW_USEDEFAULT,
                    	0, 
                    	CW_USEDEFAULT, 
                    	0, 
                    	0, 
                    	0, 
                    	hInstance, 
                    	0) ;

   /////////////////////////
   // If the window isn't made right
   // it won't work...
   if (!hWnd)
   {
  	return FALSE ;
   }
   //////////////////////////
   // expains itself, nCmdShow 
   // means that its a small window
   // not maximized
   ShowWindow(hWnd, nCmdShow) ;
   UpdateWindow(hWnd) ;

   return TRUE ;
}

////////////////////////////////////////////////////
// The function WndProc(HWND, unsigned, WORD, LONG)
// processes the window, it does whatever you want 
// the window to do.
//
// WndProc()'s purpose is processing messages for the main window.
//
// ********************* BELOW ************************
// 
//
// case**WM_MESSAGE	- Use the keyboard for the exiting the program,
// I set it up as ESCAPE Exits the program (or VK_ESCAPE does).
// 
// case**WM_PAINT    	- Paints the main window, you can blit bitmaps
// and such, but this is a simple window, so I painted it like
// that
//
// case**WM_DESTROY	- Destroys the window when you push
// the X on the upper right of the window
////////////////////////////////////////////////////

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   PAINTSTRUCT ps;
   HDC     		hdc;
    
   LoadString(hInst, 0, 0, MAX_LOADSTRING) ;
   //////////////////////////
   // This is a nice simple loop
   // that lets you input and get
   // output to and from the window
   switch (message) 
   {
  	case WM_KEYDOWN:
 		switch(wParam)
 		{
        	case VK_ESCAPE:
       		PostQuitMessage(0) ;
       		break ;
 		}

  	case WM_PAINT:
 		hdc = BeginPaint(hWnd, &ps) ;
 		RECT rt ;
 		GetClientRect(hWnd, &rt) ;
 		EndPaint(hWnd, &ps) ;
 		break ;

  	case WM_DESTROY:
 		PostQuitMessage(1) ;
 		break ;

  	default:
 		return DefWindowProc(hWnd, message, wParam, lParam) ;
   }
   ////////////////////////////////
   // Return so it doesn't complain
   return 0 ;
}

0 Comments

Note: GameDev.net moderates article comments.