/*[]=====================================================================[]*/
/*[]     LEADTOOLS for Windows - Version 11                              []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2000 LEAD Technologies, Inc.                 []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

/*---(GetRow)---------------------------------------------------------------
  LEAD Functions Used.
     L_FileInfo
     L_InitBitmap
     L_LoadBitmap
     L_CopyBitmapHandle
     L_AllocateBitmap
     L_AccessBitmap
     L_ReleaseBitmap
     L_FreeBitmap
     L_GetBitmapRow
     L_PutBitmapRowCol
     L_CreatePaintPalette
     L_PaintDC

  We have made the assumption that the user has the knowledge of programing
  in C and Windows.

  This example will:
  1. load an image from a file, whose name is sent through the command line,
     to a bitmap,
  2. display the image,
  3. do a 90 degree rotation using L_GetBitmapRow and L_PutBitmapRowCol,
  4. re-display the image.

  Usage: GETROW <filename>
  --------------------------------------------------------------------------*/

#include <windows.h>            /* Required for all Windows applications. */
#include <windowsx.h>           /* Windows header for message cracker. */
#include <ctype.h>
#include "tchar.h"

#include "..\\..\\..\\include\\l_bitmap.h"     /* LEADTOOLS main header file. */
#include "..\\..\\..\\include\\l_error.h"      /* LEADTOOLS error definition header file. */
#include "GetRow.h"             /* Application specific header file. */

L_BOOL ExtractCommandData ( );
/*---[WinMain]---------------------------------------------------------------
  Syntax:     int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                                                        LPSTR lpCmdLine, int nCmdShow )

  Parameters: hInstance       Current instance.
              hPrevInstance   previous instance.
              lpCmdLine       command line.
              nCmdShow        show-window type.

  Prototype:  Windows.h

  Notes:      Windows main function, calls initialization function
              and processes message loop.
  --------------------------------------------------------------------------*/
int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine, int nCmdShow)
{
   MSG msg;                     /* Windows' Message variable for holding
                                   messages */
   UNLOCKSUPPORT();

   if (!hPrevInstance)          /* Other instances of app running? */
      if (!InitApplication (hInstance))   /* Initialize shared things.       */
         return (FALSE);        /* Exits if unable to initialize.  */

   ExtractCommandData ( );

   if (!InitInstance (hInstance, nCmdShow))  /* Do instance initializations. */
      return (FALSE);

   /* Acquire and dispatch messages until a WM_QUIT message is received. */
   while (GetMessage (&msg, NULL, 0, 0))
   {
      TranslateMessage (&msg);  /* Translates virtual key codes. */
      DispatchMessage (&msg);   /* Dispatches message to window. */
   }
   return (msg.wParam);         /* Returns the value from PostQuitMessage. */
}
/*---[InitApplication]------------------------------------------------------
  Syntax:     L_BOOL InitApplication( HANDLE hInstance )

  Parameters: hInstance    Current instance.

  Prototype:  GetRow.h

  Notes:      Initializes window class structure and registers window class.
  --------------------------------------------------------------------------*/

L_BOOL InitApplication (HANDLE hInstance)
{
   WNDCLASS wcWindowClass;
   wcWindowClass.style = 0;     /* Class style(s).               */
   wcWindowClass.lpfnWndProc = MainWndProc;  /* Function to retrieve messages */
   /* for windows of this class.    */
   wcWindowClass.cbClsExtra = 0;/* No per-class extra data.      */
   wcWindowClass.cbWndExtra = 0;/* No per-window extra data.     */
   wcWindowClass.hInstance = hInstance;   /* Owner. */
   wcWindowClass.hIcon = LoadIcon (hInstance, TEXT("LEAD"));
   wcWindowClass.hCursor = LoadCursor (NULL, IDC_ARROW);
   wcWindowClass.hbrBackground = GetStockObject (WHITE_BRUSH);
   wcWindowClass.lpszMenuName = NULL;  /* No menu. */
   wcWindowClass.lpszClassName = TEXT("LEADWClass");  /* Name.    */

   /* Register the window class and return the result code. */
   return (RegisterClass (&wcWindowClass));
}
/*---[InitInstance]----------------------------------------------------------
  Syntax:     L_BOOL InitInstance( HANDLE hInstance, L_INT nCmdShow )

  Parameters: hInstance    Current instance.
              nCmdShow     Param for first ShowWindow() call.

  Prototype:  GetRow.h

  Notes:      Creates main window.
  --------------------------------------------------------------------------*/
