/*----------------------------------------------------------------------------
|
|  child.c
|
 ---------------------------------------------------------------------------*/


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


#ifndef HANDLE_WM_CONTEXTMENU
#define HANDLE_WM_CONTEXTMENU(hwnd, wParam, lParam, fn) \
    ((fn)((hwnd), (HWND)(wParam), (UINT)LOWORD(lParam), (UINT)HIWORD(lParam)), 0L)
#endif   // HANDLE_WM_CONTEXTMENU


typedef struct tagENUMDATA
{
   L_INT          nType;
   L_BOOL         bNeedPaint;
   L_INT          nObjectCount;
   VECTOROBJECT   LastObject;
   pVECTORGROUP   pGroup;
}
ENUMDATA, *LPENUMDATA;

typedef struct _PALETTEINFO
{
   COLORREF *prgbList;
   L_UINT32  uCount;

}PALETTEINFO, *pPALETTEINFO;

enum
{
   ENUM_COUNT,
   ENUM_ADDTOGROUP
};

typedef struct tagGROUPSDLGDATA
{
   pVECTORHANDLE  pVector;
   VECTORGROUP    Group;
}
GROUPSDLGDATA, *LPGROUPSDLGDATA;


static const L_TCHAR szSaveFileFilter[] =
{
   TEXT("LEAD Vector (VEC)\0")                                TEXT("*.vec\0")
   TEXT("AutoCAD DWF\0")                                      TEXT("*.dwf\0")
   TEXT("AutoCAD DXF\0")                                      TEXT("*.dxf\0")
   TEXT("Computer Graphics Metafile (CGM)\0")                 TEXT("*.cgm\0")
   TEXT("HP-GL2 (PLT)\0")                                     TEXT("*.plt\0")
   TEXT("Mac PICT (PCT)\0")                                   TEXT("*.pct\0")
   TEXT("Micrografx (DRW)\0")                                 TEXT("*.drw\0")
   TEXT("Windows Metafile (WMF)\0")                           TEXT("*.wmf\0")
   TEXT("Windows Enhanced Metafile (EMF)\0")                  TEXT("*.emf\0")
   TEXT("Gerber File Format (GBR)\0")                         TEXT("*.gbr\0")
   TEXT("ESRI (SHP)\0")                                       TEXT("*.shp\0")
   TEXT("Printer Command Language (PRN)\0")                   TEXT("*.prn\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 nSaveIndex = 0;

static COLORREF BackgroundColor = RGB(255,255,255);


/* Local functions */
static L_BOOL Child_OnCreate( HWND, LPCREATESTRUCT );
static L_VOID Child_OnMDIActivate( HWND, L_BOOL, HWND, HWND );
static L_VOID Child_OnSetFocus( HWND, HWND );
static L_VOID Child_OnPaletteChanged(HWND, HWND );
static L_BOOL Child_OnQueryNewPalette( HWND );
static L_VOID Child_OnSize( HWND, L_UINT, L_INT, L_INT );
static L_BOOL Child_OnEraseBkgnd( HWND, HDC );
static L_VOID Child_OnPaint( HWND );
static L_VOID Child_OnMouseMove( HWND, L_INT, L_INT, L_UINT );
static L_VOID Child_OnHScroll( HWND, HWND, L_UINT, L_INT );
static L_VOID Child_OnVScroll( HWND, HWND, L_UINT, L_INT );
static L_VOID Child_OnCommand( HWND, L_INT, HWND, L_UINT );
static L_VOID Child_OnContextMenu( HWND, HWND, L_UINT, L_UINT );
static L_VOID Child_OnDestroy( HWND );   
static L_VOID Child_OnKeyDown( HWND, L_UINT, BOOL, L_INT, L_UINT );

static L_VOID OnFileSaveAs( HWND );
static L_VOID OnFileSave( HWND );
static L_VOID OnFilePrint( HWND );
static L_VOID OnFileConvert( L_BOOL );

static L_VOID OnEditUndo( HWND );
static L_VOID OnEditRedo( HWND );
static L_VOID OnEditCut( HWND );
static L_VOID OnEditCopy( HWND );
static L_VOID OnEditPaste( HWND, L_INT );
static L_VOID OnEditDelete( HWND );
static L_VOID OnEditSelectAll( HWND );
static L_VOID OnEditUnselectAll( HWND, L_BOOL );

static L_VOID OnViewScale( HWND );
static L_VOID OnViewRotate( HWND );
static L_VOID OnViewTranslate( HWND );
static L_VOID OnViewCamera( HWND );
static L_VOID OnViewMode( HWND );
static L_VOID OnViewBackColor( HWND );
static L_VOID OnViewExtent( HWND );

static L_VOID OnLayerEdit( HWND );

static L_VOID OnGroupEdit( HWND );
static L_VOID OnGroupAdd( HWND );

static L_VOID OnObjectExplode( HWND );
static L_VOID OnObjectNew( HWND, L_INT );
static L_VOID OnObjectEdit( HWND );
static L_VOID OnObjectProperties( HWND );

static L_VOID OnOptionsBindMode( HWND, L_INT );
static L_VOID OnOptionsHitTest( HWND );
static L_VOID OnOptionsRender( HWND );
static L_VOID OnOptionsApplyTransformation( HWND );
static L_VOID OnOptionsInvertColors( HWND );
static L_VOID OnOptionsPalette( HWND );


static L_INT EXT_CALLBACK MyEnumObjectsProc( pVECTORHANDLE, const pVECTOROBJECT, L_VOID * );

static L_VOID DisplayTitle( HWND );
static L_VOID UpdateMenuStatus( LPCHILDDATA );
static L_VOID UpdateScrollBars( HWND );

static L_INT SaveVector( const pVECTORHANDLE, const L_TCHAR *, L_INT );
static L_VOID SaveVectorAs( HWND );

static L_INT EXT_CALLBACK ContainerCallback( pCONTAINERHANDLE, CONTAINEREVENTTYPE, L_VOID *, L_VOID * );
static L_BOOL EXT_FUNCTION GroupsDlgProc( HWND, L_UINT, WPARAM, LPARAM );
static L_BOOL EXT_FUNCTION PaletteProc( HWND, L_UINT, WPARAM, LPARAM );
static L_BOOL EXT_FUNCTION ConvertToProc( HWND, L_UINT, WPARAM, LPARAM );

static L_INT  CreateDefaultLayer( pVECTORHANDLE pVector );


/*----------------------------------------------------------------------------
|
|  ChildWIndowProc
|
 ---------------------------------------------------------------------------*/
LRESULT EXT_FUNCTION
ChildWindowProc
(
   HWND     hWnd,
   L_UINT   uMessage,
   WPARAM   wParam,
   LPARAM   lParam
)
{
   switch( uMessage )
   {
      HANDLE_MSG( hWnd, WM_CREATE, Child_OnCreate );
      HANDLE_MSG( hWnd, WM_MDIACTIVATE, Child_OnMDIActivate );
      HANDLE_MSG( hWnd, WM_SETFOCUS, Child_OnSetFocus );
      HANDLE_MSG( hWnd, WM_PALETTECHANGED, Child_OnPaletteChanged );
      HANDLE_MSG( hWnd, WM_QUERYNEWPALETTE, Child_OnQueryNewPalette );
      HANDLE_MSG( hWnd, WM_SIZE, Child_OnSize );
      HANDLE_MSG( hWnd, WM_ERASEBKGND, Child_OnEraseBkgnd );
      HANDLE_MSG( hWnd, WM_PAINT, Child_OnPaint );
      HANDLE_MSG( hWnd, WM_MOUSEMOVE, Child_OnMouseMove );
      HANDLE_MSG( hWnd, WM_HSCROLL, Child_OnHScroll );
      HANDLE_MSG( hWnd, WM_VSCROLL, Child_OnVScroll );
      HANDLE_MSG( hWnd, WM_COMMAND, Child_OnCommand );
      HANDLE_MSG( hWnd, WM_CONTEXTMENU, Child_OnContextMenu );
      HANDLE_MSG( hWnd, WM_DESTROY, Child_OnDestroy );
      HANDLE_MSG( hWnd, WM_KEYDOWN, Child_OnKeyDown );
   }

   return DefMDIChildProc( hWnd, uMessage, wParam, lParam );
}


/*----------------------------------------------------------------------------
|
|  WM_CREATE
|
 ---------------------------------------------------------------------------*/
static L_BOOL 
Child_OnCreate 
(
   HWND           hWnd, 
   LPCREATESTRUCT pCreateStruct
)
{
   LPCREATEDATA      pCreateData;
   LPCHILDDATA       pData;
   L_INT             nRet;
   VECTOR_DISPLAY_OPTIONS DispOpt;

   pCreateData = (LPCREATEDATA) CHILDCREATELPARAM( pCreateStruct );
   pData = (LPCHILDDATA) GlobalAllocPtr( GHND, sizeof (CHILDDATA) );
   if( !pData ) 
   {
      ShowLeadError( ERROR_NO_MEMORY, NULL, NULL );
      return FALSE;
   }

   pData->bCreatedOK = FALSE;
   pData->bNewVector = pCreateData->bNewVector;

   SETCHILDDATA( hWnd, pData );
   
   lstrcpy( pData->szFileName, pCreateData->szFileName );
   DisplayTitle( hWnd );

   pData->pVector = pCreateData->pVector;

   pData->nFormat = pCreateData->nFormat;

   L_VecSetParallelogram( pData->pVector, &pCreateData->Min, &pCreateData->Max );

   if( pData->bNewVector )
   {
      L_VecSetOrigin( pData->pVector, NULL );
      L_VecSetCamera( pData->pVector, NULL );
      L_VecSetBackgroundColor( pData->pVector, RGB( 0xFF, 0xFF, 0xFF ) );
   }

   Hourglass( TRUE );
   nRet = L_VecAttachToWindow( hWnd, pData->pVector, pCreateData->nEngine, ( pCreateData->bUseDoubleBuffer ) ? VECTOR_ENGINE_DOUBLEBUFFER : 0L );
   Hourglass( FALSE );
   if( nRet != SUCCESS )
   {
      ShowLeadError( nRet, NULL, NULL );
      return FALSE;
   }

   if( L_VecGetEngine( pData->pVector ) == VECTOR_ENGINE_GDI )
   {
      SetScrollRange( hWnd, SB_HORZ, 0, 2, TRUE );
      SetScrollPos( hWnd, SB_HORZ, 1, TRUE );
      SetScrollRange( hWnd, SB_VERT, 0, 2, TRUE );
      SetScrollPos( hWnd, SB_VERT, 1, TRUE );
   }
   else
   {
      SetScrollRange( hWnd, SB_HORZ, 0, 0, TRUE );
      SetScrollPos( hWnd, SB_HORZ, 0, TRUE );
      SetScrollRange( hWnd, SB_VERT, 0, 0, TRUE );
      SetScrollPos( hWnd, SB_VERT, 0, TRUE );
   }

   nRet = L_ContainerInit( &pData->pContainer );
   if( nRet == SUCCESS )
      nRet = L_ContainerCreate( pData->pContainer, hWnd );

   if( nRet == SUCCESS )
      nRet = L_ContainerSetCallback( pData->pContainer, ContainerCallback, NULL );

   if( nRet == SUCCESS )
      nRet = L_AutAddContainer( g_pAutomation, pData->pContainer, pData->pVector );

   FORWARD_WM_CREATE( hWnd, pCreateStruct, DefMDIChildProc );

   pData->bCreatedOK = TRUE;


   L_VecGetDisplayOptions( pData->pVector, &DispOpt );
   
   DispOpt.nClipMode = VECTOR_CLIPMODE_COPY;

   L_VecSetDisplayOptions( pData->pVector, &DispOpt );


   // Create Default layer
   if ( pData->bNewVector )
      nRet = CreateDefaultLayer( pData->pVector );

   return TRUE;
}

/*----------------------------------------------------------------------------
|
|  CreateDefaultLayer
|
 ---------------------------------------------------------------------------*/
static L_INT
CreateDefaultLayer
(
   pVECTORHANDLE pVector
)
{
   VECTORLAYERDESC   LayerDesc;
   VECTORLAYER       Layer;
   L_INT             nRet;

   
   ZeroMemory( &LayerDesc, sizeof( LayerDesc ) );
   
   LayerDesc.nSize = sizeof( LayerDesc );
   
   lstrcpy( LayerDesc.szName, TEXT("0") );
   
   LayerDesc.bVisible = TRUE;
   
   nRet = L_VecAddLayer( pVector, &LayerDesc, &Layer, 0L );
   
   if( SUCCESS == nRet )
   {
      nRet = L_VecSetActiveLayer( pVector, &Layer );
   }
   
   return( nRet );
}


/*----------------------------------------------------------------------------
|
|  WM_MDIACTIVATE
|
 ---------------------------------------------------------------------------*/
static L_VOID 
Child_OnMDIActivate
( 
   HWND     hWnd, 
   L_BOOL   fActive, 
   HWND     hWndActivate,
   HWND     hWndDeactivate
)
{
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER( hWndActivate );
   UNREFERENCED_PARAMETER( hWndDeactivate );

   pData = GETCHILDDATA( hWnd );

   if( fActive )
   {
      FORWARD_WM_MDISETMENU( g_hWndClient,
                             TRUE, 
                             g_hMenuChild,
                             g_hMenuChildWindow,
                             SendMessage );
      SetFocus( hWnd );
      L_AutSetActiveContainer( g_pAutomation, pData->pContainer );
   }
   else
   {
      FORWARD_WM_MDISETMENU( g_hWndClient,
                             TRUE,
                             g_hMenuFrame,
                             g_hMenuFrameWindow,
                             SendMessage );
   }

   DrawMenuBar( g_hWndFrame );
}


/*----------------------------------------------------------------------------
|
|  WM_SETFOCUS
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnSetFocus
(
   HWND  hWnd,
   HWND  hWndOldFocus
)
{
   LPCHILDDATA pData;

   UNREFERENCED_PARAMETER( hWndOldFocus );
      
   pData = GETCHILDDATA( hWnd );
   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  WM_PALETTECHANGED
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnPaletteChanged
(
   HWND  hWnd,
   HWND  hWndPaletteChange
)
{
   HDC         hDC;
   HPALETTE    hPalette;
   HPALETTE    hOldPalette;
   LPCHILDDATA pData;

   pData = GETCHILDDATA( hWnd );

   if( hWnd == hWndPaletteChange )
      return;

   hPalette = L_VecGetPalette( pData->pVector );
   if( hPalette )
   {
      hDC = GetDC( hWnd );

      hOldPalette = SelectPalette( hDC, hPalette, TRUE );
      RealizePalette( hDC );
      InvalidateRect( hWnd, 0, FALSE );

      SelectPalette( hDC, hOldPalette, TRUE );

      ReleaseDC( hWnd, hDC );
   }
}


/*----------------------------------------------------------------------------
|
|  WM_QUERYNEWPALETTE
|
 ---------------------------------------------------------------------------*/
static L_BOOL
Child_OnQueryNewPalette
(
   HWND  hWnd
)
{
   HDC         hDC;
   HPALETTE    hPalette;
   HPALETTE    hOldPalette;
   L_INT       nNoColors = 0;
   LPCHILDDATA pData;

   pData = GETCHILDDATA( hWnd );

   hPalette = L_VecGetPalette( pData->pVector );
   if( hPalette )
   {
      hDC = GetDC( hWnd );

      hOldPalette = SelectPalette( hDC, hPalette, FALSE );
      nNoColors = RealizePalette( hDC );

      if( nNoColors )
         InvalidateRect( hWnd, NULL, FALSE );

      SelectPalette( hDC, hOldPalette, TRUE );

      ReleaseDC( hWnd, hDC );
   }

   return nNoColors;
}


/*----------------------------------------------------------------------------
|
|  WM_SIZE
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnSize
(
   HWND     hWnd,
   L_UINT   nState,
   L_INT    nCx,
   L_INT    nCy
)
{
   LPCHILDDATA       pData = GETCHILDDATA( hWnd );
   RECT              Rect;
   CONTAINERMETRICS  ContainerMetrics;

   SetRect( &Rect, 0, 0, nCx, nCy );

   L_VecSetViewport( pData->pVector, &Rect );

   ContainerMetrics.nSize = sizeof( CONTAINERMETRICS );
   ContainerMetrics.dwMask = CMF_LIMITS;
   CopyRect( &ContainerMetrics.rcLimits, &Rect );

   L_ContainerSetMetrics( pData->pContainer, &ContainerMetrics );

   UpdateScrollBars( hWnd );

   FORWARD_WM_SIZE( hWnd, nState, nCx, nCy, DefMDIChildProc );
}


/*----------------------------------------------------------------------------
|
|  WM_ERASEBKGND
|
 ---------------------------------------------------------------------------*/
static L_BOOL
Child_OnEraseBkgnd
(
   HWND  hWnd,
   HDC   hDC
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   HPALETTE    hPalette;
   HPALETTE    hOldPalette = NULL;
   HBRUSH      hBrush;
   RECT        Rect;

   hPalette = L_VecGetPalette( pData->pVector );
   if( hPalette )
   {
      hOldPalette = SelectPalette( hDC, hPalette, TRUE );
      RealizePalette( hDC );
   }

   GetClientRect( hWnd, &Rect );

   hBrush = CreateSolidBrush( L_VecGetBackgroundColor( pData->pVector ) );
   FillRect( hDC, &Rect, hBrush );
   DeleteObject( hBrush );

   if( hPalette )
      SelectPalette( hDC, hOldPalette, TRUE );

   return TRUE;
}


/*----------------------------------------------------------------------------
|
|  WM_PAINT
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnPaint
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   PAINTSTRUCT PaintStruct;
   HDC         hDC;
   HPALETTE    hPalette;
   HPALETTE    hOldPalette = NULL;

   hDC = BeginPaint( hWnd, &PaintStruct );

   hPalette = L_VecGetPalette( pData->pVector );
   if( hPalette )
   {
      hOldPalette = SelectPalette( hDC, hPalette, TRUE );
      RealizePalette( hDC );
   }

   
   L_VecPaint( hDC, pData->pVector, TRUE );

   if( hPalette )
      SelectPalette( hDC, hOldPalette, TRUE );
   EndPaint( hWnd, &PaintStruct );
}


/*----------------------------------------------------------------------------
|
|  WM_MOUSEMOVE
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnMouseMove
(
   HWND     hWnd,
   L_INT    x,
   L_INT    y,
   L_UINT   uKeyFlags
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   POINT       pt;
   VECTORPOINT Point;

   UNREFERENCED_PARAMETER( uKeyFlags );

   pt.x = x;
   pt.y = y;
   L_VecPhysicalToLogical( pData->pVector, &Point, &pt );

   StatusBarText( "%Lf, %Lf", Point.x, Point.y );
}


/*----------------------------------------------------------------------------
|
|  WM_HSCROLL
|
 ---------------------------------------------------------------------------*/
static L_VOID 
Child_OnHScroll
( 
   HWND     hWnd,
   HWND     hWndCtl,
   L_UINT   uCode,
   L_INT    nPos
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nMin, nMax;
   L_INT       nOldPos, nNewPos;
   RECT        Rect;
   L_INT       nLine, nPage;
   POINT       ptPan, ptPanOld;

   UNREFERENCED_PARAMETER( hWndCtl );

   if( L_VecGetEngine( pData->pVector ) != VECTOR_ENGINE_GDI )
      return;

   GetScrollRange( hWnd, SB_HORZ, &nMin, &nMax );
   nOldPos = GetScrollPos( hWnd, SB_HORZ );

   nNewPos = nOldPos;

   GetClientRect( hWnd, &Rect );
   nLine = Rect.right / 10;
   nPage = Rect.right / 4;

   switch( uCode )
   {
      case SB_LINELEFT:
         nNewPos -= nLine;
         break;

      case SB_LINERIGHT:
         nNewPos += nLine;
         break;

      case SB_PAGELEFT:
         nNewPos -= nPage;
         break;

      case SB_PAGERIGHT:
         nNewPos += nPage;
         break;

      case SB_LEFT:
         nNewPos = nMin;
         break;

      case SB_RIGHT:
         nNewPos = nMax;
         break;

      case SB_THUMBTRACK:
      case SB_THUMBPOSITION:
         nNewPos = nPos;
         break;

      default:
         break;
   }

   L_VecGetPan( pData->pVector, &ptPanOld );
   ptPan.x = ptPanOld.x + ( nNewPos - nOldPos );
   if( ptPan.x != ptPanOld.x )
   {
      SetScrollPos( hWnd, SB_HORZ, nNewPos, TRUE );
      ptPan.y = ptPanOld.y;
      L_VecSetPan( pData->pVector, &ptPan );
      InvalidateRect( hWnd, NULL, FALSE );
   }
}


/*----------------------------------------------------------------------------
|
|  WM_VSCROLL
|
 ---------------------------------------------------------------------------*/
static L_VOID 
Child_OnVScroll
( 
   HWND     hWnd,
   HWND     hWndCtl,
   L_UINT   uCode,
   L_INT    nPos
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nMin, nMax;
   L_INT       nOldPos, nNewPos;
   RECT        Rect;
   L_INT       nLine, nPage;
   POINT       ptPan, ptPanOld;

   UNREFERENCED_PARAMETER( hWndCtl );

   if( L_VecGetEngine( pData->pVector ) != VECTOR_ENGINE_GDI )
      return;

   GetScrollRange( hWnd, SB_VERT, &nMin, &nMax );
   nOldPos = GetScrollPos( hWnd, SB_VERT );

   nNewPos = nOldPos;

   GetClientRect( hWnd, &Rect );
   nLine = Rect.bottom / 10;
   nPage = Rect.bottom / 4;

   switch( uCode )
   {
      case SB_LINEUP:
         nNewPos -= nLine;
         break;

      case SB_LINEDOWN:
         nNewPos += nLine;
         break;

      case SB_PAGEUP:
         nNewPos -= nPage;
         break;

      case SB_PAGEDOWN:
         nNewPos += nPage;
         break;

      case SB_TOP:
         nNewPos = nMin;
         break;

      case SB_BOTTOM:
         nNewPos = nMax;
         break;

      case SB_THUMBTRACK:
      case SB_THUMBPOSITION:
         nNewPos = nPos;
         break;

      default:
         break;
   }

   L_VecGetPan( pData->pVector, &ptPanOld );
   ptPan.y = ptPanOld.y + ( nNewPos - nOldPos );
   if( ptPan.y != ptPanOld.y )
   {
      SetScrollPos( hWnd, SB_VERT, nNewPos, TRUE );
      ptPan.x = ptPanOld.x;
      L_VecSetPan( pData->pVector, &ptPan );
      InvalidateRect( hWnd, NULL, FALSE );
   }
}


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

   switch( nId )
   {
      case IDM_FILE_SAVEAS:
         OnFileSaveAs( hWnd );
         break;
       case IDM_FILE_SAVE:
         OnFileSave( hWnd );
         break;

      case IDM_FILE_PRINT:
         OnFilePrint( hWnd );
         break;

      case ID_FILE_CONVERT_EMF:
      case ID_FILE_CONVERT_WMF:
         OnFileConvert( ID_FILE_CONVERT_EMF == nId );
         break;

      case IDM_EDIT_UNDO:
         OnEditUndo( hWnd );
         break;

      case IDM_EDIT_REDO:
         OnEditRedo( hWnd );
         break;

      case IDM_EDIT_CUT:
         OnEditCut( hWnd );
         break;

      case IDM_EDIT_COPY:
         OnEditCopy( hWnd );
         break;

      case IDM_EDIT_PASTE_OBJECTS:
      case IDM_EDIT_PASTE_LAYERS:
         OnEditPaste( hWnd, nId );
         break;

      case IDM_EDIT_DELETE:
         OnEditDelete( hWnd );
         break;

      case IDM_EDIT_SELECTALL:
         OnEditSelectAll( hWnd );
         break;

      case IDM_EDIT_UNSELECTALL:
         OnEditUnselectAll( hWnd, TRUE );
         break;

      case IDM_VIEW_SCALE:
         OnViewScale( hWnd );
         break;

      case IDM_VIEW_ROTATE:
         OnViewRotate( hWnd );
         break;

      case IDM_VIEW_TRANSLATE:
         OnViewTranslate( hWnd );
         break;

      case IDM_VIEW_CAMERA:
         OnViewCamera( hWnd );
         break;

      case IDM_VIEW_MODE:
         OnViewMode( hWnd );
         break;

      case IDM_VIEW_BACKCOLOR:
         OnViewBackColor( hWnd );
         break;

      case IDM_VIEW_EXTENT:
         OnViewExtent( hWnd );
         break;

      case IDM_LAYER_EDIT:
         OnLayerEdit( hWnd );
         break;

      case IDM_GROUP_EDIT:
         OnGroupEdit( hWnd );
         break;

      case IDM_GROUP_ADD:
         OnGroupAdd( hWnd );
         break;

      case IDM_OBJECT_EXPLODE:
         OnObjectExplode( hWnd );
         break;

      case IDM_OBJECT_NEW_VERTEX:
      case IDM_OBJECT_NEW_LINE:
      case IDM_OBJECT_NEW_RECTANGLE:
      case IDM_OBJECT_NEW_POLYLINE:
      case IDM_OBJECT_NEW_POLYBEZIER:
      case IDM_OBJECT_NEW_POLYGON:
      case IDM_OBJECT_NEW_ELLIPSE:
      case IDM_OBJECT_NEW_CIRCLE:
      case IDM_OBJECT_NEW_ARC:
      case IDM_OBJECT_NEW_ELLIPTICALARC:
      case IDM_OBJECT_NEW_TEXT:
      case IDM_OBJECT_NEW_PIE:
      case IDM_OBJECT_NEW_CHORD:
      case IDM_OBJECT_NEW_POLYDRAW:
      case IDM_OBJECT_NEW_RASTER:
      case IDM_OBJECT_NEW_CLONE:
      case IDM_OBJECT_NEW_SPLINE:
      case IDM_OBJECT_NEW_HPOLYBEZIER:
         OnObjectNew( hWnd, nId );
         break;

      case IDM_OBJECT_EDIT:
         OnObjectEdit( hWnd );
         break;

      case IDM_OBJECT_PROPERTIES:
         OnObjectProperties( hWnd );
         break;

      case IDM_OPTIONS_BINDMODE_BINDVERTICES:
      case IDM_OPTIONS_BINDMODE_UNBINDVERTICES:
         OnOptionsBindMode( hWnd, nId );
         break;

      case IDM_OPTIONS_HITTEST:
         OnOptionsHitTest( hWnd );
         break;

      case IDM_OPTIONS_RENDER:
         OnOptionsRender( hWnd );
         break;

      case IDM_OPTIONS_APPLYTRANSFORMATION:
         OnOptionsApplyTransformation( hWnd );
         break;

      case ID_OPTIONS_INVERTCOLORS:
         OnOptionsInvertColors( hWnd );
         break;

      case ID_OPTIONS_PALETTE:
         OnOptionsPalette( hWnd );
         break;

      default:
         break;
   }
}


/*----------------------------------------------------------------------------
|
|  WM_CONTEXTMENU
|
 ---------------------------------------------------------------------------*/
static L_VOID Child_OnContextMenu
(
   HWND     hWnd,
   HWND     hWndContext,
   L_UINT   xPos,
   L_UINT   yPos
)
{
   UNREFERENCED_PARAMETER( hWndContext );

   TrackPopupMenu( g_hMenuObjectPopupWindow,
                   TPM_LEFTALIGN |
                   TPM_TOPALIGN,
                   xPos,
                   yPos,
                   0,
                   hWnd,
                   NULL );
}


/*----------------------------------------------------------------------------
|
|  WM_DESTROY
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnDestroy
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   
   if( pData ) 
   {
      L_AutRemoveContainer( g_pAutomation, pData->pContainer );
      L_ContainerFree( pData->pContainer );

      if( pData->bCreatedOK )
      {
         L_VecFree( pData->pVector );
         GlobalFreePtr( pData->pVector );
      }

      GlobalFreePtr( pData );

      StatusBarText( NULL );
   }
}

/*----------------------------------------------------------------------------
|
|  File/Save
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileSaveAs
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_BOOL      bTemp = pData->bNewVector;

   pData->bNewVector = TRUE;
   
   OnFileSave( hWnd );


   pData->bNewVector = bTemp;
}


/*----------------------------------------------------------------------------
|
|  File/Save
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileSave
(
   HWND  hWnd
)
{
   OPENFILENAME  OpenFileName;
   L_TCHAR        szFileName[ _MAX_PATH ] = TEXT("");
   static L_TCHAR        szFileTitle[ _MAX_PATH ] = TEXT("");

   LPCHILDDATA          pData = GETCHILDDATA( hWnd );
   L_INT                nFormat;
   L_INT                nRet;

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

   lstrcpy( szFileName, TEXT("") );
   lstrcpy( szFileTitle, TEXT("") );

   OpenFileName.lStructSize       = sizeof( OPENFILENAME );
   OpenFileName.hwndOwner         = hWnd;
   OpenFileName.hInstance         = NULL;
   OpenFileName.lpstrFilter       = szSaveFileFilter;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = nSaveIndex;
   OpenFileName.lpstrFile         = szFileName;
   OpenFileName.nMaxFile          = sizeof( szFileName )/sizeof(L_TCHAR);
   OpenFileName.lpstrFileTitle    = szFileName;
   OpenFileName.nMaxFileTitle     = sizeof( szFileName )/sizeof(L_TCHAR);
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.lpstrTitle        = TEXT("Save Vector As");
   OpenFileName.Flags             = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
   OpenFileName.nFileOffset       = 0;
   OpenFileName.nFileExtension    = 0;
   OpenFileName.lpstrDefExt       = TEXT("");
   OpenFileName.lCustData         = 0L;
   OpenFileName.lpfnHook          = NULL;
   OpenFileName.lpTemplateName    = NULL;

      if ( ! pData->bNewVector )
      {
         lstrcpy( szFileName, pData->szFileName );
         nFormat = pData->nFormat;                  
      }
   else
      {   
      if( !GetSaveFileName( &OpenFileName ) )
         return;

      nSaveIndex = OpenFileName.nFilterIndex;

      switch( nSaveIndex )
      {
         case 1:
            nFormat = FILE_VECTOR_DUMP;
            break;

         case 2:
            nFormat = FILE_DWF;
            break;

         case 3:
            nFormat = FILE_DXF;
            break;

         case 4:
            nFormat = FILE_CGM;
            break;

         case 5:
            nFormat = FILE_PLT;
            break;

         case 6:
            nFormat = FILE_PCT;
            break;

         case 7:
            nFormat = FILE_DRW;
            break;

         case 8:
            nFormat = FILE_WMF;
            break;

         case 9:
            nFormat = FILE_EMF;
            break;

         case 10:
            nFormat = FILE_GERBER;
            break;

         case 11:
            nFormat = FILE_SHP;
            break;

         case 12:
            nFormat = FILE_PCL;
            break;

         case 13:
            nFormat = FILE_SVG;
            break;

         case 14:
            nFormat = FILE_VWPG;
            break;

         case 15:
            nFormat = FILE_WMZ;
            break;

         default:
            ShowLeadError( ERROR_FILE_FORMAT, NULL, NULL );
            return;
      }
      
   }
   
   nRet = SaveVector( pData->pVector, szFileName, nFormat);
   if( nRet == SUCCESS)
   {   
      pData->bNewVector = FALSE;
      lstrcpy(pData->szFileName,szFileName );
      pData->nFormat = nFormat; 
   }
}


/*----------------------------------------------------------------------------
|
|  OnFileConvert
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFileConvert
( 
   L_BOOL bEMF
)
{
   L_INT         nRet;
   HDC           hDC;
   HWND          hWndChild;
   LPCHILDDATA   pData;
   CONVERTDATA   ConvertData;
   HENHMETAFILE  hEnhMetaFile;
   HMETAFILE     hMetaFile;
   OSVERSIONINFO OsVersionInfo;

   hWndChild = FORWARD_WM_MDIGETACTIVE( g_hWndClient, SendMessage );
   if( hWndChild )
   {
      pData = GETCHILDDATA( hWndChild );
      if( pData && pData->pVector )
      {
         /* Fill initialization data */ 
         hDC = GetDC( NULL );         
         ConvertData.uDPI  = (L_UINT)GetDeviceCaps( hDC, LOGPIXELSX );
         
         ConvertData.szFileName[ 0 ] = 0;         
         
         ConvertData.Rect  = pData->pVector->rcViewport;
         ConvertData.bEmf  = bEMF;
         nRet = DialogBoxParam( g_hInstance, 
                                MAKEINTRESOURCE( IDD_CONVERT ),
                                g_hWndClient,
                                (DLGPROC)ConvertToProc,
                                (LPARAM)&ConvertData );
         if( SUCCESS == nRet )
         {
            /* ConvertData contains all the information needed */ 
            if( TRUE == bEMF )
            {
               hEnhMetaFile = L_VecConvertToEMF( hDC, pData->pVector, &ConvertData.Rect, ConvertData.uDPI );
               if( NULL != hEnhMetaFile )
               {
                  /* Successful conversion */ 
                  CopyEnhMetaFile( hEnhMetaFile, ConvertData.szFileName );

               }
            }
            else
            {
               hMetaFile = L_VecConvertToWMF( hDC, pData->pVector, &ConvertData.Rect, ConvertData.uDPI );
               if( NULL != hMetaFile )
               {
                  /* Successful conversion */ 
                  ZeroMemory( &OsVersionInfo, sizeof(OSVERSIONINFO) );
                  
                  OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
                  
                  GetVersionEx( &OsVersionInfo );
                  
                  if( VER_PLATFORM_WIN32_WINDOWS == OsVersionInfo.dwPlatformId )
                  {
                     L_TCHAR szShortPath[MAX_PATH];
                     L_INT   dRet;
                     L_INT   nFileHandle;
                     
                     nFileHandle = _topen( ConvertData.szFileName, O_BINARY | O_RDWR | O_CREAT | O_TRUNC,S_IWRITE );
                     
                     GetShortPathName( ConvertData.szFileName, szShortPath, MAX_PATH - 1 );
                     
                     _close( nFileHandle );
                     
                     dRet = _tremove( ConvertData.szFileName );
                     
                     CopyMetaFile( hMetaFile, szShortPath );
                  }
                  else
                  {
                     CopyMetaFile( hMetaFile, ConvertData.szFileName );
                  }                  
               }
            }

            
         }
         ReleaseDC( NULL, hDC );
      }
   }
}


