Win32API

But WinExec() is compatible with 16-bit Windows.

Applications should use the CreateProcess

function.http://msdn.microsoft.com/en-us/library/ms687393(VS.85).aspx

Win3.1 supports co-operative multi-tasking. Once a process

is given the control for execution, the other tasks have to

wait until the current has relinquished its execution.

WinNT is preemptive multi-tasking. A process can be stopped

in the middle if another process needs CPU cycle.

This is handled by the windows OS.

Should be LibMain in win3.1

Win32 refers to Microsoft 32 bit Windows API. Win32

Applications are programs which are built with the Win32

API.

It evolved like this

when u write a CLASS to reuse in a application, multiple

intances of the class exists with each instance of

application,

Next u want to avoid it so u make a class and put it in DLL

now only one instance exists though multiple instances of

applications exists

Applicatoin needs to be recompiled whenever Dll is

modified, SO came COM.

COM is independent component that internally handles

networking, resources etc, COM uses IDL to communicate to

different languages

A faik CString is a MFC class. You cannot use it in win32

application unless you set your application to use MFC

libraries. To use MFC in win32 application, go to project

settings and in general tab, set it to use MFC libraries in

shared DLL. Then you can include MFC framework files like

afxwin.h.

Java just uses object oriented principals but it is not purely object oriented , because int is a primitive data type in Java but not an object similarly all primitive data types a pure object oriented language should not support a non object oriented aspects

reateWindow() physically creates the Window in memory

based on the previousy registered WNDCLASS structure and

returns a vaild HANDLE for that Window

In OnInitDialog:

-----------------

1. Create CBitmap from the bitmap.

2. Create a memory DC (CDC)

3. Put the CBitmap into the memory DC (Use

CDC::SelectObject function).

In OnPaint:

------------

4. Get your dialog DC (CDialog::GetDC)

5. Do BitBlt or StretchBlt on dialog DC with memory DC as

source DC (this will paint the bitmap on your dialog).

6. Release dialog DC (ReleaseDC function)

ShowWindow(hwnd, SW_HIDE); // to hide window

ShowWindow(hwnd, SW_SHOW); // to show window

A faik CString is a MFC class. You cannot use it in win32

application unless you set your application to use MFC

libraries. To use MFC in win32 application, go to project

settings and in general tab, set it to use MFC libraries in

shared DLL. Then you can include MFC framework files like

afxwin.h.

It uses main three patterns,

Singleton pattern - Application object(CWinApp & its

derived classes)

Bridge pattern - Serialization

Observer patten - Document/View Architecture

If we dig deeper into the MFC classes, it may use some

other patterns also.

Win32 is a set of Windows APIs written in C and MFC is a

framework built arround Win32. All MFC functions internally

use Win32 APIs. And MFC is written in C++.

In MFC, the contents of a dialog are initialized if they are

associated with their corresponding data members. This is

done through "UpdateData(FALSE)" function. The control data

is transferred to the data members through "UpdateData(TRUE)".

In WIN32, the dialog data in controls can be initialized

during WM_INITDIALOG call. The control data can be updated

to the dialog members using apppropriate "SendMessage"

functions.

BOOL MoveWindow(

HWND hWnd, // handle to window

int X, // horizontal position

int Y, // vertical position

int nWidth, // width

int nHeight, // height

BOOL bRepaint // repaint option

);

This cud be used in the WM_PAINT event section and in

WM_INITDIALOG section.

WM_SIZE message is received by the window procedure when a

user resizes a window. In order to limite the size of a

window, you could handle the WM_SIZE message appropriately.

Invalidate() -- To repaint the entire client area

InvalidateRect() -- To repaint a specific portion of the

client area.

SendMessage is a blocking call. ie., when a SendMessage()

API is called from an application, the lines written after

this API call cannot be executed until the message is

processed and returned by the window procedure.

Whereas PostMessage() just posts the message into the

windows corresponding message queue and returns immediately

irrespective of the message is processed or not.

Pre emption is releasing the process in order to serve

another process to utilize the same resource. Context

switching is the transfer of resource from once process to

another process.

WM_QUIT message in the program message queue is posted.

This causes WinMain to drop out of message loop and exit

the runing application.