L_BOOL InitInstance (HANDLE hInstance, L_INT nCmdShow)
{
   HWND hWnd;                   /* Window handle. */
   L_INT nRet;
   L_TCHAR buf[1024];
   /* Get image information. */
   Data.FileInfo.uStructSize = sizeof(FILEINFO);
   if ((nRet = L_FileInfo (Data.szFilename, &Data.FileInfo, sizeof(FILEINFO), 0, NULL)) != SUCCESS)
   {
      wsprintf (buf, TEXT("ERROR %d from L_FileInfo on file %s"), nRet, (LPTSTR) Data.szFilename);
      MessageBox (NULL, buf, TEXT("ERROR"), MB_OK);
      return (FALSE);
   }

   /* Set up RECT for window sizing. */
   rWndSize.top = 0;
   rWndSize.left = 0;
   rWndSize.bottom = Data.FileInfo.Height;
   rWndSize.right = Data.FileInfo.Width;

   AdjustWindowRect (&rWndSize, WS_OVERLAPPEDWINDOW, FALSE);

   hWnd = CreateWindow (
                        TEXT("LEADWClass"),
                        TEXT("LEADTOOLS Sample Application"),  /* Window title                  */
                        WS_OVERLAPPEDWINDOW, /* Window style.                 */
                        CW_USEDEFAULT, /* Default horizontal position.  */
                        CW_USEDEFAULT, /* Default vertical position.    */
                        rWndSize.right - rWndSize.left,  /* Window width.                 */
                        rWndSize.bottom - rWndSize.top,  /* Window height.                */
                        NULL,   /* Overlapped windows have no parent. */
                        NULL,   /* Use the window class menu.    */
                        hInstance,  /* This instance owns this window. */
                        NULL    /* Pointer not needed.           */
      );

   if (hWnd == NULL)
      return (FALSE);           /* If window could not be created, return
                                   "failure" */

   ShowWindow (hWnd, nCmdShow); /* Show the window.           */
   UpdateWindow (hWnd);         /* Sends WM_PAINT message.    */

   return (TRUE);
}
/*---[MainWndProc]-----------------------------------------------------------
  Syntax:     L_INT32 EXT_FUNCTION MainWndProc( HWND hWnd, L_UINT message,
                                                WPARAM wParam, LPARAM lParam )

  Parameters: hWnd            Window handle.
              message         Type of message.
              wParam          Additional information.
              lParam          Additional information.

  Prototype:  GetRow.h

  Notes: This procedure is responsible for dispatching window messages.
  --------------------------------------------------------------------------*/
L_INT32 EXT_FUNCTION MainWndProc (HWND hWnd, L_UINT Message, WPARAM wParam,
                                   LPARAM lParam)
{
   switch (Message)
   {
      HANDLE_MSG (hWnd, WM_CREATE, Window_OnCreate);
      HANDLE_MSG (hWnd, WM_TIMER, Window_OnTimer);
      HANDLE_MSG (hWnd, WM_COMMAND, Window_OnCommand);
      HANDLE_MSG (hWnd, WM_QUERYNEWPALETTE, Window_OnQueryNewPalette);
      HANDLE_MSG (hWnd, WM_PALETTECHANGED, Window_OnPaletteChanged);
      HANDLE_MSG (hWnd, WM_ACTIVATE, Window_OnActivate);
      HANDLE_MSG (hWnd, WM_PALETTEISCHANGING, Window_OnPaletteChanging);
      HANDLE_MSG (hWnd, WM_SYSCOLORCHANGE, Window_SysColorChange);
      HANDLE_MSG (hWnd, WM_PAINT, Window_OnPaint);
      HANDLE_MSG (hWnd, WM_DESTROY, Window_OnDestroy);
   }
   return DefWindowProc (hWnd, Message, wParam, lParam);
}
/*---[Window_OnCreate]-----------------------------------------------------
  Syntax:     BOOL Window_OnCreate(HWND hwnd, CREATESTRUCT FAR* lpCreateStruct);

  Parameters: hWnd            Window handle.
              lpCreateStruct  Windows Create Structure.

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_CREATE.
  --------------------------------------------------------------------------*/