/*----------------------------------------------------------------------------
|
|  File/Print
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnFilePrint
(
   HWND  hWnd
)
{
   L_INT nRet;

   UNREFERENCED_PARAMETER( hWnd );

   Hourglass( TRUE );
   nRet = L_AutPrint( g_pAutomation, 0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS && nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );
}


/*----------------------------------------------------------------------------
|
|  Edit/Undo
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditUndo
(
   HWND  hWnd
)
{
   LPCHILDDATA       pData = GETCHILDDATA( hWnd );
   RECT              Rect;
   L_INT             nRet;

   Hourglass( TRUE );
   nRet = L_AutUndo( g_pAutomation, 0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );
   
   GetClientRect( hWnd, &Rect );

   L_VecSetViewport( pData->pVector, &Rect );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   UpdateScrollBars( hWnd );
   InvalidateRect( hWnd, NULL, TRUE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Redo
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditRedo
(
   HWND  hWnd
)
{
   L_INT nRet;

   Hourglass( TRUE );
   nRet = L_AutRedo( g_pAutomation, 0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   UpdateScrollBars( hWnd );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Cut
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditCut
(
   HWND  hWnd
)
{
   L_INT nRet;

   Hourglass( TRUE );
   nRet = L_AutCut( g_pAutomation, 0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Copy
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditCopy
(
   HWND  hWnd
)
{
   L_INT nRet;

   Hourglass( TRUE );
   nRet = L_AutCopy( g_pAutomation, 0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Paste
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditPaste
(
   HWND  hWnd,
   L_INT nId
)
{
   L_UINT32 dwFlags;
   L_INT    nRet;

   if( nId == IDM_EDIT_PASTE_OBJECTS )
      dwFlags = VECTOR_FLAGS_COPY_INTO_ACTIVE_LAYER;
   else
      dwFlags = VECTOR_FLAGS_COPY_LAYERS_ONLY;

   Hourglass( TRUE );
   nRet = L_AutPaste( g_pAutomation, dwFlags );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Delete
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditDelete
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT nRet;

   
  
   L_ContainerReset( pData->pContainer );  

   Hourglass( TRUE );
      


   nRet = L_AutDelete( g_pAutomation, 0L );
   ShowWindow( hWnd, SW_HIDE );
   ShowWindow( hWnd, SW_SHOW );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Select All
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditSelectAll
(
   HWND  hWnd
)
{
   L_INT nRet;

   Hourglass( TRUE );
   nRet = L_AutSelect( g_pAutomation,
                      AUTOMATION_SELECT_ALL,
                      0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( GETCHILDDATA( hWnd ) );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Edit/Unselect All
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnEditUnselectAll
(
   HWND     hWnd,
   L_BOOL   bUpdate
)
{
   L_INT nRet;

   Hourglass( TRUE );
   nRet = L_AutSelect( g_pAutomation,
                      AUTOMATION_SELECT_NONE,
                      0L );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   if( bUpdate )
   {
      UpdateMenuStatus( GETCHILDDATA( hWnd ) );
      InvalidateRect( hWnd, NULL, FALSE );
   }
}


/*----------------------------------------------------------------------------
|
|  View/Scale
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewScale
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   VECTORPOINT Scale;
   L_UINT32    dwFlags;
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   L_VecGetScale( pData->pVector, &Scale );

   dwFlags = VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON;
   if( L_VecIsObjectSelected( pData->pVector, NULL ) )
      dwFlags |= VECTOR_DLG_SELECTED_ONLY;

   nRet = L_VecDlgScale( hWnd,
                         pData->pVector,
                         &Scale,
                         NULL,
                         dwFlags,
                         VectorHelpCallback, 
                         NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  View/Rotate
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewRotate
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   VECTORPOINT Rotation;
   L_UINT32    dwFlags;
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   L_VecGetRotation( pData->pVector, &Rotation );

   dwFlags = VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON;
   if( L_VecIsObjectSelected( pData->pVector, NULL ) )
      dwFlags |= VECTOR_DLG_SELECTED_ONLY;

   nRet = L_VecDlgRotate( hWnd,
                         pData->pVector,
                         &Rotation,
                         NULL,
                         dwFlags,
                         VectorHelpCallback, 
                         NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  View/Translate
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewTranslate
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   VECTORPOINT Translation;
   L_UINT32    dwFlags;
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   L_VecGetTranslation( pData->pVector, &Translation );

   dwFlags = VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON;
   if( L_VecIsObjectSelected( pData->pVector, NULL ) )
      dwFlags |= VECTOR_DLG_SELECTED_ONLY;

   nRet = L_VecDlgTranslate( hWnd,
                             pData->pVector,
                             &Translation,
                             dwFlags,
                             VectorHelpCallback, 
                             NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  View/Camera
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewCamera
(
   HWND  hWnd
)
{
   LPCHILDDATA    pData = GETCHILDDATA( hWnd );
   VECTORCAMERA   Camera;
   L_UINT32       dwFlags;
   L_INT          nRet;

   L_ContainerReset( pData->pContainer );

   L_VecGetCamera( pData->pVector, &Camera );
   dwFlags = VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON;
   nRet = L_VecDlgCamera( hWnd,
                          pData->pVector,
                          &Camera,
                          dwFlags,
                          VectorHelpCallback, 
                          NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  View/Mode
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewMode
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nViewMode;
   L_UINT32    dwFlags;
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   nViewMode = L_VecGetViewMode( pData->pVector );
   dwFlags = VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON;
   nRet = L_VecDlgViewMode( hWnd,
                            pData->pVector,
                            &nViewMode,
                            dwFlags,
                            VectorHelpCallback, 
                            NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  View/Back Color
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewBackColor
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   COLORDLGPARAMS DlgParams;
   L_INT nRet;
   
   ZeroMemory( &DlgParams, sizeof( COLORDLGPARAMS ) );
   DlgParams.crColor = BackgroundColor;
   DlgParams.uColorModel = 0;
   DlgParams.uColorSpace = DLG_COLOR_COLORSPACE_SHOW_RGB;
   DlgParams.uStructSize = sizeof( COLORDLGPARAMS );
   DlgParams.uDlgFlags = (DLG_COLOR_SHOW_OLDCOLOR	|
                        DLG_COLOR_SHOW_NEWCOLOR	|
                        DLG_COLOR_SHOW_NAME	|
                        DLG_COLOR_COLORSPACE_SHOW_HUE	|
                        DLG_COLOR_COLORSPACE_SHOW_BRIGHTNESS |
                        DLG_COLOR_COLORSPACE_SHOW_WHEEL	|
                        DLG_COLOR_COLORSPACE_SHOW_RGB	|
                        DLG_COLOR_COLORSPACE_SHOW_CMY	|
                        DLG_COLOR_COLORSPACE_SHOW_CMYK |
                        DLG_COLOR_COLORSPACE_SHOW_LAB	|
                        DLG_COLOR_COLORMODEL_SHOW_RGB	|
                        DLG_COLOR_COLORMODEL_SHOW_HSB	|
                        DLG_COLOR_COLORMODEL_SHOW_HLS	|
                        DLG_COLOR_COLORMODEL_SHOW_CMY	|
                        DLG_COLOR_COLORMODEL_SHOW_CMYK |
                        DLG_COLOR_COLORMODEL_SHOW_LAB	);


   nRet = L_DlgColor(g_hWndFrame,&DlgParams);

   if(nRet ==  SUCCESS_DLG_OK)
   {
      BackgroundColor = DlgParams.crColor ;
      L_VecSetBackgroundColor( pData->pVector, DlgParams.crColor);
      InvalidateRect( hWnd, NULL, FALSE );
   }
}


/*----------------------------------------------------------------------------
|
|  View/Extent
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnViewExtent
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;
   VECTORPOINT Scale;
   VECTORPOINT Rotation;
   VECTORPOINT Translation;
   POINT       pt;

   L_AutSetUndoEnabled( g_pAutomation, FALSE );

   Scale.x = Scale.y = Scale.z = 1.0;
   nRet = L_VecSetScale( pData->pVector, &Scale, NULL, NULL, 0L );

   Rotation.x = Rotation.y = Rotation.z = 0.0;
   nRet = L_VecSetRotation( pData->pVector, &Rotation, NULL, NULL, 0L );

   Translation.x = Translation.y = Translation.z = 0.0;
   nRet = L_VecSetTranslation( pData->pVector, &Translation, NULL, 0L );

   pt.x = 0;
   pt.y = 0;

   L_VecSetPan( pData->pVector, &pt );
   L_VecSetParallelogram( pData->pVector, NULL, NULL );
   L_VecSetOrigin( pData->pVector, NULL );
   L_VecSetCamera( pData->pVector, NULL );

   if( L_VecGetEngine( pData->pVector ) == VECTOR_ENGINE_GDI )
   {
      SetScrollRange( hWnd, SB_HORZ, 0, 2, TRUE );
      SetScrollPos( hWnd, SB_HORZ, 1, TRUE );
      SetScrollRange( hWnd, SB_VERT, 0, 2, TRUE );
      SetScrollPos( hWnd, SB_VERT, 1, TRUE );
   }

   L_AutSetUndoEnabled( g_pAutomation, TRUE );

   UpdateScrollBars( hWnd );
   UpdateMenuStatus( pData );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Layer/Edit
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnLayerEdit
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   nRet = L_VecDlgEditAllLayers( hWnd,
                                 pData->pVector,
                                 VECTOR_DLG_ENABLE_HELPBUTTON,
                                 VectorHelpCallback, 
                                 NULL );
   if( nRet == SUCCESS )
   {
      OnEditUnselectAll( hWnd, FALSE );
      InvalidateRect( hWnd, NULL, FALSE );
   }
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  Group/Edit
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnGroupEdit
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   nRet = L_VecDlgEditAllGroups( hWnd,
                                 pData->pVector,
                                 VECTOR_DLG_ENABLE_HELPBUTTON,
                                 VectorHelpCallback, 
                                 NULL );
   if( nRet == SUCCESS )
   {
      InvalidateRect( hWnd, NULL, FALSE );
      UpdateMenuStatus( pData );
   }
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );
}


/*----------------------------------------------------------------------------
|
|  Group/Add
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnGroupAdd
(
   HWND  hWnd
)
{
   LPCHILDDATA    pData = GETCHILDDATA( hWnd );
   GROUPSDLGDATA  GroupsDlgData;
   L_INT          nRet;
   ENUMDATA       EnumData;

   L_ContainerReset( pData->pContainer );

   GroupsDlgData.pVector = pData->pVector;
   if( DoDialogBoxParam( IDD_GROUPS, hWnd, (DLGPROC) GroupsDlgProc, (LPARAM) &GroupsDlgData ) == IDOK )
   {
      EnumData.nType = ENUM_ADDTOGROUP;
      EnumData.pGroup = &GroupsDlgData.Group;

      Hourglass( TRUE );
      nRet = L_VecEnumObjects( pData->pVector, MyEnumObjectsProc, &EnumData, VECTOR_FLAGS_SELECTED_ONLY );
      Hourglass( FALSE );

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


/*----------------------------------------------------------------------------
|
|  Object/Explode
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnObjectExplode
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   L_ContainerReset( pData->pContainer );

   Hourglass( TRUE );
   nRet = L_VecExplodeObject( pData->pVector, NULL, VECTOR_FLAGS_SELECTED_ONLY );
   Hourglass( FALSE );
   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Object/New
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnObjectNew
(
   HWND  hWnd,
   L_INT nId
)
{
   LPCHILDDATA    pData = GETCHILDDATA( hWnd );
   L_INT          nRet, nType;
   VECTOROBJECT   Object;

   switch( nId )
   {
      case IDM_OBJECT_NEW_VERTEX: nType = VECTOR_VERTEX; break;
      case IDM_OBJECT_NEW_LINE: nType = VECTOR_LINE; break;
      case IDM_OBJECT_NEW_RECTANGLE: nType = VECTOR_RECTANGLE; break;
      case IDM_OBJECT_NEW_POLYLINE: nType = VECTOR_POLYLINE; break;
      case IDM_OBJECT_NEW_POLYBEZIER: nType = VECTOR_POLYBEZIER; break;
      case IDM_OBJECT_NEW_POLYGON: nType = VECTOR_POLYGON; break;
      case IDM_OBJECT_NEW_ELLIPSE: nType = VECTOR_ELLIPSE; break;
      case IDM_OBJECT_NEW_CIRCLE: nType = VECTOR_CIRCLE; break;
      case IDM_OBJECT_NEW_ARC: nType = VECTOR_ARC; break;
      case IDM_OBJECT_NEW_ELLIPTICALARC: nType = VECTOR_ELLIPTICALARC; break;
      case IDM_OBJECT_NEW_TEXT: nType = VECTOR_TEXT; break;
      case IDM_OBJECT_NEW_PIE: nType = VECTOR_PIE; break;
      case IDM_OBJECT_NEW_CHORD: nType = VECTOR_CHORD; break;
      case IDM_OBJECT_NEW_POLYDRAW: nType = VECTOR_POLYDRAW; break;
      case IDM_OBJECT_NEW_RASTER: nType = VECTOR_RASTER; break;
      case IDM_OBJECT_NEW_CLONE: nType = VECTOR_CLONE; break;
      case IDM_OBJECT_NEW_SPLINE: nType = VECTOR_SPLINE; break;
      case IDM_OBJECT_NEW_HPOLYBEZIER: nType = VECTOR_HPOLYBEZIER; break;
      default:
         return;
   }

   L_ContainerReset( pData->pContainer );

   nRet = L_VecDlgNewObject( hWnd,
                             pData->pVector,
                             NULL,
                             nType,
                             NULL,
                             &Object,
                             VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_ENABLE_HELPBUTTON,
                             VectorHelpCallback, 
                             NULL );
   if( nRet == SUCCESS )
   {
      //OnEditUnselectAll( hWnd, FALSE );
      //L_VecSelectObject( pData->pVector, &Object, TRUE );
      InvalidateRect( hWnd, NULL, FALSE );
   }
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
   UpdateScrollBars( hWnd );
}


/*----------------------------------------------------------------------------
|
|  Object/Edit
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnObjectEdit
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   ENUMDATA    EnumData;
   L_INT       nRet;

   EnumData.nType = ENUM_COUNT;
   EnumData.nObjectCount = 0;
   nRet = L_VecEnumObjects( pData->pVector,
                            MyEnumObjectsProc,
                            &EnumData,
                            VECTOR_FLAGS_SELECTED_ONLY );
   if( nRet != SUCCESS || EnumData.nObjectCount != 1 )
      return;

   nRet = L_AutEditVectorObject( g_pAutomation, &EnumData.LastObject );
   if( nRet == SUCCESS )
   {
      UpdateMenuStatus( pData );
      InvalidateRect( hWnd, NULL, FALSE );
   }
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );
}


/*----------------------------------------------------------------------------
|
|  Object/Properties
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnObjectProperties
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   ENUMDATA    EnumData;
   L_INT       nRet;

   EnumData.nType = ENUM_COUNT;
   EnumData.nObjectCount = 0;
   nRet = L_VecEnumObjects( pData->pVector,
                            MyEnumObjectsProc,
                            &EnumData,
                            VECTOR_FLAGS_SELECTED_ONLY );
   if( nRet != SUCCESS || EnumData.nObjectCount != 1 )
   {
      return;
   }

   L_ContainerReset( pData->pContainer );

   nRet = L_VecDlgEditObject( hWnd,
                              pData->pVector,
                              &EnumData.LastObject,
                              EnumData.LastObject.nType,
                              NULL,
                              VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_ENABLE_HELPBUTTON,
                              VectorHelpCallback, 
                              NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  Options/Bind Mode/Bind Vertices
|  Options/Bind Mode/Unbind Vertices
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnOptionsBindMode
(
   HWND  hWnd,
   L_INT nId
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   nRet = L_VecSetBindVerticesMode( pData->pVector, 
                                    ( nId == IDM_OPTIONS_BINDMODE_BINDVERTICES ) ?
                                    VECTOR_BIND_VERTICES :
                                    VECTOR_UNBIND_VERTICES );
   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  Options/Hit Test
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnOptionsHitTest
(
   HWND  hWnd
)
{
   LPCHILDDATA    pData = GETCHILDDATA( hWnd );
   VECTORHITTEST  HitTest;
   L_INT          nRet;

   L_VecGetHitTest( pData->pVector, &HitTest );
   nRet = L_VecDlgHitTest( hWnd,
                           pData->pVector,
                           &HitTest,
                           VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_ENABLE_HELPBUTTON,
                           VectorHelpCallback, 
                           NULL );
   if( nRet != SUCCESS && nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  Options/Render
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnOptionsRender
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_BOOL      bUseLights;
   COLORREF    ColorAmbient;
   L_INT       nPolygonMode;
   L_INT       nRet;

   bUseLights = L_VecGetUseLights( pData->pVector );
   ColorAmbient = L_VecGetAmbientColor( pData->pVector );
   nPolygonMode = L_VecGetPolygonMode( pData->pVector );

   L_ContainerReset( pData->pContainer );

   nRet = L_VecDlgRender( hWnd,
                          pData->pVector,
                          &bUseLights,
                          &ColorAmbient,
                          &nPolygonMode,
                          VECTOR_DLG_AUTO_PROCESS | VECTOR_DLG_SHOW_PREVIEW | VECTOR_DLG_ENABLE_HELPBUTTON,
                          VectorHelpCallback, 
                          NULL );
   if( nRet == SUCCESS )
      InvalidateRect( hWnd, NULL, FALSE );
   else
   if( nRet != SUCCESS_DLG_CANCEL )
      ShowLeadError( nRet, NULL, NULL );

   UpdateMenuStatus( pData );
}


/*----------------------------------------------------------------------------
|
|  Options/Apply Transformation
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnOptionsApplyTransformation
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   nRet = L_VecApplyTransformation( pData->pVector );
   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   InvalidateRect( hWnd, NULL, FALSE );
}

/*----------------------------------------------------------------------------
|
|  OnOptionsInvertColors
|
 ---------------------------------------------------------------------------*/
