rimshotview.cpp

fortran并行计算包

	RLOG_GetNextGlobalEvent(pDoc->m_pInput, &event2);
    pDoc->m_dLeft = event2.start_time - (3.0 * d);
    pDoc->m_dRight = event2.start_time + (3.0 * d);
    StartDrawing();
}

void CRimshotView::OnPrevious() 
{
    double d;
    RLOG_EVENT event;
    CRimshotDoc* pDoc = GetDocument();

    StopDrawing();
    d = (pDoc->m_dRight - pDoc->m_dLeft) / 6.0;
    RLOG_FindGlobalEventBeforeTimestamp(pDoc->m_pInput, (pDoc->m_dLeft + pDoc->m_dRight) / 2.0 - d, &event);
    pDoc->m_dLeft = event.start_time - (3.0 * d);
    pDoc->m_dRight = event.start_time + (3.0 * d);
    StartDrawing();
}

void CRimshotView::OnResetZoom() 
{
    CRimshotDoc* pDoc = GetDocument();
    StopDrawing();
    pDoc->m_dLeft = pDoc->m_dFirst;
    pDoc->m_dRight = pDoc->m_dLast;
    StartDrawing();
}

void CRimshotView::OnZoomIn() 
{
    double d;
    CRimshotDoc* pDoc = GetDocument();

    StopDrawing();
    d = (pDoc->m_dRight - pDoc->m_dLeft) / 4.0;
    pDoc->m_dLeft += d;
    pDoc->m_dRight -= d;
    StartDrawing();
}

void CRimshotView::OnZoomOut() 
{
    double d;
    CRimshotDoc* pDoc = GetDocument();

    StopDrawing();
    d = (pDoc->m_dRight - pDoc->m_dLeft) / 2.0;
    pDoc->m_dLeft -= d;
    pDoc->m_dRight += d;
    StartDrawing();
}

void CRimshotView::OnZoomTo() 
{
    CRect rect;
    RLOG_EVENT event;
    CRimshotDoc* pDoc = GetDocument();
    double width;

    if (pDoc->m_pInput)
    {
	StopDrawing();
	RLOG_GetCurrentGlobalEvent(pDoc->m_pInput, &event);
	GetClientRect(&rect);
	width = event.end_time - event.start_time;
	pDoc->m_dLeft = event.start_time - (10.0 * width);
	pDoc->m_dRight = event.start_time + (10.0 * width);
	StartDrawing();
    }
}

void CRimshotView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    RLOG_EVENT event;
    double d;
    CRimshotDoc* pDoc = GetDocument();

    if (pDoc->m_pInput)
    {
	switch (nChar)
	{
	case VK_RIGHT:
	    if (RLOG_GetNextGlobalEvent(pDoc->m_pInput, &event) == 0)
	    {
		while (!m_Draw.pCursorRanks[event.rank].active)
		{
		    if (RLOG_GetNextGlobalEvent(pDoc->m_pInput, &event) != 0)
			break;
		}
		StopDrawing();
		d = (pDoc->m_dRight - pDoc->m_dLeft) / 2;
		pDoc->m_dLeft = event.start_time - d;
		pDoc->m_dRight = event.start_time + d;
		StartDrawing();
	    }
	    break;
	case VK_LEFT:
	    if (RLOG_GetPreviousGlobalEvent(pDoc->m_pInput, &event) == 0)
	    {
		while (!m_Draw.pCursorRanks[event.rank].active)
		{
		    if (RLOG_GetPreviousGlobalEvent(pDoc->m_pInput, &event) != 0)
			break;
		}
		StopDrawing();
		d = (pDoc->m_dRight - pDoc->m_dLeft) / 2;
		pDoc->m_dLeft = event.start_time - d;
		pDoc->m_dRight = event.start_time + d;
		StartDrawing();
	    }
	    break;
	default:
	    break;
	}
    }

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

void CRimshotView::OnSize(UINT nType, int cx, int cy) 
{
    CView::OnSize(nType, cx, cy);

    if (m_Draw.pCanvas != NULL)
    {
	// stop any current drawing
	StopDrawing();

	if (m_Draw.max_rect_size.cx < cx || m_Draw.max_rect_size.cy < cy)
	{
	    m_Draw.max_rect_size.cx = max(m_Draw.max_rect_size.cx, cx);
	    m_Draw.max_rect_size.cy = max(m_Draw.max_rect_size.cy, cy);
	    // create a new resized canvas bitmap
	    CBitmap *pBmp = new CBitmap();
	    pBmp->CreateDiscardableBitmap(GetDC(), m_Draw.max_rect_size.cx, m_Draw.max_rect_size.cy);
	    
	    if (m_Draw.pBitmap)
	    {
		m_Draw.pCanvas->SelectObject(pBmp);
		delete m_Draw.pBitmap;
		m_Draw.pBitmap = pBmp;
	    }
	    else
	    {
		m_Draw.pOriginalBmp = m_Draw.pCanvas->SelectObject(pBmp);
		m_Draw.pBitmap = pBmp;
	    }
	}
	m_Draw.rect_size.cx = cx;
	m_Draw.rect_size.cy = cy;

	// create the copy bitmap if this is the first size event
	if (m_Draw.pCopyBitmap == NULL)
	{
	    CBitmap *pBmpCopy = new CBitmap();
	    pBmpCopy->CreateDiscardableBitmap(GetDC(), cx, cy);

	    m_Draw.pCopyOriginalBmp = m_Draw.pCopyCanvas->SelectObject(pBmpCopy);
	    m_Draw.pCopyBitmap = pBmpCopy;
	    m_Draw.copy_size.cx = cx;
	    m_Draw.copy_size.cy = cy;
	    m_Draw.max_copy_size.cx = cx;
	    m_Draw.max_copy_size.cy = cy;
	}

	// start redrawing
	StartDrawing();
    }
}