BOOL Window_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
   L_INT nRet;
   UNREFERENCED_PARAMETER (lpCreateStruct);

   /* Tell Window_OnPaint to start a timer. */
   bFirst = TRUE;

   /* Initialize the bitmap handle to the image width, height, and 8 Bits per
      pixel. */
   L_InitBitmap (&Data.BitmapHandle, Data.FileInfo.Width, sizeof(BITMAPHANDLE),
                 Data.FileInfo.Height, 8);

   /* Load the image to the bitmap. */
   nRet = L_LoadBitmap (Data.szFilename, &Data.BitmapHandle, sizeof(BITMAPHANDLE), 8, ORDER_RGB, NULL, &Data.FileInfo);

   if (nRet != SUCCESS)
   {
      L_TCHAR buf[1024];           /* buffer to hold the error message */
      wsprintf (buf, TEXT("Error %d Loading %s"), nRet, (LPTSTR) Data.szFilename);
      MessageBox (hWnd, buf, TEXT("Error"), MB_OK);
      return (FALSE);           /* Failure in creation, so return FALSE. */
   }

   FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
   return (TRUE);
}
/*---[Window_OnTimer]-------------------------------------------------------
  Syntax:     VOID Window_OnTimer( HWND hWnd, UINT id );

  Parameters: hWnd            Window handle.
              id              ID of the Timer.

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_TIMER.
  --------------------------------------------------------------------------*/
VOID Window_OnTimer (HWND hWnd, UINT id)
{
   static HCURSOR hOrigCursor;
   UNREFERENCED_PARAMETER (id);

   nCount++;                    /* Increment the Counter. */

   /* Has the image been displayed about 3 seconds? (this is reset in the
      function Window_OnPaint) */
   if (nCount == 1)
   {
      hOrigCursor = SetCursor (LoadCursor (NULL, IDC_SIZENS));
      return;
   }
   else if (nCount == 2)
   {
      SetCursor (LoadCursor (NULL, IDC_SIZENESW));
      return;
   }
   KillTimer (hWnd, nTimer);

   SetCursor (hOrigCursor);

   FORWARD_WM_COMMAND (hWnd, 0, 0, 0, PostMessage);
   return;
}
/*---[Window_OnCommand]-----------------------------------------------------
  Syntax:     VOID Window_OnCommand( HWND hWnd, L_INT id, HWND hwndCtl,
                                     UINT codeNotify )

  Parameters: hWnd            Window handle.
              id              Menu item or Control ID.
              hwndCtl         0 if menu item selected, else window handle of
                              the control.
              codeNotify      1 if accelerator keystroke, else notification
                              code, such as BN_CLICKED.

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_ONCOMMAND.
  --------------------------------------------------------------------------*/