static L_VOID
OnOptionsInvertColors
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_INT       nRet;

   nRet = L_VecInvertColors( pData->pVector );
   if( nRet != SUCCESS )
      ShowLeadError( nRet, NULL, NULL );

   InvalidateRect( hWnd, NULL, FALSE );
}


/*----------------------------------------------------------------------------
|
|  OnOptionsPalette
|
 ---------------------------------------------------------------------------*/
static L_VOID 
OnOptionsPalette
( 
   HWND  hWnd 
)
{   
   LPCHILDDATA    pData = GETCHILDDATA( hWnd );
   L_INT          nRet;
   WORD           i;
   WORD           k;
   PALETTEINFO    PaletteInfo;
   LPLOGPALETTE   pLogPalette;
   HPALETTE       hPalette;
   PALETTEENTRY   PalEnt[ 256 ];
   
   ZeroMemory( &PaletteInfo, sizeof( PaletteInfo ) );

   hPalette = L_VecGetPalette( pData->pVector );
   if( NULL != hPalette )
   {
      /* get palette entries and load them to the Palette info structure */ 
      GetPaletteEntries( hPalette, 0, sizeof( PalEnt ) / sizeof( PalEnt[ 0 ] ), PalEnt );

      /* search the palette to see how many actual item exist */ 
      PaletteInfo.uCount   = sizeof( PalEnt ) / sizeof( PalEnt[ 0 ] );
      PaletteInfo.prgbList = malloc( sizeof( COLORREF ) * PaletteInfo.uCount );      
      for( i = 1 ; i < sizeof( PalEnt ) / sizeof( PalEnt[ 0 ] ) ; i++ )
      {
         if( PalEnt[ i ].peRed == PalEnt[ i - 1 ].peRed && 
             PalEnt[ i ].peGreen == PalEnt[ i - 1 ].peGreen && 
             PalEnt[ i ].peBlue == PalEnt[ i - 1 ].peBlue )
         {
            PaletteInfo.uCount = i;
            break;
         }
         else
         {
            PaletteInfo.prgbList[ i - 1 ] = RGB( PalEnt[ i - 1 ].peRed, PalEnt[ i - 1 ].peGreen, PalEnt[ i - 1 ].peBlue );
         }         
      }
      
      PaletteInfo.prgbList[ i - 1 ] = RGB( PalEnt[ i - 1 ].peRed, PalEnt[ i - 1 ].peGreen, PalEnt[ i - 1 ].peBlue );      
   }
   
   nRet = DialogBoxParam( g_hInstance, 
                          MAKEINTRESOURCE( IDD_PALETTE ), 
                          g_hWndFrame, 
                          (DLGPROC)PaletteProc, 
                          (LPARAM)&PaletteInfo );
   if( SUCCESS == nRet )
   {
      if( PaletteInfo.uCount > 0 )
      {      
         pLogPalette = (LPLOGPALETTE) malloc( sizeof( LOGPALETTE ) + sizeof( PALETTEENTRY ) * 255 );
         if( NULL != pLogPalette  )
         {
            pLogPalette->palVersion    = 0x300;
            pLogPalette->palNumEntries = 256;
            for( i = 0 ; i < pLogPalette->palNumEntries ; i++ )
            {
               if( i < PaletteInfo.uCount )
               {
                  k = i;
               }
               else
               {
                  k = (WORD)( PaletteInfo.uCount - 1 );
               }
            
               pLogPalette->palPalEntry[ i ].peRed   = GetRValue( PaletteInfo.prgbList[ k ] );
               pLogPalette->palPalEntry[ i ].peGreen = GetGValue( PaletteInfo.prgbList[ k ] );
               pLogPalette->palPalEntry[ i ].peBlue  = GetBValue( PaletteInfo.prgbList[ k ] );            
               pLogPalette->palPalEntry[ i ].peFlags = 0;
            }

            hPalette = CreatePalette( pLogPalette );
            if( NULL != hPalette )
            {
               nRet = L_VecSetPalette( pData->pVector, hPalette );
               DeleteObject( hPalette );
               if( SUCCESS != nRet )            
               {
                  ShowLeadError( nRet, NULL, NULL );
               }
            }

            free( pLogPalette );
         }
      
         free( PaletteInfo.prgbList );
      }
      else
      {
         L_VecSetPalette( pData->pVector, NULL );
      }
   }
   InvalidateRect( hWnd, NULL, TRUE );   
}


