/*----------------------------------------------------------------------------
|
|  frame.c
|
 ---------------------------------------------------------------------------*/


#include "precomp.h"
#include "demo.h"
#include "resource.h"
#include "subclass.h"



L_INT OpenDroppedFile (LPCREATEDATA   pCreateData, L_TCHAR * szFilePath);


static L_TCHAR szOpenFileFilter[] = 
{
   TEXT("All Files (*.*)\0")                                  TEXT("*.*\0")
   TEXT("AutoCAD (*.dxf;*.dwg;*.dwf)\0")                      TEXT("*.dxf;*.dwg;*.dwf\0")
   TEXT("Computer Graphics Metafile (*.cgm)\0")               TEXT("*.cgm\0")
   TEXT("Corel Presentation Exchange (CMX)\0")                TEXT("*.cmx\0")
   TEXT("HP-GL/HP-GL2 (*.plt)\0")                             TEXT("*.plt\0")
   TEXT("LEAD Vector (*.vec)\0")                              TEXT("*.vec\0")
   TEXT("Mac PICT (*.pct)\0")                                 TEXT("*.pct\0")
   TEXT("Micrografx DRW (*.drw)\0")                           TEXT("*.drw\0")
   TEXT("MicroStation DGN (*.dgn)\0")                         TEXT("*.dgn\0")
   TEXT("Windows Metafile (*.wmf;*.emf)\0")                   TEXT("*.wmf;*.emf\0")
   TEXT("Gerber File Format (*.gbr)\0")                       TEXT("*.gbr\0")
   TEXT("E S R I (SHP)\0")                                    TEXT("*.shp\0")
   TEXT("Printer Command Language(*.pcl;*.prn;*.prt)\0")      TEXT("*.pcl;*.prn;*.prt\0")
   TEXT("Scalable Vector Graphics (*.svg)\0")                 TEXT("*.svg\0")
   TEXT("Word Perfect Graphics (*.wpg)\0")                    TEXT("*.wpg\0")
   TEXT("Compressed Windows Metafile (WMZ)\0")                TEXT("*.wmz\0")
};


static L_INT   nOpenIndex = 0;
static L_INT   nExportIndex = 0;
static L_INT   nNewIndex = 0;

L_INT   nChildsNumber = 0;

HWND        hwndRB   = NULL;
static HWND hwndTB   = NULL;

// Internal functions
static L_BOOL LEADTOOLS_OnCreate( HWND, LPCREATESTRUCT );
static L_VOID LEADTOOLS_OnPaletteChanged( HWND, HWND );
static L_BOOL LEADTOOLS_OnQueryNewPalette( HWND );
static L_VOID LEADTOOLS_OnSize( HWND, L_UINT, L_INT, L_INT );
static L_VOID LEADTOOLS_OnCommand( HWND, L_INT, HWND, L_UINT );
static L_VOID LEADTOOLS_OnClose( HWND );
static L_VOID LEADTOOLS_OnDestroy( HWND );
static L_VOID LEADTOOLS_OnDropFiles(HWND, HDROP );

static L_VOID OnFileNew( L_VOID );
static L_VOID OnFileOpen( L_VOID );
static L_VOID OnFileExport( L_VOID );

static L_VOID OnFileExit( HWND );
static L_VOID OnViewStatusBar( HWND );
static L_VOID OnWindowCascade( L_VOID );
static L_VOID OnWindowTile( L_VOID );
static L_VOID OnWindowArrangeIcons( L_VOID );
static L_VOID OnWindowCloseAll( L_VOID );
static L_VOID OnHelpAbout( HWND );

static L_INT NewVector( LPCREATEDATA );
static L_INT OpenVector( LPCREATEDATA );
static L_VOID ExportVector( const pVECTORHANDLE );
static HWND CreateChildWindow( LPCREATEDATA );
static L_BOOL EXT_FUNCTION CloseAll( HWND, LPARAM );
static L_BOOL EXT_FUNCTION PaletteChangedAll( HWND, LPARAM );

static L_BOOL EXT_FUNCTION AboutDlgProc( HWND, L_UINT, WPARAM, LPARAM );
static L_BOOL EXT_FUNCTION VectorDlgProc( HWND, L_UINT, WPARAM, LPARAM );



/*----------------------------------------------------------------------------
|
|  FrameWindowProc
|
 ---------------------------------------------------------------------------*/
LRESULT EXT_FUNCTION
FrameWindowProc
(
   HWND     hWnd,
   L_UINT   uMessage,
   WPARAM   wParam,
   LPARAM   lParam
)
{
   switch( uMessage )
   {
      HANDLE_MSG( hWnd, WM_CREATE, LEADTOOLS_OnCreate );
      HANDLE_MSG( hWnd, WM_PALETTECHANGED, LEADTOOLS_OnPaletteChanged );
      HANDLE_MSG( hWnd, WM_QUERYNEWPALETTE, LEADTOOLS_OnQueryNewPalette );
      HANDLE_MSG( hWnd, WM_SIZE, LEADTOOLS_OnSize );
      HANDLE_MSG( hWnd, WM_COMMAND, LEADTOOLS_OnCommand );
      HANDLE_MSG( hWnd, WM_CLOSE, LEADTOOLS_OnClose );
      HANDLE_MSG( hWnd, WM_DESTROY, LEADTOOLS_OnDestroy );
      HANDLE_MSG( hWnd, WM_DROPFILES, LEADTOOLS_OnDropFiles);
   }

   if( IsWindow( g_hWndClient ) )
      return DefFrameProc( hWnd, g_hWndClient, uMessage, wParam, lParam );
   else
      return DefWindowProc( hWnd, uMessage, wParam, lParam );
}


