Windows Internal

Dynamical heap allocation

2010-01-22T06:02:00.000-08:00

#include <windows.h>
#include <iostream.h>

int main()
{
 HANDLE hHeap; // handle to the heap
 int *a = NULL; // pointer to array
 int h_size = 4096; // size of the heap
 int a_size = 2048; // size of array
 
 hHeap = HeapCreate(HEAP_NO_SERIALIZE, h_size, h_size); // create heap dynamically
 a = (int*)HeapAlloc(hHeap, NULL, a_size); // heap allocation
 cout << "a[10] = " << a[10] << endl;
 HeapFree(hHeap, NULL, a); // free memory from heap
 HeapDestroy(hHeap); // destroy the heap
 return 0;
}

HEAP_NO_SERIALIZE - allow parallel access to the heap.

Allocation and Free memory from Heap

2010-01-22T03:16:00.000-08:00

#include <windows.h>
#include <iostream.h>

int main()
{
  HANDLE hHeap;
  int *a = NULL; // pointer to array
  int size = 100;
  hHeap = GetProcessHeap(); // receive handle of the process's heap
  a = (int*)HeapAlloc(hHeap, HEAP_ZERO_MEMORY, size *sizeof(int));
  cout << " a[10] = " << a[10] << endl;
  HeapFree(hHeap, NULL, a);
  return 0;
}

Functions to remember:

LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)

I think the parameters are straight-forward here.

Reverse

2009-10-29T12:53:00.000-07:00

REVERSE is a Windows with Multimedia sample application that illustrates how to use the low-level waveform playback services. It also shows how to use the multimedia file I/O services to read data from a WAVE file.

reverse.h:

/* reverse.h - Header file for REVERSE sample application.
*/


/*
*  Constants
*/

// Child window identifiers
#define IDE_NAME        200
#define IDB_PLAY        201
#define IDB_QUIT        202

// Window Position and size definitions
#define WMAIN_DX        207
#define WMAIN_DY        120
#define NAME_DX         180
#define NAME_DY         30
#define NAME_X          10
#define NAME_Y          10
#define PLAY_DX         85
#define PLAY_DY         35
#define PLAY_X          10
#define PLAY_Y          50
#define QUIT_DX         85
#define QUIT_DY         35
#define QUIT_X          105
#define QUIT_Y          50

#define IDM_ABOUT           0x101

/*
* Data Types
*/
typedef struct waveInst
{
  HANDLE hWaveInst;
  HANDLE hWaveHdr;
  HANDLE hWaveData;
} WAVEINST;

typedef WAVEINST FAR *LPWAVEINST;

/*
*  Function prototypes
*/
BOOL FAR PASCAL AppAbout(HWND, unsigned, UINT, LONG);
LONG FAR PASCAL WndProc(HWND, unsigned, UINT, LONG);
void Interchange(HPSTR, HPSTR, unsigned);
void ReversePlay(void);

reverse.cpp:

#include <windows.h>
#include <mmsystem.h>
#include "reverse.h"

#define MAX_FILENAME_SIZE   128

/* Global variables.
*/
char szAppName[] = "Reverse"; // application name
HANDLE hInstApp = NULL; // instance handle
HWND hwndApp = NULL; // main window handle
HWND hwndName = NULL; // filename window handle
HWND hwndPlay = NULL; // "Play" button window handle
HWND hwndQuit = NULL; // "Exit" button window handle
HWAVEOUT hWaveOut = NULL;
LPWAVEHDR lpWaveHdr = NULL;
VOID cleanup(LPWAVEINST lpWaveInst);


/* WinMain - Entry point for Reverse.
*/
int PASCAL WinMain(HANDLE hInst, HANDLE hPrev, LPSTR szCmdLine, int cmdShow)
{
  MSG msg;
  WNDCLASS wc;

  hInstApp = hInst;

  /* Define and register a window class for the main window.
*/
  if (!hPrev)
  {
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(hInst, szAppName);
    wc.lpszMenuName = szAppName;
    wc.lpszClassName = szAppName;
    wc.hbrBackground = GetStockObject(LTGRAY_BRUSH);
    wc.hInstance = hInst;
    wc.style = 0;
    wc.lpfnWndProc = WndProc;
    wc.cbWndExtra = 0;
    wc.cbClsExtra = 0;

    if (!RegisterClass(&wc))
      return FALSE;
  }

  /* Create and show the main window.
*/
  hwndApp = CreateWindow(szAppName,  // class name
  szAppName,  // caption
  WS_OVERLAPPEDWINDOW,  // style bits
  CW_USEDEFAULT,  // x position
  CW_USEDEFAULT,  // y position
  WMAIN_DX,  // x size
  WMAIN_DY,  // y size
  (HWND)NULL,  // parent window
  (HMENU)NULL,  // use class menu
  (HANDLE)hInst,  // instance handle
  (LPSTR)NULL  // no params to pass on
  );
  /* Create child windows for the "Play" and "Exit" buttons
* and for an edit field to enter filenames.
*/
  hwndPlay = CreateWindow("BUTTON", "Play", WS_CHILD | WS_VISIBLE |
    BS_PUSHBUTTON, PLAY_X, PLAY_Y, PLAY_DX, PLAY_DY, hwndApp, (HMENU)IDB_PLAY,
    hInstApp, NULL);
  if (!hwndPlay)
    return (FALSE);

  hwndQuit = CreateWindow("BUTTON", "Exit", WS_CHILD | WS_VISIBLE |
    BS_PUSHBUTTON, QUIT_X, QUIT_Y, QUIT_DX, QUIT_DY, hwndApp, (HMENU)IDB_QUIT,
    hInstApp, NULL);
  if (!hwndQuit)
    return (FALSE);

  hwndName = CreateWindow("EDIT", "", WS_CHILD | WS_VISIBLE | WS_BORDER |
    ES_AUTOHSCROLL, NAME_X, NAME_Y, NAME_DX, NAME_DY, hwndApp, (HMENU)IDE_NAME,
    hInstApp, NULL);
  if (!hwndName)
    return (FALSE);
  SendMessage(hwndName, EM_LIMITTEXT, MAX_FILENAME_SIZE - 1, 0);

  ShowWindow(hwndApp, cmdShow);

  /* Add about dialog to system menu.
*/
  AppendMenu(GetSystemMenu(hwndApp, 0), MF_STRING | MF_ENABLED, IDM_ABOUT, 
"About Reverse...");


  /* The main message processing loop. Nothing special here.
*/
  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }

  return msg.wParam;
}


