programminggallery.com

Collection classes in MFC

2007-10-05T23:43:00.000-07:00

MFC provides two kinds of collection classes

1. Template based collection classes
2. Non template collection classes

Collection classes are charectarised by the "shape" and type of it's elements. Shape means the way objects are organiced and stored in the collection. MFC provides three basic collection shapes. Lists , arrays and maps . You can select which one is using based on your particular requirement.

The following are the Description of the above items

1. Lists

The list class provides an ordered, nonindexed list of elements, implemented as a doubly linked list. A list has a "head" and a "tail," and adding or removing elements from the head or tail, or inserting or deleting elements in the middle, is very fast.

2. Arrays

The array class provides a dynamically sized, ordered, and integer-indexed array of objects.

3. Maps
a map is also known as a dictionaryA map is a collection that associates a key object with a value object.

The Search In the Maps are Fast and they are indexed by the key. While the Search inside the
Lists and arrays are slower .For inserting an element in list and maps it is fast and for array it is slower

List Classes and Opreation on The lists

CList is the main class that we can use to implement the list .

See the following egsample for how to implement a list for Insertion search and retreaving a string data

void main()
{
CList strlist;
// inserting the element to the list
for (int i = 0; i<=20; i++) { CString strelement; strelement.Format("Element at %d",i); strlist.AddTail(strelement); } // the elements in the list POSITION pos = strlist.GetHeadPosition(); while(pos != NULL)
{
cout strlist.GetAt(pos) endl;
strlist.GetNext(pos);
}

// Search the elementcout<<"Search for a string element" endl endl;CString strtosearch = "Element at 5";
pos = strlist.Find(strtosearch,NULL);
cout strlist.GetAt(pos) endl;

}

How to Create modal and Modeless Dialog using MFC and what is the difference

2007-09-27T00:54:00.000-07:00

Difference between Modal and Modless Dialog

In some discussion discussion boards i saw lot of questions regarding what is the difference between the modal dialog and modeless dialog boxes. as to my opinion modal dialog if once invoked it will not allow to access the parent window. but modeless dialog is will allow the user to access the parent window.

How to create a modal dialog

A modal dialog can easily created using the following steps.

Start your visual studio Editor 6

step 1

Select File->New
in the project tab select MFC appWizard(exe)
Give "DialogModalDemo" in the project name text box
Give OK

Step 2

Select single document
uncheck document/architecture support
click next

Step 3

Click Finish

Now you created the farameword for implementing or Modal and Modeless dialog

step 4

Now go to the Resource view and select the menu item on there.

Add a New Menu item as Dialog Demo to the main menu and also add tw2o sub menu item as
"Modal Dialog" and "Modeless Dialog"

step 5

Now press the Ctrl+R and add a new dialog Templete to the project

Rename the template id from IDD_DIALOG1 to IDD_MODAL_DIALOG

Now go to to the CMainFrame class and press Ctrl + W
add a handler for the ID_DIALOGDEMO_MODALDIALOG item

Now go to the CFrameWnd eader implementation file and add #include "ModalDialog.h" on there

now go to the handler CMainFrame::OnDialogdemoModaldialog() that we added and add the code on there

as following looks like

ModalDialog dlg;
dlg.DoModal();

Now run the application and Go to the Modal Dialog Menu and click it. Check weather it is working file. If not Please let me know.

How to Create Modless Dialog

Now i will explain how you can create a modeless dialog.

Go to the CmainFrame class and add a handler for the ID_DIALOGDEMO_MODELESSDIALOG menu item to the CMainFrame class. Next go to the
CMainFrame window class definition header file and decalre a variable of ModalDialog in the CMainFrame class as like following

ModalDialog modelessdialog;

Now go to the handler void CMainFrame::OnDialogdemoModelessdialog() that we have created befor and add the following code on there.

modelessdialog.Create(IDD_MODAL_DIALOG,this);
modelessdialog.ShowWindow(SW_SHOW);

Now run the application and check weather it is working for you.

Expecting your comments on thi article you can contact me at my mail id shinejos@gmail.com

implementing your application as Single instance.

2007-09-23T05:51:00.000-07:00

How to implement your application as Single instance.

Some times you need to create an application that your application is allowed to run only one instance in the entire operating system. There are a lot of ways that you can implement the single instance for your application. Here I am going to explain a methods that you can implement

Create a Mutes instance in the by a valid name in the InitInstance() function in the application class as like

HANDLE m_mutex = CreateMutex(NULL,false,"GuiThreadDemoApp");

if(m_mutex && GetLastError() == ERROR_ALREADY_EXISTS)
{

ReleaseMutex(m_mutex);
AfxMessageBox("Application already running",MB_ICONINFORMATION);
return false;

}

