// ZoomViewView.cpp : implementation of the CZoomViewView class
//

#include "stdafx.h"
#include "ZoomView.h"
#include "RangeDlg.h"
#include "ZoomViewDoc.h"
#include "ZoomViewView.h"
#include "ZoomViewOptionsDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CZoomViewView

IMPLEMENT_DYNCREATE(CZoomViewView, CView)

BEGIN_MESSAGE_MAP(CZoomViewView, CView)
   //{{AFX_MSG_MAP(CZoomViewView)
   ON_WM_CREATE()
   ON_COMMAND(ID_FILE_SAVE, OnFileSave)
   ON_COMMAND(ID_VIEW_NORMAL, OnViewNormal)
   ON_UPDATE_COMMAND_UI(ID_VIEW_NORMAL, OnUpdateViewNormal)
   ON_COMMAND(ID_VIEW_FITIMAGETOWINDOW, OnViewFitImage)
   ON_UPDATE_COMMAND_UI(ID_VIEW_FITIMAGETOWINDOW, OnUpdateViewFitImage)
   ON_COMMAND(ID_VIEW_ZOOM, OnViewZoom)
   ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
   ON_COMMAND(ID_VIEW_HILITEIMAGE, OnViewHiliteimage)
   ON_WM_CONTEXTMENU()
   ON_WM_LBUTTONUP()
   ON_WM_LBUTTONDOWN()
   ON_COMMAND(IDM_ZOOMVIEW_OPTIONS, OnZoomViewOptions)
   ON_COMMAND(IDM_ZOOMVIEW_DELETE, OnZoomViewDelete)
   ON_COMMAND(IDM_ABOUT, OnAbout)
   ON_COMMAND(IDM_BITONALNORMAL, OnBitonalNormal)
   ON_UPDATE_COMMAND_UI(IDM_BITONALNORMAL, OnUpdateBitonalNormal)
   ON_COMMAND(IDM_FAVORBLACK, OnFavorBlack)
   ON_UPDATE_COMMAND_UI(IDM_FAVORBLACK, OnUpdateFavorBlack)
   ON_COMMAND(IDM_SCALETOGRAY, OnScaleToGray)
   ON_UPDATE_COMMAND_UI(IDM_SCALETOGRAY, OnUpdateScaleToGray)
   ON_UPDATE_COMMAND_UI(ID_VIEW_HILITEIMAGE, OnUpdateViewHiliteImage)
   ON_WM_KEYDOWN()
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CZoomViewView construction/destruction

CZoomViewView::CZoomViewView()
{
   m_nBitonalScaling =0;
   memset(&m_rcOldClip, 0, sizeof(m_rcOldClip));
}

CZoomViewView::~CZoomViewView()
{
}

BOOL CZoomViewView::PreCreateWindow(CREATESTRUCT& cs)
{
   // TODO: Modify the Window class or styles here by modifying
   //  the CREATESTRUCT cs
   cs.style|=(WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
   return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CZoomViewView drawing

void CZoomViewView::OnDraw(CDC* pDC)
{
   CZoomViewDoc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);
   // TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CZoomViewView diagnostics

#ifdef _DEBUG
void CZoomViewView::AssertValid() const
{
   CView::AssertValid();
}

void CZoomViewView::Dump(CDumpContext& dc) const
{
   CView::Dump(dc);
}

CZoomViewDoc* CZoomViewView::GetDocument() // non-debug version is inline
{
   ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CZoomViewDoc)));
   return (CZoomViewDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CZoomViewView message handlers

int CZoomViewView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
   if (CView::OnCreate(lpCreateStruct) == -1)
      return -1;
   
   L_INT nRetCode = SUCCESS;
   HWND  hWnd     =!NULL; 

   //.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>.>
   //  
   //     There are two way to use LEAD controls :
   //     1.As a control:
   //          Enable A and Disable B 
   //     2.As a Window :
   //          Enable B and Disable As 
   //

   // A : (LBitmapWindow works as a Window )
   nRetCode = m_LBitmapWnd.SetWndHandle(m_hWnd);
   //End of A.
         
   // B : (LBitmapWindow works as a Control)
   
   /*hWnd         = m_LBitmapWnd.CreateWnd(m_hWnd,0,
                                      WS_VISIBLE|L_BS_CENTER|
                                      L_BS_PROCESSKEYBOARD,
                                      0,0,200,200);
   */
   //End of B.

   m_LBitmapWnd.EnableDoubleBuffer(TRUE);
   m_LBitmapWnd.SetToolType(TOOL_ZOOMVIEW);
   m_LBitmapWnd.EnableCenterOnZoom(FALSE);
   m_LBitmapWnd.EnableKeyBoard(FALSE);

   if(nRetCode!=SUCCESS||hWnd==NULL)
   {
      LBase::DisplayErrorFromList();
      return -1;
   }

   return 0;
}

