// VectorDoc.cpp : implementation of the CVectorDoc class
//

#include "stdafx.h"
#include "Vector.h"

#include "VecDoc.h"
#include "MainFrm.h"
#include "VecDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CVectorDoc

IMPLEMENT_DYNCREATE(CVectorDoc, CDocument)

BEGIN_MESSAGE_MAP(CVectorDoc, CDocument)
	//{{AFX_MSG_MAP(CVectorDoc)
	ON_COMMAND(ID_IMAGE_TRANSFORMATIONLEVEL_ALLOBJECTS, OnImageTransformationlevelAllobjects)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_TRANSFORMATIONLEVEL_ALLOBJECTS, OnUpdateImageTransformationlevelAllobjects)
	ON_COMMAND(ID_IMAGE_TRANSFORMATIONLEVEL_SELECTEDOBJECTS, OnImageTransformationlevelSelectedobjects)
	ON_UPDATE_COMMAND_UI(ID_IMAGE_TRANSFORMATIONLEVEL_SELECTEDOBJECTS, OnUpdateImageTransformationlevelSelectedobjects)
	ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

extern CVectorApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CVectorDoc construction/destruction

CVectorDoc::CVectorDoc()
{
   m_pVectorWindow = new LMyVectorWindow;
   m_nViewMode = VECTOR_VIEWMODE_FIT;
   m_nBindVerticesMode = VECTOR_BIND_VERTICES;
   m_bZoomOut = FALSE;
   m_bSelectedOnly = FALSE;
   m_bAutoScroll = TRUE;
   m_dwVectorEngineFlags = VECTOR_ENGINE_DOUBLEBUFFER;
   m_VectorEngine = VECTOR_ENGINE_GDI;
}

CVectorDoc::~CVectorDoc()
{
   delete m_pVectorWindow;
}


/////////////////////////////////////////////////////////////////////////////
// CVectorDoc serialization


/////////////////////////////////////////////////////////////////////////////
// CVectorDoc diagnostics

#ifdef _DEBUG
void CVectorDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CVectorDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CVectorDoc commands

BOOL CVectorDoc::OnOpenDocument(LPCTSTR lpszPathName) 
{
   L_BOOL bRet = TRUE;
   if (!CDocument::OnOpenDocument(lpszPathName))
      return FALSE;
   
   L_TCHAR szTemp[_MAX_PATH];
   
   lstrcpy(szTemp, lpszPathName);
   
   theApp.m_Automation.SetUndoEnabled(FALSE);
   L_INT nRet = this->m_pVectorWindow->Load(szTemp);  
   
   if (nRet == SUCCESS)
   {
      L_INT  nRet;
      CVectorDlg VectorDlg;      
      
      VECTORPOINT Min, Max;
      m_pVectorWindow->GetParallelogram(&Min, &Max );
      
      VectorDlg.m_MinX =   Min.x;
      VectorDlg.m_MinY =   Min.y;
      VectorDlg.m_MinZ =   Min.z;
      
      VectorDlg.m_MaxX =   Max.x;
      VectorDlg.m_MaxY =   Max.y;
      VectorDlg.m_MaxZ =   Max.z;
      
      VectorDlg.m_nEngine = VECTOR_ENGINE_GDI;
      VectorDlg.m_bDoubleBuffer = TRUE;
      VectorDlg.m_bUseEngine = TRUE;
      nRet = VectorDlg.DoModal();
      if (nRet == IDOK)
      {
         VECTORPOINT Min, Max;
         
         Min.x = VectorDlg.m_MinX;
         Min.y = VectorDlg.m_MinY;
         Min.z = VectorDlg.m_MinZ;
         
         Max.x = VectorDlg.m_MaxX;
         Max.y = VectorDlg.m_MaxY;
         Max.z = VectorDlg.m_MaxZ;
         
         m_VectorEngine = VectorDlg.m_nEngine;
         m_dwVectorEngineFlags = VectorDlg.m_bDoubleBuffer * VECTOR_ENGINE_DOUBLEBUFFER;
         
         m_pVectorWindow->SetSelectedOnly(m_bSelectedOnly); 
         m_pVectorWindow->EnableAutoScroll(m_bAutoScroll);
         m_bAutoScroll = m_pVectorWindow->IsAutoScrollEnabled();
         
         m_pVectorWindow->SetParallelogram(&Min, &Max);
         m_pVectorWindow->SetEngine(m_VectorEngine, m_dwVectorEngineFlags);
         m_pVectorWindow->Reset();
      }   
      else //cancel
      {
         m_pVectorWindow->Free();
         bRet = FALSE;
      }
   }
   else
   {
      L_TCHAR szTemp[200];
      
      wsprintf(szTemp, TEXT("Error Loading File[%d]"), nRet);
      AfxMessageBox(szTemp);
      bRet = FALSE;
   }
   if ((theApp.m_bUseAutomation) && (bRet == TRUE))
   {
      theApp.m_Automation.SetUndoEnabled();
   }
   
   return bRet; 
}