Expecting your comments

Multithreading in MFC

2007-09-09T03:15:00.000-07:00

Multithreading in MFC

Using MFC you can create two kinds of threads.

1. Worker threads or Generic Threads
2. User interface threads.

Worker threads

Worker threads or Generic Threads worker threads are using mainly for background tasks like long mathematical calculation or doing the time taking process that the user intervention is not needed MFC provides a Specific function to create the Worker threads using AfxBeginThread

Starting the thread

An MFC thread is started with a call to the function AfxBeginThread(). Here is the prototype of the AfxBefinThread()

CWinThread* AfxBeginThread(

AFX_THREADPROC pfnThreadProc,

LPVOID pParam,

int nPriority = THREAD_PRIORITY_NORMAL,

UINT nStackSize = 0,

DWORD dwCreateFlags = 0,

LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );

CWinThread* AfxBeginThread(

CRuntimeClass* pThreadClass,

int nPriority = THREAD_PRIORITY_NORMAL,

UINT nStackSize = 0,

DWORD dwCreateFlags = 0,

LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );

Parameters

pfnThreadProc Points to the controlling function for the worker thread. Cannot be NULL. This function must be declared as follows: UINT MyControllingFunction( LPVOID pParam );

pThreadClass The RUNTIME_CLASS of an object derived from CWinThread.
pParam Parameter to be passed to the controlling function as shown in the parameter to the function declaration in pfnThreadProc.

nPriority The desired priority of the thread. If 0, the same priority as the creating thread will be used. For a full list and description of the available priorities, see SetThreadPriority.

nStackSize Specifies the size in bytes of the stack for the new thread. If 0, the stack size defaults to the same size stack as the creating thread.

dwCreateFlags Specifies an additional flag that controls the creation of the thread. This flag can contain one of two values:

CREATE_SUSPENDED Start the thread with a suspend count of one. Use CREATE_SUSPENDED if you want to initialize any member data of the CWinThread object, such as m_bAutoDelete or any members of your derived class, before the thread starts running. Once your initialization is complete, use the CWinThread::ResumeThread to start the thread running. The thread will not execute until CWinThread::ResumeThread is called.
providing zero will Start the thread immediately after creation.

lpSecurityAttrs Points to a SECURITY_ATTRIBUTES structure that specifies the security attributes for the thread. If NULL, the same security attributes as the creating thread will be used. For more information on this structure, see the Platform SDK.

Return Value
Pointer to the newly created thread object.

Now let us See how we can create a WorkerThread using AfxBeginThread. the Worker threads functionality is incorporated into a static function. The prototype looks like

UINT MyThreadProc(LPVOID pParam);

following is a sample that using the worker thread using MFC

Create a Simple Dialog Based application using Application Wizard. Put a Button in the dialog and add the following code to the Dialog Template Header file

static UINT ThreadFun(LPVOID lparam);

add the corresponding implementation to the .Cpp file like

UINT CWorkerThreadDlg::ThreadFun(LPVOID lparam)
{

HWND m_hwnd = (HWND)lparam;
for(int i = 0; i<=2000;i++)
{
CString str;
str.Format("%d",i);
::SetWindowText(m_hwnd, str);
Sleep(1000);
}
return 1;
}

Add the following code to the click event of the Button you added to the Dialog template looks like

void CWorkerThreadDlg::OnButton1()
{
HWND m_hwn = this->m_hWnd;
CWinThread *thread1 = NULL;
thread1 = ::AfxBeginThread(ThreadFun,(LPVOID)m_hwn);
if(thread1->;m_hThread == NULL)
{
MessageBox("AfxBeginThread Failed to Create");
}
}

Now hit the F5 and find how it is working

Creating GUI threads or user interface threads using MFC

The secon kind of thread hat is provided by the MFC is User interface threads. The main advantage of the user interface threads over the worker threads is that it can imlement message maps and message handlers. If you want to create a user inerface thread you have to derive a class using CwinThread

To Create a GUI thread follow the following Steps

Create a Dialog Based application by Starting the Visual studio editor 6

1. Select File->Project Tab->Select MFC Application Wizard Exe
2. In the project name column Give "GuiThreadDemo" and click Next
3. Select the 'Dialog Based' option from the 2nd Wizard and click next and Click Finish

Now you have Created a Dialog Template for your Purpose. Next step is to create the GUI
Thread class for your purpose
4. Add a label to the dialog template and Rename its id as IDC_STATIC_CNTR

5. change the caption of the OK button to “Start Thread”

For Creating A GUI thread you need to create a Class that is derived from the CWinThread

