C++

Forum

 
how to make next page function

IDIR YACINE (3)
I have WndProc which is the main window class and there is another class which is Page2

how can i possibly change the main class from WndProc to Page2 ? as if i am exploring a book

this is the current code *a test one*
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
#include <windows.h>
#include "resource.h"

const char g_szClassName[] = "myWindowClass";

BOOL CALLBACK Page2(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{
	switch(Message)
	{
	
	case WM_PAINT:{

           hdc = BeginPaint(hwnd, &ps);

           DrawText(hdc, TEXT("Hello, Parent Window"), -1, &rect,
                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);

	  EndPaint(hwnd, &ps);

     }
     break;

	
	
		default:
			return DefWindowProc(hwnd, Message, wParam, lParam);
	}
	return 0;
}

//-----------------------------------------------------------------------------------------------------------------------------------------

//--------------------------------------------------MAIN WINDOW----------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{

case WM_CREATE :
    {
    
    }
 
				break;
//-----------------------------------------------------------------------------------
case WM_PAINT:{

           hdc = BeginPaint(hwnd, &ps);

           DrawText(hdc, TEXT("Hello, Parent Window"), -1, &rect,
                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);

	  EndPaint(hwnd, &ps);

     }
     break;

//-------------------------------------------------------------------------------------------
		case WM_CLOSE:
			DestroyWindow(hwnd);
		break;
		case WM_DESTROY:
			PostQuitMessage(0);
		break;
		default:
			return DefWindowProc(hwnd, msg, wParam, lParam);
	}
	return 0;
}
//------------------------------------------------------------------------



