Алгоритм Киркпатрика-Зайделя / Source / CH_KSView

#include "stdafx.h"
#include "CH_KS.h"

#include "CH_KSDoc.h"
#include "CH_KSView.h"
#include "CH.H"

IMPLEMENT_DYNCREATE(CCH_KSView, CScrollView)

BEGIN_MESSAGE_MAP(CCH_KSView, CScrollView)
	//{{AFX_MSG_MAP(CCH_KSView)
	ON_WM_LBUTTONDOWN()
	ON_COMMAND(ID_SHOW_TEXT, OnShowText)
	ON_UPDATE_COMMAND_UI(ID_SHOW_TEXT, OnUpdateShowText)
	ON_WM_HSCROLL()
	ON_WM_VSCROLL()
	ON_COMMAND(ID_ZOOM_IN, OnZoomIn)
	ON_COMMAND(ID_ZOOM_OUT, OnZoomOut)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_OUT, OnUpdateZoomOut)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_IN, OnUpdateZoomIn)
	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
	ON_COMMAND(ID_EDIT_CUT, OnEditCut)
	ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
	ON_COMMAND(ID_SHOW_DIAG, OnShowDiag)
	ON_UPDATE_COMMAND_UI(ID_SHOW_DIAG, OnUpdateShowDiag)
	ON_COMMAND(ID_SAVE_TEXT, OnSaveText)
	ON_COMMAND(ID_OPEN_TEXT, OnOpenText)
	ON_COMMAND(ID_POINTS_ADD, OnPointsAdd)
	ON_COMMAND(ID_POINTS_DEL, OnPointsDel)
	ON_COMMAND(ID_STEP_BY_STEP, OnStepByStep)
	ON_COMMAND(ID_POINTS_EDT, OnPointsEdt)
	ON_COMMAND(ID_POINTS_RND, OnPointsRnd)
	ON_COMMAND(ID_BEST_FIT, OnBestFit)
	ON_COMMAND(ID_STEP_BY_STEP_TOOLBAR, OnStepByStepToolbar)
	ON_WM_SIZE()
	ON_COMMAND(ID_STOP, OnStop)
	ON_UPDATE_COMMAND_UI(ID_STOP, OnUpdateStop)
	ON_WM_MOUSEMOVE()
	ON_WM_MOUSEWHEEL()
	ON_COMMAND(ID_POINTS_DELETE, OnPointsDelete)
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
	ON_UPDATE_COMMAND_UI(ID_POINTS_DELETE, OnUpdatePointsDelete)
	ON_COMMAND(ID_1_1, OnOneToOne)
	ON_UPDATE_COMMAND_UI(ID_1_1, OnUpdateOneToOne)
	ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
	ON_UPDATE_COMMAND_UI(ID_REWIND, OnUpdateRewind)
	ON_COMMAND(ID_DEMO, OnDemo)
	ON_WM_TIMER()
	ON_UPDATE_COMMAND_UI(ID_DEMO, OnUpdateDemo)
	ON_COMMAND(ID_REWIND, OnRewind)
	ON_UPDATE_COMMAND_UI(ID_BEST_FIT, OnUpdateBestFit)
	ON_COMMAND(ID_SHOW_POINTS, OnShowPoints)
	ON_UPDATE_COMMAND_UI(ID_SHOW_POINTS, OnUpdateShowPoints)
	ON_COMMAND(ID_PAUSE, OnPause)
	ON_UPDATE_COMMAND_UI(ID_PAUSE, OnUpdatePause)
	ON_UPDATE_COMMAND_UI(ID_STEP_BY_STEP_TOOLBAR, OnUpdateStepByStepToolbar)
	ON_COMMAND(ID_BACK, OnBack)
	ON_UPDATE_COMMAND_UI(ID_BACK, OnUpdateBack)
	ON_UPDATE_COMMAND_UI(ID_OPEN_TEXT, OnUpdateOpenText)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_CHP, OnUpdateIndicatorCHP)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_CAPS, OnUpdateIndicatorX)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_NUM, OnUpdateIndicatorY)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_SCALE, OnUpdateIndicatorScale)
	ON_UPDATE_COMMAND_UI(ID_INDICATOR_SPACE, OnUpdateIndicatorSpace)
	ON_UPDATE_COMMAND_UI(ID_POINTS_ADD, OnUpdateMenuPointsAdd)
	ON_UPDATE_COMMAND_UI(ID_POINTS_RND, OnUpdateMenuPoints)
	ON_UPDATE_COMMAND_UI(ID_POINTS_GRD, OnUpdateMenuPoints)
    ON_UPDATE_COMMAND_UI(ID_POINTS_DEL, OnUpdateMenuPointsDeleteEdit)
    ON_UPDATE_COMMAND_UI(ID_POINTS_EDT, OnUpdateMenuPointsDeleteEdit)
	//}}AFX_MSG_MAP
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

