//MyVecWnd.cpp
#include "stdafx.h"
#include "MyVecWnd.h"
#include "MainFrm.h"
#include "Vector.h"

extern CVectorApp theApp;


LMyVectorWindow::LMyVectorWindow()
{
   m_nObjectCount = 0;
   memset( &m_LastObject, 0, sizeof( VECTOROBJECT ) );
   SetToolType(TOOL_VECTOR_USERMODE);
   m_bCountSelectObject = FALSE;
   m_bAddToGroup = FALSE;
   m_pVectorGroup = NULL;
}

LMyVectorWindow::~LMyVectorWindow()
{
}

LRESULT LMyVectorWindow::MsgProcCallBack(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
   L_TCHAR L_FAR *lpszMsg;
   L_TCHAR szMsg[256];
   static iCount = 0;
   L_UINT32 uFlagMsg;

   iCount = (iCount + 1)% 1000;

   switch (uMsg) 
   {
   case WM_LBUTTONDOWN:
      uFlagMsg = FLAG_MOUSE_MSG;
      lpszMsg = TEXT("WM_LBUTTONDOWN");
      break;

   case WM_RBUTTONDOWN: 
      uFlagMsg = FLAG_MOUSE_MSG;
      lpszMsg = TEXT("WM_RBUTTONDOWN");
      break;
      
   case WM_LBUTTONUP:
      uFlagMsg = FLAG_MOUSE_MSG;
      lpszMsg = TEXT("WM_LBUTTONUP");
      break;

   case WM_RBUTTONUP:
      uFlagMsg = FLAG_MOUSE_MSG;
      lpszMsg = TEXT("WM_RBUTTONUP");
      break;
      
   case WM_MOUSEMOVE:
      uFlagMsg = FLAG_MOUSE_MSG;         
      lpszMsg = TEXT("WM_MOUSEMOVE");
      break;
      
   case WM_SETFOCUS:
      uFlagMsg = FLAG_FOCUS_MSG;
      lpszMsg = TEXT("WM_SETFOCUS");
      break;
      
   case WM_KILLFOCUS:
      uFlagMsg = FLAG_FOCUS_MSG;
      lpszMsg = TEXT("WM_KILLFOCUS");
      break;
      
   case WM_KEYDOWN:
      uFlagMsg = FLAG_KEY_MSG;
      lpszMsg = TEXT("WM_KEYDOWN");
      break;
      
   case WM_KEYUP:
      uFlagMsg = FLAG_KEY_MSG;
      lpszMsg = TEXT("WM_KEYUP");
      break;
      
   case WM_CHAR:
      uFlagMsg = FLAG_KEY_MSG;
      lpszMsg = TEXT("WM_CHAR");
      break;
      
   case WM_HSCROLL:
      uFlagMsg = FLAG_SCROLL_MSG;
      lpszMsg = TEXT("WM_HSCROLL");
      break;

   case WM_VSCROLL:
      uFlagMsg = FLAG_SCROLL_MSG;
      lpszMsg = TEXT("WM_VSCROLL");
      break;

   case WM_SIZE:
      uFlagMsg = FLAG_SIZE_MSG;
      lpszMsg = TEXT("WM_SIZE");
      break;

   default:
      uFlagMsg = FLAG_NONE_MSG;
      lpszMsg = NULL;
   }

   if (lpszMsg != NULL)
   {
      POINT       pt;
      VECTORPOINT Point;
      
      pt.x = LOWORD(lParam);
      pt.y = HIWORD(lParam); 
      PhysicalToLogical(  &Point, &pt );
      
      wsprintf(szMsg, TEXT("[%d]\tuMsg[%d][%s]\n"),iCount ,uMsg, lpszMsg);
      ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(uFlagMsg, lpszMsg, &Point);
   }
   return LVectorWindow::MsgProcCallBack( hWnd, uMsg, wParam, lParam);
}

L_BOOL  LMyVectorWindow::OnFileDropped(L_TCHAR L_FAR* pszFile,L_UINT uFileNumber,L_UINT uFilesCount)
{
   L_TCHAR szMsg[256];

   wsprintf(szMsg, TEXT("OnFileDropped(%s, %d, %d)"), pszFile, uFileNumber, uFilesCount);
   ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_DRAGDROP_MSG, szMsg);
   return LVectorWindow::OnFileDropped( pszFile, uFileNumber, uFilesCount);
}

L_VOID  LMyVectorWindow::OnDraw(HDC hdc,RECT& Rect)
{
   L_TCHAR szMsg[256];

   wsprintf(szMsg, TEXT("OnDraw(%d, %d, %d, %d)"), Rect.left, Rect.top, Rect.right, Rect.bottom);
   ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_PAINT_MSG, szMsg);
}

L_VOID  LMyVectorWindow::OnZoom(L_INT ZoomPercent)
{
      L_TCHAR szMsg[256];

      wsprintf(szMsg, TEXT("OnZoom[%d]"), ZoomPercent);
      ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_ZOOM_MSG,szMsg);
}

L_VOID  LMyVectorWindow::OnScale(VECTORPOINT ScalePercent)
{
      L_TCHAR szMsg[256];

      wsprintf(szMsg, TEXT("OnScale[%lf, %lf, %lf]"), ScalePercent.x, ScalePercent.y, ScalePercent.z);
      ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_SCALE_MSG,szMsg);
}


