/*[]=====================================================================[]*/
/*[]     LeadTools Run Time Library - Version 10                         []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2000 LEAD Technologies, Inc.                 []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

#include "All.h"


LRESULT CALLBACK    FrameWndProc         (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    ChildWndProc         (HWND, UINT, WPARAM, LPARAM);
L_BOOL  CALLBACK    AboutDlgProc         (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK    CloseEnumProc        (HWND, LPARAM);
LRESULT CALLBACK    EnumChildProc        (HWND, LPARAM);

//      Macros Definitions   
BOOL Frame_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct);
void Frame_OnSize(HWND hwnd, UINT state, int cx, int cy);
void Frame_OnTimer(HWND hwnd, UINT id);
BOOL Frame_OnQueryNewPalette(HWND hwnd);
void Frame_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange);
void Frame_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange);
void Frame_SysColorChange(HWND hwnd);
void Frame_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, BOOL fMinimized);
void Frame_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify);
void Frame_OnDestroy(HWND hwnd);
void Frame_OnInitMenuPopup(HWND hwnd, HMENU hMenu, UINT uPos, BOOL bSysMenu);
void Statusbar (int id, HWND hwnd);

//      Child Macros Definitions   
BOOL Child_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct);
void Child_OnSize(HWND hwnd, UINT state, int cx, int cy);
void Child_OnVScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos);
void Child_OnHScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos);
void Child_OnPaint(HWND hwnd);
void Child_OnTimer(HWND hwnd, UINT id);
void Child_OnMDIActivate(HWND hwnd, BOOL fActive, HWND hwndActivate, HWND hwndDeactivate);
void Child_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange);
BOOL Child_OnQueryNewPalette (HWND hWnd);

void Child_OnDestroy(HWND hwnd);


L_BOOL              gbHotKey;      /* Is Hotkey enabled? */
L_INT               InitializeApp      (HINSTANCE);
L_INT L_EXPORT      pfnCaptureCallback (pBITMAPHANDLE pBitmap, pLEADCAPTUREINFO pCaptureInfo, L_VOID L_FAR* pUserData);

void                InitializeInst (HINSTANCE, L_INT);

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

   ghInst = hInstance;
   InitializeApp (hInstance);
   UNLOCKSUPPORT ();  // Lead tools security function

   ghMenuInit       = LoadMenu (hInstance, TEXT("IDRCAPMENU"));
   ghMenuInitWindow = GetSubMenu (ghMenuInit, 0);

   InitializeInst (hInstance, iCmdShow);

   SetTimer (ghWndFrame, ID_TIMER, 100, NULL); //This Timer is for the bitmap if it has a region. 

   if (ghWndClient == NULL)
      return -1;

   L_DlgInit(DLG_INIT_COLOR);

   while (GetMessage (&msg, NULL, 0, 0))
   {
      if (!TranslateMDISysAccel (ghWndClient, &msg))
      {
         TranslateMessage (&msg) ;
         DispatchMessage (&msg) ;
      }
   }

   L_DlgFree();

   return msg.wParam ;
} 

 
LRESULT CALLBACK FrameWndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
   switch (iMsg)
   {
      HANDLE_MSG (hwnd, WM_CREATE,          Frame_OnCreate);
      HANDLE_MSG (hwnd, WM_SIZE,            Frame_OnSize);
      HANDLE_MSG (hwnd, WM_TIMER,           Frame_OnTimer);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE, Frame_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,  Frame_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_PALETTEISCHANGING, Frame_OnPaletteChanging);
      HANDLE_MSG (hwnd, WM_SYSCOLORCHANGE,  Frame_SysColorChange);
      HANDLE_MSG (hwnd, WM_ACTIVATE,        Frame_OnActivate);
      HANDLE_MSG (hwnd, WM_COMMAND,         Frame_OnCommand);
      HANDLE_MSG (hwnd, WM_DESTROY,         Frame_OnDestroy);
      HANDLE_MSG (hwnd, WM_INITMENUPOPUP,   Frame_OnInitMenuPopup);
   }
   return DefFrameProc (hwnd, ghWndClient, iMsg, wParam, lParam);
}


LRESULT CALLBACK EnumChildProc(HWND hwnd, LPARAM hwndActiveChild)
{
   if (hwnd != (HWND)hwndActiveChild)
      SendMessage (hwnd, WM_PALETTECHANGED, 0, 0);
   return 0;
}

LRESULT CALLBACK CloseEnumProc (HWND hwnd, LPARAM lParam)
{
   if (GetWindow (hwnd, GW_OWNER))
      return 1;

   SendMessage (GetParent (hwnd), WM_MDIDESTROY, (WPARAM) hwnd, 0);

   return 1;
}


LRESULT CALLBACK ChildWndProc (HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
   switch (iMsg)
   {
      HANDLE_MSG (hwnd, WM_CREATE,          Child_OnCreate);
      HANDLE_MSG (hwnd, WM_SIZE,            Child_OnSize);
      HANDLE_MSG (hwnd, WM_VSCROLL,         Child_OnVScroll);
      HANDLE_MSG (hwnd, WM_HSCROLL,         Child_OnHScroll);
      HANDLE_MSG (hwnd, WM_PAINT,           Child_OnPaint);
      HANDLE_MSG (hwnd, WM_TIMER,           Child_OnTimer);
      HANDLE_MSG (hwnd, WM_MDIACTIVATE,     Child_OnMDIActivate);
      HANDLE_MSG (hwnd, WM_PALETTECHANGED,  Child_OnPaletteChanged);
      HANDLE_MSG (hwnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette);
      HANDLE_MSG (hwnd, WM_DESTROY,         Child_OnDestroy);
   }
   return DefMDIChildProc (hwnd, iMsg, wParam, lParam) ;
}

L_INT  InitializeApp  (HINSTANCE hInstance)
{
   WNDCLASSEX   wndclass;

   gbHotKey = TRUE;
   wndclass.cbSize        = sizeof (wndclass) ;
   wndclass.style         = 0;
   wndclass.lpfnWndProc   = FrameWndProc ;
   wndclass.cbClsExtra    = 0 ;
   wndclass.cbWndExtra    = 0 ;
   wndclass.hInstance     = hInstance ;
//   wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
   wndclass.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1));
   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground = (HBRUSH) GetStockObject (GRAY_BRUSH);
   wndclass.lpszMenuName  = NULL;
   wndclass.lpszClassName = gszFrameClass;