void CZoomViewView::OnFileSave() 
{
   // TODO: Add your command handler code here
   TCHAR szFileName[260];

   SAVEDLGPARAMS SaveParms ;  
   OPENFILENAME  OpenFileName ;

   memset ( &SaveParms, 0, sizeof ( SAVEDLGPARAMS ) ) ;
   memset ( &OpenFileName, 0, sizeof ( OPENFILENAME ) ) ;

   OpenFileName.lStructSize     = sizeof ( OPENFILENAME ) ;
   OpenFileName.lpstrInitialDir = NULL;
   OpenFileName.lpstrTitle      = _T("Save a File");
   OpenFileName.nFilterIndex    = 0 ;

   SaveParms.uStructSize       = sizeof ( SAVEDLGPARAMS) ;
   SaveParms.nQFactor          = 2 ;
   SaveParms.nPageNumber       = 1 ;
   SaveParms.nStampBits        = 24;
   SaveParms.nStampWidth       = 120;
   SaveParms.nStampHeight      = 120;
   SaveParms.nBitsPerPixel     = 24;
   SaveParms.nFormat           = FILE_BMP;
   SaveParms.uSaveMulti        = MULTIPAGE_OPERATION_REPLACE ;
   SaveParms.uDlgFlags         = DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE     |
                                 DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE       |
                                 DLG_SAVE_SHOW_FILEOPTIONS_STAMP           |
                                 DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR         |
                                 DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS      |
                                 DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS ;


   m_LBitmapWnd.DialogFile()->SetSaveParams(&SaveParms);
   m_LBitmapWnd.DialogFile()->SetOpenFileName(&OpenFileName);

   m_LBitmapWnd.DialogFile()->EnableAutoProcess(TRUE);
   m_LBitmapWnd.DialogFile()->SetFileName((LPTSTR)(LPCTSTR)GetDocument()->GetPathName()) ;

   L_INT nRetCode = m_LBitmapWnd.DialogFile()->DoModalSave(m_hWnd);
   
   if (nRetCode == SUCCESS_DLG_OK)
   {
      HCURSOR hCursor;
      int            nRet;
      SAVEFILEOPTION SaveFileOption;

      m_LBitmapWnd.DialogFile()->GetFileName(szFileName, sizeof(szFileName));
      
      hCursor = SetCursor (LoadCursor (NULL, IDC_WAIT));
      
      /********************************************/
      
      LBaseFile::GetDefaultSaveFileOption(&SaveFileOption,sizeof(SaveFileOption));
      m_LBitmapWnd.DialogFile()->GetSaveParams(&SaveParms, sizeof(SaveParms));

      switch(SaveParms.uSaveMulti)
      {
         case MULTIPAGE_OPERATION_OVERWRITE:
               SaveFileOption.PageNumber = 1; 
               //SaveFileOption.Flags |= ESO_REPLACEPAGE;
               break;
         case MULTIPAGE_OPERATION_APPEND:
               //Do nothing
               //pSaveFileOption->PageNumber = 2;
               break;
         case MULTIPAGE_OPERATION_REPLACE:
               SaveFileOption.PageNumber = SaveParms.nPageNumber; 
               SaveFileOption.Flags |= ESO_REPLACEPAGE;
               break;
         case MULTIPAGE_OPERATION_INSERT:
               SaveFileOption.PageNumber = SaveParms.nPageNumber;
               SaveFileOption.Flags |= ESO_INSERTPAGE;
               break;
      }
      /*********************************************/

      nRet = m_LBitmapWnd.Save(  szFileName,
                                 SaveParms.nFormat,
                                 SaveParms.nBitsPerPixel,
                                 SaveParms.nQFactor,
                                 SaveParms.uSaveMulti,
                                 &SaveFileOption);
      SetCursor (hCursor);
   }
}