VOID Window_OnCommand (HWND hWnd, L_INT id, HWND hwndCtl, UINT codeNotify)
{
   HCURSOR hCursor;
   BITMAPHANDLE NewBitmap;
   HANDLE hBuf;
   L_UCHAR L_FAR *pBuf;
   L_INT i = 0;
   L_INT nInRow = 0;
   L_INT nOutRow = Data.BitmapHandle.Width - 1;
   L_INT nOutCol = 0;
   L_INT32 nRet32;
   RECT rWndRect;
   UNREFERENCED_PARAMETER (id);
   UNREFERENCED_PARAMETER (hwndCtl);
   UNREFERENCED_PARAMETER (codeNotify);

   hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
   SetWindowText (hWnd, TEXT("Rotating Image..."));

   /* Initialize the bitmap handle where: Width of NewBitmap = Height of
      Data.BitmapHandle Height of NewBitmap = Width of Data.BitmapHandle and
      8 Bits/pixel. */
   L_InitBitmap (&NewBitmap, sizeof(BITMAPHANDLE), Data.BitmapHandle.Height,
                 Data.BitmapHandle.Width, 8);

   /* Copy the palette to the new bitmap. */
   L_CopyBitmapPalette(&NewBitmap, &Data.BitmapHandle);

   /* Allocate the storage to hold the image data. */
   L_AllocateBitmap (&NewBitmap, TYPE_CONV);

   /* Lock the images' data area so we can access them. */
   L_AccessBitmap (&NewBitmap);
   L_AccessBitmap (&Data.BitmapHandle);

   if ((hBuf = GlobalAlloc (GMEM_MOVEABLE, Data.BitmapHandle.Width)) == NULL)
   {
      MessageBox (hWnd, TEXT("Not enough memory!"), TEXT("ERROR"), MB_OK);
      L_ReleaseBitmap (&Data.BitmapHandle);
      L_ReleaseBitmap (&NewBitmap);
      L_FreeBitmap (&NewBitmap);
      SetCursor (hCursor);
      return;
   }
   pBuf = (L_UCHAR L_FAR *) GlobalLock (hBuf);

   for (nInRow = 0; nInRow < Data.BitmapHandle.Height; nInRow++)
   {
      /* Get data from the original bitmap one row at a time.  If the view
         perspective is TOP_LEFT, the rows should be retrieved "backwards". */
      if (Data.BitmapHandle.ViewPerspective == TOP_LEFT)
         nRet32 = L_GetBitmapRow (&Data.BitmapHandle,
                                  pBuf,
                                  (Data.BitmapHandle.Height - 1) - nInRow,
                                  Data.BitmapHandle.Width);
      else
         nRet32 = L_GetBitmapRow (&Data.BitmapHandle,
                                  pBuf,
                                  nInRow,
                                  Data.BitmapHandle.Width);

      if (nRet32 != Data.BitmapHandle.Width)
      {
         MessageBox (hWnd, TEXT("Error getting rows of data!"), TEXT("ERROR"), MB_OK);
         L_ReleaseBitmap (&Data.BitmapHandle);
         L_ReleaseBitmap (&NewBitmap);
         L_FreeBitmap (&NewBitmap);
         SetCursor (hCursor);
         return;
      }

      for (i = 0; i < NewBitmap.Height; i++)
      {
         /* Put the data in pBuf as a column in NewBitmap. */
         nRet32 = L_PutBitmapRowCol (&NewBitmap,
                                     pBuf + i,
                                     nOutRow,
                                     nOutCol,
                                     1);

         if (nRet32 != 1)
         {
            MessageBox (hWnd, TEXT("Error putting rotated data!"), TEXT("ERROR"), MB_OK);
            L_ReleaseBitmap (&Data.BitmapHandle);
            L_ReleaseBitmap (&NewBitmap);
            L_FreeBitmap (&NewBitmap);
            SetCursor (hCursor);
            return;
         }
         nOutRow--;
      }

      nOutCol++;
      nOutRow = Data.BitmapHandle.Width - 1;
   }

   /* Release bitmaps */
   L_ReleaseBitmap (&Data.BitmapHandle);
   L_ReleaseBitmap (&NewBitmap);

   /* Free the old bitmap */
   L_FreeBitmap(&Data.BitmapHandle);

   /* Make Data.BitmapHandle point to the new image data. */
   L_CopyBitmapHandle (&Data.BitmapHandle, &NewBitmap, sizeof(BITMAPHANDLE));

   /* Free Buffers. */
   GlobalUnlock (hBuf);
   GlobalFree (hBuf);

   GetWindowRect (hWnd, &rWndSize);

   /* Set up RECT for resizing the window to the rotated dimensions. */
   rWndRect.left = 0;
   rWndRect.top = 0;
   rWndRect.right = Data.FileInfo.Height;
   rWndRect.bottom = Data.FileInfo.Width;

   /* Create RECT to size of image plus window frame. */
   AdjustWindowRect (&rWndRect, WS_OVERLAPPEDWINDOW, FALSE);

   /* Change the window size to match the image. */
   MoveWindow (hWnd,
               rWndSize.left,
               rWndSize.top,
               (rWndRect.right - rWndRect.left),
               (rWndRect.bottom - rWndRect.top),
               TRUE);

   /* Force a repaint of the image. */
   InvalidateRect (hWnd, NULL, TRUE);

   SetWindowText (hWnd, TEXT("Image Is Rotated, Example Is Complete"));
   SetCursor (hCursor);

   return;
}
/*----(Window_OnPaletteChanged)--------------------------------------------
  Syntax:     VOID Window_OnPaletteChanged( HWND hWnd, HWND hWndPaletteChange )

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

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_PALETTECHANGED.
--------------------------------------------------------------------------*/
VOID Window_OnPaletteChanged (HWND hWnd, HWND hWndPaletteChange)
{
   HDC hDC;
   HPALETTE hPalette;
   /* If this window initiated the palette change, do nothing. */
   if (hWnd == hWndPaletteChange)
      return;

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

   /* Does this window have a bitmap and a palette? */
   if (Data.BitmapHandle.Flags.Allocated)
   {
      hDC = GetDC (hWnd);

      /* Generate a new logical palette (if needed) for painting. */
      Data.hPalette = L_CreatePaintPalette (hDC, &Data.BitmapHandle);

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

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

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

      ReleaseDC (hWnd, hDC);
   }
   return;
}
/*----(Window_OnQueryNewPalette)--------------------------------------------
  Syntax:     BOOL Window_OnQueryNewPalette( HWND hWnd )

  Parameters: hWnd          Handle to a window.

  Prototype:  GetRow.h

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

   if (Data.BitmapHandle.Flags.Allocated)
   {
      hDC = GetDC (hWnd);

      /* Generate a new logical palette (if needed) for painting. */
      Data.hPalette = L_CreatePaintPalette (hDC, &Data.BitmapHandle);

      if (Data.hPalette)        /* Is a palette needed? */
      {
         hPalette = SelectPalette (hDC, Data.hPalette, 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);
}