//   wndclass.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;
   wndclass.hIconSm         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1));

   if (RegisterClassEx (&wndclass) == 0)
      return 0;


   wndclass.cbSize        = sizeof (wndclass) ;
   wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
   wndclass.lpfnWndProc   = ChildWndProc;
   wndclass.cbClsExtra    = 0;
   wndclass.cbWndExtra    = sizeof (pBITMAPHANDLE);
   wndclass.hInstance     = hInstance ;
//   wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
   wndclass.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1));
   wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
   wndclass.hbrBackground = (HBRUSH) GetStockObject (GRAY_BRUSH) ;
   wndclass.lpszMenuName  = NULL ;
   wndclass.lpszClassName = gszChildClass;
//   wndclass.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;
   wndclass.hIconSm         = LoadIcon (hInstance, MAKEINTRESOURCE(IDI_ICON1));

   if (RegisterClassEx (&wndclass) == 0)
      return 0;

   return 1;
}

void InitializeInst (HINSTANCE hInstance, L_INT iCmdShow)
{
   HWND   hwnd;

   ghWndFrame = CreateWindow (gszFrameClass,    
                          TEXT("LEADTOOLS Screen Capture Demo"),       
                           WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,  
                           CW_USEDEFAULT,           
                           CW_USEDEFAULT,           
                           CW_USEDEFAULT,           
                           CW_USEDEFAULT,           
                           NULL,                    
                           ghMenuInit,               
                           hInstance,               
                           NULL);                

   if (ghWndFrame == NULL)
      return;

   hwnd = GetWindow (ghWndFrame, GW_CHILD);

   ShowWindow   (ghWndFrame, iCmdShow);
   UpdateWindow (ghWndFrame);
}

L_INT L_EXPORT pfnCaptureCallback (pBITMAPHANDLE pBitmap, pLEADCAPTUREINFO pCaptureInfo, L_VOID L_FAR* pUserData)
{
   MDICREATESTRUCT      mdicreate;
   RECT                 rcDest;

   mdicreate.szClass = gszChildClass;
   mdicreate.szTitle = (LPCTSTR)pUserData;
   mdicreate.hOwner  = ghInst;
   mdicreate.x       = CW_USEDEFAULT;
   mdicreate.y       = CW_USEDEFAULT;
   mdicreate.cx      = CW_USEDEFAULT;
   mdicreate.cy      = CW_USEDEFAULT;
   mdicreate.style   = WS_CHILD | WS_CLIPSIBLINGS| WS_CLIPCHILDREN| WS_SYSMENU| WS_CAPTION| WS_THICKFRAME| WS_MINIMIZEBOX| WS_MAXIMIZEBOX | WS_VSCROLL | WS_HSCROLL;
   mdicreate.lParam  = (LPARAM) pBitmap;

   SendMessage (ghWndClient,
               WM_MDICREATE, 
               0, 
               (LPARAM) &mdicreate);
   GetClientRect  (ghSBwnd, &rcDest);
   DrawStatusText (GetDC (ghSBwnd), &rcDest, TEXT("Ready"), SBT_RTLREADING);

   if (gbBeepOn)
      MessageBeep (0xffffffff);

   if (gbRestore)
   {
      ShowWindow (ghWndFrame, SW_RESTORE);
      SendMessage (ghWndClient, WM_MDICASCADE, MDITILE_SKIPDISABLED, 0);
   }

   return TRUE;
}

L_BOOL CALLBACK  AboutDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
   switch (iMsg)
   {
   case WM_INITDIALOG :
      return TRUE;

   case WM_COMMAND :
      switch (LOWORD (wParam))
      {
      case IDOK :
      case IDCANCEL :
         EndDialog (hDlg, 0);
         return TRUE;
      }
      break;
   }
   return FALSE;
}

/*====(Child_OnCreate)=====================================================
Description: Creates an MDI child window. 

Syntax     : BOOL Child_OnCreate(HWND hWnd, CREATESTRUCT FAR* lpCreateStruct)

Parameters : hWnd             Handle of a window.
             lpCreateStruct   Pointer to CREATESTRUCT

Return Value: TRUE            The function was successful.
              FALSE           The function was not successful.
==========================================================================*/
static BOOL Child_OnCreate (HWND hwnd, CREATESTRUCT FAR * lpCreateStruct)
{
   LPCHILDDATA pData = GlobalAllocPtr(GMEM_MOVEABLE, sizeof(CHILDDATA));
   // allocate the memory to store the bitmap
   // copy the bitmap data to the newly allocated bitmap
   pData->Bitmap = *(pBITMAPHANDLE) ((LPMDICREATESTRUCT)(lpCreateStruct->lpCreateParams))->lParam;
   pData->iVscrollPos = 0;
   pData->iHscrollPos = 0;
   SetWindowLong (hwnd, GWL_USERDATA, (L_INT32)pData);
   return TRUE;
}


/*====(Child_OnSize)=====================================================
Description: Responds to WM_SIZE message and sets the internal data
             accordingly. Also forwards the message to DefMDIChildProc.

Syntax     : void Child_OnSize(HWND hwnd, UINT state, int cxClient, int cyClient)

Parameters : hWnd          Handle to the child window.
             nState        State of resizing requested.
             nCx           Size to be used for the "x" direction.
             nCy           Size to be used for the "y" direction.

Return Value: None.
==========================================================================*/
void Child_OnSize(HWND hwnd, UINT state, int cxClient, int cyClient)
{
   LPCHILDDATA pData = GETCHILDDATA(hwnd);
   pData->cxClient = cxClient;
   pData->cyClient = cyClient;
   pData->iVscrollMax = max (0, BITMAPHEIGHT (&pData->Bitmap) - cyClient);
   pData->iVscrollPos = min (pData->iVscrollPos, pData->iVscrollMax);
   SetScrollRange (hwnd, SB_VERT, 0, pData->iVscrollMax, FALSE);
   SetScrollPos   (hwnd, SB_VERT, pData->iVscrollPos, TRUE) ;
   pData->iHscrollMax = max(0, BITMAPWIDTH (&pData->Bitmap) - cxClient);
   pData->iHscrollPos = min (pData->iHscrollPos, pData->iHscrollMax) ;
   SetScrollRange (hwnd, SB_HORZ, 0, pData->iHscrollMax, FALSE) ;
   SetScrollPos   (hwnd, SB_HORZ, pData->iHscrollPos, TRUE) ;
   DefMDIChildProc (hwnd, WM_SIZE, state, MAKELPARAM(cxClient, cyClient));
}