void CZoomViewView::OnViewNormal() 
{
   m_LBitmapWnd.SetZoomMode(ZOOM_NORMAL);
}

void CZoomViewView::OnUpdateViewNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck((m_LBitmapWnd.GetZoomMode()==ZOOM_NORMAL));
}

void CZoomViewView::OnViewFitImage() 
{
   m_LBitmapWnd.SetZoomMode(ZOOM_FIT);
}

void CZoomViewView::OnUpdateViewFitImage(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck((m_LBitmapWnd.GetZoomMode()==ZOOM_FIT)); 
}

void CZoomViewView::OnViewZoom() 
{
   // TODO: Add your command handler code here
   CRangeDlg dlg;

   dlg.m_strTitle = _T("Zoom");
   dlg.m_strLabel = _T("&Amount");
   dlg.m_nValue   = m_LBitmapWnd.GetZoomPercent();
   dlg.m_nMin     = 1;
   dlg.m_nMax     = 800;
   dlg.m_nPage    = 100;
   dlg.m_nValue   = (int)m_LBitmapWnd.GetZoomPercent();

   if(dlg.DoModal() == IDOK)
      m_LBitmapWnd.SetZoomPercent((L_UINT)dlg.m_nValue);   
}

void CZoomViewView::OnEditCopy() 
{
   m_LBitmapWnd.CopyToClipboard(m_hWnd);
}

void CZoomViewView::OnViewHiliteimage() 
{
   m_LBitmapWnd.EnableHiliteZoomView(!m_LBitmapWnd.IsHiliteZoomViewEnabled());
}

void CZoomViewView::OnContextMenu(CWnd* pWnd, CPoint point) 
{
   CMenu    ContextMenu;
   CMenu*   pMenu = NULL;
   POINT    pt,tmpPoint;
   RECT rcDst;

   pt = point;
   ScreenToClient(&pt);

   m_LBitmapWnd.GetRects(NULL, NULL, &rcDst, NULL);

   tmpPoint.x = (pt.x - rcDst.left);
   tmpPoint.y = (pt.y - rcDst.top);

   tmpPoint.x = (long)(tmpPoint.x / ( m_LBitmapWnd.GetZoomPercent() / 100.0) * 100);
   tmpPoint.y = (long)(tmpPoint.y / ( m_LBitmapWnd.GetZoomPercent() / 100.0) * 100);

   m_nZoomViewIndex = PointInZoomView(&tmpPoint);
   if(m_nZoomViewIndex  >= 0 && !m_bLButton)
   {
      /* Load the context menu. */
      if (ContextMenu.LoadMenu (IDR_CONTEXT_MENU))
      {
         /* Retrieves a pointer to a pop-up menu. */
         if (pMenu = ContextMenu.GetSubMenu (0))
         {
            /* Display the pop-up menu */
            pMenu->TrackPopupMenu (TPM_LEFTALIGN, point.x, point.y, this);
         }
      }
   }
}

int CZoomViewView::PointInZoomView(POINT *pt)
{
   int nZoomViewIndex = -1;
   unsigned int uCount = 0;

   if(m_LBitmapWnd.HasZoomView())
   {
      ZOOMVIEWPROPS ZoomViewProps;
      memset(&ZoomViewProps, 0,sizeof(ZOOMVIEWPROPS));

      uCount = m_LBitmapWnd.GetZoomViewsCount();
      for(L_UINT i = 0; i < uCount; ++i)
      {
         ZoomViewProps.uIndex = uCount-i-1;
         m_LBitmapWnd.GetZoomViewProps(&ZoomViewProps, sizeof(ZOOMVIEWPROPS));

          if(PtInRect(&ZoomViewProps.rcDst ,*pt) || PtInRect(&ZoomViewProps.rcSrc ,*pt))
         {
            return m_LBitmapWnd.GetZoomViewsCount()-i-1;
         }
      }
   }

   return nZoomViewIndex;
}