TMyPointVector CCH_KSDoc::t;

CCH_KSView::CCH_KSView()
{
	 
}

CCH_KSView::~CCH_KSView()
{
 
}

BOOL CCH_KSView::PreCreateWindow(CREATESTRUCT& cs)
{
	return CView::PreCreateWindow(cs);	
}

void CCH_KSView::OnDraw(CDC* pDC)
{
	Image.Paint(pDC);
}

BOOL CCH_KSView::OnPreparePrinting(CPrintInfo* pInfo)
{
    pInfo->SetMaxPage(1);
        
	return DoPreparePrinting(pInfo);
}

void CCH_KSView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
{
 
}

void CCH_KSView::OnEndPrinting(CDC* pDC, CPrintInfo* pInfo)
{

}

void CCH_KSView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CCH_KSDoc* pDoc = GetDocument();
    TMyPoint pnt;

	if (!Image.hScale) {
	  if (!Image.hInStepMode && pDoc->p.N() < MAXPT) {
        Image.hPoints = true;
	    if (!Image.hBestFit) {
		  point += GetScrollPosition();
	      pnt.x = (int)(point.x / Image.hScaleX);
		  pnt.y = (int)(point.y / Image.hScaleY);
		}
		else
		{
		  CRect r;
		  GetClientRect(&r);
		  pnt.x = (int)(point.x*((float)SIZEX) / r.right);
		  pnt.y = (int)(point.y*((float)SIZEY) / r.bottom);
		}
	      	  
		pDoc->p.Add(pnt);
		Image.hKnow = false;
		Image.hStepOn = false;
        MyUpdate(pDoc->p, Image);
        Invalidate();
	  }
    }
	else 
	{
      CPoint p, v;

      Image.hScaleX *= 2;
	  Image.hScaleY = Image.hScaleX;

	  SetScrollSizes(MM_TEXT, CSize(SIZEX*Image.hScaleX, SIZEY*Image.hScaleY));

	  p = GetScrollPosition();

	  v.x = p.x*2 + point.x;
	  v.y = p.y*2 + point.y;

	  ScrollToPosition(v);
	  
      Image.hScale = false;
      Invalidate();
	}

	CView::OnLButtonDown(nFlags, point);

}

void CCH_KSView::OnShowText()
{
	CCH_KSDoc* pDoc = GetDocument();
	Image.hNumbers = !Image.hNumbers;

	if (!Image.hInStepMode)
	  MyUpdate(pDoc->p, Image);
	else
	{
      Image.ClearImage();
	  Image.Update(pDoc->p);
      if(Image.fr && !Image.nc) Image.nc=Image.anc;       
//	  Diag.DiagrammaVoronogo(pDoc->p, Image);
	}
	
	Invalidate();
}

void CCH_KSView::OnUpdateShowText(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(Image.hPoints && !Image.hInStepMode && !Image.hScale);
    pCmdUI->SetCheck(Image.hNumbers);
}

void CCH_KSView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	int Pos, Scroll;
	
	Scroll = GetScrollPos(SB_HORZ);

	switch (nSBCode)
	{
		case SB_RIGHT:
          Pos = SIZEX*Image.hScaleX;
		  break;
		
		case SB_ENDSCROLL:
		  Pos = Scroll;
		  break;

		case SB_LINERIGHT:
		  Pos = 10*Image.hScaleX + Scroll;
		  break;

		case SB_LINELEFT:
		  Pos = -10*Image.hScaleX + Scroll;
		  break;

		case SB_PAGERIGHT:
		  Pos = 100*Image.hScaleX + Scroll;
		  break;

		case SB_PAGELEFT:
		  Pos = -100*Image.hScaleX + Scroll;
		  break;

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

		case SB_LEFT:
		  Pos = 0;
		  break;
	}


	ScrollToPosition(CPoint(Pos, GetScrollPos(SB_VERT)));
	
	CView::OnHScroll(nSBCode, nPos, pScrollBar);
}