void CRimshotView::OnInitialUpdate() 
{
    DWORD dwThreadID;
    CRimshotDoc* pDoc = GetDocument();
    CView::OnInitialUpdate();

    m_Draw.pCanvas = new CDC();
    m_Draw.pCanvas->CreateCompatibleDC(GetDC());
    m_Draw.pCanvas->SetStretchBltMode(COLORONCOLOR);
    m_Draw.pCopyCanvas = new CDC();
    m_Draw.pCopyCanvas->CreateCompatibleDC(GetDC());
    m_Draw.pCopyCanvas->SetStretchBltMode(COLORONCOLOR);
    m_Draw.hWnd = m_hWnd;
    m_Draw.pDoc = pDoc;
    m_Draw.hDrawEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
    m_Draw.hStoppedEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
    m_Draw.hMutex = CreateMutex(NULL, FALSE, NULL);
    m_Draw.bStop = false;
    m_Draw.nCmd = -1;
    m_Draw.bDrawArrows = true;
    m_hDrawThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)RimshotDrawThread, &m_Draw, 0, &dwThreadID);
}

BOOL CRimshotView::DestroyWindow() 
{
    StopDrawing();
    m_Draw.nCmd = EXIT_CMD;
    SetEvent(m_Draw.hDrawEvent);
    WaitForSingleObject(m_hDrawThread, 10000);
    CloseHandle(m_Draw.hDrawEvent);
    CloseHandle(m_Draw.hStoppedEvent);
    CloseHandle(m_hDrawThread);

    if (m_Draw.pCanvas)
    {
	if (m_Draw.pBitmap)
	{
	    // select out the bitmap
	    m_Draw.pCanvas->SelectObject(m_Draw.pOriginalBmp);
	}
	delete m_Draw.pCanvas;
	m_Draw.pCanvas = NULL;
    }
    if (m_Draw.pBitmap)
    {
	delete m_Draw.pBitmap;
	m_Draw.pBitmap = NULL;
    }

    if (m_Draw.pCopyCanvas)
    {
	if (m_Draw.pCopyBitmap)
	{
	    m_Draw.pCopyCanvas->SelectObject(m_Draw.pCopyOriginalBmp);
	}
	delete m_Draw.pCopyCanvas;
	m_Draw.pCopyCanvas = NULL;
    }
    if (m_Draw.pCopyBitmap)
    {
	delete m_Draw.pCopyBitmap;
	m_Draw.pCopyBitmap = NULL;
    }

    return CView::DestroyWindow();
}

LRESULT CRimshotView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
{
    CRect rect;
    CBitmap *pBmp;

    switch (message)
    {
    case DRAW_COMPLETE_MSG:
	GetClientRect(&rect);
	if (m_Draw.max_copy_size.cx < rect.Width() || m_Draw.max_copy_size.cy < rect.Height())
	{
	    m_Draw.max_copy_size.cx = max(m_Draw.max_copy_size.cx, rect.Width());
	    m_Draw.max_copy_size.cy = max(m_Draw.max_copy_size.cy, rect.Height());
	    pBmp = new CBitmap();
	    pBmp->CreateDiscardableBitmap(GetDC(), m_Draw.max_copy_size.cx, m_Draw.max_copy_size.cy);
	    m_Draw.pCopyCanvas->SelectObject(pBmp);
	    delete m_Draw.pCopyBitmap;
	    m_Draw.pCopyBitmap = pBmp;
	}
	m_Draw.copy_size.cx = rect.Width();
	m_Draw.copy_size.cy = rect.Height();
	if (WaitForSingleObject(m_Draw.hMutex, 2000) == WAIT_OBJECT_0)
	{
	    m_Draw.pCopyCanvas->BitBlt(0, 0, rect.Width(), rect.Height(), m_Draw.pCanvas, 0, 0, SRCCOPY);
	    ReleaseMutex(m_Draw.hMutex);
	}
	Invalidate(FALSE);
	break;
    }
    return CView::WindowProc(message, wParam, lParam);
}