/*----------------------------------------------------------------------------
|
|  MyEnumObjectsProc
|
 ---------------------------------------------------------------------------*/
static L_INT EXT_CALLBACK
MyEnumObjectsProc
(
   pVECTORHANDLE        pVector,
   const pVECTOROBJECT  pObject,
   L_VOID              *pUserData
)
{
   LPENUMDATA  pEnumData = (LPENUMDATA) pUserData;
   L_INT       nRet;
   L_CHAR      pBuffer[ VECTOR_OBJECT_BUFFER_SIZE ];

   switch( pEnumData->nType )
   {
      case ENUM_ADDTOGROUP:
         nRet = L_VecGetObject( pVector, pObject, pObject->nType, pBuffer );
         if( nRet == SUCCESS )
         {
            nRet = L_VecAddObjectToGroup( pVector, pEnumData->pGroup, pObject->nType, pBuffer, NULL );
            L_VecFreeObject( pObject->nType, pBuffer );
         }
         break;

      default:
         pEnumData->nObjectCount++;
         memcpy( &pEnumData->LastObject, pObject, sizeof( VECTOROBJECT ) );
         nRet = SUCCESS;
   }

   return nRet;
}


/*----------------------------------------------------------------------------
|
|  DisplayTitle
|
 ---------------------------------------------------------------------------*/