BOOL CVectorDoc::OnSaveDocument(LPCTSTR lpszPathName) 
{
	// TODO: Add your specialized code here and/or call the base class
   //Determine format of file
   LBitmapBase  Bitmap;
   LFile        LeadFile ;
   FILEINFO     FileInfo ;
   L_TCHAR       szFileName[_MAX_PATH];
   L_INT        nRet = 0;

   lstrcpy(szFileName, lpszPathName);
   LeadFile.SetBitmap(&Bitmap) ;
   LeadFile.SetFileName(szFileName) ;
   FileInfo.uStructSize =  sizeof(FILEINFO);
   LeadFile.GetInfo(&FileInfo, sizeof(FILEINFO));

   switch(FileInfo.Format)
   {
   case FILE_DXF:
   case FILE_WMF:
   case FILE_EMF:
   case FILE_DRW:
   case FILE_CGM:
   case FILE_PLT:
   case FILE_PCT:
   case FILE_INTERGRAPH_VECTOR:
   case FILE_TIF_DXF:
   case FILE_VECTOR_DUMP:
      L_BOOL bApply = ((CMainFrame *)(theApp.GetMainWnd()))->m_bApplyTransformsBeforeSave;
      if (bApply)
         m_pVectorWindow->ApplyTransformation();
      nRet = m_pVectorWindow->Save( szFileName, FileInfo.Format);
      if (nRet != SUCCESS)
      {
         L_TCHAR szTemp[200];

         wsprintf(szTemp, TEXT("Error Saving File[%d]"), nRet);
         AfxMessageBox(szTemp);
      }
      break;
   }

   if (nRet == SUCCESS)
      SetModifiedFlag(FALSE);
	//return CDocument::OnSaveDocument(lpszPathName);
   return (nRet == SUCCESS);
}



