{

static const std::vector<double>* xptr;

static const std::vector<double>* yptr;

xptr = &(*config.value.get())[0];

yptr = &(*config.value.get())[1];

std::vector<ImVec2> points;

for (unsigned i = 0; i < xptr->size(); i++)

{

auto p = ImPlot::PlotToPixels({ (*xptr)[i], (*yptr)[i] });

points.push_back(p);

}

if (config.fill.r > 0.0f)

{

size_t i;

double y;

double miny, maxy;

double x1, y1;

double x2, y2;

int ind1, ind2;

size_t ints;

size_t n = points.size();

int* polyints = new int[n];

/* Get plot Y range in pixels */

ImPlotRect limits = ImPlot::GetPlotLimits();

auto upperLimitsPix = ImPlot::PlotToPixels({ limits.X.Max, limits.Y.Max });

auto lowerLimitsPix = ImPlot::PlotToPixels({ limits.X.Min, limits.Y.Min });

/* Determine Y range of data*/

miny = (int)points[0].y;

maxy = (int)points[0].y;

for (i = 1; i < n; i++)

{

miny = std::min((int)miny, (int)points[i].y);

maxy = std::max((int)maxy, (int)points[i].y);

}

/* Determine to clip scans based on plot bounds y or data bounds y

miny = std::max((int)miny, (int)upperLimitsPix.y);

maxy = std::min((int)maxy, (int)lowerLimitsPix.y);

/* Draw, scanning y */

for (y = miny; y <= maxy; y++) {

ints = 0;

for (i = 0; (i < n); i++) {

if (!i)

{

ind1 = (int)n - 1;

ind2 = 0;

}

else

{

ind1 = (int)i - 1;

ind2 = (int)i;

}

y1 = (int)points[ind1].y;

y2 = (int)points[ind2].y;

if (y1 < y2)

{

x1 = (int)points[ind1].x;

x2 = (int)points[ind2].x;

}

else if (y1 > y2)

{

y2 = (int)points[ind1].y;

y1 = (int)points[ind2].y;

x2 = (int)points[ind1].x;

x1 = (int)points[ind2].x;

}

else

continue;

if (((y >= y1) && (y < y2)) || ((y == maxy) && (y > y1) && (y <= y2)))

polyints[ints++] = (y - y1) * (x2 - x1) / (y2 - y1) + x1;

}

auto compare_int = [](const void* a, const void* b)

{

return (*(const int*)a) - (*(const int*)b);

};

qsort(polyints, ints, sizeof(int), compare_int);

for (i = 0; i < ints; i += 2)

ImGui::GetWindowDrawList()->AddLine({ (float)polyints[i], (float)y }, { (float)polyints[i + 1], (float)y }, config.fill, 1.0f);

}

delete[] polyints;

}

if (r >= l) {

int mid = l + (r - l) / 2;

if (arr[mid] == x)

return mid;

if (arr[mid] > x)

return BinarySearch(arr, l, mid - 1, x);

return BinarySearch(arr, mid + 1, r, x);

}

return -1;

const double* closes, const double* lows, const double* highs, int count,

bool tooltip, float width_percent, const ImVec4& bullCol, const ImVec4& bearCol, int time_unit)