static L_VOID
DisplayTitle
(
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   
   SetWindowText( hWnd, pData->szFileName );
}


/*----------------------------------------------------------------------------
|
|  UpdateScrollBars
|
 ---------------------------------------------------------------------------*/
static L_VOID 
UpdateScrollBars
( 
   HWND  hWnd
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   RECT        rcDraw;
   POINT       ptPan;
   L_INT       nOldMax, nOldPos, nNewMax, nNewPos;
   L_INT       cxDraw, cyDraw;

   if( L_VecGetEngine( pData->pVector) != VECTOR_ENGINE_GDI )
      return;

   L_VecGetPan( pData->pVector, &ptPan );

   L_VecGetObjectRect( pData->pVector, NULL, &rcDraw, 0L );
   rcDraw.left += abs( ptPan.x );
   rcDraw.top += abs( ptPan.y );
   rcDraw.right += abs( ptPan.x );
   rcDraw.bottom += abs( ptPan.y );

   cxDraw = rcDraw.right - rcDraw.left;
   cyDraw = rcDraw.bottom - rcDraw.top;

   nNewMax = cxDraw;

   GetScrollRange( hWnd, SB_HORZ, &nOldPos, &nOldMax );
   nOldPos = GetScrollPos( hWnd, SB_HORZ );

   if( nOldMax != 0 )
      nNewPos = nNewMax * nOldPos / nOldMax;
   else
      nNewPos = nNewMax / 2;

   SetScrollRange( hWnd, SB_HORZ, 0, nNewMax, TRUE );
   SetScrollPos( hWnd, SB_HORZ, nNewPos, TRUE );

   nNewMax = cyDraw;

   GetScrollRange( hWnd, SB_VERT, &nOldPos, &nOldMax );
   nOldPos = GetScrollPos( hWnd, SB_VERT );

   if( nOldMax != 0 )
      nNewPos = nNewMax * nOldPos / nOldMax;
   else
      nNewPos = nNewMax / 2;

   SetScrollRange( hWnd, SB_VERT, 0, nNewMax, TRUE );
   SetScrollPos( hWnd, SB_VERT, nNewPos, TRUE );
}