/*---[Window_OnActivate]-----------------------------------------------------
  Syntax:     VOID  Window_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_ACTIVATE.
  --------------------------------------------------------------------------*/
VOID Window_OnActivate(HWND hwnd, UINT state, HWND hwndActDeact, BOOL fMinimized)
{
   if(state!=WA_INACTIVE)
      Window_OnQueryNewPalette (hwnd);
}

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

Syntax     : VOID Window_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  Window_OnPaletteChanging(HWND hWnd, HWND hWndPaletteChange)
{
   Window_OnPaletteChanged (hWnd, hWndPaletteChange);
}

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

  Parameters: hWnd          Handle to a window.

  Prototype:  Loadsave.h

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

/*---[Window_OnPaint]-------------------------------------------------------
  Syntax:     VOID Window_OnPaint( HWND hWnd );

  Parameters: hWnd            Window handle.

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_PAINT.
  --------------------------------------------------------------------------*/
VOID Window_OnPaint (HWND hWnd)
{
   HDC hdc;
   RECT rc;
   PAINTSTRUCT ps;
   HPALETTE hOldPal = NULL;
   hdc = BeginPaint (hWnd, &ps);/* Get DC */

   if (Data.BitmapHandle.Flags.Allocated) /* Do we have an image? */
   {
      if (Data.hPalette)        /* Is there a palette that needs to be
                                   selected? */
         hOldPal = SelectPalette (hdc, Data.hPalette, TRUE);  /* Select it. */

      /* Setup the Destination Rectangle. */
      SetRect (&rc, 0, 0, Data.BitmapHandle.Width, Data.BitmapHandle.Height);

      /* Paint it */
      L_PaintDC (hdc,
                 &Data.BitmapHandle,
                 NULL,
                 NULL,
                 &rc,
                 &ps.rcPaint,
                 SRCCOPY);

      if (Data.hPalette)        /* Return old palette if there is one. */
         SelectPalette (hdc, hOldPal, TRUE);

      if (bFirst)
      {
         bFirst = FALSE;

         /* Start a timer to be used for display delay. */
         if ((nTimer = SetTimer (hWnd, 1, 1000, NULL)) == 0)
         {
            MessageBox (hWnd, TEXT("No Timers Are Available!"),
                        TEXT("ERROR - Resources"), MB_OK);

            /* No timers are available, so quit the application. */
            FORWARD_WM_DESTROY (hWnd, PostMessage);
         }
      }
   }
   EndPaint (hWnd, &ps);        /* Return DC */
   return;
}
/*---[Window_OnDestroy]----------------------------------------------------
  Syntax:     VOID Window_OnDestroy( HWND hWnd );

  Parameters: hWnd            Window handle.

  Prototype:  GetRow.h

  Notes:      This procedure is responsible for handling WM_DESTROY.
  --------------------------------------------------------------------------*/