//-----------------------------------Window Creation-----------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX wc;
	HWND hwnd;
	MSG Msg;
	WPARAM wParam;

	//Step 1: Registering the Window Class
	wc.cbSize		 = sizeof(WNDCLASSEX);
	wc.style		 = 0;
	wc.lpfnWndProc	 = WndProc;
	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hInstance	 = hInstance;
	wc.hIcon		 = LoadIcon(NULL, IDI_APPLICATION);
	wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+5);
	wc.lpszMenuName  = MAKEINTRESOURCE(IDR_MYMENU);
	wc.lpszClassName = g_szClassName;
	wc.hIconSm		 = LoadIcon(NULL, IDI_APPLICATION);

	if(!RegisterClassEx(&wc))
	{
		MessageBox(NULL, "Window Registration Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	// Step 2: Creating the Window
	hwnd = CreateWindowEx(
		WS_EX_CLIENTEDGE,
		g_szClassName,
		"The title of my window",
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, 240, 120,
		NULL, NULL, hInstance, NULL);

	if(hwnd == NULL)
	{
		MessageBox(NULL, "Window Creation Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	ShowWindow(hwnd, nCmdShow);
	UpdateWindow(hwnd);

	// Step 3: The Message Loop
	while(GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return Msg.wParam;
}
Last edited on
freddie1 (1838)
The SetClassLongPtr() using the GCLP_WNDPROC parameter will allow you to change the Window Procedure for a Window Class. However, I have never attempted to do what you wish to do, and my instincts tell me not to attempt that. SetClassLongPtr() is usually used for subclassing windows, which is a bit different from what you wish to do.

I'd recommend going about it a different way. I'd create a "Book" Window Class and save each page to memory or disk, and render them in the Book Window as needed. Just my opinion.
IDIR YACINE (3)
is there any avaible samples for that ? i am still new for this
freddie1 (1838)
Probably not. But I'll post a compilable/runnable example to get you started a bit later (a few hours). In the meantime, think about this...

You can create as many windows of a Window Class as you want. In other words, there is a one to many relationship between a Window Class and instantiated windows of that class (think of your pages).
freddie1 (1838)
The way I would code a project to display pages of a book would be to create a main or master Form/Window/Dialog based on a Main Window Class.

In the WM_CREATE handler code for this main window class (Constructor of the class) I’d register a “DisplayPage” class whose purpose was to display a page of a book. There would be some kind of user interface control on the main form which allowed the user to choose which page he/she wanted to view, i.e., a combo box or something.

Here is a link to some code and tutorials I’ve provided that should give you some ideas on handling multiple windows/forms/dialogs and their relations with Window Classes…

Multiple Forms
http://www.jose.it-berater.org/smfforum/index.php?topic=3392.0

And here is a link to a tutorial on the way I structure my code using function pointers instead of the typical switch construct of Window Procedures (my way is better)…

Function Pointers
http://www.jose.it-berater.org/smfforum/index.php?topic=3391.0

Here is a full compilable project showing multiple forms. In your case take particular note of Form3…
freddie1 (1838)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
#ifndef UNICODE           // 13,824 bytes with MinGW 4.4.1
   #define UNICODE
#endif
#ifndef _UNICODE
   #define _UNICODE
#endif
//Main.cpp                //Program displays a main Form/Window/Dialog With Three Buttons on it
#include <windows.h>      //to simulate a program started from a main Form with three modules/
#include <tchar.h>        //options/modalities within which it operates.  When you click the top
#include <stdio.h>        //button a new Form/Window/Dialog is created with CreateWindow() of
#include "Main.h"         //the "Form1" Window Class, and in the WM_CREATE handler of this new
#include "Form1.h"        //window it disables the main form with the three buttons and therefore
#include "Form2.h"        //is an example of a modal dialog.  When you dismiss this modal dialog
#include "Form3.h"        //and click on Button/Option #2 on the Main Form, a CreateWindow() call
                          //creates a window of "Form2" Window Class, and in the WM_CREATE handler

long fnWndProc_OnCreate(WndEventArgs& Wea)  //for this window it hides or makes invisible the main
{                                           //window.  After dismssing this window you'll find that
 DWORD dwStyle=WS_CHILD|WS_VISIBLE;         //you can click on the Option #3 button as many times as
 TCHAR szClassName[16];                     //you like because the window-form-dialog it creates neither
 WNDCLASSEX wc;                             //disables nor makes invisible the main window.  Further
 HWND hCtl;                                 //note that these Option #3 windows can be interacted with
                                            //irregardless of what ever is going on with the other windows.
 Wea.hIns=((LPCREATESTRUCT)Wea.lParam)->hInstance;
 hCtl=CreateWindow(_T("button"),_T("Option #1"),dwStyle,65,15,120,25,Wea.hWnd,(HMENU)IDC_BUTTON_FORM1,Wea.hIns,0);
 hCtl=CreateWindow(_T("button"),_T("Option #2"),dwStyle,65,55,120,25,Wea.hWnd,(HMENU)IDC_BUTTON_FORM2,Wea.hIns,0);
 hCtl=CreateWindow(_T("button"),_T("Option #3"),dwStyle,65,95,120,25,Wea.hWnd,(HMENU)IDC_BUTTON_FORM3,Wea.hIns,0);

 //Register Window Classes For Form1, Form2 and Form3
 wc.cbSize=sizeof(WNDCLASSEX),                            wc.style=CS_HREDRAW | CS_VREDRAW;
 wc.cbClsExtra=0,                                         wc.cbWndExtra=0;
 wc.hInstance=Wea.hIns,                                  wc.hIcon=LoadIcon(NULL, IDI_APPLICATION);
 wc.hIconSm=0,                                            wc.hCursor=LoadCursor(NULL, IDC_ARROW);
 wc.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH),    wc.lpszMenuName=NULL;
 _tcscpy(szClassName,_T("Form1")),                        wc.lpszClassName=szClassName;
 wc.lpfnWndProc=fnForm1_WndProc;
 RegisterClassEx(&wc);

 _tcscpy(szClassName,_T("Form2"));
 wc.lpfnWndProc=fnForm2_WndProc;
 wc.lpszClassName=szClassName;              //Note that a WM_CREATE call is akin to a constructor call in typical
 RegisterClassEx(&wc);                      //C++ class architecture.  When you receive this call/message Windows
                                            //has finished doing what it needs to support the Window object, and
 _tcscpy(szClassName,_T("Form3"));          //is 'passing the ball' to you.  In my apps with multiple windows I
 wc.lpszClassName=szClassName;              //typically use the WM_CREATE handler to register any window classes
 wc.lpfnWndProc=fnForm3_WndProc;            //I need in the app, so that I can make CreateWindow() calls when I
 RegisterClassEx(&wc);                      //need to instantiate a window of some type.

 return 0;
}


long btnForm1_Click(WndEventArgs& Wea)
{
 HWND hWnd;

 hWnd=CreateWindow(_T("Form1"),_T("Form1"),WS_OVERLAPPEDWINDOW,50,25,310,185,Wea.hWnd,(HMENU)0,GetModuleHandle(0),Wea.hWnd);
 ShowWindow(hWnd,SW_SHOWNORMAL);
 UpdateWindow(hWnd);

 return 0;
}


long btnForm2_Click(WndEventArgs& Wea)
{
 HWND hWnd;

 hWnd=CreateWindow(_T("Form2"),_T("Form2"),WS_OVERLAPPEDWINDOW,200,250,310,185,Wea.hWnd,(HMENU)0,GetModuleHandle(0),Wea.hWnd);
 ShowWindow(hWnd,SW_SHOWNORMAL);
 UpdateWindow(hWnd);

 return 0;
}


long btnForm3_Click(WndEventArgs& Wea)
{
 HWND hWnd;

 hWnd=CreateWindow(_T("Form3"),_T("Form3"),WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,300,260,0,(HMENU)0,GetModuleHandle(0),Wea.hWnd);
 ShowWindow(hWnd,SW_SHOWNORMAL);
 UpdateWindow(hWnd);

 return 0;
}


long fnWndProc_OnCommand(WndEventArgs& Wea)
{
 switch(LOWORD(Wea.wParam))
 {
    case IDC_BUTTON_FORM1:
      return btnForm1_Click(Wea);
    case IDC_BUTTON_FORM2:
      return btnForm2_Click(Wea);
    case IDC_BUTTON_FORM3:
      return btnForm3_Click(Wea);
 }

 return 0;
}


long fnWndProc_OnClose(WndEventArgs& Wea)  //Search And Destroy Mission For Any Form3
{                                           //Windows Hanging Around.
 HWND hForm;

 do
 {
  hForm=FindWindow(_T("Form3"),_T("Form3"));
  if(hForm)
     SendMessage(hForm,WM_CLOSE,0,0);
  else
     break;
 }while(TRUE);
 DestroyWindow(Wea.hWnd);
 PostQuitMessage(0);

 return 0;
}


LRESULT CALLBACK fnWndProc(HWND hwnd, unsigned int msg, WPARAM wParam,LPARAM lParam)
{
 WndEventArgs Wea;

 for(unsigned int i=0; i<dim(EventHandler); i++)
 {
     if(EventHandler[i].iMsg==msg)
     {
        Wea.hWnd=hwnd, Wea.lParam=lParam, Wea.wParam=wParam;
        return (*EventHandler[i].fnPtr)(Wea);
     }
 }

 return (DefWindowProc(hwnd, msg, wParam, lParam));
}


int WINAPI WinMain(HINSTANCE hIns, HINSTANCE hPrevIns, LPSTR lpszArgument, int iShow)
{
 TCHAR szClassName[]=_T("Multiple Forms");
 WNDCLASSEX wc;
 MSG messages;
 HWND hWnd;

 wc.lpszClassName=szClassName;                wc.lpfnWndProc=fnWndProc;
 wc.cbSize=sizeof (WNDCLASSEX);               wc.style=CS_DBLCLKS;
 wc.hIcon=LoadIcon(NULL,IDI_APPLICATION);     wc.hInstance=hIns;
 wc.hIconSm=LoadIcon(NULL, IDI_APPLICATION);  wc.hCursor=LoadCursor(NULL,IDC_ARROW);
 wc.hbrBackground=(HBRUSH)COLOR_BTNSHADOW;    wc.cbWndExtra=0;
 wc.lpszMenuName=NULL;                        wc.cbClsExtra=0;
 RegisterClassEx(&wc);
 hWnd=CreateWindowEx(0,szClassName,szClassName,WS_OVERLAPPEDWINDOW,250,500,260,170,HWND_DESKTOP,0,hIns,0);
 ShowWindow(hWnd,iShow);
 while(GetMessage(&messages,NULL,0,0))
 {
    TranslateMessage(&messages);
    DispatchMessage(&messages);
 }

 return messages.wParam;
}


continued...
Last edited on
freddie1 (1838)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
//Main.h
#ifndef MAIN_H
#define MAIN_H
#define dim(x)             (sizeof(x) / sizeof(x[0]))
#define IDC_BUTTON_FORM1   1600
#define IDC_BUTTON_FORM2   1605
#define IDC_BUTTON_FORM3   1610

typedef struct             WindowsEventArguments
{
 HWND                      hWnd;
 WPARAM                    wParam;
 LPARAM                    lParam;
 HINSTANCE                 hIns;
}WndEventArgs;

struct EVENTHANDLER
{
 unsigned int              iMsg;
 LRESULT                   (*fnPtr)(WndEventArgs&);
};

LRESULT fnWndProc_OnCreate    (WndEventArgs& Wea);  //We need foreward declarations of
LRESULT fnWndProc_OnCommand   (WndEventArgs& Wea);  //the various functions in a main
LRESULT fnWndProc_OnClose     (WndEventArgs& Wea);  //header file so that the event
                                                    //handlers can be attached below.
LRESULT fnForm1_OnCreate      (WndEventArgs&);
LRESULT fnForm1_OnPaint       (WndEventArgs&);
LRESULT fnForm1_OnClose       (WndEventArgs&);

LRESULT fnForm2_OnCreate      (WndEventArgs&);
LRESULT fnForm2_OnPaint       (WndEventArgs&);
LRESULT fnForm2_OnClose       (WndEventArgs&);

LRESULT fnForm3_OnCreate      (WndEventArgs&);
LRESULT fnForm3_OnPaint       (WndEventArgs&);
LRESULT fnForm3_OnClose       (WndEventArgs&);

const EVENTHANDLER         EventHandler[]=        //Since we foreward declared above
{                                                 //the various event handling functions
 {WM_CREATE,               fnWndProc_OnCreate},   //of the various forms, windows, dialogs
 {WM_COMMAND,              fnWndProc_OnCommand},  //above, we can fill out the fields of
 {WM_CLOSE,                fnWndProc_OnClose}     //our EVENTHANDLER structures for the
};                                                //various objects.

const EVENTHANDLER         Form1EventHandler[]=
{
 {WM_CREATE,               fnForm1_OnCreate},
 {WM_PAINT,                fnForm1_OnPaint},
 {WM_CLOSE,                fnForm1_OnClose}
};

const EVENTHANDLER         Form2EventHandler[]=
{
 {WM_CREATE,               fnForm2_OnCreate},
 {WM_PAINT,                fnForm2_OnPaint},
 {WM_CLOSE,                fnForm2_OnClose}
};

const EVENTHANDLER         Form3EventHandler[]=
{
 {WM_PAINT,                fnForm3_OnPaint},
 {WM_CLOSE,                fnForm3_OnClose}
};
#endif 


1
2
3
4
5
 
//Form1.h         //Needs to be included in Main.cpp because the WM_CREATE handler there
#ifndef FORM1_H   //references fnForm1_WndProc as the Window Procedure for the Form1 Class.
#define FORM1_H   //This would be needed to register the class.
LRESULT CALLBACK fnForm1_WndProc(HWND, unsigned int, WPARAM, LPARAM);
#endif 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
//Form1.cpp
#ifndef UNICODE
   #define UNICODE
#endif
#ifndef _UNICODE
   #define _UNICODE
#endif
#include  <Windows.h>
#include  <tchar.h>
#include  <stdio.h>
#include  "Form1.h"
#include  "Main.h"


LRESULT fnForm1_OnCreate(WndEventArgs& Wea)
{
 CREATESTRUCT* pCreateStruct=NULL;
 HWND hMain;

 pCreateStruct=(CREATESTRUCT*)Wea.lParam;
 hMain=(HWND)pCreateStruct->lpCreateParams;
 SetWindowLongPtr(Wea.hWnd,GWLP_USERDATA,(LONG_PTR)hMain);
 EnableWindow(hMain,FALSE);

 return 0;
}


LRESULT fnForm1_OnPaint(WndEventArgs& Wea)
{
 PAINTSTRUCT ps;
 HDC hDC;

 hDC=BeginPaint(Wea.hWnd,&ps);
 TextOut(hDC,0,0,_T("This Is Form1.  It Disables The Main"),36);
 TextOut(hDC,0,16,_T("Window, And That Makes It Modal.  Note"),38);
 TextOut(hDC,0,32,_T("That We Passed The Handle Of The Main"),37);
 TextOut(hDC,0,48,_T("Window In The Last Parameter Of The"),35);
 TextOut(hDC,0,64,_T("CreateWindow() Call, And Retrieved It In"),40);
 TextOut(hDC,0,80,_T("fnForm1_OnCreate().  We Then Stored It So"),41);
 TextOut(hDC,0,96,_T("We Could EnableWindow(TRUE) The Main"),36);
 TextOut(hDC,0,112,_T("Window When This Modal Form Is"),30);
 TextOut(hDC,0,128,_T("Dismissed."),10);
 EndPaint(Wea.hWnd,&ps);

 return 0;
}


LRESULT fnForm1_OnClose(WndEventArgs& Wea)
{
 HWND hMain;

 hMain=(HWND)GetWindowLongPtr(Wea.hWnd,GWLP_USERDATA);
 EnableWindow(hMain,TRUE);
 DestroyWindow(Wea.hWnd);
 return 0;
}


LRESULT CALLBACK fnForm1_WndProc(HWND hWnd, unsigned int msg, WPARAM wParam, LPARAM lParam)
{
 WndEventArgs Wea;

 for(unsigned int i=0; i<dim(Form1EventHandler); i++)
 {
     if(Form1EventHandler[i].iMsg==msg)
     {
        Wea.hWnd=hWnd, Wea.lParam=lParam, Wea.wParam=wParam;
        return (*Form1EventHandler[i].fnPtr)(Wea);
     }
 }

 return (DefWindowProc(hWnd, msg, wParam, lParam));
}


1
2
3
4
5
 
//Form2.h        //Needs to be included in Main.cpp because the WM_CREATE handler there
#ifndef FORM2_H  //references fnForm2_WndProc as the Window Procedure for the Form1 Class.
#define FORM2_H  //This would be needed to register the class.
LRESULT CALLBACK fnForm2_WndProc(HWND, unsigned int, WPARAM, LPARAM);
#endif 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
//Form2.cpp
#ifndef UNICODE
   #define UNICODE
#endif
#ifndef _UNICODE
   #define _UNICODE
#endif
#include  <Windows.h>
#include  <tchar.h>
#include  <stdio.h>
#include  "Main.h"
#include  "Form2.h"


LRESULT fnForm2_OnCreate(WndEventArgs& Wea)
{
 CREATESTRUCT* pCreateStruct=NULL;
 HWND hMain;

 pCreateStruct=(CREATESTRUCT*)Wea.lParam;
 hMain=(HWND)pCreateStruct->lpCreateParams;
 SetWindowLongPtr(Wea.hWnd,GWLP_USERDATA,(LONG_PTR)hMain);
 ShowWindow(hMain,SW_HIDE);

 return 0;
}


LRESULT fnForm2_OnPaint(WndEventArgs& Wea)
{
 PAINTSTRUCT ps;
 HDC hDC;

 hDC=BeginPaint(Wea.hWnd,&ps);
 TextOut(hDC,0,0,_T("This Is Form2.  It SW_HIDEs The Main"),36);
 TextOut(hDC,0,16,_T("Window, And SW_SHOWs It Upon Closing."),37);
 TextOut(hDC,0,32,_T("This Technique Can Be Used Similiarly"),37);
 TextOut(hDC,0,48,_T("To A Modal Dialog If It Isn't Necessary To"),42);
 TextOut(hDC,0,64,_T("View Simultaneously A Form Underneath The"),41);
 TextOut(hDC,0,80,_T("Dialog With Which You Can't Interact"),36);
 TextOut(hDC,0,96,_T("Anyway"),6);
 EndPaint(Wea.hWnd,&ps);

 return 0;
}


LRESULT fnForm2_OnClose(WndEventArgs& Wea)
{
 HWND hMain;

 hMain=(HWND)GetWindowLongPtr(Wea.hWnd,GWLP_USERDATA);
 EnableWindow(hMain,TRUE);
 DestroyWindow(Wea.hWnd);
 ShowWindow(hMain,TRUE);

 return 0;
}


LRESULT CALLBACK fnForm2_WndProc(HWND hWnd, unsigned int msg, WPARAM wParam, LPARAM lParam)
{
 WndEventArgs Wea;

 for(unsigned int i=0; i<dim(Form2EventHandler); i++)
 {
     if(Form2EventHandler[i].iMsg==msg)
     {
        Wea.hWnd=hWnd, Wea.lParam=lParam, Wea.wParam=wParam;
        return (*Form2EventHandler[i].fnPtr)(Wea);
     }
 }

 return (DefWindowProc(hWnd, msg, wParam, lParam));
}

freddie1 (1838)
1
2
3
4
5
 
//Form3.h        //Needs to be included in Main.cpp because the WM_CREATE handler there
#ifndef FORM3_H  //references fnForm3_WndProc as the Window Procedure for the Form1 Class.
#define FORM3_H  //This would be needed to register the class.
LRESULT CALLBACK fnForm3_WndProc(HWND, unsigned int, WPARAM, LPARAM);
#endif 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
//Form3.cpp
#ifndef UNICODE
   #define UNICODE
#endif
#ifndef _UNICODE
   #define _UNICODE
#endif
#include  <Windows.h>
#include  <tchar.h>
#include  <stdio.h>
#include  "Main.h"
#include  "Form3.h"


LRESULT fnForm3_OnPaint(WndEventArgs& Wea)
{
 PAINTSTRUCT ps;
 HDC hDC;

 hDC=BeginPaint(Wea.hWnd,&ps);
 TextOut(hDC,0,0,_T("This Is Form3.  Not Only Does It Neither"),40);
 TextOut(hDC,0,16,_T("Hide Nor Disable The Main Window, But"),37);
 TextOut(hDC,0,32,_T("You'll Find That You Can Create As Many"),39);
 TextOut(hDC,0,48,_T("Of These As You Like By Continually"),35);
 TextOut(hDC,0,64,_T("Clicking The Bottom Button On The Main"),38);
 TextOut(hDC,0,80,_T("Form.  However, You'll Have To Drag One"),39);
 TextOut(hDC,0,96,_T("From On Top Of The Other Because They"),37);
 TextOut(hDC,0,112,_T("All Appear In The Same Location (I"),34);
 TextOut(hDC,0,128,_T("Changed That).  You May Further Note"),36);
 TextOut(hDC,0,144,_T("That Since These Windows Are Neither"),36);
 TextOut(hDC,0,160,_T("Disabled Nor Hidden At Any Time, You"),36);
 TextOut(hDC,0,176,_T("May Interact With Them Irregardless Of"),38);
 TextOut(hDC,0,192,_T("The State Of Form1 Or Form2. Pretty"),35);
 TextOut(hDC,0,208,_T("Neat, Don't You Think?"),22);
 EndPaint(Wea.hWnd,&ps);

 return 0;
}


LRESULT fnForm3_OnClose(WndEventArgs& Wea)
{
 HWND hMain;

 MessageBox
 (
  Wea.hWnd,
  _T("Good Way To Release Any Resources, Memory, etc., You May Have Allocated"),
  _T("Window Close Report!"),
  MB_OK
 );
 hMain=(HWND)GetWindowLongPtr(Wea.hWnd,GWLP_USERDATA);
 EnableWindow(hMain,TRUE);
 DestroyWindow(Wea.hWnd);
 ShowWindow(hMain,TRUE);

 return 0;
}


LRESULT CALLBACK fnForm3_WndProc(HWND hWnd, unsigned int msg, WPARAM wParam, LPARAM lParam)
{
 WndEventArgs Wea;

 for(unsigned int i=0; i<dim(Form3EventHandler); i++)
 {
     if(Form3EventHandler[i].iMsg==msg)
     {
        Wea.hWnd=hWnd, Wea.lParam=lParam, Wea.wParam=wParam;
        return (*Form3EventHandler[i].fnPtr)(Wea);
     }
 }

 return (DefWindowProc(hWnd, msg, wParam, lParam));
}


Note that the above code is C++ code and won't compile as C. It should compile with either GCC or MSVC. If not, let me know.
Last edited on
IDIR YACINE (3)
thanks,that trully helped me
Topic archived. No new replies allowed.