void CreateMyTooltip(HWND hwnd)
{
   L_INT  i;
   HWND hwndTT;
   TOOLINFO ti;   
   RECT rect;
   L_TCHAR *pszButtonsTooltip[ ] = 
   {  
      TEXT( "Vertex" ),
      TEXT( "Line" ),
      TEXT( "Rectangle" ),
      TEXT( "Polyline" ),
      TEXT( "PolyBezier" ),
      TEXT( "Polygon" ),
      TEXT( "Ellipse" ),
      TEXT( "Circle" ),
      TEXT( "Arc" ),
      TEXT( "Elliptical Arc" ),
      TEXT( "Text" ),
      TEXT( "Pie" ),
      TEXT( "Chord" ),
      TEXT( "Polydraw" ),
      TEXT( "Raster" ),
      TEXT( "Clone" ),
      TEXT( "Spline" ),
      TEXT( "HPolyBezier" )
   };

   /* create a tooltip window */
   hwndTT = CreateWindowEx( WS_EX_TOPMOST, TOOLTIPS_CLASS, 
                            NULL, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP, 
                            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
                            hwnd, NULL, g_hInstance, NULL );

   SetWindowPos( hwndTT, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );

   /* get coordinates of the main client area */
   GetClientRect ( hwnd, &rect );

   /* initialize members of the toolinfo structure */
   ti.cbSize = sizeof( TOOLINFO );
   ti.uFlags = TTF_SUBCLASS;
   ti.hwnd = hwnd;
   ti.hinst = g_hInstance;
   ti.uId = 0;

   for( i = 0 ; i < sizeof( pszButtonsTooltip ) / sizeof( pszButtonsTooltip[ 0 ] ) ; i++ )
   {
      ti.lpszText = pszButtonsTooltip[ i ];

      SendMessage( hwnd, TB_GETRECT, IDM_OBJECT_NEW_VERTEX + i, (LPARAM)&ti.rect );

      /* send an addtool message to the tooltip control window */
      SendMessage( hwndTT, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti );	
   }
} 

/*----------------------------------------------------------------------------
|
|  WM_CREATE
|
 ---------------------------------------------------------------------------*/