void CCH_KSView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{ 
	int Pos, Scroll;
	
	Scroll = GetScrollPos(SB_VERT);

	switch (nSBCode)
	{
		case SB_BOTTOM:
          Pos = SIZEY*Image.hScaleY;
		  break;
		
		case SB_ENDSCROLL:
		  Pos = Scroll;
		  break;

		case SB_LINEDOWN:
		  Pos = 10*Image.hScaleY + Scroll;
		  break;

		case SB_LINEUP:
		  Pos = -10*Image.hScaleY + Scroll;
		  break;

		case SB_PAGEDOWN:
		  Pos = 100*Image.hScaleY + Scroll;
		  break;

		case SB_PAGEUP:
		  Pos = -100*Image.hScaleY + Scroll;
		  break;

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

		case SB_TOP:
		  Pos = 0;
		  break;
	}


	ScrollToPosition(CPoint(GetScrollPos(SB_HORZ), Pos));
	
	CView::OnVScroll(nSBCode, nPos, pScrollBar);
}

void CCH_KSView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
{
	SetScrollSizes(MM_TEXT, CSize(((float)SIZEX)*Image.hScaleX, ((float)SIZEY)*Image.hScaleY));
	ScrollToPosition(CPoint(GetScrollPos(SB_HORZ), gr_y/2));
    MyUpdate(GetDocument()->p, Image);
}

void CCH_KSView::OnZoomIn() 
{    
	if (!Image.hBestFit) {

	  if (!Image.hScale) {
      //Image.hScaleX *= 2;
	  //Image.hScaleY = Image.hScaleX;

        Image.hScale = true;
	  }
	  else
	    OnZoomOut();
	}
	else
	{
	  SetScrollSizes(MM_TEXT, CSize(((float)SIZEX)*Image.hScaleX, ((float)SIZEY)*Image.hScaleY));
	  Image.hBestFit = false;
	}
}

void CCH_KSView::OnZoomOut() 
{
	if (!Image.hBestFit) {

      if (!Image.hScale) {
	    Image.hScaleX /= 2;
	    Image.hScaleY = Image.hScaleX;
      }

      Image.hScale = false;
	  SetScrollSizes(MM_TEXT, CSize(SIZEX*Image.hScaleX, SIZEY*Image.hScaleY));
	  CPoint p = GetScrollPosition();
	  p.x = (p.x / 2);
	  p.y = (p.y / 2);
	  ScrollToPosition(p);
	  Invalidate();
	}
}

void CCH_KSView::OnUpdateZoomOut(CCmdUI* pCmdUI) 
{
	if (Image.hScaleX <= 1.0 || Image.hBestFit)
	 pCmdUI->Enable(FALSE);
	else
	 pCmdUI->Enable(TRUE);
}

void CCH_KSView::OnUpdateZoomIn(CCmdUI* pCmdUI) 
{
    if (Image.hScaleX >= 16.0)
	  if (!Image.hBestFit)
	    pCmdUI->Enable(FALSE);
	  else 
	    pCmdUI->Enable(TRUE);

    pCmdUI->SetCheck(Image.hScale);
}

void CCH_KSView::OnEditCopy() 
{
	CClientDC dc(this);
	CBitmap hBmp;
	CDC hMemDC;
	CRect hRect;

	GetClientRect(&hRect);
	hMemDC.CreateCompatibleDC(&dc);
	hBmp.CreateCompatibleBitmap(&dc, hRect.right, hRect.bottom);
	hMemDC.SelectObject(&hBmp);
	hMemDC.BitBlt(0, 0, hRect.right, hRect.bottom, &dc, 0, 0, SRCCOPY);
    
	if (OpenClipboard()) {
	  EmptyClipboard();
      SetClipboardData(CF_BITMAP, hBmp);
      CloseClipboard();
	}

    CCH_KSDoc::t = GetDocument()->p;
}

void CCH_KSView::OnEditCut()
{
    OnEditCopy();
	GetDocument()->p.Resize(0);
	Image.ClearImage();
	Invalidate();
}

void CCH_KSView::OnEditPaste()
{
	if (CCH_KSDoc::t.N()) {
	  CCH_KSDoc* pDoc = GetDocument();
	  
	  for (int i = 0; i < CCH_KSDoc::t.N(); i++)
		 pDoc->p.Add(CCH_KSDoc::t[i].x, CCH_KSDoc::t[i].y);

	  MyUpdate(pDoc->p, Image);
	  Invalidate();
	}
}