L_INT   LMyVectorWindow::StartChanging(L_UINT nChangeType,L_UINT nChangeCategory)
{
   L_TCHAR L_FAR *lpszMsg = NULL;

   switch(nChangeType)
   {
   case NC_VECTOR_ROTATE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_ROTATE]");
      break;

   case NC_VECTOR_TRANSLATE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_TRANSLATE]");
      break;

   case NC_VECTOR_SCALE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_SCALE]");
      break;

   case NC_VECTOR_DIALOG_3DOPTIONS:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_DIALOG_3DOPTIONS]");
      break;
   case NC_VECTOR_CAMERA:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_CAMERA]");
      break;	
   case NC_VECTOR_FREE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_FREE]");
      break;	
   case NC_VECTOR_BACKCOLOR:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_BACKCOLOR]");
      break;	

   case NC_VECTOR_VIEW_MODE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_VIEW_MODE]");
      break;	
   case NC_VECTOR_PAN:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_PAN]");
      break;
   case NC_VECTOR_BIND_VERTICES:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_BIND_VERTICES]");
      break;
   case NC_VECTOR_DELETE_OBJECT:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_DELETE_OBJECT]");
      break;

   case NC_VECTOR_SELECT_OBJECT:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_SELECT_OBJECT]");
      break;
   case NC_VECTOR_POLYGON_MODE:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_POLYGON_MODE]");
      break;
   case NC_VECTOR_USE_LIGHTS:
      lpszMsg =  TEXT("StartChanging[NC_VECTOR_USE_LIGHTS]");
      break;
   }

   if (lpszMsg != NULL)
   {
      ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_VECTORCHANGED_MSG, lpszMsg);
   }

   return LVectorWindow::StartChanging(nChangeType,nChangeCategory);
}

L_VOID  LMyVectorWindow::EndChanging(L_UINT nChangeType,L_UINT nChangeCategory,L_INT nRetCode)
{
   L_TCHAR L_FAR *lpszMsg;

   lpszMsg =  NULL;

   switch(nChangeType)
   {
   case NC_VECTOR_ROTATE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_ROTATE]");
      break;

   case NC_VECTOR_TRANSLATE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_TRANSLATE]");
      break;

   case NC_VECTOR_SCALE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_SCALE]");
      break;

   case NC_VECTOR_DIALOG_3DOPTIONS:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_DIALOG_3DOPTIONS]");
      break;
   case NC_VECTOR_CAMERA:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_CAMERA]");
      break;	
   case NC_VECTOR_FREE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_FREE]");
      break;	
   case NC_VECTOR_BACKCOLOR:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_BACKCOLOR]");
      break;	

   case NC_VECTOR_VIEW_MODE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_VIEW_MODE]");
      break;	
   case NC_VECTOR_PAN:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_PAN]");
      break;
   case NC_VECTOR_BIND_VERTICES:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_BIND_VERTICES]");
      break;
   case NC_VECTOR_DELETE_OBJECT:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_DELETE_OBJECT]");
      break;

   case NC_VECTOR_SELECT_OBJECT:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_SELECT_OBJECT]");
      break;
   case NC_VECTOR_POLYGON_MODE:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_POLYGON_MODE]");
      break;
   case NC_VECTOR_USE_LIGHTS:
      lpszMsg =  TEXT("EndChanging[NC_VECTOR_USE_LIGHTS]");
      break;
   }

   if (lpszMsg != NULL)
   {
      ((CMainFrame *)(theApp.GetMainWnd()))->UpdateStatusBar(FLAG_VECTORCHANGED_MSG, lpszMsg);
   }

   LVectorWindow::EndChanging( nChangeType, nChangeCategory, nRetCode);
}


L_INT LMyVectorWindow::EnumObjectsCallBack(pVECTORHANDLE pVector, pVECTOROBJECT pObject)
{
   L_INT nRet;
   if (m_bCountSelectObject)
   {
      m_nObjectCount++;
      memcpy( &m_LastObject, pObject, sizeof( VECTOROBJECT ) );
   }
   else if (m_bAddToGroup)
   {
      LVectorObject MyObject(pObject, this);
      nRet = m_pVectorGroup->AddObject(&MyObject);
   }
   else 
   {
      LVectorWindow::EnumObjectsCallBack(pVector, pObject);
   }
   return SUCCESS;
}

L_INT LMyVectorWindow::GetCountSelectedObject()
{
   L_BOOL bEnable;
   L_INT  nRet;
   m_nObjectCount = 0;
   
   bEnable = EnableCallBack(TRUE);
   m_bCountSelectObject = TRUE;
   nRet = EnumObjects(VECTOR_FLAGS_SELECTED_ONLY);
   m_bCountSelectObject = FALSE;
   if (nRet != SUCCESS)
      return -1;
   EnableCallBack(bEnable);
   return m_nObjectCount;
   
}

void LMyVectorWindow::AddSelectedObjectsToGroup(LVectorGroup * pGroup)
{
   L_BOOL bEnable;
   bEnable = EnableCallBack(TRUE);
   m_bAddToGroup = TRUE;
   m_pVectorGroup = pGroup;
   EnumObjects(VECTOR_FLAGS_SELECTED_ONLY);
   m_pVectorGroup = NULL;
   m_bAddToGroup = FALSE;
   m_bCountSelectObject = FALSE;
   EnableCallBack(bEnable);
}