/*====(Child_OnVScroll)=====================================================
Description: Scrolls the child window horizontally.

Syntax     : VOID Child_OnHScroll(HWND hWnd, HWND hWndCtl, UINT nCode,
                                  int npos)

Parameters : hWnd          Handle of a window.
             hWndCtl       Not used.
             nCode         Amount/Direction to be scrolled.
             npos          The new position of the thumb.

Return Value: None.
==========================================================================*/
void Child_OnVScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos)
{
   LPCHILDDATA pData = GETCHILDDATA(hwnd);
   L_INT       iVscrollInc;
   RECT        rcUpdated;

   pData->iVscrollPos = GetScrollPos (hwnd, SB_VERT);

   switch (code)
   {
   case SB_TOP :
      iVscrollInc = -pData->iVscrollPos ;
      break ;

   case SB_BOTTOM :
      iVscrollInc = pData->iVscrollMax - pData->iVscrollPos ;
      break ;

   case SB_LINEUP :
      iVscrollInc = -3 ;
      break ;

   case SB_LINEDOWN :
      iVscrollInc = 3 ;
      break ;

   case SB_PAGEUP :
      iVscrollInc = min (-9, -pData->cyClient) ;
      break ;

   case SB_PAGEDOWN :
      iVscrollInc = max (9, pData->cyClient) ;
      break ;

   case SB_THUMBTRACK :
      iVscrollInc = pos - pData->iVscrollPos ;
      break ;

   default :
      iVscrollInc = 0 ;
   }
   iVscrollInc = max (-pData->iVscrollPos, min (iVscrollInc, pData->iVscrollMax - pData->iVscrollPos)) ;

   if (iVscrollInc != 0)
   {
      pData->iVscrollPos += iVscrollInc ;
      ScrollWindowEx(hwnd, 0, -iVscrollInc, NULL, NULL, NULL, &rcUpdated, 0); 
      SetScrollPos (hwnd, SB_VERT, pData->iVscrollPos, TRUE) ;
      InvalidateRect (hwnd, &rcUpdated, TRUE);
      UpdateWindow (hwnd) ;
   }
}


/*====(Child_OnHScroll)=====================================================
Description: Scrolls the child window horizontally.

Syntax     : VOID Child_OnHScroll(HWND hWnd, HWND hWndCtl, UINT nCode,
                                  int npos)

Parameters : hWnd          Handle of a window.
             hWndCtl       Not used.
             nCode         Amount/Direction to be scrolled.
             npos          The new position of the thumb.

Return Value: None.
==========================================================================*/
void Child_OnHScroll(HWND hwnd, HWND hwndCtl, UINT code, int pos)
{
   LPCHILDDATA pData = GETCHILDDATA(hwnd);
   L_INT       iHscrollInc;
   RECT        rcUpdated;

   pData->iHscrollPos = GetScrollPos (hwnd, SB_HORZ);
   switch (code)
   {
   case SB_LINEUP :
      iHscrollInc = -3;
      break ;

   case SB_LINEDOWN :
      iHscrollInc = 3;
      break ;

   case SB_PAGEUP :
      iHscrollInc = -9;
      break ;

   case SB_PAGEDOWN :
      iHscrollInc = 9;
      break ;

   case SB_THUMBTRACK :
      iHscrollInc = pos - pData->iHscrollPos ;
      break ;

   default :
      iHscrollInc = 0 ;
   }
   iHscrollInc = max (-pData->iHscrollPos,
                 min (iHscrollInc, pData->iHscrollMax - pData->iHscrollPos)) ;

   if (iHscrollInc != 0)
   {
      pData->iHscrollPos += iHscrollInc ;
      ScrollWindowEx(hwnd, -iHscrollInc, 0, NULL, NULL, NULL, &rcUpdated, 0); 
      SetScrollPos (hwnd, SB_HORZ, pData->iHscrollPos, TRUE);
      InvalidateRect (hwnd, &rcUpdated, TRUE);
      UpdateWindow (hwnd);
   }
}

/*====(Child_OnPaint)=====================================================
Description: Paints the child window.

Syntax     : VOID Child_OnPaint(HWND hWnd)

Parameters : hWnd          Handle of the child window.

Return Value: None.
==========================================================================*/
void Child_OnPaint(HWND hwnd)
{
   LPCHILDDATA    pData = GETCHILDDATA(hwnd);
   PAINTSTRUCT    ps;
   HDC            hdc   = BeginPaint (hwnd, &ps);
   HPALETTE       hSavedPalette;
   L_INT          nRet;
   RECT           rcDest;

   if (!ghPalette)
      ghPalette = L_CreatePaintPalette(hdc, &pData->Bitmap);
   
   if (ghPalette)
   {
      hSavedPalette = SelectPalette (hdc, ghPalette, TRUE);
      RealizePalette(hdc);
   }
   
   GetClientRect (hwnd, &rcDest);
   pData->iVscrollPos=GetScrollPos (hwnd, SB_VERT);
   pData->iHscrollPos=GetScrollPos (hwnd, SB_HORZ);

   SetRect (&rcDest,-pData->iHscrollPos,-pData->iVscrollPos, BITMAPWIDTH(&pData->Bitmap)-pData->iHscrollPos, BITMAPHEIGHT(&pData->Bitmap)-pData->iVscrollPos);
   
   nRet = L_PaintDC (ps.hdc, 
                     &pData->Bitmap,
                     NULL, 
                     NULL, 
                     &rcDest, 
                     &ps.rcPaint, 
                     SRCCOPY);
   
   
   if (ghPalette!= NULL)
   {
      SelectPalette (hdc, hSavedPalette, TRUE);
   }
   
   ReleaseDC (hwnd, hdc);
   EndPaint  (hwnd, &ps);
}