void CCH_KSView::OnShowDiag()
{
    Image.hDiagram=!Image.hDiagram;
	Image.hCHP=false;

	MyUpdate(GetDocument()->p, Image);
		
    Invalidate();
}

void CCH_KSView::OnUpdateShowDiag(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!Image.hInStepMode && !Image.hScale);
	pCmdUI->SetCheck(Image.hDiagram);	
}

void CCH_KSView::OnSaveText() 
{
  	CCH_KSDoc* pDoc = GetDocument();
	CFileDialog OpenFileDlg(0);

	CString Template("Text files (*.txt)"); 
	
	Template += (TCHAR) NULL;
	Template += "*.txt";
	Template += (TCHAR) NULL;
	Template += "All files (*.*)"; 
	Template += (TCHAR) NULL;
	Template += "*.*";
	Template += (TCHAR) NULL;
	
	OpenFileDlg.m_ofn.lpstrFilter = Template;
	//OpenFileDlg.m_ofn.lpstrFile = fn;
	OpenFileDlg.m_ofn.lpstrInitialDir = NULL;
	
    if (OpenFileDlg.DoModal() == IDOK) {
      CString sFileName = OpenFileDlg.GetPathName();
      ofstream fstr(sFileName, ios::out, ios::trunc);

      fstr << pDoc->p.N() << '\n';
	  for (int i = 0; i < pDoc->p.N(); i++)
	     fstr << pDoc->p[i].x << ' ' << pDoc->p[i].y << '\n';

	  fstr.close();
    }
}

void CCH_KSView::OnOpenText() 
{
  	CCH_KSDoc* pDoc = GetDocument();
	CFileDialog OpenFileDlg(1);

	CString Template("Text files (*.txt)"); 
	
	Template += (TCHAR) NULL;
	Template += "*.txt";
	Template += (TCHAR) NULL;
	Template += "All files (*.*)"; 
	Template += (TCHAR) NULL;
	Template += "*.*";
	Template += (TCHAR) NULL;
	
	OpenFileDlg.m_ofn.Flags |= OFN_FILEMUSTEXIST;
	OpenFileDlg.m_ofn.lpstrFilter = Template;
	OpenFileDlg.m_ofn.lpstrInitialDir = NULL;
    if (OpenFileDlg.DoModal() == IDOK) {

	  CString sFileName = OpenFileDlg.GetPathName();
      ifstream fstr(sFileName, ios::in, filebuf::sh_read);
      int sz;
      fstr >> sz;
      int old = pDoc->p.N();
      BOOL b_Resize = false;

      if (sz <= MAXPT - old && sz > 0) {

	    pDoc->p.Resize(old + sz);
        Tcoord x, y;
        int k = 0;
	
        for (int i = 0; i < sz; i++)	{

		  fstr >> x;
		  fstr >> y;

          if (!pDoc->p.Check(TMyPoint(x, y), old+k) && x < SIZEX && y < SIZEY) {
            pDoc->p[old+k].x = x;
            pDoc->p[old+k].y = y;
            k++;
          }
          else
            b_Resize = true;
        }

        if (b_Resize)
          pDoc->p.Resize(old+k);

          MyUpdate(pDoc->p, Image);
          Invalidate();

          CString s; 
          s.Format("%d points of %d was added.", k, sz);
          MessageBox(s);
      }
      else
        MessageBox("Can't import data in current document.");

	fstr.close();
   }
}

void CCH_KSView::OnPointsAdd()
{
  CCH_KSDoc* pDoc = GetDocument();  
  Add dlg;

  while (pDoc->p.N() < MAXPT && dlg.DoModal() == IDADD) {
    pDoc->p.Add(dlg.m_x, dlg.m_y);
    MyUpdate(pDoc->p, Image);
	Invalidate();
  }
}

void CCH_KSView::OnPointsDel() 
{
  CCH_KSDoc* pDoc = GetDocument();
  Delete dlg;
  dlg.p = &pDoc->p;

  while (pDoc->p.N() && dlg.DoModal() != IDCANCEL) {
    MyUpdate(pDoc->p, Image);
    Invalidate();
  }
  Image.hKnow = false;
}

void CCH_KSView::OnStepByStep() 
{
  Step dlg;

  dlg.Img = &Image;
  dlg.m_delay = Image.hDelay;

  if (dlg.DoModal() == IDOK) {
    Image.hDelay = dlg.m_delay;

    CString temp;

    temp.Format("%d", Image.hDelay);
       WritePrivateProfileString("Settings", "Delay", temp, ini_file);
  }
}