6. Go to Insert->In the main Menu-> Insert->New Class
7. Insert a New class GuiThreadSample where choosing the class derived from CWinThread

8. Add the following members as public to the class GuiThreadSample

CDialog dlg;
bool exitthread;

9. Add a member function to the GuiThreadSample as

void GuiThreadSample::StartCounter()
{
for(int i = 0;i<=50;i++)
{
Sleep(100);
CString str;
str.Format("%d",i);
SetDlgItemText(dlg.m_hWnd,IDC_STATIC_CNTR,str);
if(exitthread == true)
break;
}
}

10. Add following to the GuiThreadSample constructor

exitthread = false;

11. and add the following to the destructor member function of GuiThreadSample

AfxMessageBox("Closed The Thread");

12. Add the following to the Run() member function

StartCounter();

13. Now go to the dialog class add add the following code on the OnOk Member function by douleclicking on the Ok button

void CGuiThreadDemoDlg::OnOK()
{
// TODO: Add extra validation here

CString strcaption;
GetDlgItemText(IDOK,strcaption);
if(strcaption == "Start Thread")
{
SetDlgItemText(IDOK,"Stop Thread");
threadwork = (GuiThreadSample *)AfxBeginThread(RUNTIME_CLASS(GuiThreadSample),THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED,0);

threadwork->dlg.m_hWnd = this->m_hWnd;
threadwork->ResumeThread();

if(threadwork == NULL)
{
MessageBox("Failed to Create the Thread");
}
// Creating The GUI Thread
}else
{
threadwork->exitthread = true;
if(!threadwork->PostThreadMessage(WM_QUIT,0,0))
{
AfxMessageBox("Failed to Post Message");
}
}
// CDialog::OnOK();
}

Now execute the application by hitting alt + F5 and see how the thread is working for you

any comments mail to me at shinejos@gmail.com

Multithreading in win32

2007-09-07T22:45:00.000-07:00

what is a thread or multithreading

multithreading is a specialized form of multitasking. Generally there are two kinds of multitasking. process based and thread based. A process is an essence one that is an application or program that is executed in an operating system. for example a word process or a notepad on your desktop is a process.

All process have at least one thread. But they can have more than one.So a multi thread application can have more than one path of executions concurrently. The main thread starts first and the main thread is creating child threads. so a thread that is designed properly will handle different logical units of it's functionality.

The main advantage of multithread is it helps you to write applications that will utilize the idle time is that is available in the application or it will increase the throughput of the application.

Creating and managing a thread

to use windows multithreading you must use '<'windows.h'>' .

To create a thread windows api provides CreateThread API.

HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);

where

lpThreadAttributes [in] Pointer to a SECURITY_ATTRIBUTES structure that determines whether the returned handle can be inherited by child processes. If lpThreadAttributes is NULL, the handle cannot be inherited.

The lpSecurityDescriptor member of the structure specifies a security descriptor for the new thread. If lpThreadAttributes is NULL, the thread gets a default security descriptor. The ACLs in the default security descriptor for a thread come from the primary or impersonation token of the creator.

dwStackSize [in] Initial size of the stack, in bytes. The system rounds this value to the nearest page. If this parameter is zero, the new thread uses the default size for the executable.

lpStartAddress [in] Pointer to the application-defined function to be executed by the thread and represents the starting address of the thread. For more information on the thread function, see ThreadProc.

lpParameter[in] Pointer to a variable to be passed to the thread.

dwCreationFlags [in] Flags that control the creation of the thread. If the CREATE_SUSPENDED flag is specified, the thread is created in a suspended state, and will not run until the ResumeThread function is called. If this value is zero, the thread runs immediately after creation.

If the STACK_SIZE_PARAM_IS_A_RESERVATION flag is specified, the dwStackSize parameter specifies the initial reserve size of the stack. Otherwise, dwStackSize specifies the commit size.

lpThreadId [out] Pointer to a variable that receives the thread identifier. If this parameter is NULL, the thread identifier is not returned.
Windows Me/98/95: This parameter may not be NULL.

Return Values

If the function succeeds, the return value is a handle to the new thread.
If the function fails, the return value is NULL. To get extended error information, call GetLastError.

Thread Function

Each thread of execution should start with a ThreadFunction that is passed to the lpStartAddress the prototype for the function is

DWORD WINAPI threadfunc(LPVOID param);

Arguements that you want to pass to the thread should pass to lpParameter of CreateThread()

Here is a sample application that will state how to use the Createthread

#include<windows.h>

#include<iostream.h>

#include<string.h>

DWORD WINAPI MyThread(LPVOID lparam)