/*====(Child_OnTimer)=====================================================
Description: Called when the timer value expires

Syntax     : L_VOID Child_OnTimer(HWND hWnd, UINT id)

Parameters : hWnd          Handle of the child window.
             id            Timer id supplied in SetTimer

Return Value: None.
==========================================================================*/
void Child_OnTimer(HWND hwnd, UINT id)
{
   LPCHILDDATA    pData = GETCHILDDATA(hwnd);
   HDC            hdc   = GetDC (hwnd);
   RGNXFORM       RgnXForm;

   if (L_BitmapHasRgn (&pData->Bitmap))
   {
      RgnXForm.uViewPerspective = TOP_LEFT;

      RgnXForm.nXScalarDen = BITMAPWIDTH  (&pData->Bitmap);
      RgnXForm.nYScalarDen = BITMAPHEIGHT (&pData->Bitmap);

      RgnXForm.nXScalarNum = BITMAPWIDTH  (&pData->Bitmap);
      RgnXForm.nYScalarNum = BITMAPHEIGHT (&pData->Bitmap);

      RgnXForm.nXOffset    = -GetScrollPos (hwnd, SB_HORZ);
      RgnXForm.nYOffset    = -GetScrollPos (hwnd, SB_VERT);;

      L_FrameBitmapRgn (hdc, &pData->Bitmap, &RgnXForm, gMode=(gMode+2)%8);
   }
   ReleaseDC (hwnd, hdc);
}

/*====(Child_OnMDIActivate)=====================================================
Description: Informs the child window it is going to receive the focus.

Syntax     : VOID Child_OnMDIActivate(HWND hWnd, BOOL fActive, HWND hWndActivate,
                                      HWND hWndDeactivate)

Parameters : hWnd                 Handle of a window.
             fActive              Truth of "Is the window active".
             hWndActivate         Handle to the window to be activated.
             hWndDeactivate       Handle to the window to be deactivated.

Return Value: None.
==========================================================================*/
void Child_OnMDIActivate(HWND hwnd, BOOL fActive, HWND hwndActivate, HWND hwndDeactivate)
{
   SendMessage (ghWndClient, WM_MDISETMENU, (WPARAM) ghMenuInit, (LPARAM) ghMenuInitWindow);
}

/*----(Child_OnQueryNewPalette)--------------------------------------------
  Syntax:     BOOL Child_OnQueryNewPalette( HWND hWnd )

  Parameters: hWnd          Handle to a window.

  Prototype:  Loadsave.h

  Notes:      This procedure is responsible for handling WM_QUERYNEWPALETTE.
--------------------------------------------------------------------------*/
BOOL Child_OnQueryNewPalette (HWND hWnd)
{
   HDC hDC;
   HPALETTE hPalette;
   L_INT nNoColors = 0;
   LPCHILDDATA    pData = GETCHILDDATA(hWnd);
   /* Delete the previous palette, if there is one. */
   if (ghPalette)
   {
      DeleteObject (ghPalette);
      ghPalette = NULL;
   }

   if (pData->Bitmap.Flags.Allocated)
   {
      hDC = GetDC (hWnd);

      /* Generate a new logical palette (if needed) for painting. */
      ghPalette = L_CreatePaintPalette (hDC, &pData->Bitmap);

      if (ghPalette)        /* Is a palette needed? */
      {
         hPalette = SelectPalette (hDC, ghPalette, FALSE);
         nNoColors = RealizePalette (hDC);

         if (nNoColors)         /* If the palette changed, force a WM_PAINT */
            InvalidateRect (hWnd, NULL, FALSE);

         /* Restore the old palette. */
         SelectPalette (hDC, hPalette, TRUE);
      }
      ReleaseDC (hWnd, hDC);
   }
   return (nNoColors);
}

/*====(Child_OnPaletteChanged)=====================================================
Description: Processes WM_PALETTECHANGED message for a child window.

Syntax     : VOID Child_OnPaletteChanged(HWND hWnd, HWND hWndPaletteChange)

Parameters : hWnd                 Handle of a window.
             hWndPaletteChange    Handle of the window that has the palette
                                  realized.

Return Value: None.
==========================================================================*/
void Child_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)
{

   HDC hDC;
   HPALETTE hPalette;

   LPCHILDDATA pData = GETCHILDDATA(hwnd);

   /* If this window initiated the palette change, do nothing. */
   if (hwnd == hwndPaletteChange)
      return;

   /* Delete the previous palette, if there is one. */
   if (ghPalette)
   {
      DeleteObject (ghPalette);
      ghPalette = NULL;
   }

   /* Does this window have a bitmap and a palette? */
   if (pData->Bitmap.Flags.Allocated)
   {
      hDC = GetDC (hwnd);

      /* Generate a new logical palette (if needed) for painting. */
      ghPalette = L_CreatePaintPalette (hDC, &pData->Bitmap);

      /* Select and Realize the palette. */
      hPalette = SelectPalette (hDC, ghPalette, TRUE);
      RealizePalette (hDC);

      /* Force a repaint. */
      InvalidateRect (hwnd, NULL, FALSE);

      /* Return the old palette. */
      SelectPalette (hDC, ghPalette, TRUE);

      ReleaseDC (hwnd, hDC);
   }
   return;
}

/*====(Child_OnDestroy)=====================================================
Description: Performs cleanup for the child window.

Syntax     : VOID Child_OnDestroy(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/
void Child_OnDestroy(HWND hwnd)
{
   LPCHILDDATA pData = GETCHILDDATA(hwnd);
   L_FreeBitmap (&pData->Bitmap);
   GlobalFreePtr(pData);
}

/*====(Frame_OnCreate)=====================================================
Description: Creates the Frame window.

Syntax     : BOOL Frame_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)

Parameters : hWnd             Handle of a window.
             lpCreateStruct   Pointer to CREATESTRUCT

Return Value: TRUE            The function was successful.
              FALSE           The function was not successful.
==========================================================================*/
BOOL Frame_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
   CLIENTCREATESTRUCT   clientcreate;
   L_INT SBHeight, TBHeight;
   RECT  SBRect, TBRect;

   TBBUTTON tbb[] =
   {
      STD_FILESAVE, IDM_FILE_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0, 0, 0,
      STD_HELP,     IDM_HELP_ABOUT, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0, 0, 0,
   };

   clientcreate.hWindowMenu  = ghMenuInitWindow;
   clientcreate.idFirstChild = 300;

   InitCommonControls();

   SetMenuDefaultItem (ghMenuInit, IDM_CAPTURE_ACTIVECLIENT, TRUE);
   ghTBwnd = CreateToolbarEx (hwnd,
                             WS_CHILD | WS_CLIPSIBLINGS | CCS_TOP,
                             TOOLBAR_ID,
                             0,
                             HINST_COMMCTRL,
                             IDB_STD_SMALL_COLOR,
                             tbb,
                             2,
                             0,
                             0,
                             0,
                             0,
                             sizeof (TBBUTTON)
                            );

   ghSBwnd = CreateStatusWindow (WS_CHILD | WS_CLIPSIBLINGS | CCS_BOTTOM,
                                NULL,
                                hwnd,
                                STATUSBAR_ID
                               );
                         
   GetWindowRect (ghTBwnd , &TBRect);
   GetWindowRect (ghSBwnd , &SBRect);

   TBHeight = TBRect.bottom - TBRect.top;
   SBHeight = SBRect.bottom - SBRect.top;

   ghWndClient = CreateWindow (TEXT("MDICLIENT"), 
                              NULL,
                              WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_VSCROLL | WS_HSCROLL,
                              0, 
                              0, 
                              0, 
                              0,
                              hwnd,
                              (HMENU) CLIENTWINDOW_ID,
                              ghInst, 
                              (LPSTR) &clientcreate
                             );


   if (ghWndClient == NULL)
      return (LRESULT)ghWndClient;

   L_GetDefaultObjectOption (&gObjectOptions,sizeof(gObjectOptions));
   L_GetDefaultAreaOption   (&gCaptureAreaOption,sizeof(gCaptureAreaOption));
   return TRUE;
}
/*---[Frame_OnActivate]-----------------------------------------------------
  Syntax:     VOID  Frame_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, 
                                      BOOL fMinimized)
  Parameters: hWnd            Window handle.
              state           WA_ACTIVE | WA_CLICKACTIVE | WA_INACTIVE    
              hwndActDeact    the winodw habdle that deactivate
              fMinimized      Window is minimized

  Prototype:  Color.h

  Notes:      This procedure is responsible for handling WM_ONCOMMAND.
  --------------------------------------------------------------------------*/