void CCH_KSView::OnPointsEdt() 
{
  CCH_KSDoc* pDoc = GetDocument();
  Edit dlg;
  dlg.p = &pDoc->p;

  while (dlg.DoModal() != IDCANCEL) {
    MyUpdate(pDoc->p, Image);
    Invalidate();
  }
}

void CCH_KSView::OnPointsRnd() 
{
  CCH_KSDoc* pDoc = GetDocument();
  Random dlg;

  dlg.m_n = pDoc->p.N();
  if (MAXPT - dlg.m_n > 0 && dlg.DoModal() == IDOK) {
    
	srand((unsigned) time(NULL));

	int old = pDoc->p.N();

    int x, y;

    pDoc->p.Resize(old + dlg.m_amount);

    int k = 0;

    for (long i = 0; k < dlg.m_amount && i < 50000; i++) {

	   x = (rand() % dlg.m_sizex) + dlg.m_left;
       y = (rand() % dlg.m_sizey) + dlg.m_upper;
           
       if (!pDoc->p.Check(TMyPoint(x, y), old+k)) {
	     pDoc->p[old+k].x = x;
         pDoc->p[old+k].y = y;
         k++;
       }
    }

    if (k < dlg.m_amount)
      pDoc->p.Resize(old+k);

    MyUpdate(pDoc->p, Image);
    Invalidate();
  }
}

void CCH_KSView::OnBestFit()
{
  if (!Image.hBestFit) {
    Image.hBestFit = true;
	SetScaleToFitSize(CSize(((float)SIZEX)*Image.hScaleX, ((float)SIZEY)*Image.hScaleY));
  }
}

void CCH_KSView::OnStepByStepToolbar() 
{
   CCH_KSDoc* pDoc = GetDocument();
   tpoint *Ar;

   if(!Image.hKnow)
   {
	Image.hStepOn=true;
	Image.hInStepMode=true;
	Image.all_step=0;
	Image.cal_step=0;
    if (pDoc->p.N()>1) 
	 {
      Ar=ReadMas(pDoc->p);
	  qsort((void *)Ar, all_el, sizeof(tpoint), sort_points);
	  CH_all(Ar,all_el-1,Image);
	 }
	Image.hKnow=true;
   }
   
   if (Image.cal_step<Image.all_step)
   {
	Image.hInStepMode=true;
	Image.ClearImage();
	Image.Update(pDoc->p);
	Image.cal_step++;
	Image.cur_step=0;
	Image.hStepOn=true;
	Ar=ReadMas(pDoc->p);
	qsort((void *)Ar, all_el, sizeof(tpoint), sort_points);
	CH_all(Ar,all_el-1,Image);
	Invalidate();  
   }   
}

void CCH_KSView::OnInitialUpdate() 
{
	 CClientDC dc(this);
	 Image.Initialize(&dc);

     char *p;
     GetModuleFileName(AfxGetApp()->m_hInstance, ini_file, sizeof(ini_file));
     p=ini_file+lstrlen(ini_file);
     while (p >= ini_file && *p != '\\') p--;
     if (++p >= ini_file) *p = 0;
     lstrcat(ini_file,"CH_KS.ini");
  
     Image.hConvex = GetPrivateProfileInt("Settings", "Convex", 0, ini_file);
     Image.hBridges = GetPrivateProfileInt("Settings", "Bridges", 0, ini_file);
     Image.hDiagramStep = GetPrivateProfileInt("Settings", "Diagram", 0, ini_file);
     Image.hDiagramUnion = GetPrivateProfileInt("Settings", "Union", 0, ini_file);
     Image.hDividingChain = GetPrivateProfileInt("Settings", "Chain", 0, ini_file);
     Image.hDividingChainStep = GetPrivateProfileInt("Settings", "ChainStep", 0, ini_file);
     Image.hDelay = GetPrivateProfileInt("Settings", "Delay", 1, ini_file);

	 lhCursor = AfxGetApp()->LoadCursor(IDC_ZOOMIN);

	 CScrollView::OnInitialUpdate();	 
}

void CCH_KSView::OnSize(UINT nType, int cx, int cy) 
{
	CScrollView::OnSize(nType, cx, cy);
}