void CVectorDoc::OnFileSaveAs() 
{
   static OPENFILENAME  OpenFileName;
   static L_TCHAR        szFileName[ _MAX_PATH ] = TEXT("");
   static L_TCHAR        szFileTitle[ _MAX_PATH ] = TEXT("");
   L_INT nRet;

   static const L_TCHAR szFilter[] =
   {
      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 nFileFormats[] = {
      FILE_VECTOR_DUMP,
      FILE_DWF,
      FILE_DXF,
      FILE_CGM,
      FILE_PLT,
      FILE_PCT,
      FILE_DRW,
      FILE_WMF,
      FILE_EMF,
      FILE_GERBER,
      FILE_SHP,
      FILE_PCL,
      FILE_SVG,
      FILE_VWPG,
      FILE_WMZ
   };

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

   OpenFileName.lStructSize       = sizeof( OPENFILENAME );
   OpenFileName.hwndOwner         = theApp.m_pMainWnd->m_hWnd;
   OpenFileName.hInstance         = NULL;
   OpenFileName.lpstrFilter       = szFilter;
   OpenFileName.lpstrCustomFilter = NULL;
   OpenFileName.nMaxCustFilter    = 0;
   OpenFileName.nFilterIndex      = 0;
   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( !GetSaveFileName( &OpenFileName ) )
         return;  

   
   L_BOOL bApply = ((CMainFrame *)(theApp.GetMainWnd()))->m_bApplyTransformsBeforeSave;
   if (bApply)
      m_pVectorWindow->ApplyTransformation();

   if(OpenFileName.nFilterIndex >= 1 && 
      OpenFileName.nFilterIndex <= sizeof(nFileFormats)/sizeof(nFileFormats[0]))
   {
      nRet = m_pVectorWindow->Save(szFileName, nFileFormats[OpenFileName.nFilterIndex-1]);
   }
   else
      nRet = ERROR_FILE_FORMAT;

   if (nRet != SUCCESS)
   {
      L_TCHAR szTemp[200];
      
      wsprintf(szTemp, TEXT("Error Saving File[%d]"), nRet);
      AfxMessageBox(szTemp);
   }
   
}

void CVectorDoc::OnImageTransformationlevelAllobjects() 
 {
    this->m_bSelectedOnly = FALSE;
    this->m_pVectorWindow->SetSelectedOnly(m_bSelectedOnly);
 }
 
void CVectorDoc::OnUpdateImageTransformationlevelAllobjects(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_bSelectedOnly == FALSE);
   pCmdUI->Enable(!theApp.m_bViewOnly);
}

void CVectorDoc::OnImageTransformationlevelSelectedobjects() 
{
   this->m_bSelectedOnly = TRUE;
   this->m_pVectorWindow->SetSelectedOnly(m_bSelectedOnly);
}

void CVectorDoc::OnUpdateImageTransformationlevelSelectedobjects(CCmdUI* pCmdUI) 
{	
   pCmdUI->SetCheck(m_bSelectedOnly);
   pCmdUI->Enable(!theApp.m_bViewOnly);
}

BOOL CVectorDoc::OnNewDocument() 
{

   if (!CDocument::OnNewDocument())      
      return FALSE;

   L_INT  nRet;
   CVectorDlg VectorDlg;
   VECTOR_DISPLAY_OPTIONS DispOpt;
   
   VectorDlg.m_MinX =   0.0;
   VectorDlg.m_MinY =   0.0;
   VectorDlg.m_MinZ =   0.0;
   
   VectorDlg.m_MaxX = 100.0;
   VectorDlg.m_MaxY = 100.0;
   VectorDlg.m_MaxZ =   0.0;
   
   VectorDlg.m_nEngine = VECTOR_ENGINE_GDI;
   VectorDlg.m_bDoubleBuffer = TRUE;
   VectorDlg.m_bUseEngine = FALSE;
   nRet = VectorDlg.DoModal();
   if (nRet == IDOK)
   {

      if (theApp.m_bUseAutomation)
      {
         theApp.m_Automation.SetUndoEnabled(FALSE);
      }

      VECTORPOINT Min, Max;
      
      Min.x = VectorDlg.m_MinX;
      Min.y = VectorDlg.m_MinY;
      Min.z = VectorDlg.m_MinZ;
      
      Max.x = VectorDlg.m_MaxX;
      Max.y = VectorDlg.m_MaxY;
      Max.z = VectorDlg.m_MaxZ;

      m_VectorEngine = VectorDlg.m_nEngine;
      m_dwVectorEngineFlags = VectorDlg.m_bDoubleBuffer * VECTOR_ENGINE_DOUBLEBUFFER;

      m_pVectorWindow->SetSelectedOnly(m_bSelectedOnly); 
      m_pVectorWindow->EnableAutoScroll(m_bAutoScroll);
      m_bAutoScroll = m_pVectorWindow->IsAutoScrollEnabled();
            
      m_pVectorWindow->SetParallelogram(&Min, &Max);
      m_pVectorWindow->SetEngine(m_VectorEngine, m_dwVectorEngineFlags);

      //Create an empty layer
      VECTORLAYERDESC VectorLayerDesc;

      VectorLayerDesc.nSize = sizeof(VECTORLAYERDESC); 
      lstrcpy(VectorLayerDesc.szName, TEXT("First Layer"));
      VectorLayerDesc.bVisible = TRUE;
      VectorLayerDesc.bLocked = FALSE;
      VectorLayerDesc.dwTag = 0; 

      LVectorLayer MyLayer(&VectorLayerDesc);
      m_pVectorWindow->AddLayer(&MyLayer);
      m_pVectorWindow->SetActiveLayer(&MyLayer);

      if (theApp.m_bUseAutomation)
      {
         theApp.m_Automation.SetUndoEnabled();
      }

      m_pVectorWindow->GetDisplayOptions(&DispOpt);

      DispOpt.nClipMode = VECTOR_CLIPMODE_COPY;

      m_pVectorWindow->SetDisplayOptions(&DispOpt);

   }
      
   return nRet == IDOK;
}