void Frame_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, BOOL fMinimized)
{
   if(state!=WA_INACTIVE)
      Frame_OnQueryNewPalette (hwnd);
}

/*====(Frame_OnSize)=====================================================
Description: Responds to WM_SIZE message and sets the internal data
             accordingly. Also forwards the message to DefMDIChildProc.

Syntax     : void Frame_OnSize(HWND hwnd, UINT state, int cx, int cy)

Parameters : hWnd          Handle to the child window.
             nState        State of resizing requested.
             nCx           Size to be used for the "x" direction.
             nCy           Size to be used for the "y" direction.

Return Value: None.
==========================================================================*/
void Frame_OnSize(HWND hwnd, UINT state, int cx, int cy)
{
   L_INT SBHeight, TBHeight;
   RECT  SBRect, TBRect;
   L_INT ClientWndTop, ClientWndBottom;

   if(gbShowToolbar)
   {
      GetWindowRect (ghTBwnd , &TBRect);
      TBHeight = TBRect.bottom - TBRect.top;
   }
   else
      TBHeight = 0;

   if(gbShowStatusbar)
   {
      GetWindowRect (ghSBwnd , &SBRect);
      SBHeight = SBRect.bottom - SBRect.top;
   }
   else
      SBHeight = 0;

   if (GetMenuState (ghMenuInit, IDM_VIEW_TOOLBAR, MF_BYCOMMAND) & MF_CHECKED)
   {
      SendMessage (GetDlgItem(hwnd, TOOLBAR_ID), TB_AUTOSIZE,0,0);
      MoveWindow (ghTBwnd, 0, 0, cx, TBHeight, TRUE);
      ClientWndTop = TBHeight;
   }
   else
      ClientWndTop = 0;


   if (GetMenuState (ghMenuInit, IDM_VIEW_STATUSBAR, MF_BYCOMMAND) & MF_CHECKED)
   {
      ClientWndBottom = cy-SBHeight;
      MoveWindow (ghSBwnd, 0, ClientWndBottom, cx, SBHeight, TRUE);
   }
   else
      ClientWndBottom = cy;

   MoveWindow (ghWndClient, 0, ClientWndTop, cx, ClientWndBottom-ClientWndTop, TRUE);
}

/*====(Frame_OnTimer)=====================================================
Description: Called when the timer value expires

Syntax     : L_VOID Child_OnTimer(HWND hWnd, UINT id)

Parameters : hWnd          Handle of the child window.
             id            Timer id supplied in SetTimer

Return Value: None.
==========================================================================*/
void Frame_OnTimer(HWND hwnd, UINT id)
{
   HWND hwndActiveChild = (HWND) SendMessage (ghWndClient, WM_MDIGETACTIVE, 0, 0);
   SendMessage (hwndActiveChild, WM_TIMER, 0, 0);
}

/*====(Frame_OnQueryNewPalette)=====================================================
Description: Processes WM_QUERYNEWPALETTE message for the Frame window.

Syntax     : BOOL Frame_OnQueryNewPalette(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: nNoColors    Number of colors changed in the palette.
==========================================================================*/
BOOL Frame_OnQueryNewPalette(HWND hwnd)
{
  HWND hwndActiveChild = (HWND) SendMessage (ghWndClient, 
                                        WM_MDIGETACTIVE, 
                                        0, 
                                        0); 

   SendMessage (hwndActiveChild, 
               UPDATEPALETTE, 
               0, 
               0);
   return 0;
}

/*====(Frame_OnPaletteChanging)==========================================
Description: Enumerates all child windows and asks them to realize their
             logical palettes beside the physical palette.

Syntax     : VOID Frame_OnPaletteChanging(HWND hwnd, HWND hWndPaletteChange)

Parameters : hwnd                 Handle to a window.
             hWndPaletteChange    Handle to a window that has the palette
                                  realized.

Return Value: None.
==========================================================================*/
VOID  Frame_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   Frame_OnPaletteChanged (hWnd, hWndPaletteChange);
}

/*====(Frame_SysColorChange)==========================================
  Syntax:     VOID Frame_SysColorChange( HWND hWnd )

  Parameters: hWnd          Handle to a window.

  Prototype:  Loadsave.h

  Notes:      This procedure is responsible for handling WM_SYSCOLORCHANGE.
--------------------------------------------------------------------------*/
VOID Frame_SysColorChange(HWND hwnd)
{
   Frame_OnQueryNewPalette (hwnd);
}


/*====(Frame_OnPaletteChanged)=====================================================
Description: Processes WM_PALETTECHANGED message for the Frame window.

Syntax     : VOID Frame_OnPaletteChanged(HWND hWnd, HWND hWndPaletteChange)

Parameters : hWnd                 Handle of a window.
             hWndPaletteChange    Handle of the window that has the palette
                                  realized.

Return Value: None.
==========================================================================*/
void Frame_OnPaletteChanged(HWND hwnd, HWND hwndPaletteChange)
{
   EnumChildWindows (ghWndClient, (WNDENUMPROC) &EnumChildProc, 
                     SendMessage (ghWndClient, WM_MDIGETACTIVE, 0, 0));
}