{

cout<<"Printing the values that passed";

char lzparam[10];

strcpy(lzparam,(char*)lparam);

int len = strlen(lzparam);

for (int i = 0;i<=len;i++)

{

cout<<lzparam[i];

}

cout<<"\n\r";

return 1;

}

void main()

{

HANDLE handle1,handle2;

DWORD Generalthread;

char lparamtopass[10];

strcpy(lparamtopass,"fromfirst ");

handle1 = CreateThread(NULL,0,MyThread,&lparamtopass,0,&amp;amp;amp;amp;Generalthread);

if(handle1 == NULL)

{

cout<<"Error Creating the Thread 1";

return ;

}

WaitForSingleObject(handle1,INFINITE);

strcpy(lparamtopass,"fromsecond");

handle2 = CreateThread(NULL,0,MyThread,&lparamtopass,0,&amp;amp;amp;amp;Generalthread);

if(handle2 == NULL)

{

cout<<"Error Creating the Thread 2";

return ;

}

WaitForSingleObject(handle2,INFINITE);

}

Using a WaitForSingleObject API to wait for the first thread to be executed and then execute second thread. If the thread is failed to return the WaitForSingleObject will wait for a infinite time . If you want you can give the milliseconds that you want to wait like 1000 (1 second) .

Sending Message to Threads

2007-09-06T11:09:00.000-07:00

When a user want to send a message to a window postMessage or SendMessage is used but if you want to send a message to a Thread use PostThreadMessage

The PostThreadMessage API is posts a message to the message queue of a specified GUI thread.

The following is the prototype for the PostThreadMessage

BOOL PostThreadMessage ( DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam);

where the parameters

idThread [in] identifier of the thread to be the message posted
The function will fail if the thread is not a GUI Thread

Msg [in] Secify the message to me posted

wParam [in] Additional message specific information

lParam [in] Additional message specific information

return type

if the function call is suceeded the return type is non zero. otherwise it will be zero. for getting the error information use the GetLastError

SendMessage Vs PostMessage

2007-09-06T10:49:00.000-07:00

Usually in win32 for sending a message to a window is doing by using the messageing API's like SendMessage And PostMessage

The Sendmessage and postmessage works similer with same parameters . But they have a slight difference.

The prototype for the Sendmessage is

LRESULT SendMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

and for PostMessage is

BOOL PostMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

The difference is that when you send a message by using SendMessage thewindow procedure is called and the calling procedure will wait for the message to be processed and replied back. and the calling program or procedure will wait for it's completion and then only it will resume while the PostMessage will notwait for the completion of the process and it will return to the calling program immediatly.

So incase of the application is busy in processing a long procedure and hangs the application it is better to use PostMessage insted of the SendMessage. The usage of the SendMessage and PostMessage is depends upon your requirement

how to create a simple widow using MFC and Win32

2007-09-05T22:00:00.000-07:00

A simple MFC window Application

Introduction

Creating a Simple window or dialog application using VC++ 6.00 or 7.00 applications Wizard is quiet easy job. But if you Examine the code you find that a lot of Stuff inside that you not familiar and for a beginner he will not get any idea how the basic stuff will work.

Here i am going to explain how you can create a simple window without the help of Wizard. For simplicity I am using VC++ 6.00 Editor . Your machine must have installed the VC++ 6.0.

Start The VC++ Editor From your Programs And

The following window will pop up

Give ‘Simple Window’ in the project name box. And click ‘win32 Application’ from the project List and click OK. You can see the next dialog as shown below

now select 'An empty project' and click finishNow you have created the workspace named 'simple window' sucessfully.Next you have to add the Cpp files to the workspace. For adding the files to the workspace goto File->New and select the 'files' tab from the pop up dialog. select 'C++ Source file from the tab' and give 'Windowsource' in the as shown in the foollowing figure and click OK button

Now you have created all the necessaries to create a simple window.
Now we can move to the coding section open the Windowsource.cpp and decalre the following header

#include "afxwin.h"

The above decalration will afxwin.h contain all the decalarations and reference for accessing the MFC classes including the CFrameWnd and CWinApp

Write down the following code to the Windowsource.cpp

#include "afxwin.h"

class mywindow : public CFrameWnd

{

public :

mywindow()

{

Create(0,"Simple Window"); }

};

class myapplication : public CWinApp

{

public: int InitInstance()

{

mywindow *p = new mywindow;

p->ShowWindow(1);

m_pMainWnd = p;

return 1;

}

};myapplication a;

Before compiling you go to project->settings or click ALT + F7 .Now your code redy to compile.

Now Run the project by selecting Build->Execute Simple Window.exe or use Ctrl + F5
ow you can see the window on your desktop.

Try Your self see it working.