void CVectorDoc::OnCloseDocument() 
{
   theApp.m_Automation.RemoveContainer(&m_Container);
   m_Container.Free();

	CDocument::OnCloseDocument();
}

/*
void CVectorDoc::OnEditCopy() 
{
      theApp.m_Automation.Copy();

}

void CVectorDoc::OnUpdateEditCopy(CCmdUI* pCmdUI) 
{
   L_BOOL bSelected = FALSE;
   m_pVectorWindow->IsObjectSelected(&bSelected);
   pCmdUI->Enable(bSelected);
}


void CVectorDoc::OnEditCut() 
{
   if (theApp.m_bUseAutomation)
   {
      theApp.m_Automation.Cut();
   }
   else
   {
      m_pVectorWindow->CopyToClipboard(VECTOR_FLAGS_SELECTED_ONLY);
      m_pVectorWindow->DeleteObject(VECTOR_FLAGS_SELECTED_ONLY);
   }
}

void CVectorDoc::OnUpdateEditCut(CCmdUI* pCmdUI) 
{
   L_BOOL bSelected = FALSE;
   m_pVectorWindow->IsObjectSelected(&bSelected);
   pCmdUI->Enable(bSelected);
}


void CVectorDoc::OnEditDelete() 
{
   m_pVectorWindow->DeleteObject(VECTOR_FLAGS_SELECTED_ONLY);  
}



void CVectorDoc::OnUpdateEditDelete(CCmdUI* pCmdUI) 
{
   L_BOOL bSelected = FALSE;
   m_pVectorWindow->IsObjectSelected(&bSelected);
   pCmdUI->Enable(bSelected);
}

  

void CVectorDoc::OnEditPaste() 
{
   theApp.m_Automation.Paste();
}

void CVectorDoc::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
   pCmdUI->Enable(theApp.m_Automation.ClipboardDataReady() == TRUE);
}
*/

BOOL CVectorDoc::SaveModified() 
{
	if (!IsModified())
      return TRUE;

   CString name;
   if (m_strPathName.IsEmpty())
   {
      // get name based on caption
      name = m_strTitle;
      if (name.IsEmpty())
         VERIFY(name.LoadString(AFX_IDS_UNTITLED));
   }
   else
   {
      name = m_strPathName;
   }

   CString prompt;
   AfxFormatString1(prompt, AFX_IDP_ASK_TO_SAVE, name);
   switch (AfxMessageBox(prompt, MB_YESNOCANCEL, AFX_IDP_ASK_TO_SAVE))
   {
   case IDYES:
      OnFileSaveAs();
      break;

   case IDNO:
      // If not saving changes, revert the document
      break;

   default:
      return FALSE;
      break;
   }
   return TRUE;    // keep going
}