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


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


// Internal variables.
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("ESRI (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")
};


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

L_INT OpenDroppedFile (LPCREATEDATA   pCreateData, L_TCHAR * szFilePath);


// 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_OnPaletteChanging (HWND hwnd, HWND hwndPaletteChange);
static L_VOID LEADTOOLS_SysColorChange(HWND 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 OnViewToolbar( L_VOID );
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 );

static L_INT EXT_CALLBACK ToolbarCallback( pTOOLBARHANDLE, L_UINT, L_UINT32, L_VOID * );


/*----------------------------------------------------------------------------
|
|  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_PALETTEISCHANGING, LEADTOOLS_OnPaletteChanging);
      HANDLE_MSG (hWnd, WM_SYSCOLORCHANGE,   LEADTOOLS_SysColorChange);
      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 );
}


/*----------------------------------------------------------------------------
|
|  WM_CREATE
|
 ---------------------------------------------------------------------------*/
static L_BOOL
LEADTOOLS_OnCreate
(
   HWND           hWnd,
   LPCREATESTRUCT pCreateStruct
)
{
   CLIENTCREATESTRUCT   ClientStruct;
   L_INT                nRet;
   L_BOOL               bVisible;
   POINT                pt;
   RECT                 rcClient;

   UNREFERENCED_PARAMETER( pCreateStruct );
   
   L_DlgInit(DLG_INIT_COLOR);

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

   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;


   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;

   nRet = L_AutInit( &g_pAutomation );
   if( nRet == SUCCESS )
      nRet = L_AutCreate( g_pAutomation, AUTOMATION_MODE_VECTOR, 0L );

   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, NULL, NULL );
      return FALSE;
   }

   nRet = L_TBInit( &g_pToolbar );
   if( nRet == SUCCESS )
   {
      GetClientRect( g_hWndClient, &rcClient );

      pt.x = rcClient.left;
      pt.y = rcClient.top;

      ClientToScreen( g_hWndClient, &pt );

      nRet = L_TBCreate( g_pToolbar,
                         g_hWndClient,
                         TEXT("Vector"),
                         TOOLBAR_VECTOR );
      if( nRet == SUCCESS )
      {
         L_TBSetCallback( g_pToolbar, ToolbarCallback, NULL );

         L_TBSetRows( g_pToolbar, 8 );
         L_TBSetPosition( g_pToolbar,
                          &pt,
                          TOOLBAR_POSITION_TOP | TOOLBAR_POSITION_LEFT );
         L_TBIsVisible( g_pToolbar, &bVisible );
         if( !bVisible )
            L_TBSetVisible( g_pToolbar, TRUE );

         L_TBIsVisible( g_pToolbar, &bVisible );
         CHECKMENUITEM( g_hMenuFrame, IDM_VIEW_TOOLBAR, bVisible );
         CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, bVisible );

         CHECKMENUITEM( g_hMenuFrame, IDM_VIEW_STATUSBAR, TRUE );

         nRet = L_AutSetToolbar( g_pAutomation, g_pToolbar );
      }
   }

   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, NULL, NULL );
      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_PALETTEISCHANGING
|
 ---------------------------------------------------------------------------*/

L_VOID  LEADTOOLS_OnPaletteChanging
(
   HWND hWnd, 
   HWND hWndPaletteChange
)
{
   LEADTOOLS_OnPaletteChanged (hWnd, hWndPaletteChange);
}

/*----------------------------------------------------------------------------
|
|  WM_SYSCOLORCHANGE
|
 ---------------------------------------------------------------------------*/

static L_VOID LEADTOOLS_SysColorChange
(
   HWND hwnd
)
{
   LEADTOOLS_OnQueryNewPalette(hwnd);
}

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

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

   GetClientRect( hWnd, &RectFrame );

   // 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,
                  RectFrame.top,
                  RectFrame.right  - RectFrame.left,
                  RectFrame.bottom - RectFrame.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_TOOLBAR:
         OnViewToolbar();
         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 );
   DestroyWindow( hWnd );
}


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

   if( L_AutIsValid( g_pAutomation ) == SUCCESS )
      L_AutFree( g_pAutomation );

   if( L_TBIsValid( g_pToolbar ) == SUCCESS )
      L_TBFree( g_pToolbar );

   L_DlgFree();
   
   PostQuitMessage( 0 );
}


/*----------------------------------------------------------------------------
|
|  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 );
      }
   }
}


/*----------------------------------------------------------------------------
|
|  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 );
      }      
   }
}


/*----------------------------------------------------------------------------
|
|  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/Toolbar
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewToolbar
(
   L_VOID
)
{
   L_BOOL   bVisible;

   L_TBIsVisible( g_pToolbar, &bVisible );
   L_TBSetVisible( g_pToolbar, !bVisible );
   L_TBIsVisible( g_pToolbar, &bVisible );

   CHECKMENUITEM( g_hMenuFrame, IDM_VIEW_TOOLBAR, bVisible );
   CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, bVisible );
}


/*----------------------------------------------------------------------------
|
|  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 );
}


/*----------------------------------------------------------------------------
|
|  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->bUseEngine = FALSE;
   pCreateData->bUseDoubleBuffer = 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++;

   pCreateData->bNewVector = TRUE;

   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.hInstance         = NULL;
   OpenFileName.lpstrFilter       = szOpenFileFilter;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   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.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = TEXT( "" ); 
   OpenFileName.lCustData         = 0L;
   OpenFileName.lpfnHook          = NULL;
   OpenFileName.lpTemplateName    = NULL;

   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->bUseEngine = TRUE;
   pCreateData->bUseDoubleBuffer = TRUE;
   

   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 );
   pCreateData->bNewVector = FALSE;

   return SUCCESS;
}


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

   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(&OpenFileName,0,sizeof(OpenFileName));
   memset(&FSParm,0,sizeof(FSParm));

   FSParm.uStructSize      = sizeof( FSParm);
   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;

   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.uSaveMulti = uSaveMulti;


   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 ] );
         }

         EnableWindow( hWndCombo, pCreateData->bUseEngine );

         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 );

         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;
}


/*----------------------------------------------------------------------------
|
|  ToolbarCallback
|
 ---------------------------------------------------------------------------*/
static L_INT EXT_CALLBACK
ToolbarCallback
(
   pTOOLBARHANDLE    pToolbar, 
   L_UINT            nButtonID,
   L_UINT32          dwData,  
   L_VOID           *pUserData
)
{
   L_BOOL   bVisible;

   UNREFERENCED_PARAMETER( pToolbar );
   UNREFERENCED_PARAMETER( dwData );
   UNREFERENCED_PARAMETER( pUserData );
   
   if( nButtonID == -1 )
   {
      L_TBIsVisible( g_pToolbar, &bVisible );
      CHECKMENUITEM( g_hMenuFrame, IDM_VIEW_TOOLBAR, bVisible );
      CHECKMENUITEM( g_hMenuChild, IDM_VIEW_TOOLBAR, bVisible );
   }

   return SUCCESS;
}

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);
   }
	

}

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, NULL );
   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 );
      }     
   }

   return TRUE;
}




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