static L_BOOL
LEADTOOLS_OnCreate
(
   HWND           hWnd,
   LPCREATESTRUCT pCreateStruct
)
{
   CLIENTCREATESTRUCT   ClientStruct;
   INITCOMMONCONTROLSEX icex;
   REBARINFO            rbi;
   REBARBANDINFO		   rbBand;
   L_INT                nSize;
   RECT                 rc;
   
   TBBUTTON tbObjectsButtons[] = 
   {  
      {0,  IDM_OBJECT_NEW_VERTEX,        TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {1,  IDM_OBJECT_NEW_LINE,          TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {2,  IDM_OBJECT_NEW_RECTANGLE,     TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {3,  IDM_OBJECT_NEW_POLYLINE,      TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {4,  IDM_OBJECT_NEW_POLYBEZIER,    TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {5,  IDM_OBJECT_NEW_POLYGON,       TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {6,  IDM_OBJECT_NEW_ELLIPSE,       TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {7,  IDM_OBJECT_NEW_CIRCLE,        TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {8,  IDM_OBJECT_NEW_ARC,           TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {9,  IDM_OBJECT_NEW_ELLIPTICALARC, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {10, IDM_OBJECT_NEW_TEXT,          TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {11, IDM_OBJECT_NEW_PIE,           TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {12, IDM_OBJECT_NEW_CHORD,         TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {13, IDM_OBJECT_NEW_POLYDRAW,      TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {14, IDM_OBJECT_NEW_RASTER,        TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {15, IDM_OBJECT_NEW_CLONE,         TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {16, IDM_OBJECT_NEW_SPLINE,        TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
      {17, IDM_OBJECT_NEW_HPOLYBEZIER,   TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0}
   };

   UNREFERENCED_PARAMETER( pCreateStruct );

   L_DlgInit(DLG_INIT_COLOR);

   ClientStruct.hWindowMenu   = GetSubMenu( GetMenu( hWnd ), MENU_FILE_POS );
   ClientStruct.idFirstChild  = IDM_FIRSTCHILD;

   // Load the Common Controls if not loaded.
   icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
   icex.dwICC   = ICC_COOL_CLASSES|ICC_BAR_CLASSES;

   InitCommonControlsEx( &icex );

   hwndRB = CreateWindowEx( WS_EX_TOOLWINDOW, REBARCLASSNAME, NULL, WS_CHILD|WS_BORDER |WS_VISIBLE|RBS_BANDBORDERS |
                            WS_DLGFRAME,
                            0, 0, 0, 0, hWnd, NULL, g_hInstance, NULL );
   
   if( NULL == hwndRB )
   {
      MessageBox( hWnd, TEXT("Unable to create the rebar band"), TEXT("Note"), MB_OK | MB_ICONERROR );
   }

   // Subclass the Rebar Band window to capture the resize event.
	OldRBandProc = (WNDPROC) GetWindowLong( hwndRB, GWL_WNDPROC );
   SetWindowLong( hwndRB, GWL_WNDPROC, (LONG)RBProc );

   ZeroMemory(&rbi, sizeof(rbi));
   rbi.cbSize = sizeof(rbi);
	rbi.fMask  = 0;
	rbi.himl   = (HIMAGELIST)NULL;
	if(!SendMessage(hwndRB, RB_SETBARINFO, 0, (LPARAM)&rbi))
   {
      MessageBox( hWnd, TEXT("Unable to set the rebar band info"), TEXT("Note"), MB_OK | MB_ICONERROR );
   }

   // Initialize structure members that all bands will share.
   rbBand.cbSize = sizeof(REBARBANDINFO);  
   rbBand.fMask  = RBBIM_COLORS | RBBIM_STYLE | RBBIM_CHILD 
                   |RBBIM_CHILDSIZE | RBBIM_SIZE;
   rbBand.clrBack = GetSysColor( COLOR_3DFACE );
   rbBand.fStyle = RBBS_CHILDEDGE | RBBS_FIXEDBMP;    
	rbBand.hbmBack= LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_BACKGRND) );

	nSize = sizeof(tbObjectsButtons) / sizeof(tbObjectsButtons[0]);

   hwndTB = CreateToolbarEx( hwndRB, WS_CHILD|WS_VISIBLE|CCS_NORESIZE|CCS_NODIVIDER|TBSTYLE_FLAT, IDB_OBJECTSTOOLBAR,
                             nSize, NULL, (L_UINT)LoadBitmap( g_hInstance, MAKEINTRESOURCE(IDB_TOOLBAR) ), 
                             tbObjectsButtons, nSize, 16, 23, 16, 23, sizeof(TBBUTTON) );
   
   if( NULL == hwndTB )
   {
      MessageBox( hWnd, TEXT("Unable to create the toolbar"), TEXT("Note"), MB_OK | MB_ICONERROR );
   }

   SendMessage( hwndTB, WM_SIZE, 0, 0 );

   GetClientRect( hwndTB, &rc );
   
   // Fill the info of the band
   rbBand.lpText      = NULL;
   rbBand.hwndChild   = hwndTB;
   rbBand.cxMinChild  = 0;
   rbBand.cyMinChild  = rc.bottom - rc.top;
   rbBand.cx          = 200;
	rbBand.fStyle     |= RBBS_BREAK;
   
   SendMessage( hwndRB, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand );
   SendMessage( hwndRB, RB_SHOWBAND, 0, (LPARAM)FALSE );
   g_bIsToolBarVisible = FALSE;
   CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, g_bIsToolBarVisible );
   
   g_hWndClient = CreateWindowEx( 0L,
                                  TEXT("MDICLIENT"),
                                  NULL,
                                  WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  hWnd,
                                  (HMENU) 1,
                                  g_hInstance,
                                  (L_VOID*) &ClientStruct );
   if( !g_hWndClient )
      return FALSE;
   
   // Subclass the toolbar to gain more control
	OldToolbarProc = (WNDPROC) GetWindowLong( hwndTB, GWL_WNDPROC );
   SetWindowLong( hwndTB, GWL_WNDPROC, (LONG)ObjectsToolbarProc );

   CreateMyTooltip( hwndTB );

   OldMdiClientProc = (WNDPROC) GetWindowLong( g_hWndClient, GWL_WNDPROC );
   SetWindowLong( g_hWndClient, GWL_WNDPROC, (LONG)MdiClientProc );

   g_hWndStatus = CreateWindowEx( 0L,
                                  STATUSCLASSNAME,
                                  TEXT(""),
                                  WS_CHILD | WS_BORDER | WS_VISIBLE,
                                  -100, -100, 10, 10,
                                  hWnd,
                                  (HMENU) 100,
                                  g_hInstance,
                                  NULL );
   if( !g_hWndStatus )
      return FALSE;
   

   DragAcceptFiles(hWnd,TRUE);
   return TRUE;
}


/*----------------------------------------------------------------------------
|
|  WM_PALETTECHANGED
|
 ---------------------------------------------------------------------------*/
static L_VOID
LEADTOOLS_OnPaletteChanged
(
   HWND  hWnd,
   HWND  hWndPaletteChange
)
{
   UNREFERENCED_PARAMETER( hWnd );

   EnumChildWindows( g_hWndClient, (WNDENUMPROC) PaletteChangedAll, (LPARAM) (L_UINT) hWndPaletteChange );
}


/*----------------------------------------------------------------------------
|
|  WM_QUERYNEWPALETTE
|
 ---------------------------------------------------------------------------*/
static L_BOOL
LEADTOOLS_OnQueryNewPalette
(
   HWND  hWnd
)
{
   HWND hWndChild;

   UNREFERENCED_PARAMETER( hWnd );
   
   hWndChild = FORWARD_WM_MDIGETACTIVE( g_hWndClient, SendMessage );

   if( IsWindow( hWndChild ) )
      FORWARD_WM_QUERYNEWPALETTE( hWndChild, SendMessage );

   return TRUE;
}


/*----------------------------------------------------------------------------
|
|  WM_SIZE
|
 ---------------------------------------------------------------------------*/
static L_VOID
LEADTOOLS_OnSize
(
   HWND     hWnd,
   L_UINT   uState,
   L_INT    cx,
   L_INT    cy
)
{
   RECT  RectFrame;
   RECT  RectStatus;
   RECT  rbrect;
   L_INT cyStatus;

   UNREFERENCED_PARAMETER( uState );
   UNREFERENCED_PARAMETER( cx );
   UNREFERENCED_PARAMETER( cy );

   GetClientRect( hWnd, &RectFrame );

   GetClientRect( hwndRB, &rbrect );
   
   rbrect.right +=cx;
   
   MoveWindow( hwndRB, rbrect.left, rbrect.top, rbrect.right-rbrect.left, rbrect.bottom-
               rbrect.top, TRUE );


   // Compute the size of the hwndStatus line (which is drawn on the main frame itself).
   if ( IsWindowVisible( g_hWndStatus ) )
   {
      GetWindowRect( g_hWndStatus, &RectStatus );
      cyStatus = ( RectStatus.bottom - RectStatus.top );

      MoveWindow( g_hWndStatus, 0, RectFrame.bottom - cyStatus, RectFrame.right, cyStatus, TRUE );
      RectFrame.bottom -= cyStatus;
   }

   if( g_hWndClient )
   {
      MoveWindow( g_hWndClient,
                  RectFrame.left   + rbrect.left,
                  RectFrame.top    + rbrect.bottom,
                  RectFrame.right  - RectFrame.left - (rbrect.right - rbrect.left),
                  RectFrame.bottom - RectFrame.top  - (rbrect.bottom - rbrect.top),
                  TRUE ) ;
   }
}


/*----------------------------------------------------------------------------
|
|  WM_COMMAND
|
 ---------------------------------------------------------------------------*/
static L_VOID LEADTOOLS_OnCommand 
(
   HWND     hWnd,
   L_INT    nId,
   HWND     hWndCtl,
   L_UINT   uCodeNotify
)
{
   HWND  hWndChild;

   switch( nId )
   {
      case IDM_FILE_NEW:
         OnFileNew();
         break;

      case IDM_FILE_OPEN:
         OnFileOpen();
         break;

      case IDM_FILE_EXPORT:
         OnFileExport();
         break;      

      case IDM_FILE_EXIT:
         OnFileExit( hWnd );
         break;

      case IDM_VIEW_STATUSBAR:
         OnViewStatusBar( hWnd );
         break;

      case IDM_WINDOW_CASCADE:
         OnWindowCascade();
         break;

      case IDM_WINDOW_TILE:
         OnWindowTile();
         break;

      case IDM_WINDOW_ARRANGEICONS:
         OnWindowArrangeIcons();
         break;

      case IDM_WINDOW_CLOSEALL:
         OnWindowCloseAll();
         break;

      case IDM_HELP_ABOUT:
         OnHelpAbout( hWnd );
         break;

      default:
         hWndChild = FORWARD_WM_MDIGETACTIVE( g_hWndClient, SendMessage );
         if( IsWindow( hWndChild ))
         {
            FORWARD_WM_COMMAND( hWndChild, nId, hWndCtl, uCodeNotify, SendMessage );
            DefFrameProc( hWnd, 
                          g_hWndClient, 
                          WM_COMMAND, 
                          MAKEWPARAM( nId, uCodeNotify ),
                          (LPARAM) hWndCtl );
         }
   }
}


/*----------------------------------------------------------------------------
|
|  WM_CLOSE
|
 ---------------------------------------------------------------------------*/
static L_VOID
LEADTOOLS_OnClose
(
   HWND  hWnd
)
{
   FORWARD_WM_COMMAND( hWnd, IDM_WINDOW_CLOSEALL, 0, 0, SendMessage );
   
   if ( 0 == nChildsNumber )
      DestroyWindow( hWnd );
}


/*----------------------------------------------------------------------------
|
|  WM_DESTROY
|
 ---------------------------------------------------------------------------*/
static L_VOID
LEADTOOLS_OnDestroy
(
   HWND  hWnd
)
{
   UNREFERENCED_PARAMETER( hWnd );

   DestroyMenu( g_hMenuFrame );
   DestroyMenu( g_hMenuChild );   

   L_DlgFree();

   PostQuitMessage( 0 );
}

static L_VOID LEADTOOLS_OnDropFiles( HWND  hWnd, HDROP hDropInfo) 
{
	// TODO: Add your message handler code here and/or call default

   L_TCHAR szFilePath[255];
   int     nCount;
   int     i;
   CREATEDATA   CreateData;


   UNREFERENCED_PARAMETER( hWnd );
   nCount = DragQueryFile(hDropInfo, 0xFFFFFFFF, NULL, 0);
   
   for(i=0; i< nCount; i++)
   {
      DragQueryFile(hDropInfo, i, szFilePath, 255);
      OpenDroppedFile (&CreateData, szFilePath);
   }
	

}


/*----------------------------------------------------------------------------
|
|  File/New
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileNew
(
   L_VOID
)
{
   L_INT       nRet;
   CREATEDATA  CreateData;
   HWND        hWndChild;

   nRet = NewVector( &CreateData );
   if( nRet == SUCCESS )
   {
      hWndChild = CreateChildWindow( &CreateData );
      if( !hWndChild )
      {
         L_VecFree( CreateData.pVector );
         GlobalFreePtr( CreateData.pVector );
      }
      else
      {
         if ( 0 == nChildsNumber )
         {
            SendMessage( hwndRB, RB_SHOWBAND, 0, (LPARAM) TRUE );
            g_bIsToolBarVisible = TRUE;
            CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, g_bIsToolBarVisible );
         
            // Force the document to resize it self according to the window.
            SendMessage( hWndChild, WM_SIZE, 0, 0 );
         }

         nChildsNumber++;
      }
   }
}


/*----------------------------------------------------------------------------
|
|  File/Open
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileOpen
(
   L_VOID
)
{
   L_INT       nRet;
   CREATEDATA  CreateData;
   HWND        hWndChild;

   nRet = OpenVector( &CreateData );
   if( nRet == SUCCESS )
   {
      hWndChild = CreateChildWindow( &CreateData );
      if( !hWndChild )
      {
         L_VecFree( CreateData.pVector );
         GlobalFreePtr( CreateData.pVector );
      }
      else
      {
         if ( 0 == nChildsNumber )
         {
            SendMessage( hwndRB, RB_SHOWBAND, 0, (LPARAM) TRUE );
            g_bIsToolBarVisible = TRUE;
            CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, g_bIsToolBarVisible );
         
            // Force the document to resize it self according to the window.
            SendMessage( hWndChild, WM_SIZE, 0, 0 );
         }

         nChildsNumber++;
      }
   }
}


/*----------------------------------------------------------------------------
|
|  File/Export
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileExport
(
   L_VOID
)
{
   HWND        hWndChild;
   LPCHILDDATA pData;

   hWndChild = FORWARD_WM_MDIGETACTIVE( g_hWndClient, SendMessage );
   if( hWndChild )
   {
      pData = GETCHILDDATA( hWndChild );
      if( pData && pData->pVector )
         ExportVector( pData->pVector );
   }
}


/*----------------------------------------------------------------------------
|
|  File/Exit
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileExit
(
   HWND  hWnd
)
{
   FORWARD_WM_CLOSE( hWnd, SendMessage );
}


/*----------------------------------------------------------------------------
|
|  View/Status Bar
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewStatusBar
(
   HWND  hWnd
)
{
   L_BOOL   bVisible;

   bVisible = IsWindowVisible( g_hWndStatus );
   ShowWindow( g_hWndStatus, ( bVisible ) ? SW_HIDE : SW_SHOW );

   bVisible = IsWindowVisible( g_hWndStatus );
   CHECKMENUITEM( g_hMenuFrame, IDM_VIEW_STATUSBAR, bVisible );
   CHECKMENUITEM( g_hMenuChild, IDM_VIEW_STATUSBAR, bVisible );

   LEADTOOLS_OnSize( hWnd, 0, 0, 0 );
}


/*----------------------------------------------------------------------------
|
|  Window/Cascade
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnWindowCascade
(
   L_VOID
)
{
   FORWARD_WM_MDICASCADE( g_hWndClient, 0, SendMessage );
}


/*----------------------------------------------------------------------------
|
|  Window/Tile
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnWindowTile
(
   L_VOID
)
{
   FORWARD_WM_MDITILE( g_hWndClient, MDITILE_HORIZONTAL, SendMessage );
}


/*----------------------------------------------------------------------------
|
|  Window/Arrange Icons
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnWindowArrangeIcons
(
   L_VOID
)
{
   FORWARD_WM_MDIICONARRANGE( g_hWndClient, SendMessage );
}


/*----------------------------------------------------------------------------
|
|  OnWindowCloseAll
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnWindowCloseAll
(
   L_VOID
)
{
   EnumChildWindows( g_hWndClient, (WNDENUMPROC) CloseAll, 0 );

   if ( 0 == nChildsNumber )
   {
      SendMessage( hwndRB, RB_SHOWBAND, 0, (LPARAM) FALSE );
      g_bIsToolBarVisible = FALSE;
      CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, g_bIsToolBarVisible );
   }
}


/*----------------------------------------------------------------------------
|
|  Help/About
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnHelpAbout
(
   HWND  hWnd
)
{
   DoDialogBoxParam( IDD_ABOUT, hWnd, (DLGPROC) AboutDlgProc, 0 );
}


/*----------------------------------------------------------------------------
|
|  NewVector
|
 ---------------------------------------------------------------------------*/
static L_INT
NewVector
(
   LPCREATEDATA   pCreateData
)
{
   L_INT nRet;

   pCreateData->Min.x = 0.0;
   pCreateData->Min.y = 0.0;
   pCreateData->Min.z = 0.0;
   pCreateData->Max.x = 100.0;
   pCreateData->Max.y = 100.0;
   pCreateData->Max.z = 0.0;
   pCreateData->nEngine = VECTOR_ENGINE_GDI;
   pCreateData->bUseDoubleBuffer = TRUE;

   pCreateData->bNewVector = TRUE;

   if( DoDialogBoxParam( IDD_VECTOR, g_hWndClient, (DLGPROC) VectorDlgProc, (LPARAM) pCreateData ) != IDOK )
      return SUCCESS_DLG_CANCEL ;

   pCreateData->pVector = (pVECTORHANDLE) GlobalAllocPtr( GHND, sizeof( VECTORHANDLE ) );
   if( !pCreateData->pVector )
   {
      nRet = ERROR_NO_MEMORY;
      ShowLeadError( nRet, NULL, NULL );
      return nRet;
   }

   pCreateData->nFormat = FILE_VECTOR_DUMP;
   
   L_VecInit( pCreateData->pVector );

   wsprintf( pCreateData->szFileName, TEXT("Untitled%d"), nNewIndex );

   nNewIndex++;

   return( SUCCESS );
}


/*----------------------------------------------------------------------------
|
|  OpenVector
|
 ---------------------------------------------------------------------------*/
static L_INT
OpenVector
(
   LPCREATEDATA   pCreateData
)
{
   static OPENFILENAME  OpenFileName;
   static L_TCHAR       szFileName[ _MAX_PATH ] = TEXT("");
   static L_TCHAR       szFileTitle[ _MAX_PATH ] = TEXT("");
   L_INT                nRet;
   FILEINFO             FileInfo;

   ZeroMemory( &OpenFileName, sizeof( OpenFileName ) );
   ZeroMemory( szFileName, sizeof( szFileName ) );
   ZeroMemory( szFileTitle, sizeof( szFileTitle ) );

   OpenFileName.lStructSize       = sizeof( OPENFILENAME );
   OpenFileName.hwndOwner         = g_hWndClient;
   OpenFileName.lpstrFilter       = szOpenFileFilter;
   OpenFileName.nFilterIndex      = nOpenIndex;
   OpenFileName.lpstrFile         = szFileName;
   OpenFileName.nMaxFile          = sizeof( szFileName )/sizeof(L_TCHAR);
   OpenFileName.lpstrFileTitle    = szFileTitle;
   OpenFileName.nMaxFileTitle     = sizeof( szFileTitle )/sizeof(L_TCHAR);
   OpenFileName.lpstrTitle        = TEXT( "Open Vector" );
   OpenFileName.Flags             = OFN_HIDEREADONLY;   
   OpenFileName.lpstrDefExt       = TEXT( "" ); 

   ZeroMemory( &FileInfo, sizeof(FILEINFO) );
   FileInfo.Flags = 0;

   if( !GetOpenFileName( &OpenFileName ) )
      return SUCCESS_DLG_CANCEL;
   
   nOpenIndex = OpenFileName.nFilterIndex;
   
   pCreateData->pVector = (pVECTORHANDLE) GlobalAllocPtr( GHND, sizeof( VECTORHANDLE ) );
   if( !pCreateData->pVector )
   {
      nRet = ERROR_NO_MEMORY;
      ShowLeadError( nRet, NULL, NULL );
      return nRet;
   }

   Hourglass( TRUE );
   nRet = L_VecLoadFile( szFileName, pCreateData->pVector, NULL, &FileInfo );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, TEXT("Open File"), szFileName );
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return nRet;
   }
   
   nRet = L_FileInfo( szFileName,&FileInfo, sizeof(FILEINFO), 0, NULL );
   
   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, TEXT("Open File"), szFileName );
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return nRet;
   }

   pCreateData->nFormat = FileInfo.Format;

   L_VecGetParallelogram( pCreateData->pVector, &pCreateData->Min, &pCreateData->Max );
   pCreateData->nEngine = VECTOR_ENGINE_GDI;
   pCreateData->bUseDoubleBuffer = TRUE;

   pCreateData->bNewVector = FALSE;

   if( DoDialogBoxParam( IDD_VECTOR, g_hWndClient, (DLGPROC) VectorDlgProc, (LPARAM) pCreateData ) != IDOK )
   {
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return SUCCESS_DLG_CANCEL;
   }

   lstrcpy( pCreateData->szFileName, szFileName );

   return SUCCESS;
}


/*----------------------------------------------------------------------------
|
|  ExportVector
|
 ---------------------------------------------------------------------------*/
static L_VOID
ExportVector
(
   const pVECTORHANDLE  pVector
)
{
   static OPENFILENAME  OpenFileName;
   static SAVEDLGPARAMS FSParm;

   BITMAPHANDLE         LeadBitmap;
   RECT                 rcViewport;
   SAVEFILEOPTION       SaveFileOption;
   L_INT                nRet;
   L_INT                nSaveFormat;
   L_UINT               uResCount = 0;
   pDIMENSION           pOldResolutions = NULL;
   pDIMENSION           pJBIGResolutions = NULL;
   FILEJ2KOPTIONS       FileJ2KOptions;
   
   memset(&FSParm,0,sizeof(FSParm));
   memset(&OpenFileName,0,sizeof(OpenFileName));

   FSParm.uStructSize = sizeof(FSParm);
   
   OpenFileName.lStructSize      = sizeof( OPENFILENAME );
   OpenFileName.lpstrInitialDir  = NULL;
   OpenFileName.lpstrTitle       = TEXT("Export to a File");
   OpenFileName.nFilterIndex     = nExportIndex;

   OpenFileName.Flags            = OFN_OVERWRITEPROMPT;


   FSParm.nQFactor = 2;
   FSParm.nPageNumber = 1;

   FSParm.uDlgFlags = DLG_SAVE_ENABLESIZING                    |
                      DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE      |
                      DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE    | 
                      DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR        | 
                      DLG_SAVE_SHOW_FILEOPTIONS_STAMP          |
                      DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS|
                      DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS;

   nRet = L_DlgSave( g_hWndFrame,&OpenFileName,&FSParm);

   
   if( nRet != SUCCESS_DLG_OK )
      return;

   nExportIndex = OpenFileName.nFilterIndex;

   Hourglass( TRUE );

   L_VecGetViewport( pVector, &rcViewport );
   nRet = L_InitBitmap( &LeadBitmap, sizeof(LeadBitmap),rcViewport.right, rcViewport.bottom, 24 );
   if( nRet != SUCCESS )
   {
      Hourglass( FALSE );
      ShowLeadError( nRet, NULL, NULL );
      return;
   }

   nRet = L_AllocateBitmap( &LeadBitmap, TYPE_CONV );
   if( nRet != SUCCESS )
   {
      Hourglass( FALSE );
      ShowLeadError( nRet, NULL, NULL );
      return;
   }

   nRet = L_VecRealize( &LeadBitmap, pVector, TRUE );
   if( nRet != SUCCESS )
   {
      Hourglass( FALSE );

      if( LeadBitmap.Flags.Allocated )
         L_FreeBitmap( &LeadBitmap );

      ShowLeadError( nRet, NULL, NULL );
      return;
   }

   L_GetDefaultSaveFileOption( &SaveFileOption, sizeof(SAVEFILEOPTION) );
   SaveFileOption.PageNumber = FSParm.nPageNumber;
   SaveFileOption.Flags = 0;

   switch( FSParm.uSaveMulti )
   {
      case MULTIPAGE_OPERATION_REPLACE:
         SaveFileOption.Flags |= ESO_REPLACEPAGE;
         break;

      case MULTIPAGE_OPERATION_INSERT:
         SaveFileOption.Flags |= ESO_INSERTPAGE;
         break;

      case MULTIPAGE_OPERATION_APPEND:
         SaveFileOption.PageNumber = 2;
         break;

      case MULTIPAGE_OPERATION_OVERWRITE:
         SaveFileOption.PageNumber = 1;
         break;
   }
   
   SaveFileOption.Passes = FSParm.nPasses;

   nSaveFormat = FSParm.nFormat;

   if( FSParm.nFormat == FILE_GIF )
   {
      if( !FSParm.bSaveInterlaced )
         SaveFileOption.Flags &= ~ESO_INTERLACED;
      else
         SaveFileOption.Flags |= ESO_INTERLACED;
   }

   if( FSParm.bSaveWithStamp )
   {
      SaveFileOption.Flags |= ESO_SAVEWITHSTAMP;
      SaveFileOption.StampWidth = FSParm.nStampWidth;
      SaveFileOption.StampHeight = FSParm.nStampHeight;
      SaveFileOption.StampBits = FSParm.nStampBits;
   }

   if( nSaveFormat == FILE_JBIG )
   {
      // get current resolutions
      L_GetSaveResolution( &uResCount, NULL );
      if( uResCount > 0 )
      {
         pOldResolutions = (pDIMENSION) GlobalAllocPtr( GHND, sizeof( DIMENSION ) * uResCount );
         if( pOldResolutions )
            L_GetSaveResolution( &uResCount, pOldResolutions );
      }

      pJBIGResolutions = (pDIMENSION) GlobalAllocPtr( GHND, sizeof( DIMENSION ) * FSParm.nPasses );
      if( pJBIGResolutions )
      {
         // largest resolution will be actual image size
         pJBIGResolutions[0].nWidth  = rcViewport.right;
         pJBIGResolutions[0].nHeight = rcViewport.left;
            
         // will save nPasses resolution layers
         L_SetSaveResolution( FSParm.nPasses, pJBIGResolutions );
      }
   }

   if( ( nSaveFormat == FILE_J2K ) ||
       ( nSaveFormat == FILE_JP2 ) ||
       ( nSaveFormat == FILE_CMW ) ||
       ( nSaveFormat == FILE_TIF_J2K ) ||
       ( nSaveFormat == FILE_TIF_CMW ) )
   {
      /*Restore the old J2K Options*/
      L_GetJ2KOptions(&FileJ2KOptions,sizeof(FILEJ2KOPTIONS));
      
      L_SetJ2KOptions(&FSParm.FileJ2KOptions);
   }

   nRet = L_SaveBitmap( FSParm.szFileName,
                        &LeadBitmap,
                        nSaveFormat,
                        FSParm.nBitsPerPixel,
                        FSParm.nQFactor,
                        &SaveFileOption );

   if( LeadBitmap.Flags.Allocated )
      L_FreeBitmap( &LeadBitmap );

   // restore the old save dimensions
   if( pOldResolutions )
   {
      L_SetSaveResolution( uResCount, pOldResolutions );
      GlobalFreePtr( pOldResolutions );
   }
   
   if(pJBIGResolutions)
      GlobalFreePtr( pJBIGResolutions );

   if( ( nSaveFormat == FILE_J2K ) ||
       ( nSaveFormat == FILE_JP2 ) ||
       ( nSaveFormat == FILE_CMW ) ||
       ( nSaveFormat == FILE_TIF_J2K ) ||
       ( nSaveFormat == FILE_TIF_CMW ) )
   {
      /*Restore the old J2K Options*/
      L_SetJ2KOptions(&FileJ2KOptions);
   }   

   Hourglass( FALSE );

   if( nRet == SUCCESS )
      ShowMessageBox( FALSE, MB_ICONINFORMATION, 
                      TEXT("Drawing has been exported to file\n%s"), FSParm.szFileName );
   else
      ShowLeadError( nRet, TEXT("Export File"), FSParm.szFileName );
}


/*----------------------------------------------------------------------------
|
|  CreateChildWindow
|
 ---------------------------------------------------------------------------*/
static HWND
CreateChildWindow 
(
   LPCREATEDATA  pCreateData
)
{
   MDICREATESTRUCT   MdiCreateStruct;
   HWND              hWndChild;

   MdiCreateStruct.szClass = g_szChildClass;
   MdiCreateStruct.szTitle = pCreateData->szFileName;
   MdiCreateStruct.hOwner  = g_hInstance;
   MdiCreateStruct.x       = CW_USEDEFAULT;
   MdiCreateStruct.y       = CW_USEDEFAULT;
   MdiCreateStruct.cx      = CW_USEDEFAULT;
   MdiCreateStruct.cy      = CW_USEDEFAULT;
   MdiCreateStruct.style   = MDIS_ALLCHILDSTYLES | WS_CLIPCHILDREN | WS_HSCROLL | WS_VSCROLL;
   MdiCreateStruct.lParam  = (LPARAM) pCreateData;

   hWndChild = FORWARD_WM_MDICREATE( g_hWndClient, (LPMDICREATESTRUCT) &MdiCreateStruct, SendMessage);

   return hWndChild;
}


/*----------------------------------------------------------------------------
|
|  CloseAll
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION 
CloseAll 
(
   HWND     hWnd, 
   LPARAM   lParam
)
{
   UNREFERENCED_PARAMETER( lParam );

   if( GetParent( hWnd ) != g_hWndClient )
      return TRUE;

   if( GetWindow( hWnd, GW_OWNER ) )
      return TRUE;

   //	FORWARD_WM_MDIRESTORE( GetParent( hWnd ), hWnd, SendMessage );
   FORWARD_WM_CLOSE( hWnd, SendMessage );

   return TRUE;
}


/*----------------------------------------------------------------------------
|
|  PaletteChangedAll
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION
PaletteChangedAll
(
   HWND     hWnd,
   LPARAM   lParam
)
{
   if( GetParent( hWnd ) != g_hWndClient )
      return TRUE;

   if( GetWindow( hWnd, GW_OWNER ) )
      return TRUE;

   FORWARD_WM_PALETTECHANGED( hWnd, (HWND) lParam, SendMessage );

   return TRUE;
}


/*----------------------------------------------------------------------------
|
|  AboutDlgProc
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION
AboutDlgProc
( 
   HWND     hWnd, 
   L_UINT   uMessage,
   WPARAM   wParam,
   LPARAM   lParam
)
{
   UNREFERENCED_PARAMETER( lParam );

   switch( uMessage )
   {
      case WM_COMMAND:
         switch( LOWORD( wParam ) )
         {
            case IDOK:
            case IDCANCEL:
               EndDialog( hWnd, 0 );
               return TRUE;
         }

      default:
         break;
   }

   return FALSE;
}


/*----------------------------------------------------------------------------
|
|  VectorDlgProc
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION
VectorDlgProc
(
   HWND     hWnd,
   L_UINT   uMessage,
   WPARAM   wParam,
   LPARAM   lParam
)
{
   static LPCREATEDATA  pCreateData;
   static L_INT         nEngine[] =
   {
      VECTOR_ENGINE_GDI,
      VECTOR_ENGINE_OPENGL
   };

   static const L_TCHAR *szEngine[] =
   {
      __TEXT( "GDI" ),
      __TEXT( "OpenGL" )
   };

   VECTORPOINT          TempPoint1, TempPoint2;
   HWND                 hWndCombo;
   L_INT                i, nCount, nIndex;

   switch( uMessage )
   {
      case WM_INITDIALOG:
         pCreateData = (LPCREATEDATA) lParam;
         SetMyDlgItemDouble( hWnd, IDC_MINX, pCreateData->Min.x );
         SetMyDlgItemDouble( hWnd, IDC_MINY, pCreateData->Min.y );
         SetMyDlgItemDouble( hWnd, IDC_MINZ, pCreateData->Min.z );
         SetMyDlgItemDouble( hWnd, IDC_MAXX, pCreateData->Max.x );
         SetMyDlgItemDouble( hWnd, IDC_MAXY, pCreateData->Max.y );
         SetMyDlgItemDouble( hWnd, IDC_MAXZ, pCreateData->Max.z );

         hWndCombo = GetDlgItem( hWnd, IDC_ENGINE );
         nCount = sizeof( nEngine ) / sizeof( nEngine[ 0 ] );
         for( i = 0; i < nCount; i++ )
         {
            nIndex = ComboBox_AddString( hWndCombo, szEngine[ i ] );
            ComboBox_SetItemData( hWndCombo, nIndex, nEngine[ i ] );
         }

         nIndex = -1;
         i = 0;
         while( i < nCount && nIndex == -1 )
         {
            if( pCreateData->nEngine == ComboBox_GetItemData( hWndCombo, i ) )
               nIndex = i;
            else
               i++;
         }

         if( -1 != nIndex )
            ComboBox_SetCurSel( hWndCombo, nIndex );

         if( pCreateData->bNewVector )
            EnableWindow( hWndCombo, FALSE );

         Button_SetCheck( GetDlgItem( hWnd, IDC_DOUBLEBUFFER ),
                          ( pCreateData->bUseDoubleBuffer ) ?
                          BST_CHECKED : BST_UNCHECKED );

         return TRUE;

      case WM_COMMAND:
         switch( LOWORD( wParam ) )
         {
            case IDOK:
               if( !GetMyDlgItemDouble( hWnd, IDC_MINX, &TempPoint1.x ) ||
                   !GetMyDlgItemDouble( hWnd, IDC_MINY, &TempPoint1.y ) ||
                   !GetMyDlgItemDouble( hWnd, IDC_MINZ, &TempPoint1.z ) ||
                   !GetMyDlgItemDouble( hWnd, IDC_MAXX, &TempPoint2.x ) ||
                   !GetMyDlgItemDouble( hWnd, IDC_MAXY, &TempPoint2.y ) ||
                   !GetMyDlgItemDouble( hWnd, IDC_MAXZ, &TempPoint2.z ) ||
                   TempPoint1.x > TempPoint2.x ||
                   TempPoint1.y > TempPoint2.y ||
                   TempPoint1.z > TempPoint2.z )
                   return TRUE;

               pCreateData->Min.x = TempPoint1.x;
               pCreateData->Min.y = TempPoint1.y;
               pCreateData->Min.z = TempPoint1.z;
               pCreateData->Max.x = TempPoint2.x;
               pCreateData->Max.y = TempPoint2.y;
               pCreateData->Max.z = TempPoint2.z;

               hWndCombo = GetDlgItem( hWnd, IDC_ENGINE );
               nIndex = ComboBox_GetCurSel( hWndCombo );
               pCreateData->nEngine = ComboBox_GetItemData( hWndCombo, nIndex );

               pCreateData->bUseDoubleBuffer =
                  Button_GetCheck( GetDlgItem( hWnd, IDC_DOUBLEBUFFER ) ) == BST_CHECKED;

            case IDCANCEL:
               EndDialog( hWnd, LOWORD( wParam ) );
               return TRUE;
         }
         break;

      default:
         break;
   }

   return FALSE;
}



L_INT OpenDroppedFile (LPCREATEDATA pCreateData, L_TCHAR * szFileName)
{
   L_INT                nRet;
   FILEINFO             FileInfo;
   HWND                 hWndChild;

   pCreateData->pVector = (pVECTORHANDLE) GlobalAllocPtr( GHND, sizeof( VECTORHANDLE ) );
   if( !pCreateData->pVector )
   {
      nRet = ERROR_NO_MEMORY;
      ShowLeadError( nRet, NULL, NULL );
      return nRet;
   }

   Hourglass( TRUE );
   nRet = L_VecLoadFile( szFileName, pCreateData->pVector, NULL, &FileInfo );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, TEXT("Open File"), szFileName );
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return nRet;
   }
   
   nRet = L_FileInfo( szFileName,&FileInfo, sizeof(FILEINFO), 0, NULL );
   
   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, TEXT("Open File"), szFileName );
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return nRet;
   }

   pCreateData->nFormat = FileInfo.Format;

   L_VecGetParallelogram( pCreateData->pVector, &pCreateData->Min, &pCreateData->Max );
   pCreateData->nEngine = VECTOR_ENGINE_GDI;
   pCreateData->bUseDoubleBuffer = TRUE;

   pCreateData->bNewVector = FALSE;

   if( DoDialogBoxParam( IDD_VECTOR, g_hWndClient, (DLGPROC) VectorDlgProc, (LPARAM) pCreateData ) != IDOK )
   {
      L_VecFree( pCreateData->pVector );
      GlobalFreePtr( pCreateData->pVector );
      return SUCCESS_DLG_CANCEL;
   }

   lstrcpy( pCreateData->szFileName, szFileName );

   if( nRet == SUCCESS )
   {
      hWndChild = CreateChildWindow( pCreateData );
      if( !hWndChild )
      {
         L_VecFree( pCreateData->pVector );
         GlobalFreePtr( pCreateData->pVector );
      }
      else
      {
         if ( 0 == nChildsNumber )
         {
            SendMessage( hwndRB, RB_SHOWBAND, 0, (LPARAM) TRUE );
            g_bIsToolBarVisible = TRUE;
            CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, g_bIsToolBarVisible );
         
            // Force the document to resize it self according to the window.
            SendMessage( hWndChild, WM_SIZE, 0, 0 );
         }

         nChildsNumber++;
      }
   }

   return TRUE;
}


/* EOF ----------------------------------------------------------------------*/