/* WndProc - Main window procedure function.
*/
LONG FAR PASCAL WndProc(HWND hWnd, unsigned msg, UINT wParam, LONG lParam)
{
  FARPROC fpfn;
  LPWAVEINST lpWaveInst;

  switch (msg)
  {
    case WM_DESTROY:
      if (hWaveOut)
      {
        waveOutReset(hWaveOut);
        waveOutUnprepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
        lpWaveInst = (LPWAVEINST)lpWaveHdr->dwUser;
        cleanup(lpWaveInst);
        waveOutClose(hWaveOut);
      }
      PostQuitMessage(0);
      break;

    case WM_SYSCOMMAND:
      switch (LOWORD(wParam))
      {
      case IDM_ABOUT:
        /* Show ABOUTBOX dialog box.
*/
        fpfn = MakeProcInstance((FARPROC)AppAbout, hInstApp); // no op in 32 bit
        DialogBox(hInstApp, "ABOUTBOX", hWnd, (DLGPROC)fpfn);
        FreeProcInstance(fpfn);
        break;
      }
      break;

      /* Process messages sent by the child window controls.
*/
    case WM_SETFOCUS:
      SetFocus(hwndName);
      return 0;

    case WM_COMMAND:
      switch (LOWORD(wParam))
      {
      case IDE_NAME:
        // filename edit control
        return (0L);

      case IDB_PLAY:
        // "Play" button
        if (HIWORD(wParam) == BN_CLICKED)
          ReversePlay();
        break;

      case IDB_QUIT:
        // "Exit" button
        if (HIWORD(wParam) == BN_CLICKED)
          PostQuitMessage(0);
        break;
      }
      return (0L);

    case MM_WOM_DONE:
      /* This message indicates a waveform data block has
* been played and can be freed. Clean up the preparation
* done previously on the header.
*/
      waveOutUnprepareHeader((HWAVEOUT)wParam, (LPWAVEHDR)lParam, sizeof
        (WAVEHDR));

      /* Get a pointer to the instance data, then unlock and free
* all memory associated with the data block, including the
* memory for the instance data itself.
*/
      lpWaveInst = (LPWAVEINST)((LPWAVEHDR)lParam)->dwUser;
      cleanup(lpWaveInst);
      /* Close the waveform output device.
*/
      waveOutClose((HWAVEOUT)wParam);

      /* Reenable both button controls.
*/
      EnableWindow(hwndPlay, TRUE);
      EnableWindow(hwndQuit, TRUE);
      SetFocus(hwndName);

      break;
  }

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


/* AppAbout -- Dialog procedure for ABOUTBOX  dialog box.
*/
BOOL FAR PASCAL AppAbout(HWND hDlg, unsigned msg, unsigned wParam, LONG lParam)
{
  switch (msg)
  {
    case WM_COMMAND:
      if (LOWORD(wParam) == IDOK)
        EndDialog(hDlg, TRUE);
      break;

    case WM_INITDIALOG:
      return TRUE;
  }
  return FALSE;
}

/* ReversePlay - Gets a filename from the edit control, then uses
*  the multimedia file I/O services to read data from the requested
*  WAVE file. If the file is a proper WAVE file, ReversePlay() calls
*  the Interchange() function to reverse the order of the waveform
*  samples in the file. It then plays the reversed waveform data.
*
*  Note that ReversePlay() only handles a single waveform data block.
*  If the requested WAVE file will not fit in a single data block, it
*  will not be played. The size of a single data block depends on the
*  amount of available system memory.
*
* Params:  void
*
* Return:  void
*/
void ReversePlay()
{
  HANDLE hWaveHdr;
  LPWAVEINST lpWaveInst;
  HMMIO hmmio;
  MMCKINFO mmckinfoParent;
  MMCKINFO mmckinfoSubchunk;
  DWORD dwFmtSize;
  char szFileName[MAX_FILENAME_SIZE];
  HANDLE hFormat;
  WAVEFORMAT *pFormat;
  DWORD dwDataSize;
  HPSTR hpch1, hpch2;
  WORD wBlockSize;
  HANDLE hWaveInst;
  HANDLE hData = NULL;
  HPSTR lpData = NULL;

  /* Get the filename from the edit control.
*/
  if (!GetWindowText(hwndName, (LPSTR)szFileName, MAX_FILENAME_SIZE))
  {
    MessageBox(hwndApp, "Failed to Get Filename", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }

  /* Open the given file for reading using buffered I/O.
*/
  if (!(hmmio = mmioOpen(szFileName, NULL, MMIO_READ | MMIO_ALLOCBUF)))
  {
    MessageBox(hwndApp, "Failed to open file.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }

  /* Locate a 'RIFF' chunk with a 'WAVE' form type
* to make sure it's a WAVE file.
*/
  mmckinfoParent.fccType = mmioFOURCC('W', 'A', 'V', 'E');
  if (mmioDescend(hmmio, (LPMMCKINFO) &mmckinfoParent, NULL, MMIO_FINDRIFF))
  {
    MessageBox(hwndApp, "This is not a WAVE file.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Now, find the format chunk (form type 'fmt '). It should be
* a subchunk of the 'RIFF' parent chunk.
*/
  mmckinfoSubchunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
  if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent, MMIO_FINDCHUNK))
  {
    MessageBox(hwndApp, "WAVE file is corrupted.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Get the size of the format chunk, allocate and lock memory for it.
*/
  dwFmtSize = mmckinfoSubchunk.cksize;
  hFormat = LocalAlloc(LMEM_MOVEABLE, LOWORD(dwFmtSize));
  if (!hFormat)
  {
    MessageBox(hwndApp, "Out of memory.", NULL, MB_OK | MB_ICONEXCLAMATION);
    mmioClose(hmmio, 0);
    return ;
  }
  pFormat = (WAVEFORMAT*)LocalLock(hFormat);
  if (!pFormat)
  {
    MessageBox(hwndApp, "Failed to lock memory for format chunk.", NULL, MB_OK 
| MB_ICONEXCLAMATION);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Read the format chunk.
*/
  if (mmioRead(hmmio, (HPSTR)pFormat, dwFmtSize) != (LONG)dwFmtSize)
  {
    MessageBox(hwndApp, "Failed to read format chunk.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Make sure it's a PCM file.
*/
  if (pFormat->wFormatTag != WAVE_FORMAT_PCM)
  {
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    MessageBox(hwndApp, "The file is not a PCM file.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }

  /* Make sure a waveform output device supports this format.
*/
  if (waveOutOpen(&hWaveOut, WAVE_MAPPER, (LPWAVEFORMAT)pFormat, 0L, 0L,
    WAVE_FORMAT_QUERY))
  {
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    MessageBox(hwndApp, "The waveform device can't play this format.", NULL,
      MB_OK | MB_ICONEXCLAMATION);
    return ;
  }

  /* Ascend out of the format subchunk.
*/
  mmioAscend(hmmio, &mmckinfoSubchunk, 0);

  /* Find the data subchunk.
*/
  mmckinfoSubchunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
  if (mmioDescend(hmmio, &mmckinfoSubchunk, &mmckinfoParent, MMIO_FINDCHUNK))
  {
    MessageBox(hwndApp, "WAVE file has no data chunk.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Get the size of the data subchunk.
*/
  dwDataSize = mmckinfoSubchunk.cksize;
  if (dwDataSize == 0L)
  {
    MessageBox(hwndApp, "The data chunk has no data.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Open a waveform output device.
*/
  if (waveOutOpen((LPHWAVEOUT) &hWaveOut, WAVE_MAPPER, (LPWAVEFORMAT)pFormat, 
(UINT)hwndApp, 0L, CALLBACK_WINDOW))
  {
    MessageBox(hwndApp, "Failed to open waveform output device.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    LocalUnlock(hFormat);
    LocalFree(hFormat);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Save block alignment info for later use.
*/
  wBlockSize = pFormat->nBlockAlign;

  /* We're done with the format header, free it.
*/
  LocalUnlock(hFormat);
  LocalFree(hFormat);

  /* Allocate and lock memory for the waveform data.
*/
  hData = GlobalAlloc(GMEM_MOVEABLE, dwDataSize);
  /* GMEM_SHARE is not needed on 32 bits */
  if (!hData)
  {
    MessageBox(hwndApp, "Out of memory.", NULL, MB_OK | MB_ICONEXCLAMATION);
    mmioClose(hmmio, 0);
    return ;
  }
  lpData = GlobalLock(hData);
  if (!lpData)
  {
    MessageBox(hwndApp, "Failed to lock memory for data chunk.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    GlobalFree(hData);
    mmioClose(hmmio, 0);
    return ;
  }

  /* Read the waveform data subchunk.
*/
  if (mmioRead(hmmio, (HPSTR)lpData, dwDataSize) != (LONG)dwDataSize)
  {
    MessageBox(hwndApp, "Failed to read data chunk.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    GlobalUnlock(hData);
    GlobalFree(hData);
    mmioClose(hmmio, 0);
    return ;
  }

  /* We're done with the file, close it.
*/
  mmioClose(hmmio, 0);

  /* Reverse the sound for playing.
*/
  hpch1 = lpData;
  hpch2 = lpData + dwDataSize - 1;
  while (hpch1 < hpch2)
  {
    Interchange(hpch1, hpch2, wBlockSize);
    hpch1 += wBlockSize;
    hpch2 -= wBlockSize;
  }

  /* Allocate a waveform data header. The WAVEHDR must be
* globally allocated and locked.
*/
  hWaveHdr = GlobalAlloc(GMEM_MOVEABLE, (DWORD)sizeof(WAVEHDR));
  if (!hWaveHdr)
  {
    GlobalUnlock(hData);
    GlobalFree(hData);
    MessageBox(hwndApp, "Not enough memory for header.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }
  lpWaveHdr = (LPWAVEHDR)GlobalLock(hWaveHdr);
  if (!lpWaveHdr)
  {
    GlobalUnlock(hData);
    GlobalFree(hData);
    GlobalFree(hWaveHdr);
    MessageBox(hwndApp, "Failed to lock memory for header.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }

  /* Allocate and set up instance data for waveform data block.
* This information is needed by the routine that frees the
* data block after it has been played.
*/
  hWaveInst = GlobalAlloc(GMEM_MOVEABLE, (DWORD)sizeof(WAVEHDR));
  if (!hWaveInst)
  {
    GlobalUnlock(hData);
    GlobalFree(hData);
    GlobalUnlock(hWaveHdr);
    GlobalFree(hWaveHdr);
    MessageBox(hwndApp, "Not enough memory for instance data.", NULL, MB_OK |
      MB_ICONEXCLAMATION);
    return ;
  }
  lpWaveInst = (LPWAVEINST)GlobalLock(hWaveInst);
  if (!lpWaveInst)
  {
    GlobalUnlock(hData);
    GlobalFree(hData);
    GlobalUnlock(hWaveHdr);
    GlobalFree(hWaveHdr);
    GlobalFree(hWaveInst);
    MessageBox(hwndApp, "Failed to lock memory for instance data.", NULL, MB_OK
| MB_ICONEXCLAMATION);
    return ;
  }
  lpWaveInst->hWaveInst = hWaveInst;
  lpWaveInst->hWaveHdr = hWaveHdr;
  lpWaveInst->hWaveData = hData;

  /* Set up WAVEHDR structure and prepare it to be written to wave device.
*/
  lpWaveHdr->lpData = lpData;
  lpWaveHdr->dwBufferLength = dwDataSize;
  lpWaveHdr->dwFlags = 0L;
  lpWaveHdr->dwLoops = 0L;
  lpWaveHdr->dwUser = (DWORD)lpWaveInst;
  if (waveOutPrepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR)))
  {
    GlobalUnlock(hData);
    GlobalFree(hData);
    GlobalUnlock(hWaveHdr);
    GlobalFree(hWaveHdr);
    GlobalUnlock(hWaveInst);
    GlobalFree(hWaveInst);
    MessageBox(hwndApp, "Unable to prepare wave header.", NULL, MB_OK |
      MB_ICONEXCLAMATION);

    return ;
  }

  /* Then the data block can be sent to the output device.
*/
  {
    MMRESULT mmResult;
    mmResult = waveOutWrite(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
    if (mmResult != 0)
    {
      waveOutUnprepareHeader(hWaveOut, lpWaveHdr, sizeof(WAVEHDR));
      GlobalUnlock(hData);
      GlobalFree(hData);
      MessageBox(hwndApp, "Failed to write block to device", NULL, MB_OK |
        MB_ICONEXCLAMATION);
      return ;
    }
  }

  /* Disable input to the button controls.
*/
  EnableWindow(hwndPlay, FALSE);
  EnableWindow(hwndQuit, FALSE);
}

/* Interchange - Interchanges two samples at the given positions.
*
* Params:  hpchPos1 - Points to one sample.
*          hpchPos2 - Points to the other sample.
*          wLength  - The length of a sample in bytes.
*
* Return:  void
*/
void Interchange(HPSTR hpchPos1, HPSTR hpchPos2, unsigned uLength)
{
  unsigned uPlace;
  BYTE bTemp;

  for (uPlace = 0; uPlace < uLength; uPlace++)
  {
    bTemp = hpchPos1[uPlace];
    hpchPos1[uPlace] = hpchPos2[uPlace];
    hpchPos2[uPlace] = bTemp;
  }
}

VOID cleanup(LPWAVEINST lpWaveInst)
{
  GlobalUnlock(lpWaveInst->hWaveData);
  GlobalFree(lpWaveInst->hWaveData);
  GlobalUnlock(lpWaveInst->hWaveHdr);
  GlobalFree(lpWaveInst->hWaveHdr);
  GlobalUnlock(lpWaveInst->hWaveInst);
  GlobalFree(lpWaveInst->hWaveInst);
}

Slider

2009-10-29T12:35:00.000-07:00

#define STRICT

#pragma comment(lib, "comctl32.lib")

#define ID_SPLITTER 1

#include
#include

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
CREATESTRUCT *cs;
static HWND hWndSlider;
static DWORD dwPos;

switch (iMsg)
{
case WM_CREATE:
cs = (LPCREATESTRUCT)lParam;
hWndSlider = CreateWindow(TRACKBAR_CLASS, "", WS_CHILD | WS_VISIBLE |
TBS_AUTOTICKS, 10, 50, 200, 20, hwnd, (HMENU)ID_SPLITTER, cs->hInstance,
NULL);
break;

case WM_HSCROLL:
switch (wParam)
{
case TB_THUMBTRACK:
dwPos = SendMessage(hWndSlider, TBM_GETPOS, 0, 0);
break;
}
break;
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
}
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
int iCmdShow)
{
HWND hwnd;
MSG msg;
WNDCLASS wndclass;
char szAppName[] = "Applicatie";

wndclass.style = 0;
wndclass.lpfnWndProc = WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIcon(hInstance, szAppName);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wndclass.lpszMenuName = szAppName;
wndclass.lpszClassName = szAppName;
RegisterClass(&wndclass);

InitCommonControls();

hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0,
0, 400, 400, NULL, NULL, hInstance, szCmdLine);

while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (int)msg.wParam;
}

DataPicker

2009-10-29T12:33:00.000-07:00

#define STRICT

#include
#include
#include

#pragma comment(lib, "comctl32.lib")

static char szAppName[] = "DatePickerApp";
HINSTANCE hInst;
HWND hwnd;

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
static SYSTEMTIME st;
static HWND hWndStartDate, hWndStartTime;
static char szDate[15], szTime[10], szStamp[20];
NMDATETIMECHANGE *Date;

switch (iMsg)
{
case WM_CREATE:
GetLocalTime(&st);
GetDateFormat(LOCALE_SYSTEM_DEFAULT, 0, &st, "yyyyMMdd", szDate, sizeof
(szDate));
GetTimeFormat(LOCALE_SYSTEM_DEFAULT, 0, &st, "HHmmss", szTime, sizeof
(szTime));

hWndStartDate = CreateWindowEx(0, DATETIMEPICK_CLASS, NULL, WS_BORDER |
WS_CHILD | WS_VISIBLE, 10, 10, 100, 25, hwnd, NULL, hInst, NULL);

hWndStartTime = CreateWindowEx(0, DATETIMEPICK_CLASS, NULL, WS_BORDER |
WS_CHILD | WS_VISIBLE | DTS_TIMEFORMAT, 10, 40, 100, 25, hwnd, NULL,
hInst, NULL);
break;

case WM_NOTIFY:
switch (((LPNMHDR)lParam)->code)
{
case DTN_DATETIMECHANGE:
Date = (LPNMDATETIMECHANGE)lParam;
if (Date->nmhdr.hwndFrom == hWndStartDate || Date->nmhdr.hwndFrom ==
hWndStartTime)
{
DateTime_SetRange(hWndStartDate, GDTR_MAX, &st);
DateTime_SetRange(hWndStartTime, GDTR_MAX, &st);
}
break;

case DTN_DROPDOWN:
MonthCal_SetFirstDayOfWeek(DateTime_GetMonthCal(hWndStartDate), 0);
break;
}
break;

case WM_COMMAND:
if (IDCANCEL == LOWORD(wParam))
{
DateTime_GetSystemtime(hWndStartDate, &st);
DateTime_GetSystemtime(hWndStartTime, &st);
break;
}
break;

case WM_CLOSE:
DestroyWindow(hwnd);
break;

case WM_DESTROY:
PostQuitMessage(0);
break;
}
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
int iCmdShow)
{
MSG msg;
WNDCLASS wndclass;
INITCOMMONCONTROLSEX icex;

wndclass.style = 0;
wndclass.lpfnWndProc = WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = hInstance;
wndclass.hIcon = LoadIcon(hInstance, szAppName);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wndclass.lpszMenuName = szAppName;
wndclass.lpszClassName = szAppName;
RegisterClass(&wndclass);

icex.dwSize = sizeof(icex);
icex.dwICC = ICC_DATE_CLASSES;
InitCommonControlsEx(&icex);

hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0,
0, 400, 400, NULL, NULL, hInstance, szCmdLine);

while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return (int)msg.wParam;
}

RichEdit

2009-10-29T12:32:00.000-07:00

#define STRICT

#include <windows.h>
#include <richedit.h>

static char szAppName[] = "RicheditApp";

void AddText(HWND hwnd, char *szTextIn, COLORREF crNewColor)
{
  char *Text = (char*)malloc(lstrlen(szTextIn) + 5);
  CHARFORMAT cf;
  int iTotalTextLength = GetWindowTextLength(hwnd);
  int iStartPos = iTotalTextLength;
  int iEndPos;

  strcpy(Text, szTextIn);
  strcat(Text, "\r\n");

  SendMessage(hwnd, EM_SETSEL, (WPARAM)(int)iTotalTextLength, (LPARAM)(int)
    iTotalTextLength);
  SendMessage(hwnd, EM_REPLACESEL, (WPARAM)(BOOL)FALSE, (LPARAM)(LPCSTR)Text);

  free(Text);

  cf.cbSize = sizeof(CHARFORMAT);
  cf.dwMask = CFM_COLOR | CFM_UNDERLINE | CFM_BOLD;
  cf.dwEffects = (unsigned long)~(CFE_AUTOCOLOR | CFE_UNDERLINE | CFE_BOLD);
  cf.crTextColor = crNewColor;

  iEndPos = GetWindowTextLength(hwnd);

  SendMessage(hwnd, EM_SETSEL, (WPARAM)(int)iStartPos, (LPARAM)(int)iEndPos);
  SendMessage(hwnd, EM_SETCHARFORMAT, (WPARAM)(UINT)SCF_SELECTION, (LPARAM) &cf)
    ;
  SendMessage(hwnd, EM_HIDESELECTION, (WPARAM)(BOOL)TRUE, (LPARAM)(BOOL)FALSE);

  SendMessage(hwnd, EM_LINESCROLL, (WPARAM)(int)0, (LPARAM)(int)1);
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
  static HWND hWndEdit;
  static int iStartPos, iEndPos;
  CHARFORMAT cf;
  CREATESTRUCT *cs;
  RECT rect;

  switch (iMsg)
  {
    case WM_CREATE:
      cs = (LPCREATESTRUCT)lParam;
      hWndEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "RichEdit", NULL, WS_CHILD |
        WS_CLIPCHILDREN | ES_WANTRETURN | ES_MULTILINE | WS_VISIBLE | ES_LEFT,
        0, 0, 1, 1, hwnd, NULL, cs->hInstance, NULL);

      SendMessage(hWndEdit, EM_SETWORDBREAKPROCEX, (WPARAM)0, (LPARAM)NULL);

      cf.cbSize = sizeof(CHARFORMAT);
      cf.dwMask = CFM_FACE | CFM_SIZE;
      cf.yHeight = 180;
      strcpy(cf.szFaceName, "MS Sans Serif");
      SendMessage(hWndEdit, EM_SETCHARFORMAT, (WPARAM)(UINT)0, (LPARAM) &cf);

      AddText(hWndEdit, "Hello world", RGB(164, 0, 0));
      break;

    case WM_SIZE:
      GetClientRect(hwnd, &rect);
      MoveWindow(hWndEdit, 3, 3, rect.right - 6, rect.bottom - 6, 1);
      break;

    case WM_CLOSE:
      DestroyWindow(hwnd);
      break;

    case WM_DESTROY:
      PostQuitMessage(0);
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
  int iCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS wndclass;
  HINSTANCE hRichEdit;

  wndclass.style = 0;
  wndclass.lpfnWndProc = WndProc;
  wndclass.cbClsExtra = 0;
  wndclass.cbWndExtra = 0;
  wndclass.hInstance = hInstance;
  wndclass.hIcon = LoadIcon(hInstance, szAppName);
  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  wndclass.lpszMenuName = szAppName;
  wndclass.lpszClassName = szAppName;
  RegisterClass(&wndclass);

  hRichEdit = LoadLibrary("RICHED32.DLL");

  hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0,
    0, 400, 400, NULL, NULL, hInstance, szCmdLine);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }

  FreeLibrary(hRichEdit);

  return (int)msg.wParam;
}

ListView

2009-10-29T12:22:00.000-07:00

#include <windows.h>
#include <stdio.h>
#include <commctrl.h>

#pragma comment(lib, "comctl32.lib")

#define ID_LISTVIEW    1

typedef struct
{
  char szItemNr[8];
  char szItem[32];
  char szItemDescription[32];
} Item;

BOOL AdjustListView(HWND hList, LV_ITEM *lv, int iItems)
{
  int i = iItems;
  int iRet;
  ListView_DeleteAllItems(hList);

  lv->mask = LVIF_TEXT;
  lv->iSubItem = 0;
  lv->pszText = LPSTR_TEXTCALLBACK;

  while (i > 0)
  {
    iRet = ListView_InsertItem(hList, lv);
    i--;
  }
  return TRUE;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
  static CREATESTRUCT *cs;
  static HWND hWndListView;
  static HFONT hFont;
  static LV_ITEM lv;
  static Item ListItem[3];
  static char szColumnHeader[3][12] = 
  {
    "Number", "Item", "Description"
  };
  int index;
  int iiWidth[3];
  LV_COLUMN lvC;
  RECT rect;

  LV_DISPINFO *lvd;
  NMHDR *hdr;

  switch (iMsg)
  {
    case WM_CREATE:
      cs = (CREATESTRUCT*)lParam;
      hFont = CreateFont(11, 0, 0, 0, 500, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
        OUT_DEFAULT_PRECIS, CLIP_CHARACTER_PRECIS, PROOF_QUALITY, FF_DONTCARE, 
        "MS SANS SERIF");
      hWndListView = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, "",
        WS_VISIBLE | WS_CHILD | LVS_REPORT | LVS_SHOWSELALWAYS, 0, 0, 0, 0,
        hwnd, (HMENU)ID_LISTVIEW, cs->hInstance, NULL);

      ListView_SetExtendedListViewStyle(hWndListView, LVS_EX_FULLROWSELECT |
        LVS_EX_GRIDLINES);

      iiWidth[0] = 60;
      iiWidth[1] = 100;
      iiWidth[2] = 400;

      lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
      lvC.fmt = LVCFMT_LEFT;

      for (index = 0; index < 3; index++)
      {
        lvC.iSubItem = index;
        lvC.cx = iiWidth[index];
        lvC.pszText = szColumnHeader[index];
        ListView_InsertColumn(hWndListView, index, &lvC);
      }

      // Add some items here
      strcpy(ListItem[0].szItemNr, "1");
      strcpy(ListItem[0].szItem, "Cat");
      strcpy(ListItem[0].szItemDescription, "Pet");

      strcpy(ListItem[1].szItemNr, "2");
      strcpy(ListItem[1].szItem, "Dog");
      strcpy(ListItem[1].szItemDescription, "Pet");

      AdjustListView(hWndListView, &lv, index);
      break;

    case WM_SIZE:
      GetClientRect(hwnd, &rect);
      MoveWindow(hWndListView, 3, 3, rect.right - 6, rect.bottom - 6, 1);
      break;

    case WM_NOTIFY:
      switch (((LPNMHDR)lParam)->code)
      {
      case NM_DBLCLK:
        hdr = (NMHDR FAR*)lParam;
        if (hdr->hwndFrom == hWndListView)
        {
          index = ListView_GetNextItem(hWndListView,  - 1, LVNI_SELECTED);
          if (index !=  - 1)
          {
            MessageBox(hwnd, ListItem[index].szItem, 
              "Doubleclicked on this item", MB_OK);
          }
        }
        break;

      case LVN_GETDISPINFO:
        lvd = (LV_DISPINFO FAR*)lParam;
        if ((((LPNMHDR)lParam)->hwndFrom == hWndListView))
        {
          switch (lvd->item.iSubItem)
          {
          case 0:
            lvd->item.pszText = ListItem[lvd->item.iItem].szItemNr;
            break;
          case 1:
            lvd->item.pszText = ListItem[lvd->item.iItem].szItem;
            break;
          case 2:
            lvd->item.pszText = ListItem[lvd->item.iItem].szItemDescription;
            break;
          }
          break;
        }
      }
      break;

    case WM_CLOSE:
      DestroyWindow(hwnd);
      break;

    case WM_DESTROY:
      DeleteObject(hFont);
      PostQuitMessage(0);
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
  int iCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS wndclass;
  char szAppName[] = "ListviewApp";
  INITCOMMONCONTROLSEX icex;

  wndclass.style = 0;
  wndclass.lpfnWndProc = WndProc;
  wndclass.cbClsExtra = 0;
  wndclass.cbWndExtra = 0;
  wndclass.hInstance = hInstance;
  wndclass.hIcon = LoadIcon(hInstance, szAppName);
  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  wndclass.lpszMenuName = szAppName;
  wndclass.lpszClassName = szAppName;
  RegisterClass(&wndclass);

  icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
  icex.dwICC = ICC_LISTVIEW_CLASSES;
  InitCommonControlsEx(&icex);

  hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | WS_VISIBLE,
    100, 100, 600, 250, NULL, NULL, hInstance, szCmdLine);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return (int)msg.wParam;
}

RightClick-Menu

2009-10-29T12:19:00.000-07:00

#define STRICT

#include <windows.h>
#include <stdio.h>

#define ID_CUT         1000
#define ID_COPY        1001
#define ID_PASTE       1002

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
  CREATESTRUCT *cs;
  HMENU hMenu;
  POINT p;
  char szText[64];
  // Menu-item identifiers 
  static char szMenuItem[3][10] = 
  {
    "Cut", "Copy", "Paste"
  };

  switch (iMsg)
  {
    case WM_CREATE:
      cs = (LPCREATESTRUCT)lParam;
      break;

    case WM_RBUTTONUP:
      p.x = LOWORD(lParam);
      p.y = HIWORD(lParam);
      hMenu = CreatePopupMenu();
      AppendMenu(hMenu, MF_STRING, ID_CUT, "Cut");
      AppendMenu(hMenu, MF_STRING, ID_COPY, "Copy");
      AppendMenu(hMenu, MF_STRING, ID_PASTE, "Paste");
      ClientToScreen(hwnd, (LPPOINT) &p);
      TrackPopupMenu(hMenu, 0, p.x, p.y, 0, hwnd, NULL);
      DestroyMenu(hMenu);
      break;

    case WM_COMMAND:
      switch (LOWORD(wParam))
      {
      case ID_CUT:
      case ID_COPY:
      case ID_PASTE:
        sprintf(szText, "You chose %s", szMenuItem[LOWORD(wParam) - 1000]);
        MessageBox(hwnd, szText, "MenuApp", MB_OK);
        break;
      }
      break;

    case WM_CLOSE:
      DestroyWindow(hwnd);
      break;

    case WM_DESTROY:
      PostQuitMessage(0);
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
  int iCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS wndclass;
  char szAppName[] = "RightclickMenuApp";

  wndclass.style = 0;
  wndclass.lpfnWndProc = WndProc;
  wndclass.cbClsExtra = 0;
  wndclass.cbWndExtra = 0;
  wndclass.hInstance = hInstance;
  wndclass.hIcon = LoadIcon(hInstance, szAppName);
  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  wndclass.lpszMenuName = szAppName;
  wndclass.lpszClassName = szAppName;
  RegisterClass(&wndclass);

  hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0,
    0, 400, 400, NULL, NULL, hInstance, szCmdLine);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return (int)msg.wParam;
}

Splitter

2009-10-28T07:35:00.000-07:00

#include <windows.h>

#define MINSIZE        50 
  // The minimal width and height a childwindow should have
#define SBS            2  // Short for SplitterBarSize

LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
  static HWND hwndChild1, hwndChild2, hwndChild3;
  static CREATESTRUCT *cs;
  static HCURSOR hcSizeNS, hcSizeEW, hcArrow;
  static int xDiv, yDiv;
  static BOOL xSizing, ySizing;

  int xPos, yPos;
  RECT rect, focusrect;
  HDC hdc;

  switch (iMsg)
  {
    case WM_CREATE:
      cs = (CREATESTRUCT*)lParam;
      xDiv = 300;
      yDiv = 300;

      hwndChild1 = CreateWindowEx(WS_EX_CLIENTEDGE, "Pane 1", "Child 1",
        WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, 0, 0, 0, 0, hwnd, NULL, cs
        ->hInstance, NULL);
      hwndChild2 = CreateWindowEx(WS_EX_CLIENTEDGE, "Pane 2", "Child 2",
        WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, 0, 0, 0, 0, hwnd, NULL, cs
        ->hInstance, NULL);
      hwndChild3 = CreateWindowEx(WS_EX_CLIENTEDGE, "Pane 3", "Child 3",
        WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN, 0, 0, 0, 0, hwnd, NULL, cs
        ->hInstance, NULL);

      hcSizeNS = LoadCursor(NULL, IDC_SIZENS);
      hcSizeEW = LoadCursor(NULL, IDC_SIZEWE);
      hcArrow = LoadCursor(NULL, IDC_ARROW);
      break;

    case WM_SIZE:
      GetClientRect(hwnd, &rect);
      // Make sure splitterbars are visible
      if (xDiv > rect.right - MINSIZE)
      {
        xDiv = rect.right - MINSIZE;
      }
      else if (xDiv < MINSIZE)
      {
        xDiv = MINSIZE;
      }
      if (yDiv > rect.bottom - MINSIZE)
      {
        yDiv = rect.bottom - MINSIZE;
      }
      else if (yDiv < MINSIZE)
      {
        yDiv = MINSIZE;
      }
      MoveWindow(hwndChild1, rect.left, rect.top + 1, rect.left + xDiv - SBS,
        rect.top + yDiv - SBS, FALSE);
      MoveWindow(hwndChild2, rect.left + xDiv + SBS, rect.top + 1, rect.right -
        rect.left - xDiv - SBS, rect.top + yDiv - SBS, FALSE);
      MoveWindow(hwndChild3, rect.left, rect.top + yDiv + SBS, rect.right -
        rect.left, rect.bottom - rect. top - yDiv - SBS, FALSE);
      InvalidateRect(hwnd, &rect, TRUE);
      break;

    case WM_LBUTTONDOWN:
      xPos = (int)LOWORD(lParam);
      yPos = (int)HIWORD(lParam);

      xSizing = (xPos > xDiv - SBS && xPos < xDiv + SBS);
      ySizing = (yPos > yDiv - SBS && yPos < yDiv + SBS);

      if (xSizing || ySizing)
      {
        SetCapture(hwnd); // Track movement of the mousepointer 
        if (xSizing)
        {
          SetCursor(hcSizeEW);
        }
        else if (ySizing)
        {
          SetCursor(hcSizeNS);
        }
      }
      break;

    case WM_LBUTTONUP:
      if (xSizing || ySizing)
      {
        ReleaseCapture();
        hdc = GetDC(hwnd);
        GetClientRect(hwnd, &rect);
        if (xSizing)
        {
          SetRect(&focusrect, xDiv - SBS, rect.top, xDiv + SBS, yDiv);
          DrawFocusRect(hdc, &focusrect);
          xSizing = FALSE;
        }
        if (ySizing)
        {
          SetRect(&focusrect, rect.left + 1, yDiv - SBS, rect.right, yDiv + SBS)
            ;
          DrawFocusRect(hdc, &focusrect);
          ySizing = FALSE;
        }
        ReleaseDC(hwnd, hdc);
      }
      // Post a size message so the childwindows get their new size
      PostMessage(hwnd, WM_SIZE, 0, 0);
      break;

    case WM_MOUSEMOVE:
      xPos = (int)LOWORD(lParam);
      yPos = (int)HIWORD(lParam);

      if (wParam == MK_LBUTTON)
      // Is one of the splitterbars being moved?
      {
        if (xSizing || ySizing)
        {
          hdc = GetDC(hwnd);
          GetClientRect(hwnd, &rect);

          if (xSizing)
          {
            SetRect(&focusrect, xDiv - SBS, rect.top, xDiv + SBS, yDiv);
            DrawFocusRect(hdc, &focusrect);

            xDiv = xPos;

            SetRect(&focusrect, xDiv - SBS, rect.top, xDiv + SBS, yDiv);
            DrawFocusRect(hdc, &focusrect);
          }
          if (ySizing)
          {
            SetRect(&focusrect, rect.left + 1, yDiv - SBS, rect.right, yDiv +
              SBS);
            DrawFocusRect(hdc, &focusrect);

            yDiv = yPos;

            SetRect(&focusrect, rect.left + 1, yDiv - SBS, rect.right, yDiv +
              SBS);
            DrawFocusRect(hdc, &focusrect);
          }
          ReleaseDC(hwnd, hdc);
        }
        break; // Leave
      }

      if ((xPos > xDiv - SBS && xPos < xDiv + SBS) && GetCursor() != hcSizeEW)
      {
        SetCursor(hcSizeEW); // hovering above the vertical splitterbar
      }
      else if ((yPos > yDiv - SBS && yPos < yDiv + SBS) && GetCursor() !=
        hcSizeNS)
      {
        SetCursor(hcSizeNS); // hovering above the horizontal splitterbar
      }
      else if (GetCursor() != hcArrow)
      {
        SetCursor(hcArrow); // not hovering above a splitterbar
      }
      break;

    case WM_CLOSE:
      DestroyWindow(hwnd);
      break;

    case WM_DESTROY:
      PostQuitMessage(0);
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

LRESULT CALLBACK Child1WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM
  lParam)
{
  switch (iMsg)
  {
    case WM_CREATE:
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

LRESULT CALLBACK Child2WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM
  lParam)
{
  switch (iMsg)
  {
    case WM_CREATE:
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

LRESULT CALLBACK Child3WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM
  lParam)
{
  switch (iMsg)
  {
    case WM_CREATE:
      break;
  }
  return DefWindowProc(hwnd, iMsg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine,
  int iCmdShow)
{
  HWND hwnd;
  MSG msg;
  WNDCLASS wndclass;
  char szAppName[] = "SplitterApp";

  wndclass.style = 0;
  wndclass.lpfnWndProc = WndProc;
  wndclass.cbClsExtra = 0;
  wndclass.cbWndExtra = 0;
  wndclass.hInstance = hInstance;
  wndclass.hIcon = LoadIcon(hInstance, szAppName);
  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
  wndclass.lpszMenuName = szAppName;
  wndclass.lpszClassName = szAppName;
  RegisterClass(&wndclass);

  wndclass.lpfnWndProc = Child1WndProc;
  wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
  wndclass.lpszClassName = "Pane 1";
  RegisterClass(&wndclass);

  wndclass.lpfnWndProc = Child2WndProc;
  wndclass.lpszClassName = "Pane 2";
  RegisterClass(&wndclass);

  wndclass.lpfnWndProc = Child3WndProc;
  wndclass.lpszClassName = "Pane 3";
  RegisterClass(&wndclass);

  hwnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW | SW_MAXIMIZE |
    WS_VISIBLE, 0, 0, 600, 500, NULL, NULL, hInstance, szCmdLine);

  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return (int)msg.wParam;
}

Part 1: Compile with MASM

2009-10-22T14:15:00.000-07:00

Create a file name test.asm

.486 
.model flat, stdcall 
option casemap :none 


MessageBoxA PROTO STDCALL :DWORD, :DWORD, :DWORD, :DWORD 
ExitProcess PROTO STDCALL :DWORD 

.data 
     ttl db '11111',0 
.code 
start: 
     invoke MessageBoxA,0,offset ttl,offset ttl,0 
     invoke ExitProcess,0 
end start

Now compile and link with command:

ml /coff test.asm /link kernel32.lib user32.lib

WH_CBT Hooking

2009-10-21T10:54:00.000-07:00

If you want to monitor programs in your computer: which programs execute, activate, or destroy , use the hook type WH_CBT.

The following messages are captured:

HCBT_ACTIVATE — program is activated
HCBT_CREATEWND — new window is created;
HCBT_DESTROYWND — exsist window is destroyed;
HCBT_MINMAX ;
HCBT_MOVESIZE

Here' s the sample code of the DLL .

// FileMonitor.cpp : Defines the entry point for the DLL application.
//

#include <windows.h>


HHOOK SysHook;
HINSTANCE hInst;

BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID
  lpReserved)
{
  hInst = (HINSTANCE)hModule;
  return TRUE;
}

LRESULT CALLBACK SysMsgProc(

int code,  // hook code
WPARAM wParam,  // removal flag
LPARAM lParam  // address of structure with message
)
{  
  CallNextHookEx(SysHook, code, wParam, lParam);

  if (code == HCBT_ACTIVATE)
  {
    char windtext[255];
    HWND Wnd = ((tagMSG*)lParam)->hwnd;
    GetWindowText(Wnd, windtext, 255);

    // Here you can save active window title    
  }

  if (code == HCBT_CREATEWND)
  {
    char windtext[255];
    HWND Wnd = ((tagMSG*)lParam)->hwnd;
    GetWindowText(Wnd, windtext, 255);

    // Here you can save New file title    
  }
  return 0;
}

///////////////////////////////////////////////////////////////////

extern "C" __declspec(dllexport) void RunStopHook(bool State, HINSTANCE hInstance)
{
  if (true)
    SysHook = SetWindowsHookEx(WH_CBT, &SysMsgProc, hInst, 0);
  else
    UnhookWindowsHookEx(SysHook);
}

Dynamic Stack Allocation

2009-10-21T10:28:00.000-07:00

You want to dynamically allocate memory from stack ?

Now use DllImport and stackalloc to implement this function.
Remember that the allocated memory block doesn't participate into the garbage collector's process.

using System;
using System.Runtime.InteropServices;
namespace StackAllocation
{
 class StackAllocator
{ 
[DllImport("kernel32.dll")]
  static extern unsafe bool GetComputerNameW(char* name, ref ulong size);
  [STAThread]
  static unsafe void Main(string[] args)
  {
   ulong size = 256;
   char * name = stackalloc char[(int)size];
   bool success = GetComputerNameW(name, ref size)
   for(uint i = 0; i < size; i++, name++)
   {
    System.Console.Write(*name);
   }
   System.Console.WriteLine();
  }
 }
}

C# Coding Style

2009-10-20T19:35:00.000-07:00

Here I offer some general coding styles for reference, you can get these C# coding standards documents freely available on the Internet.

C# Coding Style

1. Krüger

This C# Coding Style Cuide is based on the layout style devised by Mike Krüger. The PDF format document is available here. This document may be read as a guide to writing robust and reliable programs.

2. Ahmed

This Ahmed style is based on the layout style outlined of C# Coding Style Guide of Salman Ahmed. This document is a nice guide to writing robust and reliable C# programs for beginners.

Java Coding Style

2009-10-20T19:32:00.000-07:00

Here I offer some general coding styles for reference, you can get these Java coding standards documents freely available on the Internet.

Java Coding Style

1. Sun

This coding style is based on the layout style devised by Sun Microsystems, Inc. The PDF format document is available here. It is the authoritative document of Java. Here is the HTML format.

2. AmbySoft

This AmbySoft style is based on the layout style outlined of Coding standards for Java (PDF) and AmbySoft Java Coding Standard.

3. Sandvik

This coding style is based on a combination of the layout of the source code generated by the Kent Sandvik's Java Coding Style Guidelines.

4. Java Ranch

This coding style is based on the layout style outlined in the Java Ranch. They think the official coding standards in Sun's style guide are dumb, this is their style.

5. Netscape

The Netscape's Software Coding Standards Guide for Java, maybe useful for you.

C and C++ Coding Styles

2009-10-20T19:28:00.000-07:00

You can get these C/C++ coding standards documents freely available on the Internet.

C/C++ Coding Style

You can get these C/C++ coding standards documents freely available on the Internet.

1. Stroustrup

The classic Stroustrup style for C++ code as shown in the code samples from his bible The C++ Programming Language. It is a C++ version of the classic "K&R" (Kernighan and Ritchie) C formatting style. Bjarne Stroustrup's C++ Style and Technique FAQ is available here.

2. Possibility

This coding style is based on the layout style outlined in the C++ Coding Standard document written by Todd Hoff of Possibility Outpost, Inc.

3. MFC

This coding style is based on a combination of the layout of the source code generated by the Microsoft Visual C++ Class Wizard and the layout of the MFC source itself.

4. Ellemtel

This coding style is based on the layout style devised by Mats Henricson and Erik Nyquist while they worked at Ellemtel Telecommunications in Sweden. It is available in it's entirety here. It has also been rewritten as a book for Prentice Hall called "Industrial Strength C++" (ISBN: 0131209655).

5. GNU

This coding style is based on the layout style outlined in the GNU Coding Standard and the C++ ammendments from the C++ Standard Library Style Guidelines. It's the coding style of Richard Stallman too.

6. Mozilla

This coding style is based on the layout style outlined in the Mozilla C++ portability guide of David Williams.

7. Indhill

This coding style is based on the layout style outlined of Indian Hill C Style and Coding Stan-dards paper, the authors of it are Bell Labs, University of Toronto, Berkeley University & SoftQuad Incorporated.

8. Whitesmith

Popularized by the examples that came with Whitesmith's C, an early commercial C compiler. This style is known as an "Indented Braces" style. Information on Whitesmith's and other styles can be found here.

9. Wildfire

This coding style is based on the layout style documented in the Wildfire C++ Programming Style by Keith Gabryelski. This document is available here.

10. Flipcode

This coding style is based on the style of Albert Sandberg. This document is available here.

A job interview

2009-10-20T17:55:00.000-07:00

Story I E: Do u have a boyfriend? C: I have. E: Is he working Locally? C: No. He is working Overseas. E: Sorry, my company cannot employ u ! C: Why? E: U will not be able to settle down here permanently. And my Company don’t want to pay extra expenses on the Overseas calls just because of u. *********

Story II E: Any girl friends? C: No. E: So far chased any before? C: Have, but not successful. E: Ever think of getting a job first then start looking for a girlfriend? C: Career is first priority. Currently didn’t want to consider This personal issue. E: Sorry, my company cannot employ u. C: Why? E: You are lacking of P.R skills and confidence!! *********

Story III E: Any girlfriends? C: Yes. E: Is she pretty? C: Not quite. E: Sorry, my company cannot employ you. C: Why? Will this affect your company’s reputation? E: No, it does not affect the company’s reputation but because My company is dealing with arts, our company requested an artist. *********

Story IV E: Any girlfriends? C: Yes. E: Is she pretty? C: yes E: Is she your first lover? C: Yes. E: Sorry, we can’t employ you because you lack of fighting spirit. *********

Story V E: Any girlfriends? C: Yes. E: Is she your first lover? C: No. Have a few already. E: Sorry, my company cannot employ you because you are a “grasshopper”! (Job hoper lah!) *********

Story VI E: Any boyfriends? C: Yes. E: Is he rich? C: No. E: Then sorry, my company cannot employ you because our Company is dealing with money and you will seduce. *********

Story VII E: Any boyfriends? C: Yes. E: Is he rich ? C: Yes, very rich.He owns a company. E: Sorry, we cannot employ you because your boyfriend don’t Even want to employ you, neither do we! C: But,…… there is no position in his company. E: Then,….. what is your qualification? C: Secretary! E: Sorry, we still cannot employ you because your prettiness Will affect your managers’ working spirits. C: But,…… I am not pretty at all. E: It is even worse because my managers will not be interested In you!!

Animation

2009-10-19T07:14:00.000-07:00

You want to view a .AVI file in your window. Use the Animtion control.

+ Creating an Animation Control
The following function creates an animation control in a dialog box. The animation control is positioned below the specified control, and the dimensions of the animation control are based on the dimensions of a frame in the Audio-Video Interleaved (AVI) clip.

// CreateAnimationCtrl - creates an animation control, positions it 
//                       below the specified control in a dialog box, 
//                       and opens the AVI clip for the animation control. 
// Returns the handle to the animation control. 
// hwnd             - handle to the window. 
// hwndBtn              - handle of the control below which the animation control 
//                       is to be positioned. 
// 
// Constants 
//     IDC_ANIMATE - identifier of the animation control. 
//     CX_FRAME, CY_FRAME - width and height of the frames 
//     in the AVI clip. 
HWND CreateAnimationCtrl(HWND hwnd, int nIDCtl)
{
  HWND hwndAnim = NULL;
  RECT rc;
  POINT pt;

  // Create the animation control. 
  hwndAnim = Animate_Create(hwnd, IDC_ANIMATE, WS_BORDER | WS_CHILD, g_hinst);

  // Get the screen coordinates of the specified control button. 
  GetWindowRect(hwndBtn, &rc);

  // Convert the coordinates of the lower-left corner to 
  // client coordinates. 
  pt.x = rc.left;
  pt.y = rc.bottom;
  ScreenToClient(hwnd, &pt);

  // Position the animation control below the Stop button. 
  SetWindowPos(hwndAnim, 0, pt.x, pt.y + 20, CX_FRAME, CY_FRAME, SWP_NOZORDER |
    SWP_DRAWFRAME);

  // Open the AVI clip, and show the animation control. 
  Animate_Open(hwndAnim, "video.AVI");
  ShowWindow(hwndAnim, SW_SHOW);

  return hwndAnim;
}

+ Controlling the AVI Clip
The following function uses the animation control macros to control the display of the AVI clip in an animation control. Use it inside the window procedure.

// DoAnimation - plays, stops, or closes an animation control's 
//               AVI clip, depending on the value of an action flag. 
// hwndAnim    - handle to an animation control 
// nAction     - flag that determines whether to play, stop, or close 
//               the AVI clip. 

void DoAnimation(HWND hwndAnim, int nAction)
{
  switch (nAction)
  {
    case PLAYIT:
      // Play the clip continuously starting with the 
      // first frame. 
      Animate_Play(hwndAnim, 0,  - 1,  - 1);
      break;

    case STOPIT:
      Animate_Stop(hwndAnim);
      break;

    case CLOSEIT:
      Animate_Close(hwndAnim);
      break;

    default:
      break;
  }
  return ;
}

Hook WH_CALLWNDPROC

2009-10-18T13:02:00.000-07:00

The WH_CALLWNDPROC and WH_CALLWNDPROCRET hooks enable you to monitor messages sent to window procedures.

The system calls a WH_CALLWNDPROC hook procedure before passing the message to the receiving window procedure, and calls the WH_CALLWNDPROCRET hook procedure after the window procedure has processed the message.

The WH_CALLWNDPROCRET hook passes a pointer to a CWPRETSTRUCT structure to the hook procedure. The structure contains the return value from the window procedure that processed the message, as well as the message parameters associated with the message. Subclassing the window does not work for messages set between processes.

typedef struct { LRESULT lResult; LPARAM lParam; WPARAM wParam; UINT message; HWND hwnd; } CWPRETSTRUCT, *PCWPRETSTRUCT;

It's enough now for a demonstration program.
// compile with : cl /EHsc main.cpp /link /SUBSYSTEM:WINDOWS /RELEASE
#include "windows.h"
#include "stdio.h"
#pragma comment(lib,"user32")
#pragma comment(lib,"gdi32")
HINSTANCE hInst;
HHOOK hHook;
HANDLE hFile;
LRESULT CALLBACK HookWndProc(HWND, UINT, UINT, LONG);
LRESULT CALLBACK CallWndProc(int, WPARAM, LPARAM);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
  HWND hwnd;
  WNDCLASS wndclass;
  MSG msg;
  hInst = hInstance;
  wndclass.style = CS_HREDRAW | CS_VREDRAW;
  wndclass.lpfnWndProc = (WNDPROC)HookWndProc;
  wndclass.cbClsExtra = 0;
  wndclass.cbWndExtra = 0;
  wndclass.hInstance = hInstance;
  wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
  wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wndclass.lpszMenuName = NULL;
  wndclass.lpszClassName = "WH_CALLWNDPROCExample";
  RegisterClass(&wndclass);
  hwnd = CreateWindow("WH_CALLWNDPROCExample", "Hook example",
    WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
    CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
  ShowWindow(hwnd, nCmdShow);
  UpdateWindow(hwnd);
  while (GetMessage(&msg, NULL, 0, 0))
  {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return msg.wParam;
}

LRESULT CALLBACK HookWndProc(HWND hwnd, UINT msg, UINT wParam, LONG lParam)
{
  switch (msg)
  {
    case WM_CREATE:
      hFile = CreateFile("testdemo.demo", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL, 0);
      hHook = SetWindowsHookEx(WH_CALLWNDPROC, (HOOKPROC)CallWndProc, NULL,
        GetCurrentThreadId());
      return 0;
    case WM_DESTROY:
      UnhookWindowsHookEx(hHook);
      CloseHandle(hFile);
      PostQuitMessage(0);
      return 0;
    default:
      return DefWindowProc(hwnd, msg, wParam, lParam);
  }
}

LRESULT CALLBACK CallWndProc(int nCode, WPARAM w, LPARAM l)
{
  char cBuffer[0x80];
  DWORD bytesWritten;
  Beep(440, 0.2);
  if (nCode < 0)
    return CallNextHookEx(hHook, nCode, w, l);
  else
  {
    if (nCode == HC_ACTION)
    {
      sprintf(cBuffer, "nCode - %08x", nCode);
      WriteFile(hFile, cBuffer, 17, &bytesWritten, NULL);
      sprintf(cBuffer, "wParam - %08x \n", w);
      WriteFile(hFile, cBuffer, 19, &bytesWritten, NULL);
      sprintf(cBuffer, "PCWPSTRUCT->lParam - %08x \n", ((PCWPSTRUCT)l)->lParam);
      WriteFile(hFile, cBuffer, 31, &bytesWritten, NULL);
      sprintf(cBuffer, "PCWPSTRUCT->wParam - %08x \n", ((PCWPSTRUCT)l)->wParam);
      WriteFile(hFile, cBuffer, 31, &bytesWritten, NULL);
      sprintf(cBuffer, "PCWPSTRUCT->message - %08x \n", ((PCWPSTRUCT)l)
        ->message);
      WriteFile(hFile, cBuffer, 32, &bytesWritten, NULL);
      sprintf(cBuffer, "PCWPSTRUCT->hwnd - %08x \n", ((PCWPSTRUCT)l)->hwnd);
      WriteFile(hFile, cBuffer, 29, &bytesWritten, NULL);
      return CallNextHookEx(hHook, nCode, w, l);
    }
  }
}


Here's the result:

nCode - 00000000 wParam - 00000000 
PCWPSTRUCT->lParam - 00000000 
PCWPSTRUCT->wParam - 00000001 
PCWPSTRUCT->message - 00000018 
PCWPSTRUCT->hwnd - 004b0cf2 
nCode - 00000000 wParam - 00000000 
PCWPSTRUCT->lParam - 0012fe80 
PCWPSTRUCT->wParam - 00000000 
PCWPSTRUCT->message - 00000046 
PCWPSTRUCT->hwnd - 00060ce6 
nCode - 00000000 wParam - 00000000 
PCWPSTRUCT->lParam - 0012fe80 
PCWPSTRUCT->wParam - 00000000 
PCWPSTRUCT->message - 00000046 
PCWPSTRUCT->hwnd - 004b0cf2 
nCode - 00000000 wParam - 00000000 
PCWPSTRUCT->lParam - 0012fe80 
PCWPSTRUCT->wParam - 00000000 
PCWPSTRUCT->message - 00000046 
PCWPSTRUCT->hwnd - 00060ce6 
nCode - 00000000 wParam - 00000000 
PCWPSTRUCT->lParam - 0012fe80 
PCWPSTRUCT->wParam - 00000000 
PCWPSTRUCT->message - 00000046 
PCWPSTRUCT->hwnd - 004b0cf2



Mandelbrot Fractal
2009-10-18T10:16:00.000-07:00

This is a simple version of drawing fractal program using MFC.



// menus.h

#define IDM_DODRAW       1001
#define IDM_EXIT   1002
#include <windows.h>
#include <afxres.h>

#include "menus.h"

MainMenu MENU
{
  POPUP "&File"
  {
    MENUITEM "&Draw", IDM_DODRAW MENUITEM "E&xit", IDM_EXIT
  }
}

#include "afxwin.h"
#include "menus.h"
#pragma comment(lib,"nafxcw")
#define NUM_ITERATIONS 64

const double left =  - 1.0;
const double right = 1.0;
const double top =  - 1.0;
const double bottom = 1.0;

DWORD colors[64];

typedef struct
{
  double real;
  double imag;
} complex;

// Define the application object class
class CManApp: public CWinApp
{
  public:
    virtual BOOL InitInstance();
};

// Define the edit window class
class CManWindow: public CFrameWnd
{
  public:
    CManWindow();
    void RunMandel();
    void SetPix(int x, int y, WORD iter);
    afx_msg void OnPaint();
    afx_msg void OnDoDraw();
    afx_msg void OnExit();
    DECLARE_MESSAGE_MAP()
};

// Create an instance of the application object
CManApp manApp;

// member function used to set pixel colors in
// the window
void CManWindow::SetPix(int x, int y, WORD iter)
{
  CClientDC dc(this);
  dc.SetPixel(x, y, colors[iter]);
}

// member function used to redraw the
// mandelbrot set
void CManWindow::RunMandel()

{
  CRect r;
  double xstep, ystep;
  double x, y;
  int i, j;
  WORD iter;
  complex k;
  complex z;
  double real, imag, spread;

  GetClientRect(&r);

  ystep = (double)(bottom - top) / r.Height();
  xstep = (double)(right - left) / r.Width();

  for (y = top, j = 0; y <= bottom; y += ystep, j++)
  {
    for (x = left, i = 0; x <= right; x += xstep, i++)
    {
      k.real = x;
      k.imag = y;
      z.real = z.imag = 0.0;
      for (iter = 0; iter 4.0)
        break;
    }
    ((CManWindow*)manApp.m_pMainWnd)->SetPix(i, j, iter);
  }
}

}

// The message map
BEGIN_MESSAGE_MAP(CManWindow, CFrameWnd)ON_WM_PAINT()ON_COMMAND(IDM_DODRAW,
  OnDoDraw)ON_COMMAND(IDM_EXIT, OnExit)END_MESSAGE_MAP()

// Handler for the Draw menu option
void CManWindow::OnDoDraw()
{
  // clear the window
  CClientDC dc(this);
  CRect r;
  GetClientRect(&r);
  dc.PatBlt(0, 0, r.Width(), r.Height(), WHITENESS);
  // Redraw the set
  RunMandel();
}

// Handler for WM_PAINT messages
void CManWindow::OnPaint()
{
  // Do not do anything in response to
  // paint events
  ValidateRect(NULL);
}

// Handler for the Exit menu option
void CManWindow::OnExit()
{
  DestroyWindow();
}

// CManWindow constructor
CManWindow::CManWindow()
{
  WORD x;
  BYTE red = 0, green = 0, blue = 0;

  Create(NULL, ONormal Mandel ExampleO, WS_OVERLAPPEDWINDOW, CRect(0, 0, 150,
    150), NULL, OMainMenuO);
  for (x = 0; x < 64; x++)
  {
    colors[x] = RGB(red, green, blue);
    if (!(red += 64))
      if (!(green += 64))
        blue += 64;
  }
  colors[63] = RGB(255, 255, 255);
} 
  // Initialize the CManApp m_pMainWnd data member BOOL CManApp::InitInstance() { m_pMainWnd = new CManWindow(); m_pMainWnd -> ShowWindow( m_nCmdShow );
m_pMainWnd->UpdateWindow();

return TRUE;
}

Compile resource: rc mandel.rc
Compile project: cl /EHsc mandel.cpp /link /SUBSYSTEM:WINDOWS /RELEASE mandel.res
Download project here



Allocating a console inside an MFC program
2009-10-18T06:16:00.000-07:00

If you want to write the text out to the console while this is an MFC program. Here's the tip:

The thing to be remarked here is the function AllocConsole, it's called inside function InitInstance() of the App class.

// button.cpp
// compile with : cl /EHsc button.cpp /link /SUBSYSTEM:WINDOWS /RELEASE
#include "afxwin.h"
#include "iostream"
using namespace std;

#define IDB_BUTTON 100

// Declare the handles for the console
HANDLE consoleStdout, consoleStdin;

// Declare the application class
class CButtonApp : public CWinApp
{
public:
virtual BOOL InitInstance();
};

// Create an instance of the application class
CButtonApp ButtonApp;

// Declare the main window class
class CButtonWindow : public CFrameWnd
{
CButton *button;
public:
CButtonWindow();
~CButtonWindow();
afx_msg void HandleButton();

DECLARE_MESSAGE_MAP()
};

// The message handler function
void CButtonWindow::HandleButton()
{
DWORD n;

Beep(700,100);
// Two different ways to write to the console
WriteFile(consoleStdout, "hello\n", 6, &n, 0);
cout << "test string" << endl;}// The message mapBEGIN_MESSAGE_MAP(CButtonWindow, CFrameWnd)   ON_COMMAND(IDB_BUTTON, HandleButton)END_MESSAGE_MAP()// The InitInstance function is called once// when the application first executesBOOL CButtonApp::InitInstance(){   // Create an auxiliary console for cout to use.   // As soon as this function returns you   // can write to it.   AllocConsole();      // Get handles for standard in and out   consoleStdin = GetStdHandle(STD_INPUT_HANDLE);   consoleStdout = GetStdHandle(STD_OUTPUT_HANDLE);   // they must be invalid if equal   if (consoleStdin == consoleStdout)      return FALSE;         m_pMainWnd = new CButtonWindow();   m_pMainWnd->ShowWindow(m_nCmdShow);
m_pMainWnd->UpdateWindow();

return TRUE;
}

// The constructor for the window class
CButtonWindow::CButtonWindow()
{
CRect r;

// Create the window itself
Create(NULL,
"CButton Tests",
WS_OVERLAPPEDWINDOW,
CRect(0,0,200,200));

// Get the size of the client rectangle
GetClientRect(&r);
r.InflateRect(-20,-20);

// Create a button
button = new CButton();
button->Create("Push me",
WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
r,
this,
IDB_BUTTON);
}

// The destructor for the window class
CButtonWindow::~CButtonWindow()
{
delete button;
CFrameWnd::~CFrameWnd();
}



Thread Local Storage
2009-10-18T06:00:00.000-07:00

Suppose we have a Dll module, and in this dll occurs dynamic memory allocation.

If this Dll is used by only one thread of attched process, then we only need 1 pointer to save the address of new allocated memory. 
But we can use this mechanism if there are many threads accessing the Dll. 
Now we need TLS ( Thread Local Storage).
TLS of thread is an array of pointers, which are accessed through indexes.
We need to do the following:
+ Allocation memory
+ Work with pointer
+ Free allocated memory.
The functions used are TlsAlloc, TlsSetValue and TlsGetValue, and TlsFree.
That's all about TLS !!!
Here's the sample code of the DLL and the process with multiple threads.

#include "windows.h>
#include "iostream"
using namespace std;
int (*Add)(int);
DWORD WINAPI thread(LPVOID iNum)
{
for(int i = 0; i < (int)iNum; ++i)    {        cout << "count = " << Add((int)iNum) << endl;        Sleep(15);    }    return 0;}int main(){    char c;    HMODULE hDll;    HANDLE hThread[2];    DWORD idThread[2];    hDll = LoadLibrary("Count.dll");    Add = (int (*)(int))GetProcAddress(hDll,"Add");    hThread[0] = CreateThread(NULL, 0, thread, (void*)3, 0, &idThread[0]);    hThread[1] = CreateThread(NULL, 0, thread, (void*)5, 0, &idThread[1]);    WaitForMultipleObjects(2,hThread,TRUE,INFINITE);    FreeLibrary(hDll);    return 0;}



Dll


#include "windows.h"
#include "iostream"
using namespace std;
DWORD dwTlsIndex;

BOOL WINAPI DllMain(HINSTANCE hDll, DWORD dwReason, LPVOID lpReserved)
{
BOOL retVal = TRUE;
int *pCount; 
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
dwTlsIndex = TlsAlloc();
break;
case DLL_THREAD_ATTACH:
pCount = new int(0);
TlsSetValue(dwTlsIndex,pCount);
break;
case DLL_THREAD_DETACH:
pCount = (int*)TlsGetValue(dwTlsIndex);
delete pCount;
break;
case DLL_PROCESS_DETACH:
TlsFree(dwTlsIndex);
brek;
}
return retVal;
}
extern "C" __declspec(dllexport) int Add(int n)
{
int *pCount;
pCount = (int*)TlsGetValue(dwTlsIndex);
*pCount += n;
return *pCount;
}


Process communication via pagefile
2009-10-18T03:59:00.000-07:00


We have 2 process, one is to create the file, and the other one is to read the file.



The tip i want to show here is using function of mapped file.

We need 2 functions to do the thing.

HANDLE CreateFileMapping(HANDLE hFile, LPSECURITY_ATTRIBUTES lpAttr, DWORD
flProtect, DWORD maximum_size_high, DWORD maximum_size_low, LPCTSTR lpName);

where hFile - file handle lpAttr - security attributes flProtect - flags of
file access maximum_size_ * - size of object lpName - name of mapping object

Yes, this function really creates a mapping object, who will map our normal file to the memory. We need it with the second function:

LPVOID MapViewOfFile(HANDLE hFileMappingObject, DWORD desired_access, DWORD
offset_high, DWORD offset_low, SIZE_T number_of_bytes_to_map);

To understand the functions, let 's see the sample code.

#include <windows.h>
#include <fstream>
using namespace std;

int main()
{
  int a[10] = 
{
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  };
  char file_name[] = "demo.bin";
  HANDLE hFile, hMapping;
  int *ptr; // pointer to a

  ofstream out(file_name, ios: out | ios::binary);
  for (int i = 0; i < 10; i++)
    out.write((char*) &a[i], sizeof(int));
  out.close();

  hFile = CreateFile(file_name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  hMapping = CreateFileMapping(hFile, NULL, PAGE_READWRITE, 0, 0, NULL);
  ptr = (int*)MapViewOfFile(hMapping, FILE_MAP_WRITE, 0, 0, 0); 
// here we map file from beginning and map all the file.

  // modify the array
  for (int i = 0; i < 10; ++i)
    ptr[i] += 10;
  UnmapViewOfFile(ptr);

  CloseHandle(hMapping);
  CloseHandle(hFile);
}





The process here is:

[File on disk] --> [View in memory] --> [Modified File on disk]

You don't need to due complexly with direct operations on the file. Now with these 2 functions, we have a cool tool to work with files like variables and pointers.



The last example now is the process communication using mapped file.

Suppose we had the file demo.bin on disk.

The above code doesn't have a mapping object name. Now we need a name for the mapping object, and this object will be shared among processes !!!

I just recommend some modified codes here:

char mapping_name[] = "MappingName";
// now create the mapping object with this name
// use INVALID_HANDLE_VALUE indicates that we use the pagefile of operating system
hMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, n
*sizeof(int),  < b > mapping_name <  / b > );

Suppose now we have a file "C:\\ReadArray.exe" , which reads the array through file mapping.

Now is the code for loading the reading process:

char lpszAppName[] = "C:\\ReadArray.exe";
STARTUPINFO si;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
// spawn new console process
CreateProcess(lpszAppName, NULL, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL,
  NULL, &si, &pi);
// just wait now...
WaitForSingleObject(pi.hProcess, NIFINITE);
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);




Asynchronous windows I/O ( Overlapped I/O ) (continue)
2009-10-18T03:12:00.000-07:00
In part 1, i described functions and how to use the asynchronous I/O operations.

Now it's time to go more deeply in these operations



The thing i want to show here is the CALLBACK function for the completion of overlapped I/O operations.

At first, let's see the codes sample:

#include <windows.h>
#include <iostream>
using namespace std;

VOID CALLBACK completion_routine(DWORD error_code, DWORD
number_bytes_transferred, LPOVERLAPPED lovl)
{
  cout << "ErrorCode: " << error_code << endl << 
"\tNumber of bytes transferred: " << number_bytes_transferred << endl << 
"\t Offsets: " << (*lovl).OffsetHigh << ' ' << (*lovl).Offset << endl;
}

int main()
{
  HANDLE hFile;
  OVERLAPPED ovl = 
{
    0, 0, 0, 0, 0
  };
  hFile = CreateFile("C:\demo.dat", GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
    OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
  // write to file
  for (int i = 0; i < 10; ++i)
  {
    WriteFileEx(hFile, &i, sizeof(i), &ovl, completion_routine);
    SleepEx(INFINITE, TRUE);
    ovl.Offset += sizeof(i);
  }
  CloseHandle(hFile);
  return 0;
}





Firstly is the prototype of callback function:



VOID CALLBACK procedure_name(DWORD error_code, DWORD number_of_byte_transferred, LPOVERLAPPED lovl);
The parameters are self-explained.

Secondly, we use the function WriteFileEx with prototype:



BOOL WriteFileEx(HANDLE hFile, LPCVOID lpBuffer, DWORD number_of_bytes_to_write, LPOVERLAPPED lovl, LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine);
Remark the LPOVERLAPPED_COMPLETION_ROUTINE here, it's the type of callback function we described above.




Asynchronous windows I/O ( Overlapped I/O )
2009-10-18T02:33:00.000-07:00
You may check the artical : "TransmitFile internal" for understanding the use of asynchronous operations on socket.



Now it's time to clear out something. And i think after reading this artical, you can go through other codes about asychronous I/O without problems.

Remember that, in windows, asynchronous I/O is also called overlapped I/O.

To use asynchronous I/O operations, the functions are ReadFile and WriteFile , but the file needs to be opened in the mode FILE_FLAG_OVERLAPPED.

Now there is a question: How can thread knows about the completion of I/O operations ?

The answer is : Use an event descriptor.

This is the format of structure OVERLAPPED.

typedef struct _OVERLAPPED
{
  DWORD Internal; // reserved
  DWORD InternalHigh; // reserved
  DWORD Offset;
  DWORD OffsetHigh;
  HANDLE hEvent;
} OVERLAPPED,  *LPOVERLAPPED;

The fields Offset and OffsetHigh indicate low part and high part of the offset according to the beggining of the file. From this offset, operating system begins run the asynchronous operations.

Parameter hEvent is used by thread for the completion of I/O operations.

OK, let's go to the codes: Writing 0 to 10 to file demo.dat

#include <windows.h>

using namespace std;
int main()
{
  HANDLE hFile;
  HANDLE hEndWrite; // event
  OVERLAPPED ovl;
  hEndWrite = CreateEvent(NULL, FALSE, FALSE, NULL);

  ovl = 
{
    0, 0, 0, 0, hEvent
};

  hFile = CreateFile("C:\\demo.dat", GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
    OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);

  // write to file

  for (int i = 0; i < 10; ++i)
  {
    DWORD dwBytesWritten;
    DWORD ret;
    WriteFile(hFile, &i, sizeof(i), &dwBytesWritten, &ovl);
    WaitForSingleObject(hEndWrite, INFINITE);
    ovl.Offset += sizeof(i);
  }

  CloseHandle(hFile);
  CloseHandle(hEndWrite);

  return 0;
}








Understanding security
2009-10-18T02:08:00.000-07:00


- When users log in, they receive access token. An access token contains the users'ID, the users'groups, and the users's privileges according to the groups.
- Each object has a security descriptor, which acts as its lock. A security descriptor contains an owner and group identifier, a System ACL and a Discretionary ACL.
- A DACL controls who is allowed to do what to the object.
- A SACL controls who is audited for doing what to the object.
- ACLs consist of ACEs. Each ACE contains a SID, which identifies the user or group, an access mask, which determines the actions allowed to the user or group, and an ACE header, which determines the type of ACE.

First sample code: A simple security program (without any error checking) that creates a file that only the user "guest" can read. This code will not work unless you have formatted your hard disk with the NT File System
#include "windows.h"
#include "iostream"
using namespace std;

SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
BYTE aclBuffer[1024];
PACL pacl = (PACL) &aclBuffer;
BYTE sidBuffer[100];
PSID psid = (PSID) &sidBuffer;
DWORD sidBufferSize = 100;
char domainBuffer[80];
DWORD domainBufferSize = 80;
SID_NAME_USE snu;
HANDLE file;

void main(void)
{
  InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
  InitializeAcl(pacl, 1024, ACL_REVISION);
  LookupAccountName(0, "guest", psid,  &sidBufferSize, domainBuffer, 
    &domainBufferSize, &snu);
  AddAccessAllowedAce(pacl, ACL_REVISION, GENERIC_READ, psid);
  SetSecurityDescriptorDacl(&sd, TRUE, pacl, FALSE);

  sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  sa.bInheritHandle = FALSE;
  sa.lpSecurityDescriptor = &sd;

  file = CreateFile("c:\\testfile", GENERIC_READ | GENERIC_WRITE, 0, &sa,
    CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);
  CloseHandle(file);
}

Understand the code:
+ The creation of a security descriptor starts with a call to theInitialize SecurityDescriptor function 

BOOL InitializeSecurityDescriptor(
PSECURITY_DESCRIPTOR psd,
DWORD revision)
where psd -  a pointer to the security descriptor 
and revision -  revision level, must be SECURITY_DESCRIPTOR_REVISION 
The new security descriptor initially contains no information besides the revision level: no owner identifier, no group identifier, no SACL, and no DACL.
+ The next line calls InitializeAcl to create the ACL that will become the DACL for the security descriptor.

BOOL InitializeAcl(
PACL pacl,
DWORD bufferLen,
DWORD revision)

where   
pacl - a pointer to an ACL 
bufferLen - the length of the ACL buffer supplied 
revision - revision level, must be ACL_REVISION 
When the InitializeAcl function returns, pacl points to an empty ACL. That is, the ACL contains no ACEs. If you were to comment out the next two lines so that this empty ACL was placed into the security descriptor, and that security descriptor was then applied to the file, no one would be able to access the file.
+ The LookupAccountName function returns a SID for the specified account name.

BOOL LookupAccountName(
LPCTSTR system,
LPCTSTR accountName,
PSID psid,
LPDWORD sidBufferSize,
LPTSTR domainName,
LPDWORD domainNameLen,
PSID_NAME_USE psnu)

where
system - name of a remote system, or 0 for local 
accountName - the name of the account to look up 
psid - a pointer to a buffer for the returned SID 
sidBufferSize - the size of the psid buffer 
domainName - a pointer to a buffer for the returned domain name 
domainNameLen - size of the domain name buffer 
psnu - returned enumerated type indicating the type of account 
The function returns a SID for the account, the domain where it was found if the SID came from a domain controller, and an enumerated value that indicates the type of account:

SidTypeUser 
SidTypeGroup 
SidTypeDomain 
SidTypeAlias 
SidTypeWellKnownGroup 
SidTypeDeletedAccount 
SidTypeInvalid 
SidTypeUnknown 
A SID is asecurity identifier. It uniquely identifies a user or a group to the system.

+ The SID returned by the LookupAccountName function is used in a call to the AddAccessAllowedAce function to create an access-allowed (as opposed to access-denied) ACE and add it to the currently-empty ACL.

BOOL AddAccessAllowedAce(
PACL pacl,
DWORD revision,
DWORD accessMask,
PSID psid)

where    
pacl - a pointer to an ACL 
revision - revision level. Must be ACL_REVISION 
accessMask - access mask bits 
Psid - A SID 
+ Now we has an ACL containing one ACE that specifies that the user "guest" should have read access. This ACL needs to be placed into the Discretionary ACL of the security descriptor using the Set SecurityDescriptorDacl function.

BOOL SetSecurityDescriptorDacl(
PSECURITY_DESCRIPTOR psd,
BOOL daclPresent,
PACL pacl,
BOOL daclDefaulted)

where 
psd - a pointer to a security descriptor 
daclPresent - a boolean that if TRUE says pacl contains an ACL. If it is FALSE, the function ignores anything in pacl and sets the DACL in the security descriptor to NULL 
pacl - a pointer to the ACL to add 
daclDefaulted - a boolean indicating the source of the DACL