void CZoomViewView::OnLButtonUp(UINT nFlags, CPoint point) 
{
   POINT    pt,tmpPoint;
   RECT rcDst;

   pt = point;

   m_LBitmapWnd.GetRects(NULL, NULL, &rcDst, NULL);

   tmpPoint.x = (pt.x - rcDst.left);
   tmpPoint.y = (pt.y - rcDst.top);

   tmpPoint.x = (long)(tmpPoint.x / ( m_LBitmapWnd.GetZoomPercent() / 100.0) * 100);
   tmpPoint.y = (long)(tmpPoint.y / ( m_LBitmapWnd.GetZoomPercent() / 100.0) * 100);

   if(!IsRectEmpty(&m_rcOldClip))
   {
      ClipCursor(&m_rcOldClip);
   }
   
   m_bLButton = FALSE;
   m_nZoomViewIndex = PointInZoomView(&tmpPoint);
   CView::OnLButtonUp(nFlags, point);
}

void CZoomViewView::OnLButtonDown(UINT nFlags, CPoint point) 
{
   m_bLButton = TRUE;
   POINT pt;
   RECT rcClient;
   
  
   GetClientRect(&rcClient);
   pt.x = rcClient.top;
   pt.y = rcClient.left;

   ClientToScreen(&pt);
   OffsetRect(&rcClient , pt.x, pt.y);
   
   GetClipCursor(&m_rcOldClip);
   ClipCursor(&rcClient);
}

void CZoomViewView::OnZoomViewOptions() 
{
   ZOOMVIEWPROPS ZoomView;

   memset(&ZoomView, 0, sizeof(ZOOMVIEWPROPS));

   ZoomView.uIndex = m_nZoomViewIndex;
   m_LBitmapWnd.GetZoomViewProps(&ZoomView, sizeof(ZOOMVIEWPROPS));

   CZoomViewOptionsDlg ZoomViewDlg(&ZoomView);

   if(ZoomViewDlg.DoModal() == IDOK)
   {
      m_LBitmapWnd.UpdateZoomView(&ZoomView);
   }
}

void CZoomViewView::OnZoomViewDelete() 
{
   m_LBitmapWnd.DestroyZoomView(m_nZoomViewIndex);
   m_nZoomViewIndex = -1;
}

void CZoomViewView::OnAbout() 
{
   ((CZoomViewApp*)AfxGetApp())->OnAppAbout();
}

void CZoomViewView::OnBitonalNormal() 
{
   m_nBitonalScaling = 0;
   LBitmapSettings::SetDisplayMode(DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY,0);
   m_LBitmapWnd.SetDisplayMode(DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY,0);
}

void CZoomViewView::OnUpdateBitonalNormal(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nBitonalScaling==0);
}

void CZoomViewView::OnFavorBlack() 
{
   m_nBitonalScaling = DISPLAYMODE_FAVORBLACK;
   LBitmapSettings::SetDisplayMode(DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY,
                                   DISPLAYMODE_FAVORBLACK);

   m_LBitmapWnd.SetDisplayMode(DISPLAYMODE_FAVORBLACK|DISPLAYMODE_SCALETOGRAY,
                                   DISPLAYMODE_FAVORBLACK);
}

void CZoomViewView::OnUpdateFavorBlack(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nBitonalScaling==DISPLAYMODE_FAVORBLACK);
}

void CZoomViewView::OnScaleToGray() 
{
   m_nBitonalScaling = DISPLAYMODE_SCALETOGRAY;
   LBitmapSettings::SetDisplayMode(DISPLAYMODE_SCALETOGRAY|DISPLAYMODE_FAVORBLACK,
                                  DISPLAYMODE_SCALETOGRAY);

   m_LBitmapWnd.SetDisplayMode(DISPLAYMODE_SCALETOGRAY|DISPLAYMODE_FAVORBLACK,
                                  DISPLAYMODE_SCALETOGRAY);

}

void CZoomViewView::OnUpdateScaleToGray(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_nBitonalScaling==DISPLAYMODE_SCALETOGRAY);
}

void CZoomViewView::OnUpdateViewHiliteImage(CCmdUI* pCmdUI) 
{
   pCmdUI->SetCheck(m_LBitmapWnd.IsHiliteZoomViewEnabled());
}

void CZoomViewView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
   if (nChar == VK_DELETE)
   {
      m_LBitmapWnd.DestroyZoomView(m_nZoomViewIndex);
      m_nZoomViewIndex = -1;
   }

   CView::OnKeyDown(nChar, nRepCnt, nFlags);
}