/*----------------------------------------------------------------------------
|
|  UpdateMenuStatus
|
 ---------------------------------------------------------------------------*/
static L_VOID
UpdateMenuStatus
(
   LPCHILDDATA pData
)
{
   L_BOOL   bCanUndo, bCanRedo, bAnyObjectSelected, bCanPaste, bAnyObjects, bCanEditObject;
   L_INT    nBindMode;
   ENUMDATA EnumData;

   L_AutCanUndo( g_pAutomation, &bCanUndo );
   L_AutCanRedo( g_pAutomation, &bCanRedo );
   bAnyObjectSelected = L_VecIsObjectSelected( pData->pVector, NULL );
   bAnyObjects = !L_VecIsEmpty( pData->pVector );
   bCanPaste = L_VecClipboardReady();
   nBindMode = L_VecGetBindVerticesMode( pData->pVector );

   EnumData.nType = ENUM_COUNT;
   EnumData.nObjectCount = 0;
   L_VecEnumObjects( pData->pVector, MyEnumObjectsProc, &EnumData, VECTOR_FLAGS_SELECTED_ONLY );

   bCanEditObject = EnumData.nObjectCount == 1;

   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_UNDO, bCanUndo );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_REDO, bCanRedo );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_CUT, bAnyObjectSelected );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_COPY, bAnyObjectSelected );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_PASTE_OBJECTS, bCanPaste );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_PASTE_LAYERS, bCanPaste );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_DELETE, bAnyObjectSelected );

   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_SELECTALL, bAnyObjects );
   ENABLEMENUITEM( g_hMenuChild, IDM_EDIT_UNSELECTALL, bAnyObjectSelected );

   ENABLEMENUITEM( g_hMenuChild, IDM_GROUP_ADD, bAnyObjectSelected && L_VecGetGroupCount( pData->pVector ) >= 1 );

   ENABLEMENUITEM( g_hMenuChild, IDM_OBJECT_EXPLODE, bAnyObjectSelected );
   ENABLEMENUITEM( g_hMenuChild, IDM_OBJECT_EDIT, bCanEditObject );
   ENABLEMENUITEM( g_hMenuChild, IDM_OBJECT_PROPERTIES, bCanEditObject );

   ENABLEMENUITEM( g_hMenuObjectPopup, IDM_OBJECT_EXPLODE, bAnyObjectSelected );
   ENABLEMENUITEM( g_hMenuObjectPopup, IDM_OBJECT_EDIT, bCanEditObject );
   ENABLEMENUITEM( g_hMenuObjectPopup, IDM_OBJECT_PROPERTIES, bCanEditObject );
   
   if(EnumData.LastObject.nType  == VECTOR_SPLINE || 
      EnumData.LastObject.nType  == VECTOR_ELLIPTICALARC || 
      EnumData.LastObject.nType  == VECTOR_POLYDRAW ||
      EnumData.LastObject.nType  == VECTOR_HPOLYBEZIER ||
      EnumData.LastObject.nType  == VECTOR_CLONE)
   {
      ENABLEMENUITEM( g_hMenuObjectPopup, IDM_OBJECT_EDIT, FALSE );
      ENABLEMENUITEM( g_hMenuChild, IDM_OBJECT_EDIT, FALSE );
   }

   CheckMenuRadioItem( g_hMenuChild,
                       IDM_OPTIONS_BINDMODE_BINDVERTICES,
                       IDM_OPTIONS_BINDMODE_UNBINDVERTICES,
                       ( nBindMode == VECTOR_BIND_VERTICES ) ?
                       IDM_OPTIONS_BINDMODE_BINDVERTICES :
                       IDM_OPTIONS_BINDMODE_UNBINDVERTICES,
                       MF_BYCOMMAND );
}