VOID Window_OnDestroy (HWND hWnd)
{
   UNREFERENCED_PARAMETER (hWnd);

   if (Data.BitmapHandle.Flags.Allocated) /* Do we have an image? */
      L_FreeBitmap (&Data.BitmapHandle);

   if (Data.hPalette)           /* Delete palette if there is one. */
      DeleteObject (Data.hPalette);

   PostQuitMessage (0);         /* Post WM_QUIT, to end the application. */
   return;
}

/*---[ExtractCommandData]----------------------------------------------------
  Syntax:     L_BOOL ExtractCommandData( );

  Parameters: None.

  ProtoType:  getrow.c

  Notes:    - This procedure is responsible for extracting the file 
             name passed through the command line.
            - You should call this function only in WinMain function.
  --------------------------------------------------------------------------*/
L_BOOL ExtractCommandData ( )
{
   LPTSTR pszFirst   = NULL;
   LPTSTR pszCmdLine = NULL;
   LPTSTR psz        = NULL;
   L_INT  nFirstPos  = 0 ;
   L_INT  nStringLen = 0 ;

   
   pszCmdLine = GetCommandLine();

   nStringLen = lstrlen ( pszCmdLine ) + 1 ;

   // To specify that it is command line or not.
   if(( pszCmdLine[1] == ':' ) || // Shortcut case
      ( pszCmdLine[2] == ':' )) //VS case
   {
      // 1- TRY TO EXPOSE THE EXE NAME FROM THE COMMAND LINE 
      psz = _tcschr ( pszCmdLine, ':' ) ;
   
      if ( NULL == psz )
      {
         return FALSE ;
      }
   }
   else
   {
      psz = pszCmdLine ;
   }
   
   pszFirst = _tcschr ( psz + 1, ':' ) ;

   if ( NULL == pszFirst )
   {
      return FALSE ;
   }

   // Calc the char number to the image file name.
   nFirstPos = pszFirst - pszCmdLine - 1 ;

   if ( 0 > nFirstPos )
   {
      return FALSE ;
   }

   memset ( Data.szFilename, 0, sizeof ( Data.szFilename ) );
   
   lstrcpyn ( Data.szFilename, pszFirst - 1, ( nStringLen - nFirstPos ) ) ;
 
   return TRUE;
}