/*====(Frame_OnCommand)=====================================================
Description: Processes the WM_COMMAND for the Frame window.

Syntax     : VOID Frame_OnCommand(HWND hWnd, int id, HWND hWndCtl,
                                  UINT codeNotify)

Parameters : hWnd          Handle to the child window.
             id            Value of the command to be processed.
             hWndCtl       Not used.
             codeNotify    Not used.

Return Value: None.
==========================================================================*/
void Frame_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
   RECT              rect;
   COLORREF          TransparentColor;
   BITMAPHANDLE      Bitmap;
   L_INT             nRet = SUCCESS;
   HWND              hwndActiveChild;
   LPCHILDDATA       pData;
   L_TCHAR           Buffer1[MAXNAMEOFCAPFILE];
   RECT              rcDest;
   L_INT             iStatusbar;
   LEADCAPTUREOPTION CapOpt;
   L_BOOL            bCut = FALSE;

   L_TCHAR           *szCapFileNameType [] = {
                        TEXT("Capture Active Window "),
                        TEXT("Capture Client Window "),
                        TEXT("Capture Full Screen "),
                        TEXT("Capture Selected Object "),
                        TEXT("Capture Menu Under Cursor "),
                        TEXT("Capture Selected Area"),
                        TEXT("Capture WallPaper"),
                        TEXT("Capture Mouse Cursor"),
                        TEXT("Capture Window under Cursor"),
                        TEXT("Capture From Exe Dlg Tree"),
                        TEXT("Capture From Tabbed View"),
                     };
   L_TCHAR            *szStatusbarText []= {
                        TEXT("Ready to Capture Active Window"),
                        TEXT("Ready to Capture Active Client"),
                        TEXT("Ready to Capture Full Screen"),
                        TEXT("Ready to Capture Selected Object"),
                        TEXT("Ready to Capture Menu Under Cursor"),
                        TEXT("Ready to Capture Selected Area"),
                        TEXT("Ready to Capture From Wallpaper"),
                        TEXT("Ready to Capture the Mouse Cursor"),
                        TEXT("Ready to Capture the Window under cursor"),
                        TEXT("Ready to Capture From Exe Dlg-Tree"),
                        TEXT("Ready to Capture From Exe Dlg-Tabbed View")
                     };


   if (
       (id >= IDM_CAPTURE_ACTIVEWINDOW)  && 
       (id <= IDM_CAPTURE_FROMEXEDLGTABBEDVIEW)
      )
   {
      if (gbMinimize)
      {
         if(!(id == IDM_CAPTURE_FROMEXEDLGTABBEDVIEW || id ==IDM_CAPTURE_FROMEXEDLGTREE))
            ShowWindow (ghWndFrame, SW_MINIMIZE);
      }
      
      GetClientRect (ghSBwnd, &rcDest);
      iStatusbar = (int)id%40000;
      DrawStatusText (GetDC (ghSBwnd), &rcDest, szStatusbarText[iStatusbar], SBT_RTLREADING);
      
      wsprintf(Buffer1, TEXT("%s[%d]"), szCapFileNameType[(int)(id)%40000], gnCapWindowNumber[(int)(id)%40000]++); //Specifies a name caption for the new child window being captured.
   }

   switch (id)
   {
/*..........................F I L E     P O P U P.........................*/
   case IDM_FILE_EXIT:
      FORWARD_WM_CLOSE(hwnd, SendMessage);
      break;
   case IDM_FILE_SAVE :
      hwndActiveChild = (HWND) SendMessage (ghWndClient, WM_MDIGETACTIVE, 0, 0);
      if((pData = GETCHILDDATA(hwndActiveChild)) != NULL)
      {
         if(bFirstSave)
         {
            bFirstSave = FALSE;
            
            memset(&gOpenFileName,0,sizeof(gOpenFileName));

            gOpenFileName.lStructSize       = sizeof(OPENFILENAME);
            gOpenFileName.hwndOwner         = ghWndFrame;
            gOpenFileName.lpstrFilter       = gszOpenFileFilter;
            gOpenFileName.lpstrCustomFilter = NULL;
            gOpenFileName.nMaxCustFilter    = 0;
            gOpenFileName.nFilterIndex      = 0;
            gOpenFileName.lpstrFile         = gszCapFileName;
            gOpenFileName.nMaxFile          = sizeof(gszCapFileName)/sizeof(L_TCHAR);
            gOpenFileName.lpstrFileTitle    = gszCapFileName;
            gOpenFileName.nMaxFileTitle     = sizeof(gszCapFileName)/sizeof(L_TCHAR);
            gOpenFileName.lpstrInitialDir   = NULL;
            gOpenFileName.lpstrTitle        = TEXT("Save Captured Image");
            gOpenFileName.nFileExtension    = 0;
            gOpenFileName.lpstrDefExt       = NULL;
            gOpenFileName.Flags             = 0;

            memset(&gFileSaveParam,0,sizeof(gFileSaveParam));

            gFileSaveParam.uStructSize = sizeof(gFileSaveParam);

            gFileSaveParam.uDlgFlags     =  DLG_SAVE_ENABLESIZING |
                                            DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE|
                                            DLG_SAVE_AUTOPROCESS  |
                                            DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS|
                                            DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS|
                                            DLG_SAVE_SHOW_FILEOPTIONS_STAMP|
                                            DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE |
                                            DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR;
         }

         lstrcpy (gFileSaveParam.szFileName, gszCapFileName); /* Filename */

         gFileSaveParam.pBitmap          = &pData->Bitmap; /* Bitmap to save */

         nRet = L_DlgSave (hwnd, &gOpenFileName, &gFileSaveParam);
      }
      break;

/*....................E D I T   P O P U P..........................*/

   case IDM_EDIT_CUT:
      bCut = TRUE;
      //fall through
   case IDM_EDIT_COPY:
      hwndActiveChild = (HWND) FORWARD_WM_MDIGETACTIVE (ghWndClient, SendMessage);
      if((pData = GETCHILDDATA(hwndActiveChild)) != NULL)
      {
         // destroy the current child window only if the images was copied to clipboard
         if(L_CopyToClipboard(hwndActiveChild, &pData->Bitmap,COPY2CB_EMPTY|COPY2CB_DIB) == SUCCESS)
            if(bCut)
               FORWARD_WM_MDIDESTROY (ghWndClient, hwndActiveChild, SendMessage);
      }
      break;

/*....................C A P T U R E   P O P U P..........................*/
  
   case IDM_CAPTURE_ACTIVEWINDOW :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureActiveWindow (&Bitmap, sizeof(Bitmap),
                                          &gCaptureInfo,sizeof(gCaptureInfo),
                                           pfnCaptureCallback, 
                                           Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
      {
         nRet = L_CaptureActiveWindow (&Bitmap, sizeof(Bitmap),
                                       &gCaptureInfo,sizeof(gCaptureInfo),
                                       pfnCaptureCallback, 
                                       Buffer1);

      }
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_ACTIVECLIENT :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureActiveClient (&Bitmap, sizeof(Bitmap),
                                          &gCaptureInfo,sizeof(gCaptureInfo),
                                          pfnCaptureCallback, 
                                          Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureActiveClient (&Bitmap, sizeof(Bitmap),
                                       &gCaptureInfo,sizeof(gCaptureInfo),
                                       pfnCaptureCallback, 
                                       Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_FULLSCREEN :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureFullScreen (&Bitmap, sizeof(Bitmap),
                                        &gCaptureInfo,sizeof(gCaptureInfo),
                                        pfnCaptureCallback, 
                                        Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureFullScreen (&Bitmap, sizeof(Bitmap),
                                     &gCaptureInfo,sizeof(gCaptureInfo),
                                     pfnCaptureCallback, 
                                     Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_SELECTEDOBJECT :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureSelectedObject (&Bitmap, sizeof(Bitmap),
                                             &gObjectOptions,sizeof(gObjectOptions),
                                             &gCaptureInfo,sizeof(gCaptureInfo),
                                             pfnCaptureCallback, 
                                             Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureSelectedObject (&Bitmap, sizeof(Bitmap),
                                         &gObjectOptions,sizeof(gObjectOptions),
                                         &gCaptureInfo,sizeof(gCaptureInfo),
                                         pfnCaptureCallback, 
                                         Buffer1);
      Statusbar (id, hwnd);
      break;
    
   case IDM_CAPTURE_MENUUNDERCURSOR :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureMenuUnderCursor (&Bitmap, sizeof(Bitmap),
                                             &gCaptureInfo,sizeof(gCaptureInfo),
                                             pfnCaptureCallback, 
                                             Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureMenuUnderCursor (&Bitmap, sizeof(Bitmap),
                                          &gCaptureInfo,sizeof(gCaptureInfo),
                                          pfnCaptureCallback, 
                                          Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_SELECTEDAREA :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureArea (&Bitmap,sizeof(Bitmap),
                                    &gCaptureAreaOption,sizeof(gCaptureAreaOption),
                                    &gCaptureInfo,sizeof(gCaptureInfo),
                                    pfnCaptureCallback, 
                                    Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureArea (&Bitmap,sizeof(Bitmap),
                                 &gCaptureAreaOption,sizeof(gCaptureAreaOption),
                                 &gCaptureInfo,sizeof(gCaptureInfo),
                                 pfnCaptureCallback, 
                                 Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_WALLPAPER :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureWallPaper(&Bitmap, sizeof(Bitmap),
                                       &gCaptureInfo,sizeof(gCaptureInfo),
                                       pfnCaptureCallback, 
                                       Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureWallPaper(&Bitmap, sizeof(Bitmap),
                                   &gCaptureInfo,sizeof(gCaptureInfo),
                                    pfnCaptureCallback, 
                                    Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_MOUSECURSOR :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureMouseCursor (&Bitmap, sizeof(Bitmap),
                                          RGB(255, 255, 0),
                                          &gCaptureInfo,sizeof(gCaptureInfo),
                                          pfnCaptureCallback, 
                                          Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureMouseCursor (&Bitmap,sizeof(Bitmap),
                                      RGB(255, 255, 0),
                                      &gCaptureInfo,sizeof(gCaptureInfo),
                                      pfnCaptureCallback, 
                                      Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_WINDOWUNDERCURSOR :
      if(gbHotKey)
         if(gnCaptureID == id)
            break;   // do nothing. I am already capturing
      gnCaptureID = id;
      L_StopCapture();

      if(gbHotKey)
      {
         while(gnCaptureID == id)
         {
            nRet = L_CaptureWindowUnderCursor (&Bitmap, sizeof(Bitmap),
                                               &gCaptureInfo,sizeof(gCaptureInfo),
                                                pfnCaptureCallback, 
                                                Buffer1);
            if(nRet != SUCCESS)
               gnCaptureID = 0;
         }
      }
      else
         nRet = L_CaptureWindowUnderCursor (&Bitmap,sizeof(Bitmap),
                                            &gCaptureInfo,sizeof(gCaptureInfo),
                                            pfnCaptureCallback, 
                                            Buffer1);
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_FROMEXEDLGTREE :
      gbRestore = FALSE;
      gnCaptureID = id;
      L_StopCapture();

      nRet = L_CaptureFromExeDlg (&Bitmap, sizeof(Bitmap),
                                 NULL,
                                 &TransparentColor,
                                 RESTYPE_BITMAP | RESTYPE_ICON | RESTYPE_CURSOR,
                                 LTCAPDLG_TREEVIEW,
                                 0,
                                 &gCaptureInfo, sizeof(gCaptureInfo),
                                 pfnCaptureCallback,
                                 Buffer1,
                                 NULL, NULL);


      gnCaptureID = 0;
      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_FROMEXEDLGTABBEDVIEW :
      gbRestore = FALSE;
      gnCaptureID = id;
      L_StopCapture();

      nRet = L_CaptureFromExeDlg (&Bitmap, sizeof(Bitmap),
                                 NULL,
                                 &TransparentColor,
                                 RESTYPE_BITMAP | RESTYPE_ICON | RESTYPE_CURSOR,
                                 LTCAPDLG_TABVIEW,
                                 0,
                                 &gCaptureInfo,sizeof(gCaptureInfo),
                                 pfnCaptureCallback,
                                 Buffer1, NULL, NULL);

      gnCaptureID = 0;

      Statusbar (id, hwnd);
      break;

   case IDM_CAPTURE_STOP:
      if(gnCaptureID)
      {
         gnCaptureID = 0;
         L_StopCapture();
      }
      break;

/*......................O P T I O N S   P O P U P........................*/

   case IDM_OPTIONS_OPTIONS :
      gnCaptureID = 0;
      L_StopCapture();

      CapOpt.uStructSize = sizeof(LEADCAPTUREOPTION);

      nRet = L_SetCaptureOptionDlg(GetWindow(hwnd,GW_OWNER), 0, &CapOpt, NULL, NULL);

      if(CapOpt.nHotKey == 0)
         gbHotKey = FALSE;
      else
         gbHotKey = TRUE;

      break;

   case IDM_OPTIONS_AREA :
      gnCaptureID = 0;
      L_StopCapture();

      nRet = L_CaptureAreaOptionDlg (GetParent (hwnd), 0,
                                    &gCaptureAreaOption, 
                                    FALSE, NULL, NULL);
      break;

   case IDM_OPTIONS_OBJECT :
      gnCaptureID = 0;
      L_StopCapture();

      L_CaptureObjectOptionDlg (GetParent (hwnd), 0,
                               &gObjectOptions, 
                               FALSE, NULL, NULL);
      break;

   case IDM_OPTIONS_MIN :
      gbMinimize = !gbMinimize;
      break;

   case IDM_OPTIONS_RESTORE :
      gbRestore = !gbRestore;
      break;

   case IDM_OPTIONS_BEEP :
      gbBeepOn ^= 1;
      break;

/*..........................V I E W     P O P U P........................*/

   case IDM_VIEW_TOOLBAR :
      GetClientRect(hwnd,&rect);
      gbShowToolbar ^= 1;
      ShowWindow (ghTBwnd, (gbShowToolbar) ? SW_SHOW : SW_HIDE);
      Frame_OnSize(hwnd, 0, rect.right,rect.bottom);
      Statusbar (id, hwnd);
      break;

   case IDM_VIEW_STATUSBAR :
      GetClientRect(hwnd,&rect);
      gbShowStatusbar ^= 1;
      ShowWindow (ghSBwnd, (gbShowStatusbar) ? SW_SHOW : SW_HIDE);
      Frame_OnSize(hwnd, 0, rect.right,rect.bottom);
      Statusbar (id, hwnd);
      break;

/*..........................H E L P     P O P U P........................*/
   case IDM_HELP_ABOUT :
      DialogBox (ghInst, TEXT("IDDAboutBox"), hwnd, (DLGPROC) AboutDlgProc);
      break;
   }     // switch ending
   DefFrameProc(hwnd, ghWndClient,WM_COMMAND,id,MAKELPARAM(codeNotify, hwndCtl));
}

/*====(Frame_OnDestroy)=====================================================
Description: Performs cleanup for the Frame window.

Syntax     : VOID Frame_OnDestroy(HWND hWnd)

Parameters : hWnd          Handle of a window.

Return Value: None.
==========================================================================*/
void Frame_OnDestroy(HWND hwnd)
{
   PostQuitMessage (0) ;
}

/*====(Frame_OnMenuInitPopup)==============================================
Description: Initializes the popup menus.

Syntax     : VOID Frame_OnInitMenuPopup(HWND hwnd, HMENU hMenu, UINT uItem, BOOL bSysMenu)

Parameters : hWnd          Handle of the frame window.
             hMenu         Menu handle
             uItem         Menu item
             bSysMenu      TRUE if we are dealing with a system menu.

Return Value: None.
==========================================================================*/
void Frame_OnInitMenuPopup(HWND hWnd, HMENU hMenu, UINT uItem, BOOL bSysMenu)
{
   HWND  hwndChild = FORWARD_WM_MDIGETACTIVE (ghWndClient, SendMessage);

   if (!bSysMenu && GetSubMenu(GetMenu(hWnd),uItem) == hMenu)
   {
      switch(uItem)
      {
      case 0:     /* file menu */
         ENABLEMENUITEM(hMenu, IDM_FILE_SAVE, hwndChild);
         break;
      case 1:     /* edit menu */
         ENABLEMENUITEM(hMenu, IDM_EDIT_COPY, hwndChild);
         ENABLEMENUITEM(hMenu, IDM_EDIT_CUT, hwndChild);
         break;
      case 2:     /* capture menu */
         CHECKMENUITEM(hMenu, IDM_CAPTURE_ACTIVEWINDOW, gnCaptureID == IDM_CAPTURE_ACTIVEWINDOW);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_ACTIVECLIENT, gnCaptureID == IDM_CAPTURE_ACTIVECLIENT);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_FULLSCREEN, gnCaptureID == IDM_CAPTURE_FULLSCREEN);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_SELECTEDOBJECT, gnCaptureID == IDM_CAPTURE_SELECTEDOBJECT);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_MENUUNDERCURSOR, gnCaptureID == IDM_CAPTURE_MENUUNDERCURSOR);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_SELECTEDAREA, gnCaptureID == IDM_CAPTURE_SELECTEDAREA);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_WALLPAPER, gnCaptureID == IDM_CAPTURE_WALLPAPER);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_MOUSECURSOR, gnCaptureID == IDM_CAPTURE_MOUSECURSOR);
         CHECKMENUITEM(hMenu, IDM_CAPTURE_WINDOWUNDERCURSOR, gnCaptureID == IDM_CAPTURE_WINDOWUNDERCURSOR);
         ENABLEMENUITEM(hMenu, IDM_CAPTURE_STOP, gnCaptureID);
         break;
      case 3:     /* options menu */
         CHECKMENUITEM(hMenu, IDM_OPTIONS_MIN, gbMinimize);
         CHECKMENUITEM(hMenu, IDM_OPTIONS_BEEP, gbBeepOn);
         CHECKMENUITEM(hMenu, IDM_OPTIONS_RESTORE, gbRestore);
         break;
      case 4:     /* view menu */
         CHECKMENUITEM(hMenu, IDM_VIEW_TOOLBAR, gbShowToolbar);
         CHECKMENUITEM(hMenu, IDM_VIEW_STATUSBAR, gbShowStatusbar);
         break;
      case 5:     /* help menu */
         break;
      }
   }
}

/*====(Statusbar)=====================================================
Description: Changes the text of the Status bar                        

Syntax      : void Statusbar (int id, HWND hwnd)

Parameters  : id             Menu id number.
              hwnd           handle of the menu.

Return Value: void 
==========================================================================*/
void Statusbar (int id, HWND hwnd)
{
   RECT  rcDest;
   GetClientRect (ghSBwnd, &rcDest);
   DrawStatusText (GetDC (ghSBwnd), &rcDest, TEXT("Ready"), SBT_RTLREADING);
}