/*----------------------------------------------------------------------------
|
|  SaveVector
|
 ---------------------------------------------------------------------------*/
static L_INT
SaveVector
(
   const pVECTORHANDLE  pVector,
   const L_TCHAR        *pszFile,
   L_INT                nFormat
)
{
   SAVEFILEOPTION SaveFileOption;
   L_INT          nRet;

   Hourglass( TRUE );
   memset( &SaveFileOption, 0, sizeof( SAVEFILEOPTION ) );
   SaveFileOption.uStructSize = sizeof( SAVEFILEOPTION );
   nRet = L_VecSaveFile( (L_TCHAR*) pszFile, pVector, nFormat, &SaveFileOption );
   Hourglass( FALSE );

   if( nRet != SUCCESS )
      ShowLeadError( nRet, TEXT("Save Vector File"), pszFile );   

   return nRet;
}


/*----------------------------------------------------------------------------
|
|  ContainerCallback
|
 ---------------------------------------------------------------------------*/
static L_INT EXT_CALLBACK ContainerCallback 
(
   pCONTAINERHANDLE     pContainer,
   CONTAINEREVENTTYPE   nEventType,
   L_VOID              *pEventData,
   L_VOID              *pUserData
)
{
   L_INT                nError;
   HWND                 hWnd;
   pCONTAINEROBJECTDATA pObjectData;

   UNREFERENCED_PARAMETER( pUserData );

   switch( nEventType )
   {
      case CONTAINER_EVENT_TYPE_DRAW:
         pObjectData = (pCONTAINEROBJECTDATA) pEventData;
         if( pObjectData->fState == CONTAINER_STATE_END ||
             pObjectData->fState == CONTAINER_STATE_ABORT )
         {
            L_ContainerGetOwner( pContainer, &hWnd );
            InvalidateRect( hWnd, NULL, FALSE );
            UpdateMenuStatus( GETCHILDDATA( hWnd ) );
            UpdateScrollBars( hWnd );
         }
         break;

      case CONTAINER_EVENT_TYPE_ERROR:
         nError = (L_INT) pEventData;
         ShowLeadError( nError, NULL, NULL );

         L_ContainerGetOwner( pContainer, &hWnd );
         InvalidateRect( hWnd, NULL, FALSE );
         break;

      default:
         break;
   }

   return SUCCESS;
}


/*----------------------------------------------------------------------------
|
|  GroupsDlgProc
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION
GroupsDlgProc
(
   HWND     hWnd,
   L_UINT   uMessage,
   WPARAM   wParam,
   LPARAM   lParam
)
{
   static LPGROUPSDLGDATA  pGroupsDlgData;
   HWND                    hWndList;
   L_INT                   nCount, i, nIndex, nRet;
   VECTORGROUP             Group;
   VECTORGROUPDESC         GroupDesc;

   switch( uMessage )
   {
      case WM_INITDIALOG:
         pGroupsDlgData = (LPGROUPSDLGDATA) lParam;

         hWndList = GetDlgItem( hWnd, IDC_GROUPS );
         nCount = L_VecGetGroupCount( pGroupsDlgData->pVector );
         for( i = 0; i < nCount; i++ )
         {
            L_VecGetGroupByIndex( pGroupsDlgData->pVector, i, &Group );
            L_VecGetGroup( pGroupsDlgData->pVector, &Group, &GroupDesc );
            nIndex = ListBox_AddString( hWndList, GroupDesc.szName );
            L_VecFreeGroup( &GroupDesc );
            ListBox_SetItemData( hWndList, nIndex, i );
         }

         ListBox_SetCurSel( hWndList, 0 );
         return TRUE;

      case WM_COMMAND:
         switch( LOWORD( wParam ) )
         {
            case IDOK:
               hWndList = GetDlgItem( hWnd, IDC_GROUPS );
               nIndex = ListBox_GetCurSel( hWndList );

               nRet = L_VecGetGroupByIndex( pGroupsDlgData->pVector,
                                            ListBox_GetItemData( hWndList, nIndex ),
                                            &pGroupsDlgData->Group );
               if( nRet != SUCCESS )
               {
                  ShowLeadError( nRet, NULL, NULL );
                  return TRUE;
               }

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

      default:
         break;
   }

   return FALSE;
}

/*----------------------------------------------------------------------------
|
|  PaletteProc
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION 
PaletteProc
( 
   HWND  hWnd, 
   L_UINT  uMsg, 
   WPARAM  wParam, 
   LPARAM  lParam 
)
{
   static pPALETTEINFO  pPaletteInfo;
   static COLORREF  CusColors[ 16 ];
   static HWND  hList;
   LPMEASUREITEMSTRUCT  pMeasure;
   LPDRAWITEMSTRUCT  pDrawItem;
   COLORDLGPARAMS DlgParams;
   L_INT nRet;
   HBRUSH  hOldBrush;   
   COLORREF rgbValue;
   L_INT  nIndex;
   L_UINT j;
   L_CHAR szBuffer[ 20 ];

   switch( uMsg )
   {
      case WM_INITDIALOG:
         pPaletteInfo = (pPALETTEINFO) lParam;
         hList = GetDlgItem( hWnd, IDC_PALETTE_LIST );
         for( j = 0 ; j < pPaletteInfo->uCount ; j++ )
         {
            nIndex = ListBox_AddString( hList, "" );
            ListBox_SetItemData( hList, nIndex, pPaletteInfo->prgbList[ j ] );
         }
         return TRUE;

      case WM_MEASUREITEM:         
         pMeasure = (LPMEASUREITEMSTRUCT)lParam;
         
         pMeasure->itemHeight = 20;         
         return TRUE;

      case WM_DRAWITEM:
         if( IDC_PALETTE_LIST == wParam )
         {
            pDrawItem = (LPDRAWITEMSTRUCT)lParam;
            if( ODT_LISTBOX == pDrawItem->CtlType && -1 != pDrawItem->itemID )
            {
               rgbValue = ListBox_GetItemData( hList, pDrawItem->itemID ); 

               SetBkMode( pDrawItem->hDC, TRANSPARENT ); 

               SetTextAlign( pDrawItem->hDC, TA_CENTER );
               
               SetTextColor( pDrawItem->hDC, RGB( 255 - GetRValue( rgbValue ), 255 - GetGValue( rgbValue ), 255 - GetBValue( rgbValue ) ) );

               hOldBrush = (HBRUSH)SelectObject( pDrawItem->hDC, CreateSolidBrush( rgbValue ) );
               
               
               Rectangle( pDrawItem->hDC, 
                          0, 
                          pDrawItem->rcItem.top, 
                          pDrawItem->rcItem.right, 
                          pDrawItem->rcItem.bottom );
               
               sprintf( szBuffer, 
                        "0x%02X%02X%02X", 
                        GetRValue( rgbValue ), 
                        GetGValue( rgbValue ), 
                        GetBValue( rgbValue ) );
               
               TextOutA( pDrawItem->hDC, 
                        pDrawItem->rcItem.right / 2, 
                        ( pDrawItem->rcItem.bottom + pDrawItem->rcItem.top ) / 2 - 5 , 
                        szBuffer, 
                        strlen( szBuffer ) );

               DeleteObject( SelectObject( pDrawItem->hDC, hOldBrush ) );
               return TRUE;
            }
         }
         break;

      case WM_COMMAND:
         switch( LOWORD( wParam ) )
         {
            case IDOK:
               pPaletteInfo->uCount = ListBox_GetCount( hList );
               pPaletteInfo->prgbList = (COLORREF *)malloc( sizeof( COLORREF ) * pPaletteInfo->uCount );
               if( NULL == pPaletteInfo->prgbList )
               {
                  EndDialog( hWnd, ERROR_NO_MEMORY );
               }
               else
               {
                  for( j = 0 ; j < pPaletteInfo->uCount ; j++ )
                  {
                     pPaletteInfo->prgbList[ j ] = ListBox_GetItemData( hList, j );
                  }
               }
               EndDialog( hWnd, SUCCESS );
               return TRUE;

            case IDCANCEL:
               EndDialog( hWnd, SUCCESS_DLG_CANCEL );
               return TRUE;

            case IDC_PALETTE_ADD:                
               ZeroMemory( &DlgParams, sizeof( DlgParams ) );
               DlgParams.uColorModel = 0;
               DlgParams.uColorSpace = DLG_COLOR_COLORSPACE_SHOW_RGB;
               DlgParams.uStructSize = sizeof( COLORDLGPARAMS );
               DlgParams.uDlgFlags = (DLG_COLOR_SHOW_OLDCOLOR	|
                                    DLG_COLOR_SHOW_NEWCOLOR	|
                                    DLG_COLOR_SHOW_NAME	|
                                    DLG_COLOR_COLORSPACE_SHOW_HUE	|
                                    DLG_COLOR_COLORSPACE_SHOW_BRIGHTNESS |
                                    DLG_COLOR_COLORSPACE_SHOW_WHEEL	|
                                    DLG_COLOR_COLORSPACE_SHOW_RGB	|
                                    DLG_COLOR_COLORSPACE_SHOW_CMY	|
                                    DLG_COLOR_COLORSPACE_SHOW_CMYK |
                                    DLG_COLOR_COLORSPACE_SHOW_LAB	|
                                    DLG_COLOR_COLORMODEL_SHOW_RGB	|
                                    DLG_COLOR_COLORMODEL_SHOW_HSB	|
                                    DLG_COLOR_COLORMODEL_SHOW_HLS	|
                                    DLG_COLOR_COLORMODEL_SHOW_CMY	|
                                    DLG_COLOR_COLORMODEL_SHOW_CMYK |
                                    DLG_COLOR_COLORMODEL_SHOW_LAB	);


               nRet = L_DlgColor(g_hWndFrame,&DlgParams);

               if(nRet ==  SUCCESS_DLG_OK)
               {
                  nIndex = ListBox_AddString( hList, "" );
                  ListBox_SetItemData( hList, nIndex, DlgParams.crColor);
               }
               return TRUE;

            case IDC_PALETTE_REMOVE:
               nIndex = ListBox_GetCurSel( hList );
               if( LB_ERR != nIndex )
               {
                  ListBox_DeleteString( hList, nIndex );
                  Button_Enable( GetDlgItem( hWnd, IDC_PALETTE_REMOVE ), FALSE );
               }
               break;

            case IDC_PALETTE_LIST:
               nIndex = ListBox_GetCurSel( hList );
               Button_Enable( GetDlgItem( hWnd, IDC_PALETTE_REMOVE ), LB_ERR != nIndex );
               return TRUE;
         }

   }
   return FALSE;
}


/*----------------------------------------------------------------------------
|
|  ConvertToProc
|
 ---------------------------------------------------------------------------*/
