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::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 CRenderer::Polygon(PolygonVertices* _polygon, int color){
StartDrawing();
for(int i =0; i<_polygon->size()-1;i++){
Line(*((*_polygon)[i]),*((*_polygon)[i+1]), color);
}
Line(*((*_polygon)[_polygon->size()-1]), *((*_polygon)[0]), color);
StopDrawing();
}
void CRimshotView::OnResetZoom()
{
CRimshotDoc* pDoc = GetDocument();
StopDrawing();
pDoc->m_dLeft = pDoc->m_dFirst;
pDoc->m_dRight = pDoc->m_dLast;
StartDrawing();
}
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::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();
}
EDA_DRAW_PANEL_GAL::~EDA_DRAW_PANEL_GAL()
{
StopDrawing();
SaveGalSettings();
assert( !m_drawing );
delete m_painter;
delete m_viewControls;
delete m_view;
delete m_gal;
}
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::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::OnNext()
{
double d;
RLOG_EVENT event1, event2;
CRimshotDoc* pDoc = GetDocument();
StopDrawing();
d = (pDoc->m_dRight - pDoc->m_dLeft) / 6.0;
RLOG_GetCurrentGlobalEvent(pDoc->m_pInput, &event1);
RLOG_FindGlobalEventBeforeTimestamp(pDoc->m_pInput, (pDoc->m_dLeft + pDoc->m_dRight) / 2.0 + d, &event2);
if (event1.start_time == event2.start_time)
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::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 CRenderer::PolygonFilled(PolygonVertices* _polygon, int color) {
if (_polygon->size()<3) return;
StartDrawing();
float miny, maxy;
//Znajdujemy max i min na ykach
miny = maxy = ((*_polygon)[0])->y;
float temp_x1, temp_x2, temp_y1, temp_y2;
for (unsigned i=0;i<_polygon->size();i++){
temp_y1 = ((*_polygon)[i])->y;
if (miny > temp_y1) {miny = temp_y1;}
if (maxy < temp_y1) {maxy = temp_y1;}
}
//lista xów
int *xlist = new int[_polygon->size()];
unsigned xlistsize;
// dla kazdego yka na wys polygona
for (float y=miny;y<=maxy;y++) {
// szukamy przeciec linii
xlistsize = 0;
for (unsigned i=0;i<_polygon->size();i++) {
temp_y1 = ((*_polygon)[i])->y;
temp_y2 = ((*_polygon)[(i+1)%(_polygon->size())])->y;
if ((y>temp_y1 && y<=temp_y2) || (y>temp_y2 && y<=temp_y1)) {
temp_x1 = ((*_polygon)[i])->x;
temp_x2 = ((*_polygon)[(i+1)%(_polygon->size())])->x;
xlist[xlistsize++] = (int)( temp_x1 + (y-temp_y1)*(temp_x2-temp_x1)/(temp_y2-temp_y1) );
}
}
if (xlistsize==0) { continue; }
//sortujemy xy
std::sort(xlist,xlist+xlistsize);
//malujemy co drugie
for (int i=0;i<xlistsize;i+=2) {
for (int x=xlist[i];x<=xlist[i+1];x++) {
PutPixel(x,y,color);
}
}
}
delete[] xlist;
StopDrawing();
}
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();
}
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 EDA_DRAW_PANEL_GAL::SwitchBackend( GalType aGalType )
{
// Do not do anything if the currently used GAL is correct
if( aGalType == m_currentGal && m_gal != NULL )
return;
// Prevent refreshing canvas during backend switch
StopDrawing();
delete m_gal;
switch( aGalType )
{
case GAL_TYPE_OPENGL:
m_gal = new KIGFX::OPENGL_GAL( this, this, this );
break;
case GAL_TYPE_CAIRO:
m_gal = new KIGFX::CAIRO_GAL( this, this, this );
break;
case GAL_TYPE_NONE:
return;
}
wxSize size = GetClientSize();
m_gal->ResizeScreen( size.GetX(), size.GetY() );
if( m_painter )
m_painter->SetGAL( m_gal );
if( m_view )
m_view->SetGAL( m_gal );
m_currentGal = aGalType;
}
bool EDA_DRAW_PANEL_GAL::SwitchBackend( GAL_TYPE aGalType )
{
// Do not do anything if the currently used GAL is correct
if( aGalType == m_backend && m_gal != NULL )
return true;
bool result = true; // assume everything will be fine
// Prevent refreshing canvas during backend switch
StopDrawing();
KIGFX::GAL* new_gal = NULL;
try
{
switch( aGalType )
{
case GAL_TYPE_OPENGL:
new_gal = new KIGFX::OPENGL_GAL( this, this, this );
break;
case GAL_TYPE_CAIRO:
new_gal = new KIGFX::CAIRO_GAL( this, this, this );
break;
default:
assert( false );
// warn about unhandled GAL canvas type, but continue with the fallback option
case GAL_TYPE_NONE:
// KIGFX::GAL is a stub - it actually does cannot display anything,
// but prevents code relying on GAL canvas existence from crashing
new_gal = new KIGFX::GAL();
break;
}
}
catch( std::runtime_error& err )
{
new_gal = new KIGFX::GAL();
aGalType = GAL_TYPE_NONE;
DisplayError( m_parent, wxString( err.what() ) );
result = false;
}
SaveGalSettings();
assert( new_gal );
delete m_gal;
m_gal = new_gal;
wxSize size = GetClientSize();
m_gal->ResizeScreen( size.GetX(), size.GetY() );
if( m_painter )
m_painter->SetGAL( m_gal );
if( m_view )
m_view->SetGAL( m_gal );
m_backend = aGalType;
LoadGalSettings();
return result;
}
void CRimshotView::OnToggleArrows()
{
StopDrawing();
m_Draw.bDrawArrows = !m_Draw.bDrawArrows;
StartDrawing();
}