void CRimshotView::StopDrawing()
{
    m_Draw.bStop = true;
    WaitForSingleObject(m_Draw.hStoppedEvent, 10000);
    m_Draw.bStop = false;
    ResetEvent(m_Draw.hStoppedEvent);
}

void CRimshotView::StartDrawing()
{
    m_Draw.nCmd = REDRAW_CMD;
    SetEvent(m_Draw.hDrawEvent);
    Invalidate(FALSE);
}

BOOL CRimshotView::OnEraseBkgnd(CDC* pDC) 
{
    return TRUE;
}

void CRimshotView::OnToggleArrows() 
{
    StopDrawing();
    m_Draw.bDrawArrows = !m_Draw.bDrawArrows;
    StartDrawing();
}

#define PointInside(point, rect) (point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom)

void CRimshotView::OnLButtonDown(UINT nFlags, CPoint point) 
{
    bool bHit = false;
    CRimshotDoc* pDoc = GetDocument();
    if (pDoc->m_pInput)
    {
	for (int i=0; i<pDoc->m_pInput->nNumRanks; i++)
	{
	    if (PointInside(point, m_Draw.pCursorRanks[i].rect))
	    {
		m_Draw.pCursorRanks[i].active = !m_Draw.pCursorRanks[i].active;
		//InvalidateRect(&m_Draw.pCursorRanks[i].rect);
		bHit = true;
	    }
	}
    }
    if (bHit)
    {
	StopDrawing();
	StartDrawing();
    }
    CView::OnLButtonDown(nFlags, point);
}

void CRimshotView::OnViewUniform() 
{
    CMenu *pMenu = GetParentFrame()->GetMenu();

    m_Draw.bDrawUniform = !m_Draw.bDrawUniform;

    if (pMenu)
	pMenu->CheckMenuItem(ID_VIEW_UNIFORM, MF_BYCOMMAND | m_Draw.bDrawUniform ? MF_CHECKED : MF_UNCHECKED);
    StopDrawing();
    StartDrawing();
}

void CRimshotView::OnViewZoom() 
{
    CRimshotDoc* pDoc = GetDocument();
    if (pDoc->m_pInput)
    {
	CZoomDlg dlg;
	CRect rect;
	
	GetClientRect(&rect);
	dlg.m_dLeft = pDoc->m_dLeft;
	dlg.m_dRight = pDoc->m_dRight;
	dlg.m_dWidth = pDoc->m_dRight - pDoc->m_dLeft;
	dlg.m_dPerPixel = dlg.m_dWidth / (double)rect.Width();

	if (dlg.DoModal() == IDOK)
	{
	    if (dlg.m_bLR)
	    {
		if (dlg.m_dLeft < dlg.m_dRight)
		{
		    RLOG_EVENT event;
		    pDoc->m_dLeft = dlg.m_dLeft;
		    pDoc->m_dRight = dlg.m_dRight;
		    RLOG_FindGlobalEventBeforeTimestamp(pDoc->m_pInput, (dlg.m_dLeft + dlg.m_dRight) / 2.0, &event);
		    StopDrawing();
		    StartDrawing();
		}
	    }
	    if (dlg.m_bWidth)
	    {
		if (dlg.m_dWidth > 0.0)
		{
		    double middle = (pDoc->m_dLeft + pDoc->m_dRight) / 2.0;
		    pDoc->m_dLeft = middle - (dlg.m_dWidth / 2.0);
		    pDoc->m_dRight = middle + (dlg.m_dWidth / 2.0);
		    StopDrawing();
		    StartDrawing();
		}
	    }
	    if (dlg.m_bPerPixel)
	    {
		dlg.m_dWidth = dlg.m_dPerPixel * (double)rect.Width();
		if (dlg.m_dWidth > 0.0)
		{
		    double middle = (pDoc->m_dLeft + pDoc->m_dRight) / 2.0;
		    pDoc->m_dLeft = middle - (dlg.m_dWidth / 2.0);
		    pDoc->m_dRight = middle + (dlg.m_dWidth / 2.0);
		    StopDrawing();
		    StartDrawing();
		}
	    }
	}
    }
}

void CRimshotView::OnSlideRankOffset() 
{
    CRimshotDoc* pDoc = GetDocument();
    if (pDoc->m_pInput)
    {
	COffsetDlg dlg;

	if (dlg.DoModal() == IDOK)
	{
	    if (dlg.m_row < pDoc->m_pInput->nNumRanks)
	    {
		if (dlg.m_bUseGUI)
		{
		    m_Draw.bSliding = true;
		    m_Draw.nSlidingRank = dlg.m_row;
		    // setup bitmap and stuff
		}
		else
		{
		    // do file offset stuff
		}
	    }
	}
    }
}