static L_BOOL EXT_FUNCTION 
ConvertToProc
( 
   HWND hWnd, 
   L_UINT uMessage, 
   WPARAM wParam, 
   LPARAM lParam 
)
{
   L_TCHAR szFileName[ L_MAXPATH ] = TEXT("");
   OPENFILENAME  SaveFileName;
   static pCONVERTDATA  pConvert;
   
   switch( uMessage )
   {
      case WM_INITDIALOG:
         pConvert = (pCONVERTDATA)lParam;
         
         SetDlgItemInt( hWnd, IDC_CONVERT_LEFT  , pConvert->Rect.left  , FALSE );
         SetDlgItemInt( hWnd, IDC_CONVERT_TOP   , pConvert->Rect.top   , FALSE );
         SetDlgItemInt( hWnd, IDC_CONVERT_RIGHT , pConvert->Rect.right , FALSE );
         SetDlgItemInt( hWnd, IDC_CONVERT_BOTTOM, pConvert->Rect.bottom, FALSE );

         SetDlgItemInt( hWnd, IDC_CONVERT_DPI, pConvert->uDPI, FALSE );
         SetDlgItemText( hWnd, IDC_CONVERT_PATH, pConvert->szFileName );
         return TRUE;

      case WM_COMMAND:
         switch( LOWORD( wParam ) )
         {
            case IDOK:
               /* fill information and exit */ 
               GetDlgItemText( hWnd, IDC_CONVERT_PATH, pConvert->szFileName, sizeof( pConvert->szFileName ) / sizeof( L_TCHAR ) );
               if( 0 == pConvert->szFileName[ 0 ] )
               {
                  return TRUE;
               }

               pConvert->Rect.left   = GetDlgItemInt( hWnd, IDC_CONVERT_LEFT  , NULL, FALSE );
               pConvert->Rect.top    = GetDlgItemInt( hWnd, IDC_CONVERT_TOP   , NULL, FALSE );
               pConvert->Rect.right  = GetDlgItemInt( hWnd, IDC_CONVERT_RIGHT , NULL, FALSE );
               pConvert->Rect.bottom = GetDlgItemInt( hWnd, IDC_CONVERT_BOTTOM, NULL, FALSE );               

               pConvert->uDPI = GetDlgItemInt( hWnd, IDC_CONVERT_DPI, NULL, FALSE );
               

               EndDialog( hWnd, SUCCESS );
               return TRUE;

            case IDCANCEL:               
               EndDialog( hWnd, FAILURE );
               return TRUE;

            case IDC_CONVERT_BROWSE:
               ZeroMemory( &SaveFileName, sizeof( OPENFILENAME ) );
               ZeroMemory( szFileName, sizeof( szFileName ) );

               SaveFileName.lStructSize       = sizeof( OPENFILENAME );
               SaveFileName.hwndOwner         = g_hWndClient;
               SaveFileName.hInstance         = NULL;
               SaveFileName.lpstrFilter       = ( pConvert->bEmf ? TEXT("Enhanced Meta files\0*.EMF\0") : TEXT("Window Meta Files\0*.WMF\0") );
               SaveFileName.lpstrCustomFilter = NULL;
               SaveFileName.nMaxCustFilter    = 0;
               SaveFileName.nFilterIndex      = 0;
               SaveFileName.lpstrFile         = szFileName;
               SaveFileName.nMaxFile          = sizeof( szFileName )/sizeof(L_TCHAR);
               SaveFileName.lpstrFileTitle    = NULL;
               SaveFileName.nMaxFileTitle     = 0;
               SaveFileName.lpstrInitialDir   = NULL;
               SaveFileName.lpstrTitle        = TEXT("Save metafile");
               SaveFileName.Flags             = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
               SaveFileName.nFileOffset       = 0;
               SaveFileName.nFileExtension    = 0;
               SaveFileName.lpstrDefExt       = ( pConvert->bEmf ? TEXT("EMF") : TEXT("WMF") ); 
               SaveFileName.lCustData         = 0L;
               SaveFileName.lpfnHook          = NULL;
               SaveFileName.lpTemplateName    = NULL;

               if( GetSaveFileName( &SaveFileName ) )
               {
                  SetDlgItemText( hWnd, IDC_CONVERT_PATH, szFileName );                  
               }
               return TRUE;
         }
   }
   return FALSE;
}

/*----------------------------------------------------------------------------
|
|  Child_OnKeyDown
|
 ---------------------------------------------------------------------------*/
static L_VOID
Child_OnKeyDown
(
   HWND    hWnd,
   L_UINT  uVk,
   BOOL    fDown,
   L_INT   nRepeat,
   L_UINT  uFlags
)
{
   LPCHILDDATA pData = GETCHILDDATA( hWnd );
   L_UINT      uNewWidth;
   L_UINT      uNewHeight;
   L_INT       nWidthDiff;
   L_INT       nHeightDiff;
   L_INT       nTemp;
   L_INT       nRet;
   VECTORPOINT ptMin;
   VECTORPOINT ptMax;

   UNREFERENCED_PARAMETER( fDown );
   UNREFERENCED_PARAMETER( nRepeat );
   UNREFERENCED_PARAMETER( uFlags );
   
   if ( (VK_ADD != uVk) && (VK_SUBTRACT != uVk) )
      return;

   if ( VK_ADD == uVk )
   {
      nTemp = 90;
   }


   else
   {
      nTemp = 110;
   }

   nRet = L_VecGetParallelogram( pData->pVector, &ptMin, &ptMax );



   if ( SUCCESS != nRet )
      return;


   uNewWidth = MulDiv( (L_INT)( ptMax.x - ptMin.x ), nTemp, 100 );
   
   uNewHeight = MulDiv( (L_INT)( ptMax.y - ptMin.y ), nTemp, 100 );

   nWidthDiff = uNewWidth - (L_INT)( ptMax.x - ptMin.x );



   nHeightDiff = uNewHeight - (L_INT)( ptMax.y - ptMin.y );



   ptMin.x -= nWidthDiff / 2;
   
   ptMin.y -= nHeightDiff / 2;

   ptMax.x += nWidthDiff / 2;



   ptMax.y += nHeightDiff / 2;



   nRet = L_VecSetParallelogram( pData->pVector, &ptMin, &ptMax );
   
   UpdateScrollBars( hWnd );

   InvalidateRect( hWnd, NULL, TRUE );
   
}

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