void CCH_KSView::OnStop() 
{
    Image.ns = 0;
	Image.nc = 0;
	Image.hInStepMode = false;
	Image.cal_step=0;
    if (Image.hInDemoMode) {
      Image.hInDemoMode = false;
      
	  if (Image.hForwardDemo) {
        KillTimer(1);
        Image.hForwardDemo = false;
      }
      
      if (Image.hBackDemo) {
        KillTimer(2);
        Image.hBackDemo = false;
      }

    }

	MyUpdate(GetDocument()->p, Image);

	Invalidate();
}

void CCH_KSView::OnUpdateStop(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(Image.hInStepMode);
}

void CCH_KSView::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (Image.hScale)
	  SetCursor(lhCursor);

    if (!Image.hBestFit) {
      point += GetScrollPosition();
	  point.x /= Image.hScaleX;
	  point.y /= Image.hScaleY;
    }
    else
    {
      CRect r;
      GetClientRect(&r);
      point.x *= (float) SIZEX/r.right;
      point.y *= (float) SIZEY/r.bottom;
    }

	x.Format("X:%d", point.x);
	y.Format("Y:%d", gr_y-point.y);

	CScrollView::OnMouseMove(nFlags, point);
}

void CCH_KSView::OnUpdateIndicatorCHP(CCmdUI *pCmdUI)
{
    CString schp;
	schp.Format("CHP: %d",Image.chp);
	pCmdUI->Enable(Image.hCHP);
	pCmdUI->SetText(schp);
}

void CCH_KSView::OnUpdateIndicatorX(CCmdUI *pCmdUI)
{
    pCmdUI->Enable(TRUE);
	pCmdUI->SetText(x);
}

void CCH_KSView::OnUpdateIndicatorY(CCmdUI *pCmdUI)
{
    pCmdUI->Enable(TRUE);
	pCmdUI->SetText(y);
}

BOOL CCH_KSView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	pt += GetScrollPosition();

	pt.x /= Image.hScaleX;
	pt.y /= Image.hScaleY;

	x.Format("X:%d", pt.x);
	y.Format("Y:%d", pt.y);

	return CScrollView::OnMouseWheel(nFlags, zDelta, pt);
}

void CCH_KSView::OnPointsDelete() 
{
	CCH_KSDoc* pDoc = GetDocument();
	pDoc->p.Resize(0);
	Image.hKnow = false;
	MyUpdate(pDoc->p, Image);
	Invalidate();
}

void CCH_KSView::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!Image.hDiagram && CCH_KSDoc::t.N() && !Image.hInStepMode && !Image.hScale);
}

void CCH_KSView::OnUpdatePointsDelete(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Image.hDiagram && GetDocument()->p.N() && !Image.hInStepMode && !Image.hScale);
}

void CCH_KSView::OnOneToOne() 
{
    Image.hScaleX = 1.0;
    Image.hScaleY = 1.0;
 
    if (!Image.hBestFit) {
	  SetScrollSizes(MM_TEXT, CSize(SIZEX, SIZEY));
	  ScrollToPosition(CPoint(0, 0));
	  //MyUpdate(GetDocument()->p, Image);
	  Invalidate();
	}
	else
	{
      SetScrollSizes(MM_TEXT, CSize(((float)SIZEX)*Image.hScaleX, ((float)SIZEY)*Image.hScaleY));
      Image.hBestFit = false;
	}
}

void CCH_KSView::OnUpdateOneToOne(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable((Image.hScaleX != 1.0 && !Image.hScale) || Image.hBestFit);
}

void CCH_KSView::OnUpdateIndicatorScale(CCmdUI* pCmdUI)
{
    CString Scale;
	if (!Image.hBestFit)
	  Scale.Format("x%f", Image.hScaleX);
	else
	  Scale = "All";

	pCmdUI->Enable(TRUE);

    if (!Image.hScale)
	  pCmdUI->SetText(Scale);
}

void CCH_KSView::OnUpdateIndicatorSpace(CCmdUI* pCmdUI)
{
    CString Space;
	Space.Format("%dx%d", SIZEX, SIZEY);
	pCmdUI->Enable(TRUE);
    pCmdUI->SetText(Space);
}

void CCH_KSView::OnUpdateMenuPoints(CCmdUI* pCmdUI)
{
    pCmdUI->Enable(!Image.hInStepMode && GetDocument()->p.N() < MAXPT);
}

