/* Copyright (C) 2020 - 2024, Thornwave Labs Inc
* Written by Razvan Turiac <razvan.turiac@thornwave.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
* documentation files (the “Software”), to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
* Attribution shall be given to Thornwave Labs Inc. and shall be made visible to the final user.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <scope_display.h>
#include <algorithm>
#include <debug.h>
#include <math.h>
#include <wx/dcbuffer.h>
#include <wx/mstream.h>
#include <resources/img_arrow_left_png.cpp>
#include <resources/img_arrow_right_png.cpp>
#include <resources/img_arrow_up_png.cpp>
#include <resources/img_arrow_down_png.cpp>
#include <resources/img_arrow_left_double_png.cpp>
#include <resources/img_arrow_right_double_png.cpp>
#include <resources/img_plus_png.cpp>
#include <resources/img_minus_png.cpp>
#include <resources/img_home_png.cpp>
#define SCOPE_CONTROL_BORDER_SIZE FromDIP(10)
#define SCOPE_TOP_PANEL_HEIGHT FromDIP(50)
#define SCOPE_BOTTOM_PANEL_HEIGHT FromDIP(50)
#define SCOPE_LEFT_PANEL_WIDTH FromDIP(50)
#define SCOPE_LEFT_BORDER_SIZE FromDIP(20)
#define SCOPE_RIGHT_BORDER_SIZE FromDIP(20)
#define SCOPE_TOP_BORDER_SIZE FromDIP(25)
#define SCOPE_BOTTOM_BORDER_SIZE FromDIP(25)
#define SCOPE_VERTICAL_SCALE_WIDTH FromDIP(50)
#define GRID_SPACING FromDIP(60)
#define ARROW_BASE FromDIP(10)
#define ARROW_HEIGHT FromDIP(16)
//#define SCOPE_INTEGER_WAVEFORM_HEIGHT 20
//#define SCOPE_INTEGER_WAVEFORM_PITCH 50
BEGIN_EVENT_TABLE(ScopeDisplay, wxWindow)
EVT_KEY_DOWN(ScopeDisplay::OnKeyPressed)
EVT_KEY_UP(ScopeDisplay::OnKeyReleased)
END_EVENT_TABLE()
ScopeDisplay::ScopeDisplay(wxFrame* parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style): wxWindow(parent, id, pos, size, style | wxFULL_REPAINT_ON_RESIZE),
mListener(nullptr), mWaveRefresh(true)
{
mWaveColors.push_back(WaveColor(wxColour(255, 0, 0)));
mWaveColors.push_back(WaveColor(wxColour(255, 128, 0)));
mWaveColors.push_back(WaveColor(wxColour(0, 192, 0)));
mWaveColors.push_back(WaveColor(wxColour(0, 0, 255)));
mWaveColors.push_back(WaveColor(wxColour(0, 192, 192)));
mWaveColors.push_back(WaveColor(wxColour(192, 192, 0)));
mCursorsEnable = false;
mCursor1Dragging = false;
mCursor2Dragging = false;
SetBackgroundStyle(wxBG_STYLE_CUSTOM);
mGridColor = wxColour(192, 192, 192);
mScalesColor = wxColour(16, 128, 64);
mCursor1Color = wxColour(0, 0, 255);
mCursor2Color = wxColour(255, 0, 255);
//default time scales
mTimeScalesIndex = 0;
mTimeScales.push_back(1); //1us / div
mTimeResolution = mTimeScales[mTimeScalesIndex];
mMaxTime = 0;
mTimePosition = 0;
//default vertical scale
mVerticalScale = 1;
mVerticalScaleExponent = 0;
mVertPosition = 0;
mFontBig = wxFont(12, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
mFontMed = wxFont(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
mFontSmall = wxFont(8, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
mScalesFont = wxFont(6, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
//create panels
wxBoxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
SetSizer(main_sizer);
mTopPanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize/*(0, SCOPE_TOP_PANEL_HEIGHT)*/, wxFULL_REPAINT_ON_RESIZE);
main_sizer->Add(mTopPanel, 0, wxEXPAND);
wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
main_sizer->Add(sizer, 1, wxEXPAND);
mLeftPanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize/*(SCOPE_LEFT_PANEL_WIDTH, 0)*/, wxFULL_REPAINT_ON_RESIZE);
sizer->Add(mLeftPanel, 0, wxEXPAND);
mScopePanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);
mScopePanel->SetBackgroundStyle(wxBG_STYLE_PAINT);
sizer->Add(mScopePanel, 1, wxEXPAND);
mBottomPanel = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize/*(0, SCOPE_BOTTOM_PANEL_HEIGHT)*/, wxFULL_REPAINT_ON_RESIZE);
main_sizer->Add(mBottomPanel, 0, wxEXPAND);
//create buttons
mTimeScaleUpButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_SCALE_UP, wxBITMAP_PNG_FROM_DATA(img_plus), wxDefaultPosition, FromDIP(wxSize(60, 30)));
mTimeScaleDownButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_SCALE_DOWN, wxBITMAP_PNG_FROM_DATA(img_minus), wxDefaultPosition, FromDIP(wxSize(60, 30)));
mTimePosUpButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_POS_UP, wxBITMAP_PNG_FROM_DATA(img_arrow_right), wxDefaultPosition, FromDIP(wxSize(60, 30)));
mTimePosDownButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_POS_DOWN, wxBITMAP_PNG_FROM_DATA(img_arrow_left), wxDefaultPosition, FromDIP(wxSize(60, 30)));
mTimePosEndButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_POS_END, wxBITMAP_PNG_FROM_DATA(img_arrow_right_double), wxDefaultPosition, FromDIP(wxSize(40, 30)));
mTimePosHomeButton = new wxBitmapButton(mBottomPanel, ID_BUTTON_TIME_POS_HOME, wxBITMAP_PNG_FROM_DATA(img_arrow_left_double), wxDefaultPosition, FromDIP(wxSize(40, 30)));
mVertScaleUpButton = new wxBitmapButton(mLeftPanel, ID_BUTTON_VERT_SCALE_UP, wxBITMAP_PNG_FROM_DATA(img_plus), wxDefaultPosition, FromDIP(wxSize(30, 60)));
mVertScaleDownButton = new wxBitmapButton(mLeftPanel, ID_BUTTON_VERT_SCALE_DOWN, wxBITMAP_PNG_FROM_DATA(img_minus), wxDefaultPosition, FromDIP(wxSize(30, 60)));
mVertPosUpButton = new wxBitmapButton(mLeftPanel, ID_BUTTON_VERT_POS_UP, wxBITMAP_PNG_FROM_DATA(img_arrow_up), wxDefaultPosition, FromDIP(wxSize(30, 60)));
mVertPosDownButton = new wxBitmapButton(mLeftPanel, ID_BUTTON_VERT_POS_DOWN, wxBITMAP_PNG_FROM_DATA(img_arrow_down), wxDefaultPosition, FromDIP(wxSize(30, 60)));
mVertPosHomeButton = new wxBitmapButton(mLeftPanel, ID_BUTTON_VERT_POS_HOME, wxBITMAP_PNG_FROM_DATA(img_home), wxDefaultPosition, FromDIP(wxSize(30, 40)));
mClearScopeButton = new wxButton(mBottomPanel, ID_BUTTON_CLEAR_SCOPE, wxT("Clear"), wxDefaultPosition, FromDIP(wxSize(60, 30)));
mSaveImageButton = new wxButton(mBottomPanel, ID_BUTTON_SAVE_IMAGE, wxT("Save Image"), wxDefaultPosition, FromDIP(wxSize(120, 30)));
mCursorsButton = new wxToggleButton(mBottomPanel, ID_BUTTON_CURSORS, wxT("Cursors"), wxDefaultPosition, FromDIP(wxSize(80, 30)));
mSaveDataButton = new wxButton(mBottomPanel, ID_BUTTON_SAVE_DATA, wxT("Save Data"), wxDefaultPosition, FromDIP(wxSize(120, 30)));
mLoadDataButton = new wxButton(mBottomPanel, ID_BUTTON_LOAD_DATA, wxT("Load Data"), wxDefaultPosition, FromDIP(wxSize(120, 30)));
main_sizer = new wxBoxSizer(wxHORIZONTAL);
mBottomPanel->SetSizer(main_sizer);
main_sizer->Add(mTimeScaleDownButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mTimeScaleUpButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->AddSpacer(SCOPE_CONTROL_BORDER_SIZE * 4);
main_sizer->Add(mTimePosHomeButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mTimePosDownButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mTimePosUpButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mTimePosEndButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->AddStretchSpacer(1);
main_sizer->Add(mCursorsButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mClearScopeButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mSaveImageButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mLoadDataButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mSaveDataButton, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->SetSizeHints(mBottomPanel);
main_sizer = new wxBoxSizer(wxVERTICAL);
mLeftPanel->SetSizer(main_sizer);
main_sizer->Add(mVertScaleUpButton, 0, wxALL | wxALIGN_CENTER_HORIZONTAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mVertScaleDownButton, 0, wxALL | wxALIGN_CENTER_HORIZONTAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->AddSpacer(SCOPE_CONTROL_BORDER_SIZE * 4);
main_sizer->Add(mVertPosUpButton, 0, wxALL | wxALIGN_CENTER_HORIZONTAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mVertPosHomeButton, 0, wxALL | wxALIGN_CENTER_HORIZONTAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->Add(mVertPosDownButton, 0, wxALL | wxALIGN_CENTER_HORIZONTAL, SCOPE_CONTROL_BORDER_SIZE);
main_sizer->SetSizeHints(mLeftPanel);
mTopSizer = new wxBoxSizer(wxHORIZONTAL);
mTopPanel->SetSizer(mTopSizer);
mTopSizer->SetSizeHints(mTopPanel);
GetSizer()->SetSizeHints(this);
Centre();
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonVertScaleUpClicked, this, ID_BUTTON_VERT_SCALE_UP);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonVertScaleDownClicked, this, ID_BUTTON_VERT_SCALE_DOWN);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimeScaleUpClicked, this, ID_BUTTON_TIME_SCALE_UP);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimeScaleDownClicked, this, ID_BUTTON_TIME_SCALE_DOWN);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonVertPosUpClicked, this, ID_BUTTON_VERT_POS_UP);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonVertPosDownClicked, this, ID_BUTTON_VERT_POS_DOWN);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonVertPosHomeClicked, this, ID_BUTTON_VERT_POS_HOME);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimePosUpClicked, this, ID_BUTTON_TIME_POS_UP);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimePosDownClicked, this, ID_BUTTON_TIME_POS_DOWN);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimePosEndClicked, this, ID_BUTTON_TIME_POS_END);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonTimePosHomeClicked, this, ID_BUTTON_TIME_POS_HOME);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonClearScopeClicked, this, ID_BUTTON_CLEAR_SCOPE);
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonSaveImageClicked, this, ID_BUTTON_SAVE_IMAGE);
Bind(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, &ScopeDisplay::OnButtonCursorsClicked, this, ID_BUTTON_CURSORS);
mScopePanel->Bind(wxEVT_PAINT, &ScopeDisplay::OnPaint, this);
mScopePanel->Bind(wxEVT_SIZE, &ScopeDisplay::OnSize, this);
mScopePanel->Bind(wxEVT_LEFT_DOWN, &ScopeDisplay::OnMouseLeftDown, this);
mScopePanel->Bind(wxEVT_LEFT_UP, &ScopeDisplay::OnMouseLeftUp, this);
mScopePanel->Bind(wxEVT_RIGHT_DOWN, &ScopeDisplay::OnMouseRightDown, this);
mScopePanel->Bind(wxEVT_RIGHT_UP, &ScopeDisplay::OnMouseRightUp, this);
mScopePanel->Bind(wxEVT_MOTION, &ScopeDisplay::OnMouseMotion, this);
mScopePanel->Bind(wxEVT_MOUSEWHEEL, &ScopeDisplay::OnMouseWheel, this);
}
ScopeDisplay::~ScopeDisplay()
{
}
void ScopeDisplay::addWaveform(const wxString &name, const wxString &scale_name, const wxString &unit, float resolution)
{
//create the vertical scale
VerticalScale* new_vs = new VerticalScale(scale_name, unit, resolution);
//try to find a scale we can use
auto found = std::find_if(mVerticalScaleList.begin(), mVerticalScaleList.end(), [new_vs](const VerticalScale* scale)
{
return *scale == *new_vs;
});
if (found == mVerticalScaleList.end())
{
mVerticalScaleList.push_back(new_vs);
found = --mVerticalScaleList.end();
}
WaveformDescriptor desc(**found);
desc.name = name;
//find first unused color and assign it to the waveform
desc.color = *wxBLACK;
for(auto &wc: mWaveColors)
{
if (wc.in_use == false)
{
desc.color = wc.color;
wc.in_use = true;
break;
}
}
wxString button_name = name;
button_name.insert(0, wxT(" "));
button_name.append(wxT(" "));
desc.button = new wxButton(mTopPanel, wxID_ANY, button_name, wxDefaultPosition, wxSize(-1, 25), wxBU_EXACTFIT);
desc.button->SetForegroundColour(desc.color);
//desc.button->SetForegroundColour(*wxLIGHT_GREY);
desc.button->SetFont(mFontMed);
desc.id = desc.button->GetId();
Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonEnableWaveformClicked, this, desc.id);
mTopSizer->Add(desc.button, 0, wxALL | wxALIGN_CENTER_VERTICAL, SCOPE_CONTROL_BORDER_SIZE);
mWaveformDescriptorList.push_back(desc);
mDataVectors.push_back(DataVector());
mTopSizer->SetSizeHints(mTopPanel);
mTopSizer->Fit(mTopPanel);
GetSizer()->Layout();
Refresh();
}
void ScopeDisplay::clearWaveforms(void)
{
for(auto &desc: mWaveformDescriptorList)
{
Unbind(wxEVT_COMMAND_BUTTON_CLICKED, &ScopeDisplay::OnButtonEnableWaveformClicked, this, desc.id);
desc.button->Destroy();
}
mWaveformDescriptorList.clear();
for(const auto sptr: mVerticalScaleList)
delete sptr;
mVerticalScaleList.clear();
mDataVectors.clear();
for(auto it = mWaveColors.begin(); it != mWaveColors.end(); ++it)
it->in_use = false;
mTopSizer->SetSizeHints(mTopPanel);
mTopSizer->Fit(mTopPanel);
GetSizer()->Layout();
Refresh();
}
void ScopeDisplay::ChangeVerticalScale(bool up)
{
const float min_scale = 0.005f; //5mU / div
const float max_scale = 5.0f; //5U / div
int32_t scale = mVerticalScale;
int32_t exp = mVerticalScaleExponent;
if (up)
{
switch(scale)
{
case 1: scale = 2; break;
case 2: scale = 5; break;
case 5: scale = 1; exp++; break;
default: assert(0);
}
}
else
{
switch(scale)
{
case 1: scale = 5; exp--; break;
case 2: scale = 1; break;
case 5: scale = 2; break;
default: assert(0);
}
}
//validate new scale is within range
float final_scale = scale * pow(10, exp);
if ((final_scale >= min_scale) && (final_scale <= max_scale))
{
mVerticalScale = scale;
mVerticalScaleExponent = exp;
}
mScopePanel->Refresh();
}
void ScopeDisplay::AdvanceTime(uint64_t time)
{
mMaxTime += time;
}
void ScopeDisplay::SetTimeScales(const std::vector<uint64_t> &scales, size_t default_scale_index)
{
mTimeScales = scales;
if (default_scale_index >= mTimeScales.size())
default_scale_index = mTimeScales.size() - 1;
mTimeScalesIndex = default_scale_index;
mTimeResolution = mTimeScales[mTimeScalesIndex];
}
void ScopeDisplay::ChangeTimeScale(bool up)
{
if (up)
{
if (mTimeScalesIndex < (mTimeScales.size() - 1))
{
mTimeScalesIndex++;
mTimeResolution = mTimeScales[mTimeScalesIndex];
}
}
else
{
if (mTimeScalesIndex > 0)
{
mTimeScalesIndex--;
mTimeResolution = mTimeScales[mTimeScalesIndex];
}
}
mTimePosition -= mTimePosition % mTimeResolution;
mWaveRefresh = true;
mScopePanel->Refresh();
}
void ScopeDisplay::HomeTimePos(void)
{
mTimePosition = mMinTime;
mWaveRefresh = true;
mScopePanel->Refresh();
}
void ScopeDisplay::UpdateScope(void)
{
EndTimePos();
}
void ScopeDisplay::EndTimePos(void)
{
mTimePosition = mMaxTime - mCurrentTimeSpan;
if (mTimePosition < mMinTime)
mTimePosition = mMinTime;
mWaveRefresh = true;
mScopePanel->Refresh();
}
void ScopeDisplay::ChangeVerticalPos(bool up, uint32_t increment)
{
if (up)
mVertPosition += increment;
else
mVertPosition -= increment;
mVertPosition -= mVertPosition % (int32_t)increment;
mScopePanel->Refresh();
}
void ScopeDisplay::HomeVerticalPos(void)
{
mVertPosition = 0;
mScopePanel->Refresh();
}
void ScopeDisplay::ChangeTimePos(bool up, uint32_t increment)
{
uint64_t step = mTimeResolution;
if (increment)
step = (step * increment) / GRID_SPACING;
if (step == 0)
step = 1;
if (up)
{
mTimePosition += step;
}
else if (mTimePosition >= step)
{
mTimePosition -= step;
}
mWaveRefresh = true;
mScopePanel->Refresh();
}
void ScopeDisplay::OnPaint(wxPaintEvent &event)
{
wxAutoBufferedPaintDC dc(mScopePanel);
render(dc);
}
void ScopeDisplay::OnSize(wxSizeEvent &event)
{
mWaveRefresh = true;
//wxSize size = event.GetSize();
//wxLogMessage(wxT("size: %d %d"), size.GetWidth(), size.GetHeight());
// mTopPanel->SetSize(wxRect(0, 0, size.x, SCOPE_TOP_PANEL_HEIGHT));
// mBottomPanel->SetSize(wxRect(0, size.y - SCOPE_BOTTOM_PANEL_HEIGHT, size.x, SCOPE_BOTTOM_PANEL_HEIGHT));
// mLeftPanel->SetSize(wxRect(0, SCOPE_TOP_PANEL_HEIGHT, SCOPE_LEFT_PANEL_WIDTH, size.y - SCOPE_TOP_PANEL_HEIGHT - SCOPE_BOTTOM_PANEL_HEIGHT));
}
void ScopeDisplay::render(wxDC &dc)
{
int32_t x, y1, y2;
const wxSize scope_size = mScopePanel->GetSize();
//clear the background
dc.SetPen(wxPen(*wxWHITE, 1));
dc.SetBrush(wxBrush(*wxWHITE));
dc.DrawRectangle(wxPoint(0, 0), scope_size);
mGraphTop = SCOPE_TOP_BORDER_SIZE;
mGraphLeft = SCOPE_LEFT_BORDER_SIZE + SCOPE_VERTICAL_SCALE_WIDTH * mVerticalScaleList.size();
//draw grids
dc.SetTextForeground(mScalesColor);
dc.SetFont(mScalesFont);
mHGridDivisions = (scope_size.y - SCOPE_BOTTOM_BORDER_SIZE - SCOPE_TOP_BORDER_SIZE) / GRID_SPACING;
mVGridDivisions = (scope_size.x - SCOPE_RIGHT_BORDER_SIZE - SCOPE_LEFT_BORDER_SIZE - SCOPE_VERTICAL_SCALE_WIDTH * mVerticalScaleList.size()) / GRID_SPACING;
mCurrentTimeSpan = mTimeResolution * mVGridDivisions; //in us
if (mTimePosition > (mMaxTime - mCurrentTimeSpan))
mTimePosition = mMaxTime - mCurrentTimeSpan;
mGraphBottom = mGraphTop + GRID_SPACING * mHGridDivisions;
mGraphRight = mGraphLeft + GRID_SPACING * mVGridDivisions;
const int32_t graph_height = mGraphBottom - mGraphTop;
dc.SetPen(wxPen(mGridColor, 1, wxPENSTYLE_DOT));
int32_t h_grid = mGraphBottom - GRID_SPACING;
for(int32_t i = 1; i <= mHGridDivisions; i++)
{
dc.DrawLine(wxPoint(mGraphLeft, h_grid), wxPoint(mGraphRight, h_grid));
h_grid -= GRID_SPACING;
}
int32_t v_grid = mGraphLeft;
uint64_t time_grid_value = mTimePosition;
for(int32_t i = 0; i <= mVGridDivisions; i++)
{
dc.SetPen(wxPen(mGridColor, 1, wxPENSTYLE_DOT));
dc.DrawLine(wxPoint(v_grid, mGraphBottom), wxPoint(v_grid, mGraphTop));
dc.SetPen(wxPen(mScalesColor, 1));
dc.DrawLine(wxPoint(v_grid, mGraphBottom - 3), wxPoint(v_grid, mGraphBottom + 4));
const wxString text = PrintTime(time_grid_value);
const wxSize ts = dc.GetTextExtent(text);
time_grid_value += mTimeResolution;
dc.DrawText(text, v_grid - (ts.x / 2), mGraphBottom + 4);
v_grid += GRID_SPACING;
}
//draw waveforms
if (mWaveRefresh && mListener)
{
mWaveRefresh = false;
mListener->getChartData(mTimePosition, mTimePosition + mCurrentTimeSpan, mGraphRight - mGraphLeft, mDataVectors);
}
dc.SetFont(mScalesFont);
size_t i = 0;
for (auto &wd: mWaveformDescriptorList)
{
if (wd.enabled)
{
wd.button->SetForegroundColour(wd.color);
dc.SetPen(wxPen(wd.color, 2));
dc.SetTextForeground(wd.color);
DrawAnalogWaveform(dc, mDataVectors[i], wd, mGraphLeft, mGraphBottom, mGraphRight, mGraphTop);
}
else
{
wd.button->SetForegroundColour(*wxLIGHT_GREY);
}
i++;
}
//draw vertical axes
dc.SetBrush(wxBrush(*wxBLACK));
int32_t scale_x = SCOPE_LEFT_BORDER_SIZE;
for(auto scale: mVerticalScaleList)
{
scale_x += SCOPE_VERTICAL_SCALE_WIDTH;
//print scale
dc.SetPen(wxPen(mScalesColor, 1));
dc.SetFont(mScalesFont);
dc.SetTextForeground(mScalesColor);
int32_t h_grid = mGraphBottom;
float scale_value = (mVertPosition / (float)GRID_SPACING) * scale->resolution * mVerticalScale * pow(10, mVerticalScaleExponent);
for(int32_t i = 0; i < mHGridDivisions + 1; i++)
{
const wxString text = PrintValue(scale_value, scale->unit);
const wxSize ts = dc.GetTextExtent(text);
dc.SetPen(wxPen(*wxBLACK, 2));
dc.DrawLine(wxPoint(scale_x - 3, h_grid), wxPoint(scale_x + 3, h_grid));
dc.DrawText(text, scale_x - ts.x - 5, h_grid - ts.y / 2);
h_grid -= GRID_SPACING;
scale_value += scale->resolution * mVerticalScale * pow(10, mVerticalScaleExponent);
}
//draw axis
dc.SetPen(wxPen(*wxBLACK, 2));
dc.DrawLine(wxPoint(scale_x, mGraphBottom), wxPoint(scale_x, mGraphTop - 4));
DrawArrow(dc, wxPoint(scale_x, mGraphTop - 20), 0, ARROW_HEIGHT, ARROW_BASE);
//print axis name
dc.SetFont(mFontBig);
dc.SetTextForeground(*wxBLACK);
const wxSize ts = dc.GetTextExtent(scale->name);
dc.DrawText(scale->name, scale_x - ts.x - ARROW_BASE / 2 - 2, 0);
}
//draw time axis
dc.SetPen(wxPen(*wxBLACK, 2));
dc.SetBrush(wxBrush(*wxBLACK));
dc.DrawLine(wxPoint(mGraphLeft, mGraphBottom), wxPoint(mGraphRight + 4, mGraphBottom));
dc.SetTextBackground(*wxWHITE);
dc.SetTextForeground(*wxBLACK);
dc.SetFont(mFontBig);
DrawArrow(dc, wxPoint(mGraphRight + 20, mGraphBottom), 3, ARROW_HEIGHT, ARROW_BASE);
dc.DrawText(wxT("t"), scope_size.x - SCOPE_RIGHT_BORDER_SIZE + 2, mGraphBottom - ARROW_BASE / 2 - dc.GetCharHeight());
dc.DrawText(wxT("Time Scale:"), SCOPE_LEFT_BORDER_SIZE, scope_size.y - SCOPE_BOTTOM_BORDER_SIZE);
const wxSize ts = dc.GetTextExtent(wxT("Time Scale:"));
const wxString text = PrintTimeResolution(mTimeResolution);
dc.SetTextForeground(*wxRED);
dc.DrawText(text, SCOPE_LEFT_BORDER_SIZE + ts.x + dc.GetCharWidth(), scope_size.y - SCOPE_BOTTOM_BORDER_SIZE);
if (mCursorsEnable)
{
dc.SetTextBackground(*wxWHITE);
dc.SetFont(mFontSmall);
dc.SetTextForeground(*wxBLACK);
dc.DrawText(wxT("Cursors"), 40, mGraphTop - 3 * dc.GetCharHeight());
//draw cursor 1
dc.SetTextForeground(mCursor1Color);
dc.SetPen(wxPen(mCursor1Color, 1));
dc.DrawLine(wxPoint(mCursor1Pos.x, mGraphTop), wxPoint(mCursor1Pos.x, mGraphBottom));
//draw cursor 2
dc.SetTextForeground(mCursor2Color);
dc.SetPen(wxPen(mCursor2Color, 1));
dc.DrawLine(wxPoint(mCursor2Pos.x, mGraphTop), wxPoint(mCursor2Pos.x, mGraphBottom));
const int64_t time1 = (((mCursor1Pos.x - mGraphLeft) * (uint64_t)mTimeResolution) / GRID_SPACING) + mTimePosition;
const int64_t time2 = (((mCursor2Pos.x - mGraphLeft) * (uint64_t)mTimeResolution) / GRID_SPACING) + mTimePosition;
//draw cursor value text
wxString text = PrintTime(time1);
dc.SetTextForeground(mCursor1Color);
wxSize ts = dc.GetTextExtent(text);
y1 = mGraphBottom - ts.y - 10;
if ((mGraphRight - mCursor1Pos.x) > ts.x + 40)
x = mCursor1Pos.x + 10;
else
x = mCursor1Pos.x - ts.x - 10;
dc.DrawText(text, x, y1);
text = PrintTime(time2);
dc.SetTextForeground(mCursor2Color);
ts = dc.GetTextExtent(text);
y2 = mGraphBottom - ts.GetHeight() - 10;
if ((mGraphRight - mCursor2Pos.x) > ts.x + 40)
x = mCursor2Pos.x + 10;
else
x = mCursor2Pos.x - ts.x - 10;
dc.DrawText(text, x, y2);
dc.SetClippingRegion(mGraphLeft - 1, mGraphTop - 1, mGraphRight - mGraphLeft + 1, graph_height + 1);
dc.SetPen(wxNullPen);
int32_t text_pos1_y = mGraphTop;
int32_t text_pos2_y = mGraphTop;
const int32_t x1 = mCursor1Pos.x - mGraphLeft;
const int32_t x2 = mCursor2Pos.x - mGraphLeft;
for(uint32_t i = 0; i < mWaveformDescriptorList.size(); i++)
{
const auto &wd = mWaveformDescriptorList[i];
if (wd.enabled)
{
const float v1 = mDataVectors[i][x1];
const float v2 = mDataVectors[i][x2];
const float vertical_resolution = wd.scale.resolution * mVerticalScale * pow(10, mVerticalScaleExponent);
const float vertical_reference = mVertPosition * vertical_resolution / GRID_SPACING;
const float vertical_span = (graph_height / GRID_SPACING) * vertical_resolution;
dc.SetBrush(wxBrush(wd.color));
dc.SetTextForeground(wd.color);
if (!isnan(v1))
{
const int32_t y1 = ((v1 - vertical_reference) / vertical_span) * graph_height;
dc.DrawCircle(mCursor1Pos.x, mGraphBottom - y1, 4);
const wxString text = PrintValue(v1, wd.scale.unit);
dc.DrawText(wd.name + wxT(": ") + text, mCursor1Pos.x + 10, text_pos1_y);
text_pos1_y += dc.GetCharHeight();
}
if (!isnan(v2))
{
const int32_t y2 = ((v2 - vertical_reference) / vertical_span) * graph_height;
dc.DrawCircle(mCursor2Pos.x, mGraphBottom - y2, 4);
const wxString text = PrintValue(v2, wd.scale.unit);
dc.DrawText(wd.name + wxT(": ") + text, mCursor2Pos.x + 10, text_pos2_y);
text_pos2_y += dc.GetCharHeight();
}
}
}
dc.DestroyClippingRegion();
}
}
void ScopeDisplay::DrawAnalogWaveform(wxDC &dc, const std::vector<float> &wave, const WaveformDescriptor &wd, int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{
const int32_t screen_size_x = ((x1 - x0) < wave.size()) ? (x1 - x0) : wave.size();
if (screen_size_x == 0)
return;
const int32_t screen_size_y = y0 - y1;
dc.SetClippingRegion(x0 - 1, y1 - 1, screen_size_x + 1, screen_size_y + 1);
const float vertical_resolution = wd.scale.resolution * mVerticalScale * pow(10, mVerticalScaleExponent);
const float vertical_reference = mVertPosition * vertical_resolution / GRID_SPACING;
const float vertical_span = (screen_size_y / GRID_SPACING) * vertical_resolution;
const float* vptr = wave.data();
float left_val, right_val;
int32_t left_x, left_y;
int32_t right_y;
left_val = *vptr++;
left_x = 0;
left_y = ((left_val - vertical_reference) / vertical_span) * screen_size_y;
if (left_val == left_val)
dc.DrawPoint(x0 + left_x, y0 - left_y);
for(int32_t right_x = 1; right_x < screen_size_x; right_x++)
{
right_val = *vptr++;
right_y = ((right_val - vertical_reference) / vertical_span) * screen_size_y;
if ((right_val == right_val) && (left_val == left_val))
dc.DrawLine(x0 + left_x, y0 - left_y, x0 + right_x, y0 - right_y);
left_y = right_y;
left_x = right_x;
left_val = right_val;
}
dc.DestroyClippingRegion();
}
/*void ScopeDisplay::DrawIntegerWaveform(wxDC &dc, IntegerWaveform &wave, int32_t x0, int32_t y0, int32_t x1, int32_t y1)
{
const int32_t screen_size_x = x1 - x0;
const int32_t screen_size_y = y1 - y0;
const uint64_t time_per_pixel = mTimeResolution / GRID_SPACING;
if ((wave.ypos + SCOPE_INTEGER_WAVEFORM_PITCH) > screen_size_y)
return;
int32_t max_x = x0 + (mMaxTime - mTimePosition) / time_per_pixel;
if (max_x >= screen_size_x)
max_x = screen_size_x - 1;
if (!wave.data->seek(0))
return;
//search for the first value change in the screen
ValueChange vc;
uint32_t prev_val = 0;
//move to the first change in the time window
while(wave.data->pop(vc))
{
if (vc.time >= mTimePosition)
{
if (mTimePosition == 0)
prev_val = vc.val;
wave.data->advance(-1); //move back one - this is the first value to be displayed
break;
}
prev_val = vc.val;
}
const int32_t text_ypos = ((SCOPE_INTEGER_WAVEFORM_HEIGHT + dc.GetCharHeight()) / 2) + wave.ypos - 1;
int32_t prev_x = x0;
if (wave.data->pop(vc))
{
do
{
int32_t vc_x = x0 + (vc.time - mTimePosition) / time_per_pixel;
if (vc_x >= x1)
break;
//draw the cross
if (vc_x == x0)
{
if (mTimePosition)
{
prev_x = x0 + 5;
dc.DrawLine(vc_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT / 2, prev_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT);
dc.DrawLine(vc_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT / 2, prev_x, wave.ypos);
}
prev_val = vc.val;
}
else
{
if ((vc_x - 5) > prev_x)
{
dc.DrawLine(prev_x, wave.ypos, vc_x - 5, wave.ypos);
dc.DrawLine(prev_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT, vc_x - 5, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT);
}
if ((vc_x - prev_x - 5) > 25)
{
wxString text;
text.Printf(wxT("0x%X"), prev_val);
dc.DrawText(text, prev_x, text_ypos);
}
dc.DrawLine(vc_x - 5, wave.ypos, vc_x + 5, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT);
dc.DrawLine(vc_x - 5, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT, vc_x + 5, wave.ypos);
prev_x = vc_x + 5;
prev_val = vc.val;
}
}while(wave.data->pop(vc));
}
if (max_x > prev_x)
{
dc.DrawLine(prev_x, wave.ypos, max_x, wave.ypos);
dc.DrawLine(prev_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT, max_x, wave.ypos + SCOPE_INTEGER_WAVEFORM_HEIGHT);
}
if ((max_x - prev_x - 5) > 25)
{
wxString text;
text.Printf(wxT("0x%X"), prev_val);
dc.DrawText(text, prev_x, text_ypos);
}
}
*/
void ScopeDisplay::DrawArrow(wxDC &dc, const wxPoint &pos, uint8_t dir, int32_t height, int32_t base)
{
wxPoint points[3];
points[0] = wxPoint(0, 0);
switch(dir)
{
case 0: //up
points[1] = wxPoint(-base / 2, height);
points[2] = wxPoint(base / 2, height);
break;
case 1: //left
points[1] = wxPoint(height, -base / 2);
points[2] = wxPoint(height, base / 2);
break;
case 2: //down
points[1] = wxPoint(-base / 2, -height);
points[2] = wxPoint(base / 2, -height);
break;
case 3: //right
points[1] = wxPoint(-height, -base / 2);
points[2] = wxPoint(-height, base / 2);
break;
}
dc.DrawPolygon(3, points, pos.x, pos.y);
}
wxBitmap* ScopeDisplay::SaveImage(void)
{
//TODO
wxBitmap* image = new wxBitmap(1200, 800);
wxMemoryDC dc;
dc.SelectObject(*image);
render(dc);
return image;
}
void ScopeDisplay::OnKeyPressed(wxKeyEvent &event)
{
}
void ScopeDisplay::OnKeyReleased(wxKeyEvent &event)
{
}
void ScopeDisplay::OnMouseWheel(wxMouseEvent &event)
{
int32_t dir = event.GetWheelRotation() / event.GetWheelDelta();
uint32_t step = 1;
if (event.ShiftDown())
step = 10;
const int32_t mouse_x = event.GetPosition().x - SCOPE_LEFT_BORDER_SIZE;
const uint32_t index = mouse_x / SCOPE_VERTICAL_SCALE_WIDTH;
if (index < mVerticalScaleList.size())
{
if (dir > 0)
mVerticalScaleList[index]->resolution *= 2;
else if (dir < 0)
mVerticalScaleList[index]->resolution /= 2;
mScopePanel->Refresh();
}
else
{
if (event.AltDown())
{
if (dir > 0)
ChangeTimePos(true, step);
else if (dir < 0)
ChangeTimePos(false, step);
}
else
{
if (dir > 0)
ChangeVerticalPos(true, step);
else if (dir < 0)
ChangeVerticalPos(false, step);
}
}
}
void ScopeDisplay::OnMouseLeftDown(wxMouseEvent &event)
{
if (mCursor1Dragging == false)
{
mScopePanel->CaptureMouse();
mCursor1Dragging = true;
}
}
void ScopeDisplay::OnMouseLeftUp(wxMouseEvent &event)
{
if (mCursor1Dragging == true)
{
mScopePanel->ReleaseMouse();
mCursor1Dragging = false;
}
}
void ScopeDisplay::OnMouseRightDown(wxMouseEvent &event)
{
if (mCursor2Dragging == false)
{
mScopePanel->CaptureMouse();
mCursor2Dragging = true;
}
}
void ScopeDisplay::OnMouseRightUp(wxMouseEvent &event)
{
if (mCursor2Dragging == true)
{
mScopePanel->ReleaseMouse();
mCursor2Dragging = false;
}
}
void ScopeDisplay::OnMouseLeaveWindow(wxMouseEvent &event)
{
}
void ScopeDisplay::OnMouseMotion(wxMouseEvent &event)
{
wxPoint pos = event.GetPosition();
if (pos.x< mGraphLeft)
pos.x = mGraphLeft;
else if (pos.x > mGraphRight)
pos.x = mGraphRight;
if (pos.y < mGraphTop)
pos.y = mGraphTop;
else if (pos.y > mGraphBottom)
pos.y = mGraphBottom;
if (mCursor1Dragging)
{
mCursor1Pos = pos;
mScopePanel->Refresh();
}
else if (mCursor2Dragging)
{
mCursor2Pos = pos;
mScopePanel->Refresh();
}
}
void ScopeDisplay::OnButtonVertScaleUpClicked(wxCommandEvent &event)
{
ChangeVerticalScale(true);
}
void ScopeDisplay::OnButtonVertScaleDownClicked(wxCommandEvent &event)
{
ChangeVerticalScale(false);
}
void ScopeDisplay::OnButtonTimeScaleUpClicked(wxCommandEvent &event)
{
ChangeTimeScale(true);
}
void ScopeDisplay::OnButtonTimeScaleDownClicked(wxCommandEvent &event)
{
ChangeTimeScale(false);
}
void ScopeDisplay::OnButtonVertPosUpClicked(wxCommandEvent &event)
{
ChangeVerticalPos(true, GRID_SPACING);
}
void ScopeDisplay::OnButtonVertPosDownClicked(wxCommandEvent &event)
{
ChangeVerticalPos(false, GRID_SPACING);
}
void ScopeDisplay::OnButtonVertPosHomeClicked(wxCommandEvent &event)
{
HomeVerticalPos();
}
void ScopeDisplay::OnButtonTimePosUpClicked(wxCommandEvent &event)
{
ChangeTimePos(true, 0);
}
void ScopeDisplay::OnButtonTimePosDownClicked(wxCommandEvent &event)
{
ChangeTimePos(false, 0);
}
void ScopeDisplay::OnButtonTimePosEndClicked(wxCommandEvent &event)
{
EndTimePos();
}
void ScopeDisplay::OnButtonTimePosHomeClicked(wxCommandEvent &event)
{
HomeTimePos();
}
void ScopeDisplay::OnButtonClearScopeClicked(wxCommandEvent &event)
{
/* for(auto it = mWaveforms->begin(); it != mWaveforms->end(); ++it)
it->data.clear();*/
/*for(IntegerWaveformList::iterator it = mIntegerWaveforms.begin(); it != mIntegerWaveforms.end(); ++it)
it->data->clear();*/
mScopePanel->Refresh();
}
void ScopeDisplay::OnButtonCursorsClicked(wxCommandEvent &event)
{
CursorsEnable(mCursorsButton->GetValue());
}
void ScopeDisplay::OnButtonSaveImageClicked(wxCommandEvent &event)
{
//TODO bug
wxFileDialog *dlg = new wxFileDialog(this, wxT("Choose File to Save Image To"), wxString(), wxString(), wxT("PNG Image File (*.png)|*.png"), wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
if (dlg->ShowModal() == wxID_OK)
{
wxString file = dlg->GetPath();
wxBitmap *image = SaveImage();
image->SaveFile(file, wxBITMAP_TYPE_PNG, 0);
delete image;
}
dlg->Destroy();
}
void ScopeDisplay::OnButtonEnableWaveformClicked(wxCommandEvent &event)
{
const int32_t id = event.GetId();
for(auto &wd: mWaveformDescriptorList)
{
if (wd.id == id)
{
if (wd.enabled)
{
wd.enabled = false;
wd.button->SetForegroundColour(*wxLIGHT_GREY);
}
else
{
wd.enabled = true;
wd.button->SetForegroundColour(wd.color);
}
}
}
mScopePanel->Refresh();
}