{

ImDrawList* draw_list = ImPlot::GetPlotDrawList();

// calc real value width

float half_width = count > 1 ? ((float)xs[1] - (float)xs[0]) * width_percent : width_percent;

// custom tool

if (ImPlot::IsPlotHovered() && tooltip) {

ImPlotPoint mouse = ImPlot::GetPlotMousePos();

mouse.x = ImPlot::RoundTime(ImPlotTime::FromDouble(mouse.x), time_unit).ToDouble();

float tool_l = ImPlot::PlotToPixels(mouse.x - half_width * 1.5, mouse.y).x;

float tool_r = ImPlot::PlotToPixels(mouse.x + half_width * 1.5, mouse.y).x;

float tool_t = ImPlot::GetPlotPos().y;

float tool_b = tool_t + ImPlot::GetPlotSize().y;

ImPlot::PushPlotClipRect();

draw_list->AddRectFilled(ImVec2(tool_l, tool_t), ImVec2(tool_r, tool_b), IM_COL32(128, 128, 128, 64));

ImPlot::PopPlotClipRect();

// find mouse location index

int idx = BinarySearch(xs, 0, count - 1, mouse.x);

if (idx != -1)

{

if(ImGui::BeginTooltip()) {

if (time_unit == ImPlotTimeUnit_Day)

{

char buff[32];

ImPlot::FormatDate(ImPlotTime::FromDouble(xs[idx]), buff, 32, ImPlotDateFmt_DayMoYr, ImPlot::GetStyle().UseISO8601);

ImGui::Text("Day: %s", buff);

}

else if (time_unit == ImPlotTimeUnit_Us)

{

ImGui::Text("Microsecond: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_Ms)

{

ImGui::Text("Millisecond: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_S)

{

ImGui::Text("Second: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_Min)

{

ImGui::Text("Minute: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_Hr)

{

ImGui::Text("Hour: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_Mo)

{

ImGui::Text("Month: %f", xs[idx]);

}

else if (time_unit == ImPlotTimeUnit_Yr)

{

ImGui::Text("Year: %f", xs[idx]);

}

ImGui::Text("Open: $%.2f", opens[idx]);

ImGui::Text("Close: $%.2f", closes[idx]);

ImGui::Text("Low: $%.2f", lows[idx]);

ImGui::Text("High: $%.2f", highs[idx]);

ImGui::EndTooltip();

}

}

}

// begin plot item

if (ImPlot::BeginItem(label_id)) {

// override legend icon color

ImPlot::GetCurrentItem()->Color = ImGui::ColorConvertFloat4ToU32({ 0.25f, 0.25f, 0.25f, 1.0f });

// fit data if requested

if (ImPlot::FitThisFrame()) {

for (int i = 0; i < count; ++i) {

ImPlot::FitPoint(ImPlotPoint(xs[i], lows[i]));

ImPlot::FitPoint(ImPlotPoint(xs[i], highs[i]));

}

}

// render data

for (int i = 0; i < count; ++i) {

ImVec2 open_pos = ImPlot::PlotToPixels(xs[i] - half_width, opens[i]);

ImVec2 close_pos = ImPlot::PlotToPixels(xs[i] + half_width, closes[i]);

ImVec2 low_pos = ImPlot::PlotToPixels(xs[i], lows[i]);

ImVec2 high_pos = ImPlot::PlotToPixels(xs[i], highs[i]);

ImU32 color = ImGui::GetColorU32(opens[i] > closes[i] ? bearCol : bullCol);

draw_list->AddLine(low_pos, high_pos, color);

draw_list->AddRectFilled(open_pos, close_pos, color);

}

// end plot item

ImPlot::EndItem();

}

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outConfig.value = *static_cast<std::shared_ptr<std::array<double, 4>>*>(srcItem->getValue());

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outConfig.value = *static_cast<std::shared_ptr<double>*>(srcItem->getValue());

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outConfig.value = *static_cast<std::shared_ptr<double>*>(srcItem->getValue());

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outConfig.value = *static_cast<std::shared_ptr<std::array<double, 4>>*>(item.getValue());

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outConfig.value = *static_cast<std::shared_ptr<std::array<double, 2>>*>(item.getValue());

{

if (dataSource == item.config.source) return;

item.config.source = dataSource;

mvAppItem* srcItem = GetItem((*GContext->itemRegistry), dataSource);

if (!srcItem)

{

mvThrowPythonError(mvErrorCode::mvSourceNotFound, "set_value",

"Source item not found: " + std::to_string(dataSource), &item);

return;

}

if (DearPyGui::GetEntityValueType(srcItem->type) != DearPyGui::GetEntityValueType(item.type))

{

mvThrowPythonError(mvErrorCode::mvSourceNotCompatible, "set_value",

"Values types do not match: " + std::to_string(dataSource), &item);

return;

}

outValue = *static_cast<std::shared_ptr<std::vector<std::vector<double>>>*>(srcItem->getValue());

{

if (!item.config.show)

return;

// cache old cursor position

ImVec2 previousCursorPos = ImGui::GetCursorPos();

// set cursor position if user set

if (item.info.dirtyPos)

ImGui::SetCursorPos(item.state.pos);

// update widget's position state

item.state.pos = { ImGui::GetCursorPosX(), ImGui::GetCursorPosY() };

// push font if a font object is attached

if (item.font)

{

ImFont* fontptr = static_cast<mvFont*>(item.font.get())->getFontPtr();

ImGui::PushFont(fontptr);

}

// themes

apply_local_theming(&item);

// Must do this because these items are not avalable as style items

// these are here because they need to be applied every plot

ImPlot::GetStyle().UseLocalTime = config.localTime;

ImPlot::GetStyle().UseISO8601 = config.iSO8601;

ImPlot::GetStyle().Use24HourClock = config.clock24Hour;

if (config._newColorMap)

{

ImPlot::BustColorCache(item.info.internalLabel.c_str());

config._newColorMap = false;

}

if (config._useColorMap)

ImPlot::PushColormap(config._colormap);

// custom input mapping

ImPlot::GetInputMap().Pan = config.pan;

ImPlot::GetInputMap().Fit = config.fit;

ImPlot::GetInputMap().Select = config.select;

ImPlot::GetInputMap().SelectCancel = config.select_cancel;

ImPlot::GetInputMap().Menu = config.menu;

ImPlot::GetInputMap().ZoomRate = config.zoom_rate;

if (config.pan_mod != ImPlot::GetInputMap().PanMod) ImPlot::GetInputMap().PanMod = config.pan_mod;

if (config.select_mod != ImPlot::GetInputMap().SelectMod) ImPlot::GetInputMap().SelectMod = config.select_mod;

if (config.zoom_mod != ImPlot::GetInputMap().ZoomMod) ImPlot::GetInputMap().ZoomMod = config.zoom_mod;

if (config.override_mod != ImPlot::GetInputMap().OverrideMod) ImPlot::GetInputMap().OverrideMod = config.override_mod;

if (config.select_horz_mod != ImPlot::GetInputMap().SelectHorzMod) ImPlot::GetInputMap().SelectHorzMod = config.select_horz_mod;

if (config.select_vert_mod != ImPlot::GetInputMap().SelectVertMod) ImPlot::GetInputMap().SelectVertMod = config.select_vert_mod;

if (config._fitDirty)

{

// This must be called before BeginPlot

for(int i = 0; i < ImAxis_COUNT; i++) {

if (config._axisfitDirty[i] == true) {

ImPlot::SetNextAxisToFit(i);

config._axisfitDirty[i] = false;

}

}

config._fitDirty = false;

}

if (ImPlot::BeginPlot(item.info.internalLabel.c_str(), ImVec2((float)item.config.width, (float)item.config.height), config._flags))

{

// gives axes change to make changes to ticks, limits, etc.

ImAxis next_y_axis = ImAxis_Y1;

for (auto& child : item.childslots[1])

{

// skip item if it's not shown

if (!child->config.show)

continue;

if (child->type == mvAppItemType::mvPlotAxis)

{

mvPlotAxis* axis = static_cast<mvPlotAxis*>(child.get());

ImAxis_ id_axis = static_cast<ImAxis_>(axis->configData.axis);

// auto-assigning additional Y axes for compatibility with DPG 1.11 and earlier versions

auto flags = axis->configData.flags;

if (id_axis == ImAxis_Y1)

{

if (axis->configData.axis < next_y_axis)

{

id_axis = static_cast<ImAxis_>(next_y_axis);

flags |= ImPlotAxisFlags_Opposite;

axis->configData.axis = next_y_axis;

}

++next_y_axis;

}

ImPlot::SetupAxis(id_axis, axis->config.specifiedLabel.c_str(), flags);

if (axis->configData.setLimits)

ImPlot::SetupAxisLimits(id_axis, axis->configData.limits.x, axis->configData.limits.y, ImGuiCond_Always);

if (!axis->configData.formatter.empty())

ImPlot::SetupAxisFormat(id_axis, axis->configData.formatter.c_str());

ImPlot::SetupAxisScale(id_axis, axis->configData.scale);

if (axis->configData.setLimitsRange)

ImPlot::SetupAxisLimitsConstraints(id_axis, axis->configData.constraints_range.x, axis->configData.constraints_range.y);

if (axis->configData.setZoomRange)

ImPlot::SetupAxisZoomConstraints(id_axis, axis->configData.zoom_range.x, axis->configData.zoom_range.y);

if (!axis->configData.labels.empty())

{

// TODO: Checks (from original dpg)

ImPlot::SetupAxisTicks(id_axis, axis->configData.labelLocations.data(), (int)axis->configData.labels.size(), axis->configData.clabels.data());

}

}

else

child->customAction();

}

auto context = ImPlot::GetCurrentContext();

ImGuiIO& IO = ImGui::GetIO();

// Note: we can't use `config.querying` here because in the frame when

// the query modifier gets pressed, `querying` is still false but we already

// need to disable `OverrideMod`.

if (ImHasFlag(IO.KeyMods, config.query_toggle_mod) &&

(ImGui::IsMouseDown(config.select) || ImGui::IsMouseReleased(config.select)))

{

// Preventing ImPlot from getting stuck on selection if override modifier

// is pressed (e.g. when the override mod is the same as query toggle mod).

ImPlot::GetInputMap().OverrideMod = ImGuiMod_None;

}

else

ImPlot::GetInputMap().OverrideMod = config.override_mod;

bool query_dirty = false;

if (config.query_enabled && config.querying && ImGui::IsMouseReleased(config.select))

{

if (config.max_query_rects != 0 && config.rects.size() >= config.max_query_rects)

config.rects.pop_back();

config.rects.push_back(config.query_rect);

config.querying = false;

// Prevent ImPlot from handling mouse release on its own. This will block

// input handling in the current frame (later we'll reset OverrideMod).

ImPlot::GetInputMap().OverrideMod = IO.KeyMods;

// Note: this will lock the setup and might therefore skip changes

// to the legend, drag points, and lines in this frame. Nothing we

// can do about that, really.

ImPlot::CancelPlotSelection();

// We've updated the list, let's report this

query_dirty = true;

}

// legend, drag point and lines

for (auto& child : item.childslots[0]) // Using "ImPlot::GetPlotPos()" here trigger an assert

child->draw(drawlist, context->CurrentPlot->PlotRect.Min.x, context->CurrentPlot->PlotRect.Min.y);

// axes

for (auto& child : item.childslots[1])

child->draw(drawlist, ImPlot::GetPlotPos().x, ImPlot::GetPlotPos().y);

ImPlot::PushPlotClipRect();

ImPlot::SetAxis(ImAxis_Y1);

// drawings

for (auto& child : item.childslots[2])

{

// skip item if it's not shown

if (!child->config.show)

continue;

//item->draw(ImPlot::GetPlotDrawList(), ImPlot::GetPlotPos().x, ImPlot::GetPlotPos().y);

child->draw(ImPlot::GetPlotDrawList(), 0.0f, 0.0f);

UpdateAppItemState(child->state);

}

ImPlot::PopPlotClipRect();

if (config._useColorMap)

ImPlot::PopColormap();

config.querying = ImHasFlag(IO.KeyMods, config.query_toggle_mod) && ImPlot::IsPlotSelected();

if (config.querying)

config.query_rect = ImPlot::GetPlotSelection();

// While rendering query rects, we'll see which of them the user asks to

// delete (by double-clicking it). We need to run through the entire list

// to make sure that we pick the topmost candidate if there's more than one.

int delete_idx = -1;

for (int i = 0; i < config.rects.size(); ++i) {

// TODO: Implement flags

bool hovered = false;

query_dirty |= ImPlot::DragRect(i,&config.rects[i].X.Min,&config.rects[i].Y.Min,&config.rects[i].X.Max,&config.rects[i].Y.Max, config.query_color, ImPlotDragToolFlags_NoFit, nullptr, &hovered);

if (config.rects.size() > config.min_query_rects) {

if (hovered && ImGui::IsMouseDoubleClicked(config.select_cancel))

{

// remember it for future deletion

delete_idx = i;

}

}

}

// Delete rect on double click.

// We're not interested in double-clicks that modify a query rect

// (in particular, double-clicks on rect edges), and to filter them out,

// we additionally check for `query_dirty` to be false.

if (delete_idx >= 0 && !query_dirty)

{

config.rects.erase(config.rects.begin() + delete_idx);

// Preventing plot auto-fit if it uses the same mouse button.

// Kind of a dirty trick but double-click has already set

// all `FitThisFrame` to true anyway.

if (config.fit == config.select_cancel)

{

context->CurrentPlot->FitThisFrame = false;

for (int j = 0; j < ImAxis_COUNT; ++j)

context->CurrentPlot->Axes[j].FitThisFrame = false;

}

// We've updated the list, let's report this

query_dirty = true;

}

if (item.config.callback != nullptr && query_dirty)

{

if (item.config.alias.empty()) {

mvSubmitCallback([=, &item]() {

PyObject* result = PyTuple_New(config.rects.size());

for (int i = 0; i < config.rects.size(); ++i) {

auto rectMin = config.rects[i].Min();

auto rectMax = config.rects[i].Max();

PyTuple_SetItem(result, i, Py_BuildValue("(dddd)", rectMin.x, rectMin.y, rectMax.x, rectMax.y));

}

mvAddCallback(item.config.callback, item.uuid, result, item.config.user_data);

});

} else {

mvSubmitCallback([=, &item]() {

PyObject* result = PyTuple_New(config.rects.size());

for (int i = 0; i < config.rects.size(); ++i) {

auto rectMin = config.rects[i].Min();

auto rectMax = config.rects[i].Max();

PyTuple_SetItem(result, i, Py_BuildValue("(dddd)", rectMin.x, rectMin.y, rectMax.x, rectMax.y));

}

mvAddCallback(item.config.callback, item.config.alias, result, item.config.user_data);

});

}

}

if (ImPlot::IsPlotHovered())

{

GContext->input.mousePlotPos.x = ImPlot::GetPlotMousePos().x;

GContext->input.mousePlotPos.y = ImPlot::GetPlotMousePos().y;

}

// todo: resolve clipping

if (item.config.dropCallback)

{

ScopedID id(item.uuid);

if (ImPlot::BeginDragDropTargetPlot())

{

if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(item.config.payloadType.c_str()))

{

auto payloadActual = static_cast<const mvDragPayload*>(payload->Data);

if (item.config.alias.empty())

mvAddCallback(item.config.dropCallback, item.uuid, payloadActual->configData.dragData, nullptr);

else

mvAddCallback(item.config.dropCallback, item.config.alias, payloadActual->configData.dragData, nullptr);

}

ImPlot::EndDragDropTarget();

}

}

// update state

config._flags = context->CurrentPlot->Flags;

if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))

{

// update mouse

ImVec2 mousePos = ImGui::GetMousePos();

ImVec2 windowPos = ImGui::GetWindowPos();

GContext->input.mousePos.x = (int)(mousePos.x - windowPos.x);

GContext->input.mousePos.y = (int)(mousePos.y - windowPos.y);

GContext->activeWindow = item.uuid;

}

// TODO: find a better way to handle this

// We could use std::find_if from <algorithm> but it'd require item.childslots[0] to be a std::vector

for (auto& child : item.childslots[0])

{

if (child->type == mvAppItemType::mvPlotLegend)

{

auto legend = static_cast<mvPlotLegend*>(child.get());

legend->configData.legendLocation = context->CurrentPlot->Items.Legend.Location;

legend->configData.flags = context->CurrentPlot->Items.Legend.Flags;

break;

}

}

ImPlot::EndPlot();

}

// set cursor position to cached position

if (item.info.dirtyPos)

ImGui::SetCursorPos(previousCursorPos);

ImPlot::GetInputMap() = config._originalMap;

UpdateAppItemState(item.state);

if (item.font)

{

ImGui::PopFont();

}

if (item.theme)

{

item.theme->pop_theme_components();

}

if (item.handlerRegistry)

item.handlerRegistry->checkEvents(&item.state);

// drag drop

for (auto& child : item.childslots[3])

child->draw(nullptr, ImGui::GetCursorPosX(), ImGui::GetCursorPosY());

{

if (!item.config.show)

return;

// todo: add check

ImPlot::SetAxis(config.axis);

for (auto& item : item.childslots[1])

item->draw(drawlist, ImPlot::GetPlotPos().x, ImPlot::GetPlotPos().y);

// x axis

if (config.axis <= ImAxis_X3)

{

auto plotLimits = ImPlot::GetPlotLimits(config.axis, IMPLOT_AUTO);

config.limits_actual.x = (float)plotLimits.X.Min;

config.limits_actual.y = (float)plotLimits.X.Max;

}

// y axis

else

{

auto plotLimits = ImPlot::GetPlotLimits(IMPLOT_AUTO, config.axis);

config.limits_actual.x = (float)plotLimits.Y.Min;

config.limits_actual.y = (float)plotLimits.Y.Max;

}

config.flags = ImPlot::GetCurrentContext()->CurrentPlot->Axes[config.axis].Flags;

UpdateAppItemState(item.state);

if (item.font)

ImGui::PopFont();

if (item.theme)

static_cast<mvTheme*>(item.theme.get())->customAction();

if (item.config.dropCallback)

{

ScopedID id(item.uuid);

if (ImPlot::BeginDragDropTargetAxis(config.axis))

{

if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(item.config.payloadType.c_str()))

{

auto payloadActual = static_cast<const mvDragPayload*>(payload->Data);

mvAddCallback(item.config.dropCallback, item.uuid, payloadActual->configData.dragData, nullptr);

}

ImPlot::EndDragDropTarget();

}

}

{

ScopedID id(item.uuid);

if (ImPlot::BeginSubplots(item.info.internalLabel.c_str(), config.rows, config.cols, ImVec2((float)item.config.width, (float)item.config.height),

config.flags, config.row_ratios.empty() ? nullptr : config.row_ratios.data(), config.col_ratios.empty() ? nullptr : config.col_ratios.data()))

{

// plots

for (auto& item : item.childslots[1])

item->draw(drawlist, 0.0f, 0.0f);

ImPlot::EndSubplots();

}

{

if (!item.config.show)

return;

if (config.dirty)

{

ImPlot::SetupLegend(config.legendLocation, config.flags);

config.dirty = false;

}

UpdateAppItemState(item.state);

if (item.font)

{

ImGui::PopFont();

}

if (item.theme)

{

static_cast<mvTheme*>(item.theme.get())->customAction();

}

if (item.config.dropCallback)

{

if (ImPlot::BeginDragDropTargetLegend())

{

if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(item.config.payloadType.c_str()))

{

auto payloadActual = static_cast<const mvDragPayload*>(payload->Data);

mvAddCallback(item.config.dropCallback, item.uuid, payloadActual->configData.dragData, nullptr);

}

ImPlot::EndDragDropTarget();

}

}

{

if (!item.config.show)

return;

ScopedID id(item.uuid);

bool hovered = false;

bool held = false;

if (config.vertical)

{

if (ImPlot::DragLineX(item.uuid, config.value.get(), config.color, config.thickness, config.flags, nullptr, &hovered, &held))

{

mvAddCallback(item.config.callback, item.uuid, nullptr, item.config.user_data);

}

if (config.show_label && !item.config.specifiedLabel.empty() && (hovered || held)) {

char buff[IMPLOT_LABEL_MAX_SIZE];

ImPlotContext& gp = *GImPlot;

ImPlotAxis& axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentX];

auto pos = *config.value.get();

ImPlot::LabelAxisValue(axis, pos, buff, sizeof(buff), true);

ImVec4 color = ImPlot::IsColorAuto(config.color.toVec4()) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : config.color;

ImPlot::Annotation(pos, ImPlot::GetPlotLimits().Min().y, color, ImVec2(0, 0), true, "%s = %s", item.config.specifiedLabel.c_str(), buff);

}

}

else

{

if (ImPlot::DragLineY(item.uuid, config.value.get(), config.color, config.thickness, config.flags, nullptr, &hovered, &held))

{

mvAddCallback(item.config.callback, item.uuid, nullptr, item.config.user_data);

}

if (config.show_label && !item.config.specifiedLabel.empty() && (hovered || held)) {

char buff[IMPLOT_LABEL_MAX_SIZE];

ImPlotContext& gp = *GImPlot;

ImPlotAxis& axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentY];

auto label_pos = *config.value.get();

ImPlot::LabelAxisValue(axis, label_pos, buff, sizeof(buff), true);

ImVec4 color = ImPlot::IsColorAuto(config.color.toVec4()) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : config.color;

ImPlot::Annotation(ImPlot::GetPlotLimits().Min().x, label_pos, color, ImVec2(0, 0), true, "%s = %s", item.config.specifiedLabel.c_str(), buff);

}

}

{

if (!item.config.show)

return;

auto parent = (mvPlotAxis*)item.info.parentPtr;

auto axis_id = parent->configData.axis;

const bool vertical = (axis_id >= ImAxis_Y1);

if (vertical) {

if (!item.config.specifiedLabel.empty()) {

ImPlot::TagY(*config.value.get(), config.color, "%s", item.config.specifiedLabel.c_str());

} else {

ImPlot::TagY(*config.value.get(), config.color, config.auto_rounding);

}

}

else {

if (!item.config.specifiedLabel.empty()) {

ImPlot::TagX(*config.value.get(), config.color, "%s", item.config.specifiedLabel.c_str());

} else {

ImPlot::TagX(*config.value.get(), config.color, config.auto_rounding);

}

}

{

if (!item.config.show)

return;

ScopedID id(item.uuid);

static double xmin = (*config.value.get())[0];

static double ymin = (*config.value.get())[1];

static double xmax = (*config.value.get())[2];

static double ymax = (*config.value.get())[3];

// I still don't get why we need to do this

xmin = (*config.value.get())[0];

ymin = (*config.value.get())[1];

xmax = (*config.value.get())[2];

ymax = (*config.value.get())[3];

// item.config.specifiedLabel.c_str(),

if (ImPlot::DragRect(item.uuid, &xmin, &ymin, &xmax, &ymax, config.color, config.flags))

{

(*config.value.get())[0] = xmin;

(*config.value.get())[1] = ymin;

(*config.value.get())[2] = xmax;

(*config.value.get())[3] = ymax;

mvAddCallback(item.config.callback, item.uuid, nullptr, item.config.user_data);

}

{

if (!item.config.show)

return;

ScopedID id(item.uuid);

static double dummyx = (*config.value.get())[0];

static double dummyy = (*config.value.get())[1];

dummyx = (*config.value.get())[0];

dummyy = (*config.value.get())[1];

bool hovered = false;

bool held = false;

if (ImPlot::DragPoint(item.uuid, &dummyx, &dummyy, config.color, config.radius, config.flags, nullptr, &hovered, &held))

{

(*config.value.get())[0] = dummyx;

(*config.value.get())[1] = dummyy;

mvAddCallback(item.config.callback, item.uuid, nullptr, item.config.user_data);

}

if (config.show_label && !item.config.specifiedLabel.empty() && (hovered || held)) {

ImPlotContext& gp = *GImPlot;

char x_buff[IMPLOT_LABEL_MAX_SIZE];

ImPlotAxis& x_axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentX];

ImPlot::LabelAxisValue(x_axis, dummyx, x_buff, sizeof(x_buff), true);

char y_buff[IMPLOT_LABEL_MAX_SIZE];

ImPlotAxis& y_axis = gp.CurrentPlot->Axes[gp.CurrentPlot->CurrentY];

ImPlot::LabelAxisValue(y_axis, dummyy, y_buff, sizeof(y_buff), true);

ImVec4 color = ImPlot::IsColorAuto(config.color.toVec4()) ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : config.color;

ImPlot::Annotation(dummyx, dummyy, color, config.pixOffset, config.clamped, "%s = %s, %s", item.config.specifiedLabel.c_str(), x_buff, y_buff);

}

{

//-----------------------------------------------------------------------------

// pre draw

//-----------------------------------------------------------------------------

if (!item.config.show)

return;

// push font if a font object is attached

if (item.font)

{

ImFont* fontptr = static_cast<mvFont*>(item.font.get())->getFontPtr();

ImGui::PushFont(fontptr);

}

// themes

apply_local_theming(&item);

//-----------------------------------------------------------------------------

// draw

//-----------------------------------------------------------------------------

{

static const std::vector<double>* xptr;

static const std::vector<double>* yptr;

xptr = &(*config.value.get())[0];

yptr = &(*config.value.get())[1];

ImPlot::PlotBars(item.info.internalLabel.c_str(), xptr->data(), yptr->data(), (int)xptr->size(), config.weight, config.flags);

// Begin a popup for a legend entry.

if (ImPlot::BeginLegendPopup(item.info.internalLabel.c_str(), 1))

{

for (auto& childset : item.childslots)

{

for (auto& item : childset)

{

// skip item if it's not shown

if (!item->config.show)

continue;

item->draw(drawlist, ImPlot::GetPlotPos().x, ImPlot::GetPlotPos().y);

UpdateAppItemState(item->state);

}

}

ImPlot::EndLegendPopup();

}

}

//-----------------------------------------------------------------------------

// update state

// * only update if applicable

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

// post draw

//-----------------------------------------------------------------------------

// pop font off stack

if (item.font)

ImGui::PopFont();

// handle popping themes

cleanup_local_theming(&item);