void CCH_KSView::OnUpdateMenuPointsDeleteEdit(CCmdUI* pCmdUI)
{
    pCmdUI->Enable(!Image.hInStepMode && GetDocument()->p.N());
}

void CCH_KSView::OnUpdateMenuPointsAdd(CCmdUI* pCmdUI)
{
    pCmdUI->Enable(!Image.hInStepMode && GetDocument()->p.N() < MAXPT);
}

void CCH_KSView::OnUpdateEditCut(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Image.hDiagram && !Image.hInStepMode && !Image.hScale);
}

void CCH_KSView::OnUpdateRewind(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!Image.hInDemoMode && !Image.hScale);
}

void CCH_KSView::OnDemo() 
{
    Image.hInDemoMode = true;
    Image.hForwardDemo = true;
    UpdateWindow();
    SetTimer(1, Image.hDelay*1000, 0);
    //Image.hIsPaused = false;
    OnStepByStepToolbar();
}

void CCH_KSView::OnTimer(UINT nIDEvent)
{
    if (nIDEvent == 1)
      OnStepByStepToolbar();
    else
      OnRewind();

	CScrollView::OnTimer(nIDEvent);
}

void CCH_KSView::OnUpdateDemo(CCmdUI* pCmdUI) 
{
    //pCmdUI->Enable(!Image.hInDemoMode && GetDocument()->p.N() <= 1000 && !Image.hScale);
	pCmdUI->Enable(!Image.hInDemoMode && !Image.hScale);
}

void CCH_KSView::OnRewind() 
{
 CCH_KSDoc* pDoc = GetDocument();
   tpoint *Ar;
   if(!Image.hKnow)
   {
	Image.hStepOn=true;
	Image.hInStepMode=true;
	Image.all_step=0;
	Image.cal_step=0;
    if (pDoc->p.N()>1) 
	 {
      Ar=ReadMas(pDoc->p);
	  qsort((void *)Ar, all_el, sizeof(tpoint), sort_points);
	  CH_all(Ar,all_el-1,Image);
	 }
	Image.hKnow=true;
   }
   
   if (1<Image.cal_step)
   {
	Image.hInStepMode=true;
	Image.ClearImage();
    Image.Update(pDoc->p);
	Image.cal_step--;
	Image.cur_step=0;
	Image.hStepOn=true;
	Ar=ReadMas(pDoc->p);
	qsort((void *)Ar, all_el, sizeof(tpoint), sort_points);
	CH_all(Ar,all_el-1,Image);
	Invalidate();  
   } 
}

void CCH_KSView::OnUpdateBestFit(CCmdUI* pCmdUI) 
{
     pCmdUI->Enable(!Image.hBestFit && !Image.hScale);	
}

void CCH_KSView::OnShowPoints() 
{
    Image.hPoints = !Image.hPoints;
    MyUpdate(GetDocument()->p, Image);
    Invalidate();
}

void CCH_KSView::OnUpdateShowPoints(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!Image.hInStepMode && !Image.hScale);
    pCmdUI->SetCheck(Image.hPoints);	
}

void CCH_KSView::OnPause() 
{
    if (Image.hForwardDemo) {
      KillTimer(1);
      Image.hForwardDemo = false;
    }

    if (Image.hBackDemo) {
      KillTimer(2);
      Image.hBackDemo = false;
    }

    Image.hInDemoMode = false;
    //Image.hIsPaused = true;
}

void CCH_KSView::OnUpdatePause(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(Image.hInDemoMode/* && !Image.hIsPaused*/);
}

void CCH_KSView::OnUpdateStepByStepToolbar(CCmdUI* pCmdUI) 
{
    pCmdUI->Enable(!Image.hInDemoMode && !Image.hScale);	
}

void CCH_KSView::OnBack() 
{
    Image.hInDemoMode = true;
    Image.hBackDemo = true;
    SetTimer(2, Image.hDelay*1000, 0);
    //Image.hIsPaused = false;

    OnRewind();
}

void CCH_KSView::OnUpdateBack(CCmdUI* pCmdUI) 
{
//	pCmdUI->Enable(!Image.hInDemoMode && GetDocument()->p.N() <= 1000 && !Image.hScale);
	pCmdUI->Enable(!Image.hInDemoMode && !Image.hScale);
}

void CCH_KSView::OnUpdateOpenText(CCmdUI* pCmdUI) 
{
  	pCmdUI->Enable(!Image.hInStepMode && GetDocument()->p.N() < MAXPT && !Image.hScale);
}