cimplot_structs_accessor.cpp

// Code generated by cmd/codegen from https://github.com/AllenDang/cimgui-go.
// DO NOT EDIT.


#include <string.h>
#include "cimplot_wrapper.h"
#include "cimplot_structs_accessor.h"

void wrap_Formatter_Time_Data_SetTime(Formatter_Time_Data *Formatter_Time_DataPtr, ImPlotTime v) { Formatter_Time_DataPtr->Time = v; }
ImPlotTime wrap_Formatter_Time_Data_GetTime(Formatter_Time_Data *self) { return self->Time; }
void wrap_Formatter_Time_Data_SetSpec(Formatter_Time_Data *Formatter_Time_DataPtr, ImPlotDateTimeSpec v) { Formatter_Time_DataPtr->Spec = v; }
ImPlotDateTimeSpec wrap_Formatter_Time_Data_GetSpec(Formatter_Time_Data *self) { return self->Spec; }
void wrap_Formatter_Time_Data_SetUserFormatter(Formatter_Time_Data *Formatter_Time_DataPtr, ImPlotFormatter v) { Formatter_Time_DataPtr->UserFormatter = v; }
ImPlotFormatter wrap_Formatter_Time_Data_GetUserFormatter(Formatter_Time_Data *self) { return self->UserFormatter; }
void wrap_Formatter_Time_Data_SetUserFormatterData(Formatter_Time_Data *Formatter_Time_DataPtr, uintptr_t v) { Formatter_Time_DataPtr->UserFormatterData = (void*)v; }
uintptr_t wrap_Formatter_Time_Data_GetUserFormatterData(Formatter_Time_Data *self) { return (uintptr_t)self->UserFormatterData; }
void wrap_ImPlotAlignmentData_SetVertical(ImPlotAlignmentData *ImPlotAlignmentDataPtr, bool v) { ImPlotAlignmentDataPtr->Vertical = v; }
bool wrap_ImPlotAlignmentData_GetVertical(ImPlotAlignmentData *self) { return self->Vertical; }
void wrap_ImPlotAlignmentData_SetPadA(ImPlotAlignmentData *ImPlotAlignmentDataPtr, float v) { ImPlotAlignmentDataPtr->PadA = v; }
float wrap_ImPlotAlignmentData_GetPadA(ImPlotAlignmentData *self) { return self->PadA; }
void wrap_ImPlotAlignmentData_SetPadB(ImPlotAlignmentData *ImPlotAlignmentDataPtr, float v) { ImPlotAlignmentDataPtr->PadB = v; }
float wrap_ImPlotAlignmentData_GetPadB(ImPlotAlignmentData *self) { return self->PadB; }
void wrap_ImPlotAlignmentData_SetPadAMax(ImPlotAlignmentData *ImPlotAlignmentDataPtr, float v) { ImPlotAlignmentDataPtr->PadAMax = v; }
float wrap_ImPlotAlignmentData_GetPadAMax(ImPlotAlignmentData *self) { return self->PadAMax; }
void wrap_ImPlotAlignmentData_SetPadBMax(ImPlotAlignmentData *ImPlotAlignmentDataPtr, float v) { ImPlotAlignmentDataPtr->PadBMax = v; }
float wrap_ImPlotAlignmentData_GetPadBMax(ImPlotAlignmentData *self) { return self->PadBMax; }
void wrap_ImPlotAnnotation_SetPos(ImPlotAnnotation *ImPlotAnnotationPtr, ImVec2 v) { ImPlotAnnotationPtr->Pos = v; }
ImVec2 wrap_ImPlotAnnotation_GetPos(ImPlotAnnotation *self) { return self->Pos; }
void wrap_ImPlotAnnotation_SetOffset(ImPlotAnnotation *ImPlotAnnotationPtr, ImVec2 v) { ImPlotAnnotationPtr->Offset = v; }
ImVec2 wrap_ImPlotAnnotation_GetOffset(ImPlotAnnotation *self) { return self->Offset; }
void wrap_ImPlotAnnotation_SetColorBg(ImPlotAnnotation *ImPlotAnnotationPtr, ImU32 v) { ImPlotAnnotationPtr->ColorBg = v; }
ImU32 wrap_ImPlotAnnotation_GetColorBg(ImPlotAnnotation *self) { return self->ColorBg; }
void wrap_ImPlotAnnotation_SetColorFg(ImPlotAnnotation *ImPlotAnnotationPtr, ImU32 v) { ImPlotAnnotationPtr->ColorFg = v; }
ImU32 wrap_ImPlotAnnotation_GetColorFg(ImPlotAnnotation *self) { return self->ColorFg; }
void wrap_ImPlotAnnotation_SetTextOffset(ImPlotAnnotation *ImPlotAnnotationPtr, int v) { ImPlotAnnotationPtr->TextOffset = v; }
int wrap_ImPlotAnnotation_GetTextOffset(ImPlotAnnotation *self) { return self->TextOffset; }
void wrap_ImPlotAnnotation_SetClamp(ImPlotAnnotation *ImPlotAnnotationPtr, bool v) { ImPlotAnnotationPtr->Clamp = v; }
bool wrap_ImPlotAnnotation_GetClamp(ImPlotAnnotation *self) { return self->Clamp; }
void wrap_ImPlotAnnotationCollection_SetAnnotations(ImPlotAnnotationCollection *ImPlotAnnotationCollectionPtr, ImVector_ImPlotAnnotation v) { ImPlotAnnotationCollectionPtr->Annotations = v; }
ImVector_ImPlotAnnotation wrap_ImPlotAnnotationCollection_GetAnnotations(ImPlotAnnotationCollection *self) { return self->Annotations; }
void wrap_ImPlotAnnotationCollection_SetTextBuffer(ImPlotAnnotationCollection *ImPlotAnnotationCollectionPtr, ImGuiTextBuffer v) { ImPlotAnnotationCollectionPtr->TextBuffer = v; }
ImGuiTextBuffer wrap_ImPlotAnnotationCollection_GetTextBuffer(ImPlotAnnotationCollection *self) { return self->TextBuffer; }
void wrap_ImPlotAnnotationCollection_SetSize(ImPlotAnnotationCollection *ImPlotAnnotationCollectionPtr, int v) { ImPlotAnnotationCollectionPtr->Size = v; }
int wrap_ImPlotAnnotationCollection_GetSize(ImPlotAnnotationCollection *self) { return self->Size; }
void wrap_ImPlotAxis_SetID(ImPlotAxis *ImPlotAxisPtr, ImGuiID v) { ImPlotAxisPtr->ID = v; }
ImGuiID wrap_ImPlotAxis_GetID(ImPlotAxis *self) { return self->ID; }
void wrap_ImPlotAxis_SetFlags(ImPlotAxis *ImPlotAxisPtr, ImPlotAxisFlags v) { ImPlotAxisPtr->Flags = v; }
ImPlotAxisFlags wrap_ImPlotAxis_GetFlags(ImPlotAxis *self) { return self->Flags; }
void wrap_ImPlotAxis_SetPreviousFlags(ImPlotAxis *ImPlotAxisPtr, ImPlotAxisFlags v) { ImPlotAxisPtr->PreviousFlags = v; }
ImPlotAxisFlags wrap_ImPlotAxis_GetPreviousFlags(ImPlotAxis *self) { return self->PreviousFlags; }
void wrap_ImPlotAxis_SetRange(ImPlotAxis *ImPlotAxisPtr, ImPlotRange v) { ImPlotAxisPtr->Range = v; }
ImPlotRange wrap_ImPlotAxis_GetRange(ImPlotAxis *self) { return self->Range; }
void wrap_ImPlotAxis_SetRangeCond(ImPlotAxis *ImPlotAxisPtr, ImPlotCond v) { ImPlotAxisPtr->RangeCond = v; }
ImPlotCond wrap_ImPlotAxis_GetRangeCond(ImPlotAxis *self) { return self->RangeCond; }
void wrap_ImPlotAxis_SetScale(ImPlotAxis *ImPlotAxisPtr, ImPlotScale v) { ImPlotAxisPtr->Scale = v; }
ImPlotScale wrap_ImPlotAxis_GetScale(ImPlotAxis *self) { return self->Scale; }
void wrap_ImPlotAxis_SetFitExtents(ImPlotAxis *ImPlotAxisPtr, ImPlotRange v) { ImPlotAxisPtr->FitExtents = v; }
ImPlotRange wrap_ImPlotAxis_GetFitExtents(ImPlotAxis *self) { return self->FitExtents; }
void wrap_ImPlotAxis_SetOrthoAxis(ImPlotAxis *ImPlotAxisPtr, ImPlotAxis* v) { ImPlotAxisPtr->OrthoAxis = v; }
ImPlotAxis* wrap_ImPlotAxis_GetOrthoAxis(ImPlotAxis *self) { return self->OrthoAxis; }
void wrap_ImPlotAxis_SetConstraintRange(ImPlotAxis *ImPlotAxisPtr, ImPlotRange v) { ImPlotAxisPtr->ConstraintRange = v; }
ImPlotRange wrap_ImPlotAxis_GetConstraintRange(ImPlotAxis *self) { return self->ConstraintRange; }
void wrap_ImPlotAxis_SetConstraintZoom(ImPlotAxis *ImPlotAxisPtr, ImPlotRange v) { ImPlotAxisPtr->ConstraintZoom = v; }
ImPlotRange wrap_ImPlotAxis_GetConstraintZoom(ImPlotAxis *self) { return self->ConstraintZoom; }
void wrap_ImPlotAxis_SetTicker(ImPlotAxis *ImPlotAxisPtr, ImPlotTicker v) { ImPlotAxisPtr->Ticker = v; }
ImPlotTicker wrap_ImPlotAxis_GetTicker(ImPlotAxis *self) { return self->Ticker; }
void wrap_ImPlotAxis_SetFormatter(ImPlotAxis *ImPlotAxisPtr, ImPlotFormatter v) { ImPlotAxisPtr->Formatter = v; }
ImPlotFormatter wrap_ImPlotAxis_GetFormatter(ImPlotAxis *self) { return self->Formatter; }
void wrap_ImPlotAxis_SetFormatterData(ImPlotAxis *ImPlotAxisPtr, uintptr_t v) { ImPlotAxisPtr->FormatterData = (void*)v; }
uintptr_t wrap_ImPlotAxis_GetFormatterData(ImPlotAxis *self) { return (uintptr_t)self->FormatterData; }
void wrap_ImPlotAxis_SetFormatSpec(ImPlotAxis *ImPlotAxisPtr, char* v) { memcpy(ImPlotAxisPtr->FormatSpec, v, sizeof(char)*16); }
char* wrap_ImPlotAxis_GetFormatSpec(ImPlotAxis *self) { return self->FormatSpec; }
char cimplot_char_GetAtIdx(char *self, int index) { return self[index]; }
void wrap_ImPlotAxis_SetLocator(ImPlotAxis *ImPlotAxisPtr, ImPlotLocator v) { ImPlotAxisPtr->Locator = v; }
ImPlotLocator wrap_ImPlotAxis_GetLocator(ImPlotAxis *self) { return self->Locator; }
void wrap_ImPlotAxis_SetLinkedMin(ImPlotAxis *ImPlotAxisPtr, double* v) { ImPlotAxisPtr->LinkedMin = v; }
double* wrap_ImPlotAxis_GetLinkedMin(ImPlotAxis *self) { return self->LinkedMin; }
void wrap_ImPlotAxis_SetLinkedMax(ImPlotAxis *ImPlotAxisPtr, double* v) { ImPlotAxisPtr->LinkedMax = v; }
double* wrap_ImPlotAxis_GetLinkedMax(ImPlotAxis *self) { return self->LinkedMax; }
void wrap_ImPlotAxis_SetPickerLevel(ImPlotAxis *ImPlotAxisPtr, int v) { ImPlotAxisPtr->PickerLevel = v; }
int wrap_ImPlotAxis_GetPickerLevel(ImPlotAxis *self) { return self->PickerLevel; }
void wrap_ImPlotAxis_SetPickerTimeMin(ImPlotAxis *ImPlotAxisPtr, ImPlotTime v) { ImPlotAxisPtr->PickerTimeMin = v; }
ImPlotTime wrap_ImPlotAxis_GetPickerTimeMin(ImPlotAxis *self) { return self->PickerTimeMin; }
void wrap_ImPlotAxis_SetPickerTimeMax(ImPlotAxis *ImPlotAxisPtr, ImPlotTime v) { ImPlotAxisPtr->PickerTimeMax = v; }
ImPlotTime wrap_ImPlotAxis_GetPickerTimeMax(ImPlotAxis *self) { return self->PickerTimeMax; }
void wrap_ImPlotAxis_SetTransformForward(ImPlotAxis *ImPlotAxisPtr, ImPlotTransform v) { ImPlotAxisPtr->TransformForward = v; }
ImPlotTransform wrap_ImPlotAxis_GetTransformForward(ImPlotAxis *self) { return self->TransformForward; }
void wrap_ImPlotAxis_SetTransformInverse(ImPlotAxis *ImPlotAxisPtr, ImPlotTransform v) { ImPlotAxisPtr->TransformInverse = v; }
ImPlotTransform wrap_ImPlotAxis_GetTransformInverse(ImPlotAxis *self) { return self->TransformInverse; }
void wrap_ImPlotAxis_SetTransformData(ImPlotAxis *ImPlotAxisPtr, uintptr_t v) { ImPlotAxisPtr->TransformData = (void*)v; }
uintptr_t wrap_ImPlotAxis_GetTransformData(ImPlotAxis *self) { return (uintptr_t)self->TransformData; }
void wrap_ImPlotAxis_SetPixelMin(ImPlotAxis *ImPlotAxisPtr, float v) { ImPlotAxisPtr->PixelMin = v; }
float wrap_ImPlotAxis_GetPixelMin(ImPlotAxis *self) { return self->PixelMin; }
void wrap_ImPlotAxis_SetPixelMax(ImPlotAxis *ImPlotAxisPtr, float v) { ImPlotAxisPtr->PixelMax = v; }
float wrap_ImPlotAxis_GetPixelMax(ImPlotAxis *self) { return self->PixelMax; }
void wrap_ImPlotAxis_SetScaleMin(ImPlotAxis *ImPlotAxisPtr, double v) { ImPlotAxisPtr->ScaleMin = v; }
double wrap_ImPlotAxis_GetScaleMin(ImPlotAxis *self) { return self->ScaleMin; }
void wrap_ImPlotAxis_SetScaleMax(ImPlotAxis *ImPlotAxisPtr, double v) { ImPlotAxisPtr->ScaleMax = v; }
double wrap_ImPlotAxis_GetScaleMax(ImPlotAxis *self) { return self->ScaleMax; }
void wrap_ImPlotAxis_SetScaleToPixel(ImPlotAxis *ImPlotAxisPtr, double v) { ImPlotAxisPtr->ScaleToPixel = v; }
double wrap_ImPlotAxis_GetScaleToPixel(ImPlotAxis *self) { return self->ScaleToPixel; }
void wrap_ImPlotAxis_SetDatum1(ImPlotAxis *ImPlotAxisPtr, float v) { ImPlotAxisPtr->Datum1 = v; }
float wrap_ImPlotAxis_GetDatum1(ImPlotAxis *self) { return self->Datum1; }
void wrap_ImPlotAxis_SetDatum2(ImPlotAxis *ImPlotAxisPtr, float v) { ImPlotAxisPtr->Datum2 = v; }
float wrap_ImPlotAxis_GetDatum2(ImPlotAxis *self) { return self->Datum2; }
void wrap_ImPlotAxis_SetHoverRect(ImPlotAxis *ImPlotAxisPtr, ImRect v) { ImPlotAxisPtr->HoverRect = v; }
ImRect wrap_ImPlotAxis_GetHoverRect(ImPlotAxis *self) { return self->HoverRect; }
void wrap_ImPlotAxis_SetLabelOffset(ImPlotAxis *ImPlotAxisPtr, int v) { ImPlotAxisPtr->LabelOffset = v; }
int wrap_ImPlotAxis_GetLabelOffset(ImPlotAxis *self) { return self->LabelOffset; }
void wrap_ImPlotAxis_SetColorMaj(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorMaj = v; }
ImU32 wrap_ImPlotAxis_GetColorMaj(ImPlotAxis *self) { return self->ColorMaj; }
void wrap_ImPlotAxis_SetColorMin(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorMin = v; }
ImU32 wrap_ImPlotAxis_GetColorMin(ImPlotAxis *self) { return self->ColorMin; }
void wrap_ImPlotAxis_SetColorTick(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorTick = v; }
ImU32 wrap_ImPlotAxis_GetColorTick(ImPlotAxis *self) { return self->ColorTick; }
void wrap_ImPlotAxis_SetColorTxt(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorTxt = v; }
ImU32 wrap_ImPlotAxis_GetColorTxt(ImPlotAxis *self) { return self->ColorTxt; }
void wrap_ImPlotAxis_SetColorBg(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorBg = v; }
ImU32 wrap_ImPlotAxis_GetColorBg(ImPlotAxis *self) { return self->ColorBg; }
void wrap_ImPlotAxis_SetColorHov(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorHov = v; }
ImU32 wrap_ImPlotAxis_GetColorHov(ImPlotAxis *self) { return self->ColorHov; }
void wrap_ImPlotAxis_SetColorAct(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorAct = v; }
ImU32 wrap_ImPlotAxis_GetColorAct(ImPlotAxis *self) { return self->ColorAct; }
void wrap_ImPlotAxis_SetColorHiLi(ImPlotAxis *ImPlotAxisPtr, ImU32 v) { ImPlotAxisPtr->ColorHiLi = v; }
ImU32 wrap_ImPlotAxis_GetColorHiLi(ImPlotAxis *self) { return self->ColorHiLi; }
void wrap_ImPlotAxis_SetEnabled(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->Enabled = v; }
bool wrap_ImPlotAxis_GetEnabled(ImPlotAxis *self) { return self->Enabled; }
void wrap_ImPlotAxis_SetVertical(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->Vertical = v; }
bool wrap_ImPlotAxis_GetVertical(ImPlotAxis *self) { return self->Vertical; }
void wrap_ImPlotAxis_SetFitThisFrame(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->FitThisFrame = v; }
bool wrap_ImPlotAxis_GetFitThisFrame(ImPlotAxis *self) { return self->FitThisFrame; }
void wrap_ImPlotAxis_SetHasRange(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->HasRange = v; }
bool wrap_ImPlotAxis_GetHasRange(ImPlotAxis *self) { return self->HasRange; }
void wrap_ImPlotAxis_SetHasFormatSpec(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->HasFormatSpec = v; }
bool wrap_ImPlotAxis_GetHasFormatSpec(ImPlotAxis *self) { return self->HasFormatSpec; }
void wrap_ImPlotAxis_SetShowDefaultTicks(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->ShowDefaultTicks = v; }
bool wrap_ImPlotAxis_GetShowDefaultTicks(ImPlotAxis *self) { return self->ShowDefaultTicks; }
void wrap_ImPlotAxis_SetHovered(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->Hovered = v; }
bool wrap_ImPlotAxis_GetHovered(ImPlotAxis *self) { return self->Hovered; }
void wrap_ImPlotAxis_SetHeld(ImPlotAxis *ImPlotAxisPtr, bool v) { ImPlotAxisPtr->Held = v; }
bool wrap_ImPlotAxis_GetHeld(ImPlotAxis *self) { return self->Held; }
void wrap_ImPlotColormapData_SetKeys(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_ImU32 v) { ImPlotColormapDataPtr->Keys = v; }
void wrap_ImPlotColormapData_SetKeyCounts(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_int v) { ImPlotColormapDataPtr->KeyCounts = v; }
ImVector_int wrap_ImPlotColormapData_GetKeyCounts(ImPlotColormapData *self) { return self->KeyCounts; }
void wrap_ImPlotColormapData_SetKeyOffsets(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_int v) { ImPlotColormapDataPtr->KeyOffsets = v; }
ImVector_int wrap_ImPlotColormapData_GetKeyOffsets(ImPlotColormapData *self) { return self->KeyOffsets; }
void wrap_ImPlotColormapData_SetTables(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_ImU32 v) { ImPlotColormapDataPtr->Tables = v; }
ImVector_ImU32 wrap_ImPlotColormapData_GetTables(ImPlotColormapData *self) { return self->Tables; }
void wrap_ImPlotColormapData_SetTableSizes(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_int v) { ImPlotColormapDataPtr->TableSizes = v; }
ImVector_int wrap_ImPlotColormapData_GetTableSizes(ImPlotColormapData *self) { return self->TableSizes; }
void wrap_ImPlotColormapData_SetTableOffsets(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_int v) { ImPlotColormapDataPtr->TableOffsets = v; }
ImVector_int wrap_ImPlotColormapData_GetTableOffsets(ImPlotColormapData *self) { return self->TableOffsets; }
void wrap_ImPlotColormapData_SetText(ImPlotColormapData *ImPlotColormapDataPtr, ImGuiTextBuffer v) { ImPlotColormapDataPtr->Text = v; }
ImGuiTextBuffer wrap_ImPlotColormapData_GetText(ImPlotColormapData *self) { return self->Text; }
void wrap_ImPlotColormapData_SetTextOffsets(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_int v) { ImPlotColormapDataPtr->TextOffsets = v; }
ImVector_int wrap_ImPlotColormapData_GetTextOffsets(ImPlotColormapData *self) { return self->TextOffsets; }
void wrap_ImPlotColormapData_SetQuals(ImPlotColormapData *ImPlotColormapDataPtr, ImVector_bool v) { ImPlotColormapDataPtr->Quals = v; }
ImVector_bool wrap_ImPlotColormapData_GetQuals(ImPlotColormapData *self) { return self->Quals; }
void wrap_ImPlotColormapData_SetMap(ImPlotColormapData *ImPlotColormapDataPtr, ImGuiStorage v) { ImPlotColormapDataPtr->Map = v; }
ImGuiStorage wrap_ImPlotColormapData_GetMap(ImPlotColormapData *self) { return self->Map; }
void wrap_ImPlotColormapData_SetCount(ImPlotColormapData *ImPlotColormapDataPtr, int v) { ImPlotColormapDataPtr->Count = v; }
int wrap_ImPlotColormapData_GetCount(ImPlotColormapData *self) { return self->Count; }
void wrap_ImPlotContext_SetPlots(ImPlotContext *ImPlotContextPtr, ImPool_ImPlotPlot v) { ImPlotContextPtr->Plots = v; }
ImPool_ImPlotPlot wrap_ImPlotContext_GetPlots(ImPlotContext *self) { return self->Plots; }
void wrap_ImPlotContext_SetSubplots(ImPlotContext *ImPlotContextPtr, ImPool_ImPlotSubplot v) { ImPlotContextPtr->Subplots = v; }
ImPool_ImPlotSubplot wrap_ImPlotContext_GetSubplots(ImPlotContext *self) { return self->Subplots; }
void wrap_ImPlotContext_SetCurrentPlot(ImPlotContext *ImPlotContextPtr, ImPlotPlot* v) { ImPlotContextPtr->CurrentPlot = v; }
ImPlotPlot* wrap_ImPlotContext_GetCurrentPlot(ImPlotContext *self) { return self->CurrentPlot; }
void wrap_ImPlotContext_SetCurrentSubplot(ImPlotContext *ImPlotContextPtr, ImPlotSubplot* v) { ImPlotContextPtr->CurrentSubplot = v; }
ImPlotSubplot* wrap_ImPlotContext_GetCurrentSubplot(ImPlotContext *self) { return self->CurrentSubplot; }
void wrap_ImPlotContext_SetCurrentItems(ImPlotContext *ImPlotContextPtr, ImPlotItemGroup* v) { ImPlotContextPtr->CurrentItems = v; }
ImPlotItemGroup* wrap_ImPlotContext_GetCurrentItems(ImPlotContext *self) { return self->CurrentItems; }
void wrap_ImPlotContext_SetCurrentItem(ImPlotContext *ImPlotContextPtr, ImPlotItem* v) { ImPlotContextPtr->CurrentItem = v; }
ImPlotItem* wrap_ImPlotContext_GetCurrentItem(ImPlotContext *self) { return self->CurrentItem; }
void wrap_ImPlotContext_SetPreviousItem(ImPlotContext *ImPlotContextPtr, ImPlotItem* v) { ImPlotContextPtr->PreviousItem = v; }
ImPlotItem* wrap_ImPlotContext_GetPreviousItem(ImPlotContext *self) { return self->PreviousItem; }
void wrap_ImPlotContext_SetCTicker(ImPlotContext *ImPlotContextPtr, ImPlotTicker v) { ImPlotContextPtr->CTicker = v; }
ImPlotTicker wrap_ImPlotContext_GetCTicker(ImPlotContext *self) { return self->CTicker; }
void wrap_ImPlotContext_SetAnnotations(ImPlotContext *ImPlotContextPtr, ImPlotAnnotationCollection v) { ImPlotContextPtr->Annotations = v; }
ImPlotAnnotationCollection wrap_ImPlotContext_GetAnnotations(ImPlotContext *self) { return self->Annotations; }
void wrap_ImPlotContext_SetTags(ImPlotContext *ImPlotContextPtr, ImPlotTagCollection v) { ImPlotContextPtr->Tags = v; }
ImPlotTagCollection wrap_ImPlotContext_GetTags(ImPlotContext *self) { return self->Tags; }
void wrap_ImPlotContext_SetStyle(ImPlotContext *ImPlotContextPtr, ImPlotStyle v) { ImPlotContextPtr->Style = v; }
ImPlotStyle wrap_ImPlotContext_GetStyle(ImPlotContext *self) { return self->Style; }
void wrap_ImPlotContext_SetColorModifiers(ImPlotContext *ImPlotContextPtr, ImVector_ImGuiColorMod v) { ImPlotContextPtr->ColorModifiers = v; }
ImVector_ImGuiColorMod wrap_ImPlotContext_GetColorModifiers(ImPlotContext *self) { return self->ColorModifiers; }
void wrap_ImPlotContext_SetStyleModifiers(ImPlotContext *ImPlotContextPtr, ImVector_ImGuiStyleMod v) { ImPlotContextPtr->StyleModifiers = v; }
ImVector_ImGuiStyleMod wrap_ImPlotContext_GetStyleModifiers(ImPlotContext *self) { return self->StyleModifiers; }
void wrap_ImPlotContext_SetColormapData(ImPlotContext *ImPlotContextPtr, ImPlotColormapData v) { ImPlotContextPtr->ColormapData = v; }
ImPlotColormapData wrap_ImPlotContext_GetColormapData(ImPlotContext *self) { return self->ColormapData; }
void wrap_ImPlotContext_SetColormapModifiers(ImPlotContext *ImPlotContextPtr, ImVector_ImPlotColormap v) { ImPlotContextPtr->ColormapModifiers = v; }
ImVector_ImPlotColormap wrap_ImPlotContext_GetColormapModifiers(ImPlotContext *self) { return self->ColormapModifiers; }
void wrap_ImPlotContext_SetTm(ImPlotContext *ImPlotContextPtr, tm v) { ImPlotContextPtr->Tm = v; }
tm wrap_ImPlotContext_GetTm(ImPlotContext *self) { return self->Tm; }
void wrap_ImPlotContext_SetTempDouble1(ImPlotContext *ImPlotContextPtr, ImVector_double v) { ImPlotContextPtr->TempDouble1 = v; }
ImVector_double wrap_ImPlotContext_GetTempDouble1(ImPlotContext *self) { return self->TempDouble1; }
void wrap_ImPlotContext_SetTempDouble2(ImPlotContext *ImPlotContextPtr, ImVector_double v) { ImPlotContextPtr->TempDouble2 = v; }
ImVector_double wrap_ImPlotContext_GetTempDouble2(ImPlotContext *self) { return self->TempDouble2; }
void wrap_ImPlotContext_SetTempInt1(ImPlotContext *ImPlotContextPtr, ImVector_int v) { ImPlotContextPtr->TempInt1 = v; }
ImVector_int wrap_ImPlotContext_GetTempInt1(ImPlotContext *self) { return self->TempInt1; }
void wrap_ImPlotContext_SetDigitalPlotItemCnt(ImPlotContext *ImPlotContextPtr, int v) { ImPlotContextPtr->DigitalPlotItemCnt = v; }
int wrap_ImPlotContext_GetDigitalPlotItemCnt(ImPlotContext *self) { return self->DigitalPlotItemCnt; }
void wrap_ImPlotContext_SetDigitalPlotOffset(ImPlotContext *ImPlotContextPtr, int v) { ImPlotContextPtr->DigitalPlotOffset = v; }
int wrap_ImPlotContext_GetDigitalPlotOffset(ImPlotContext *self) { return self->DigitalPlotOffset; }
void wrap_ImPlotContext_SetNextPlotData(ImPlotContext *ImPlotContextPtr, ImPlotNextPlotData v) { ImPlotContextPtr->NextPlotData = v; }
ImPlotNextPlotData wrap_ImPlotContext_GetNextPlotData(ImPlotContext *self) { return self->NextPlotData; }
void wrap_ImPlotContext_SetNextItemData(ImPlotContext *ImPlotContextPtr, ImPlotNextItemData v) { ImPlotContextPtr->NextItemData = v; }
ImPlotNextItemData wrap_ImPlotContext_GetNextItemData(ImPlotContext *self) { return self->NextItemData; }
void wrap_ImPlotContext_SetInputMap(ImPlotContext *ImPlotContextPtr, ImPlotInputMap v) { ImPlotContextPtr->InputMap = v; }
ImPlotInputMap wrap_ImPlotContext_GetInputMap(ImPlotContext *self) { return self->InputMap; }
void wrap_ImPlotContext_SetOpenContextThisFrame(ImPlotContext *ImPlotContextPtr, bool v) { ImPlotContextPtr->OpenContextThisFrame = v; }
bool wrap_ImPlotContext_GetOpenContextThisFrame(ImPlotContext *self) { return self->OpenContextThisFrame; }
void wrap_ImPlotContext_SetMousePosStringBuilder(ImPlotContext *ImPlotContextPtr, ImGuiTextBuffer v) { ImPlotContextPtr->MousePosStringBuilder = v; }
ImGuiTextBuffer wrap_ImPlotContext_GetMousePosStringBuilder(ImPlotContext *self) { return self->MousePosStringBuilder; }
void wrap_ImPlotContext_SetSortItems(ImPlotContext *ImPlotContextPtr, ImPlotItemGroup* v) { ImPlotContextPtr->SortItems = v; }
ImPlotItemGroup* wrap_ImPlotContext_GetSortItems(ImPlotContext *self) { return self->SortItems; }
void wrap_ImPlotContext_SetAlignmentData(ImPlotContext *ImPlotContextPtr, ImPool_ImPlotAlignmentData v) { ImPlotContextPtr->AlignmentData = v; }
ImPool_ImPlotAlignmentData wrap_ImPlotContext_GetAlignmentData(ImPlotContext *self) { return self->AlignmentData; }
void wrap_ImPlotContext_SetCurrentAlignmentH(ImPlotContext *ImPlotContextPtr, ImPlotAlignmentData* v) { ImPlotContextPtr->CurrentAlignmentH = v; }
ImPlotAlignmentData* wrap_ImPlotContext_GetCurrentAlignmentH(ImPlotContext *self) { return self->CurrentAlignmentH; }
void wrap_ImPlotContext_SetCurrentAlignmentV(ImPlotContext *ImPlotContextPtr, ImPlotAlignmentData* v) { ImPlotContextPtr->CurrentAlignmentV = v; }
ImPlotAlignmentData* wrap_ImPlotContext_GetCurrentAlignmentV(ImPlotContext *self) { return self->CurrentAlignmentV; }
void wrap_ImPlotDateTimeSpec_SetDate(ImPlotDateTimeSpec *ImPlotDateTimeSpecPtr, ImPlotDateFmt v) { ImPlotDateTimeSpecPtr->Date = v; }
ImPlotDateFmt wrap_ImPlotDateTimeSpec_GetDate(ImPlotDateTimeSpec *self) { return self->Date; }
void wrap_ImPlotDateTimeSpec_SetTime(ImPlotDateTimeSpec *ImPlotDateTimeSpecPtr, ImPlotTimeFmt v) { ImPlotDateTimeSpecPtr->Time = v; }
ImPlotTimeFmt wrap_ImPlotDateTimeSpec_GetTime(ImPlotDateTimeSpec *self) { return self->Time; }
void wrap_ImPlotDateTimeSpec_SetUseISO8601(ImPlotDateTimeSpec *ImPlotDateTimeSpecPtr, bool v) { ImPlotDateTimeSpecPtr->UseISO8601 = v; }
bool wrap_ImPlotDateTimeSpec_GetUseISO8601(ImPlotDateTimeSpec *self) { return self->UseISO8601; }
void wrap_ImPlotDateTimeSpec_SetUse24HourClock(ImPlotDateTimeSpec *ImPlotDateTimeSpecPtr, bool v) { ImPlotDateTimeSpecPtr->Use24HourClock = v; }
bool wrap_ImPlotDateTimeSpec_GetUse24HourClock(ImPlotDateTimeSpec *self) { return self->Use24HourClock; }
void wrap_ImPlotInputMap_SetPan(ImPlotInputMap *ImPlotInputMapPtr, ImGuiMouseButton v) { ImPlotInputMapPtr->Pan = v; }
ImGuiMouseButton wrap_ImPlotInputMap_GetPan(ImPlotInputMap *self) { return self->Pan; }
void wrap_ImPlotInputMap_SetPanMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->PanMod = v; }
int wrap_ImPlotInputMap_GetPanMod(ImPlotInputMap *self) { return self->PanMod; }
void wrap_ImPlotInputMap_SetFit(ImPlotInputMap *ImPlotInputMapPtr, ImGuiMouseButton v) { ImPlotInputMapPtr->Fit = v; }
ImGuiMouseButton wrap_ImPlotInputMap_GetFit(ImPlotInputMap *self) { return self->Fit; }
void wrap_ImPlotInputMap_SetSelect(ImPlotInputMap *ImPlotInputMapPtr, ImGuiMouseButton v) { ImPlotInputMapPtr->Select = v; }
ImGuiMouseButton wrap_ImPlotInputMap_GetSelect(ImPlotInputMap *self) { return self->Select; }
void wrap_ImPlotInputMap_SetSelectCancel(ImPlotInputMap *ImPlotInputMapPtr, ImGuiMouseButton v) { ImPlotInputMapPtr->SelectCancel = v; }
ImGuiMouseButton wrap_ImPlotInputMap_GetSelectCancel(ImPlotInputMap *self) { return self->SelectCancel; }
void wrap_ImPlotInputMap_SetSelectMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->SelectMod = v; }
int wrap_ImPlotInputMap_GetSelectMod(ImPlotInputMap *self) { return self->SelectMod; }
void wrap_ImPlotInputMap_SetSelectHorzMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->SelectHorzMod = v; }
int wrap_ImPlotInputMap_GetSelectHorzMod(ImPlotInputMap *self) { return self->SelectHorzMod; }
void wrap_ImPlotInputMap_SetSelectVertMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->SelectVertMod = v; }
int wrap_ImPlotInputMap_GetSelectVertMod(ImPlotInputMap *self) { return self->SelectVertMod; }
void wrap_ImPlotInputMap_SetMenu(ImPlotInputMap *ImPlotInputMapPtr, ImGuiMouseButton v) { ImPlotInputMapPtr->Menu = v; }
ImGuiMouseButton wrap_ImPlotInputMap_GetMenu(ImPlotInputMap *self) { return self->Menu; }
void wrap_ImPlotInputMap_SetOverrideMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->OverrideMod = v; }
int wrap_ImPlotInputMap_GetOverrideMod(ImPlotInputMap *self) { return self->OverrideMod; }
void wrap_ImPlotInputMap_SetZoomMod(ImPlotInputMap *ImPlotInputMapPtr, int v) { ImPlotInputMapPtr->ZoomMod = v; }
int wrap_ImPlotInputMap_GetZoomMod(ImPlotInputMap *self) { return self->ZoomMod; }
void wrap_ImPlotInputMap_SetZoomRate(ImPlotInputMap *ImPlotInputMapPtr, float v) { ImPlotInputMapPtr->ZoomRate = v; }
float wrap_ImPlotInputMap_GetZoomRate(ImPlotInputMap *self) { return self->ZoomRate; }
void wrap_ImPlotItem_SetID(ImPlotItem *ImPlotItemPtr, ImGuiID v) { ImPlotItemPtr->ID = v; }
ImGuiID wrap_ImPlotItem_GetID(ImPlotItem *self) { return self->ID; }
void wrap_ImPlotItem_SetColor(ImPlotItem *ImPlotItemPtr, ImU32 v) { ImPlotItemPtr->Color = v; }
ImU32 wrap_ImPlotItem_GetColor(ImPlotItem *self) { return self->Color; }
void wrap_ImPlotItem_SetLegendHoverRect(ImPlotItem *ImPlotItemPtr, ImRect v) { ImPlotItemPtr->LegendHoverRect = v; }
ImRect wrap_ImPlotItem_GetLegendHoverRect(ImPlotItem *self) { return self->LegendHoverRect; }
void wrap_ImPlotItem_SetNameOffset(ImPlotItem *ImPlotItemPtr, int v) { ImPlotItemPtr->NameOffset = v; }
int wrap_ImPlotItem_GetNameOffset(ImPlotItem *self) { return self->NameOffset; }
void wrap_ImPlotItem_SetShow(ImPlotItem *ImPlotItemPtr, bool v) { ImPlotItemPtr->Show = v; }
bool wrap_ImPlotItem_GetShow(ImPlotItem *self) { return self->Show; }
void wrap_ImPlotItem_SetLegendHovered(ImPlotItem *ImPlotItemPtr, bool v) { ImPlotItemPtr->LegendHovered = v; }
bool wrap_ImPlotItem_GetLegendHovered(ImPlotItem *self) { return self->LegendHovered; }
void wrap_ImPlotItem_SetSeenThisFrame(ImPlotItem *ImPlotItemPtr, bool v) { ImPlotItemPtr->SeenThisFrame = v; }
bool wrap_ImPlotItem_GetSeenThisFrame(ImPlotItem *self) { return self->SeenThisFrame; }
void wrap_ImPlotItemGroup_SetID(ImPlotItemGroup *ImPlotItemGroupPtr, ImGuiID v) { ImPlotItemGroupPtr->ID = v; }
ImGuiID wrap_ImPlotItemGroup_GetID(ImPlotItemGroup *self) { return self->ID; }
void wrap_ImPlotItemGroup_SetLegend(ImPlotItemGroup *ImPlotItemGroupPtr, ImPlotLegend v) { ImPlotItemGroupPtr->Legend = v; }
ImPlotLegend wrap_ImPlotItemGroup_GetLegend(ImPlotItemGroup *self) { return self->Legend; }
void wrap_ImPlotItemGroup_SetItemPool(ImPlotItemGroup *ImPlotItemGroupPtr, ImPool_ImPlotItem v) { ImPlotItemGroupPtr->ItemPool = v; }
ImPool_ImPlotItem wrap_ImPlotItemGroup_GetItemPool(ImPlotItemGroup *self) { return self->ItemPool; }
void wrap_ImPlotItemGroup_SetColormapIdx(ImPlotItemGroup *ImPlotItemGroupPtr, int v) { ImPlotItemGroupPtr->ColormapIdx = v; }
int wrap_ImPlotItemGroup_GetColormapIdx(ImPlotItemGroup *self) { return self->ColormapIdx; }
void wrap_ImPlotLegend_SetFlags(ImPlotLegend *ImPlotLegendPtr, ImPlotLegendFlags v) { ImPlotLegendPtr->Flags = v; }
ImPlotLegendFlags wrap_ImPlotLegend_GetFlags(ImPlotLegend *self) { return self->Flags; }
void wrap_ImPlotLegend_SetPreviousFlags(ImPlotLegend *ImPlotLegendPtr, ImPlotLegendFlags v) { ImPlotLegendPtr->PreviousFlags = v; }
ImPlotLegendFlags wrap_ImPlotLegend_GetPreviousFlags(ImPlotLegend *self) { return self->PreviousFlags; }
void wrap_ImPlotLegend_SetLocation(ImPlotLegend *ImPlotLegendPtr, ImPlotLocation v) { ImPlotLegendPtr->Location = v; }
ImPlotLocation wrap_ImPlotLegend_GetLocation(ImPlotLegend *self) { return self->Location; }
void wrap_ImPlotLegend_SetPreviousLocation(ImPlotLegend *ImPlotLegendPtr, ImPlotLocation v) { ImPlotLegendPtr->PreviousLocation = v; }
ImPlotLocation wrap_ImPlotLegend_GetPreviousLocation(ImPlotLegend *self) { return self->PreviousLocation; }
void wrap_ImPlotLegend_SetScroll(ImPlotLegend *ImPlotLegendPtr, ImVec2 v) { ImPlotLegendPtr->Scroll = v; }
ImVec2 wrap_ImPlotLegend_GetScroll(ImPlotLegend *self) { return self->Scroll; }
void wrap_ImPlotLegend_SetIndices(ImPlotLegend *ImPlotLegendPtr, ImVector_int v) { ImPlotLegendPtr->Indices = v; }
ImVector_int wrap_ImPlotLegend_GetIndices(ImPlotLegend *self) { return self->Indices; }
void wrap_ImPlotLegend_SetLabels(ImPlotLegend *ImPlotLegendPtr, ImGuiTextBuffer v) { ImPlotLegendPtr->Labels = v; }
ImGuiTextBuffer wrap_ImPlotLegend_GetLabels(ImPlotLegend *self) { return self->Labels; }
void wrap_ImPlotLegend_SetRect(ImPlotLegend *ImPlotLegendPtr, ImRect v) { ImPlotLegendPtr->Rect = v; }
ImRect wrap_ImPlotLegend_GetRect(ImPlotLegend *self) { return self->Rect; }
void wrap_ImPlotLegend_SetRectClamped(ImPlotLegend *ImPlotLegendPtr, ImRect v) { ImPlotLegendPtr->RectClamped = v; }
ImRect wrap_ImPlotLegend_GetRectClamped(ImPlotLegend *self) { return self->RectClamped; }
void wrap_ImPlotLegend_SetHovered(ImPlotLegend *ImPlotLegendPtr, bool v) { ImPlotLegendPtr->Hovered = v; }
bool wrap_ImPlotLegend_GetHovered(ImPlotLegend *self) { return self->Hovered; }
void wrap_ImPlotLegend_SetHeld(ImPlotLegend *ImPlotLegendPtr, bool v) { ImPlotLegendPtr->Held = v; }
bool wrap_ImPlotLegend_GetHeld(ImPlotLegend *self) { return self->Held; }
void wrap_ImPlotLegend_SetCanGoInside(ImPlotLegend *ImPlotLegendPtr, bool v) { ImPlotLegendPtr->CanGoInside = v; }
bool wrap_ImPlotLegend_GetCanGoInside(ImPlotLegend *self) { return self->CanGoInside; }
void wrap_ImPlotNextItemData_SetColors(ImPlotNextItemData *ImPlotNextItemDataPtr, ImVec4* v) { memcpy(ImPlotNextItemDataPtr->Colors, v, sizeof(ImVec4)*5); }
ImVec4* wrap_ImPlotNextItemData_GetColors(ImPlotNextItemData *self) { return self->Colors; }
ImVec4 cimplot_ImVec4_GetAtIdx(ImVec4 *self, int index) { return self[index]; }
void wrap_ImPlotNextItemData_SetLineWeight(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->LineWeight = v; }
float wrap_ImPlotNextItemData_GetLineWeight(ImPlotNextItemData *self) { return self->LineWeight; }
void wrap_ImPlotNextItemData_SetMarker(ImPlotNextItemData *ImPlotNextItemDataPtr, ImPlotMarker v) { ImPlotNextItemDataPtr->Marker = v; }
ImPlotMarker wrap_ImPlotNextItemData_GetMarker(ImPlotNextItemData *self) { return self->Marker; }
void wrap_ImPlotNextItemData_SetMarkerSize(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->MarkerSize = v; }
float wrap_ImPlotNextItemData_GetMarkerSize(ImPlotNextItemData *self) { return self->MarkerSize; }
void wrap_ImPlotNextItemData_SetMarkerWeight(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->MarkerWeight = v; }
float wrap_ImPlotNextItemData_GetMarkerWeight(ImPlotNextItemData *self) { return self->MarkerWeight; }
void wrap_ImPlotNextItemData_SetFillAlpha(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->FillAlpha = v; }
float wrap_ImPlotNextItemData_GetFillAlpha(ImPlotNextItemData *self) { return self->FillAlpha; }
void wrap_ImPlotNextItemData_SetErrorBarSize(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->ErrorBarSize = v; }
float wrap_ImPlotNextItemData_GetErrorBarSize(ImPlotNextItemData *self) { return self->ErrorBarSize; }
void wrap_ImPlotNextItemData_SetErrorBarWeight(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->ErrorBarWeight = v; }
float wrap_ImPlotNextItemData_GetErrorBarWeight(ImPlotNextItemData *self) { return self->ErrorBarWeight; }
void wrap_ImPlotNextItemData_SetDigitalBitHeight(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->DigitalBitHeight = v; }
float wrap_ImPlotNextItemData_GetDigitalBitHeight(ImPlotNextItemData *self) { return self->DigitalBitHeight; }
void wrap_ImPlotNextItemData_SetDigitalBitGap(ImPlotNextItemData *ImPlotNextItemDataPtr, float v) { ImPlotNextItemDataPtr->DigitalBitGap = v; }
float wrap_ImPlotNextItemData_GetDigitalBitGap(ImPlotNextItemData *self) { return self->DigitalBitGap; }
void wrap_ImPlotNextItemData_SetRenderLine(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->RenderLine = v; }
bool wrap_ImPlotNextItemData_GetRenderLine(ImPlotNextItemData *self) { return self->RenderLine; }
void wrap_ImPlotNextItemData_SetRenderFill(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->RenderFill = v; }
bool wrap_ImPlotNextItemData_GetRenderFill(ImPlotNextItemData *self) { return self->RenderFill; }
void wrap_ImPlotNextItemData_SetRenderMarkerLine(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->RenderMarkerLine = v; }
bool wrap_ImPlotNextItemData_GetRenderMarkerLine(ImPlotNextItemData *self) { return self->RenderMarkerLine; }
void wrap_ImPlotNextItemData_SetRenderMarkerFill(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->RenderMarkerFill = v; }
bool wrap_ImPlotNextItemData_GetRenderMarkerFill(ImPlotNextItemData *self) { return self->RenderMarkerFill; }
void wrap_ImPlotNextItemData_SetHasHidden(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->HasHidden = v; }
bool wrap_ImPlotNextItemData_GetHasHidden(ImPlotNextItemData *self) { return self->HasHidden; }
void wrap_ImPlotNextItemData_SetHidden(ImPlotNextItemData *ImPlotNextItemDataPtr, bool v) { ImPlotNextItemDataPtr->Hidden = v; }
bool wrap_ImPlotNextItemData_GetHidden(ImPlotNextItemData *self) { return self->Hidden; }
void wrap_ImPlotNextItemData_SetHiddenCond(ImPlotNextItemData *ImPlotNextItemDataPtr, ImPlotCond v) { ImPlotNextItemDataPtr->HiddenCond = v; }
ImPlotCond wrap_ImPlotNextItemData_GetHiddenCond(ImPlotNextItemData *self) { return self->HiddenCond; }
void wrap_ImPlotNextPlotData_SetRangeCond(ImPlotNextPlotData *ImPlotNextPlotDataPtr, ImPlotCond* v) { memcpy(ImPlotNextPlotDataPtr->RangeCond, v, sizeof(ImPlotCond)*6); }
ImPlotCond* wrap_ImPlotNextPlotData_GetRangeCond(ImPlotNextPlotData *self) { return self->RangeCond; }
ImPlotCond cimplot_ImPlotCond_GetAtIdx(ImPlotCond *self, int index) { return self[index]; }
void wrap_ImPlotNextPlotData_SetRange(ImPlotNextPlotData *ImPlotNextPlotDataPtr, ImPlotRange* v) { memcpy(ImPlotNextPlotDataPtr->Range, v, sizeof(ImPlotRange)*6); }
ImPlotRange* wrap_ImPlotNextPlotData_GetRange(ImPlotNextPlotData *self) { return self->Range; }
ImPlotRange cimplot_ImPlotRange_GetAtIdx(ImPlotRange *self, int index) { return self[index]; }
void wrap_ImPlotNextPlotData_SetHasRange(ImPlotNextPlotData *ImPlotNextPlotDataPtr, bool* v) { memcpy(ImPlotNextPlotDataPtr->HasRange, v, sizeof(bool)*6); }
bool* wrap_ImPlotNextPlotData_GetHasRange(ImPlotNextPlotData *self) { return self->HasRange; }
bool cimplot_bool_GetAtIdx(bool *self, int index) { return self[index]; }
void wrap_ImPlotNextPlotData_SetFit(ImPlotNextPlotData *ImPlotNextPlotDataPtr, bool* v) { memcpy(ImPlotNextPlotDataPtr->Fit, v, sizeof(bool)*6); }
bool* wrap_ImPlotNextPlotData_GetFit(ImPlotNextPlotData *self) { return self->Fit; }
void wrap_ImPlotNextPlotData_SetLinkedMin(ImPlotNextPlotData *ImPlotNextPlotDataPtr, double** v) { memcpy(ImPlotNextPlotDataPtr->LinkedMin, v, sizeof(double*)*6); }
double** wrap_ImPlotNextPlotData_GetLinkedMin(ImPlotNextPlotData *self) { return self->LinkedMin; }
double* cimplot_doublePtr_GetAtIdx(double* *self, int index) { return self[index]; }
void wrap_ImPlotNextPlotData_SetLinkedMax(ImPlotNextPlotData *ImPlotNextPlotDataPtr, double** v) { memcpy(ImPlotNextPlotDataPtr->LinkedMax, v, sizeof(double*)*6); }
double** wrap_ImPlotNextPlotData_GetLinkedMax(ImPlotNextPlotData *self) { return self->LinkedMax; }
void wrap_ImPlotPlot_SetID(ImPlotPlot *ImPlotPlotPtr, ImGuiID v) { ImPlotPlotPtr->ID = v; }
ImGuiID wrap_ImPlotPlot_GetID(ImPlotPlot *self) { return self->ID; }
void wrap_ImPlotPlot_SetFlags(ImPlotPlot *ImPlotPlotPtr, ImPlotFlags v) { ImPlotPlotPtr->Flags = v; }
ImPlotFlags wrap_ImPlotPlot_GetFlags(ImPlotPlot *self) { return self->Flags; }
void wrap_ImPlotPlot_SetPreviousFlags(ImPlotPlot *ImPlotPlotPtr, ImPlotFlags v) { ImPlotPlotPtr->PreviousFlags = v; }
ImPlotFlags wrap_ImPlotPlot_GetPreviousFlags(ImPlotPlot *self) { return self->PreviousFlags; }
void wrap_ImPlotPlot_SetMouseTextLocation(ImPlotPlot *ImPlotPlotPtr, ImPlotLocation v) { ImPlotPlotPtr->MouseTextLocation = v; }
ImPlotLocation wrap_ImPlotPlot_GetMouseTextLocation(ImPlotPlot *self) { return self->MouseTextLocation; }
void wrap_ImPlotPlot_SetMouseTextFlags(ImPlotPlot *ImPlotPlotPtr, ImPlotMouseTextFlags v) { ImPlotPlotPtr->MouseTextFlags = v; }
ImPlotMouseTextFlags wrap_ImPlotPlot_GetMouseTextFlags(ImPlotPlot *self) { return self->MouseTextFlags; }
void wrap_ImPlotPlot_SetAxes(ImPlotPlot *ImPlotPlotPtr, ImPlotAxis* v) { memcpy(ImPlotPlotPtr->Axes, v, sizeof(ImPlotAxis)*6); }
ImPlotAxis* wrap_ImPlotPlot_GetAxes(ImPlotPlot *self) { return self->Axes; }
ImPlotAxis cimplot_ImPlotAxis_GetAtIdx(ImPlotAxis *self, int index) { return self[index]; }
void wrap_ImPlotPlot_SetTextBuffer(ImPlotPlot *ImPlotPlotPtr, ImGuiTextBuffer v) { ImPlotPlotPtr->TextBuffer = v; }
ImGuiTextBuffer wrap_ImPlotPlot_GetTextBuffer(ImPlotPlot *self) { return self->TextBuffer; }
void wrap_ImPlotPlot_SetItems(ImPlotPlot *ImPlotPlotPtr, ImPlotItemGroup v) { ImPlotPlotPtr->Items = v; }
ImPlotItemGroup wrap_ImPlotPlot_GetItems(ImPlotPlot *self) { return self->Items; }
void wrap_ImPlotPlot_SetCurrentX(ImPlotPlot *ImPlotPlotPtr, ImAxis v) { ImPlotPlotPtr->CurrentX = v; }
ImAxis wrap_ImPlotPlot_GetCurrentX(ImPlotPlot *self) { return self->CurrentX; }
void wrap_ImPlotPlot_SetCurrentY(ImPlotPlot *ImPlotPlotPtr, ImAxis v) { ImPlotPlotPtr->CurrentY = v; }
ImAxis wrap_ImPlotPlot_GetCurrentY(ImPlotPlot *self) { return self->CurrentY; }
void wrap_ImPlotPlot_SetFrameRect(ImPlotPlot *ImPlotPlotPtr, ImRect v) { ImPlotPlotPtr->FrameRect = v; }
ImRect wrap_ImPlotPlot_GetFrameRect(ImPlotPlot *self) { return self->FrameRect; }
void wrap_ImPlotPlot_SetCanvasRect(ImPlotPlot *ImPlotPlotPtr, ImRect v) { ImPlotPlotPtr->CanvasRect = v; }
ImRect wrap_ImPlotPlot_GetCanvasRect(ImPlotPlot *self) { return self->CanvasRect; }
void wrap_ImPlotPlot_SetPlotRect(ImPlotPlot *ImPlotPlotPtr, ImRect v) { ImPlotPlotPtr->PlotRect = v; }
ImRect wrap_ImPlotPlot_GetPlotRect(ImPlotPlot *self) { return self->PlotRect; }
void wrap_ImPlotPlot_SetAxesRect(ImPlotPlot *ImPlotPlotPtr, ImRect v) { ImPlotPlotPtr->AxesRect = v; }
ImRect wrap_ImPlotPlot_GetAxesRect(ImPlotPlot *self) { return self->AxesRect; }
void wrap_ImPlotPlot_SetSelectRect(ImPlotPlot *ImPlotPlotPtr, ImRect v) { ImPlotPlotPtr->SelectRect = v; }
ImRect wrap_ImPlotPlot_GetSelectRect(ImPlotPlot *self) { return self->SelectRect; }
void wrap_ImPlotPlot_SetSelectStart(ImPlotPlot *ImPlotPlotPtr, ImVec2 v) { ImPlotPlotPtr->SelectStart = v; }
ImVec2 wrap_ImPlotPlot_GetSelectStart(ImPlotPlot *self) { return self->SelectStart; }
void wrap_ImPlotPlot_SetTitleOffset(ImPlotPlot *ImPlotPlotPtr, int v) { ImPlotPlotPtr->TitleOffset = v; }
int wrap_ImPlotPlot_GetTitleOffset(ImPlotPlot *self) { return self->TitleOffset; }
void wrap_ImPlotPlot_SetJustCreated(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->JustCreated = v; }
bool wrap_ImPlotPlot_GetJustCreated(ImPlotPlot *self) { return self->JustCreated; }
void wrap_ImPlotPlot_SetInitialized(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->Initialized = v; }
bool wrap_ImPlotPlot_GetInitialized(ImPlotPlot *self) { return self->Initialized; }
void wrap_ImPlotPlot_SetSetupLocked(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->SetupLocked = v; }
bool wrap_ImPlotPlot_GetSetupLocked(ImPlotPlot *self) { return self->SetupLocked; }
void wrap_ImPlotPlot_SetFitThisFrame(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->FitThisFrame = v; }
bool wrap_ImPlotPlot_GetFitThisFrame(ImPlotPlot *self) { return self->FitThisFrame; }
void wrap_ImPlotPlot_SetHovered(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->Hovered = v; }
bool wrap_ImPlotPlot_GetHovered(ImPlotPlot *self) { return self->Hovered; }
void wrap_ImPlotPlot_SetHeld(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->Held = v; }
bool wrap_ImPlotPlot_GetHeld(ImPlotPlot *self) { return self->Held; }
void wrap_ImPlotPlot_SetSelecting(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->Selecting = v; }
bool wrap_ImPlotPlot_GetSelecting(ImPlotPlot *self) { return self->Selecting; }
void wrap_ImPlotPlot_SetSelected(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->Selected = v; }
bool wrap_ImPlotPlot_GetSelected(ImPlotPlot *self) { return self->Selected; }
void wrap_ImPlotPlot_SetContextLocked(ImPlotPlot *ImPlotPlotPtr, bool v) { ImPlotPlotPtr->ContextLocked = v; }
bool wrap_ImPlotPlot_GetContextLocked(ImPlotPlot *self) { return self->ContextLocked; }
void wrap_ImPlotPointError_SetX(ImPlotPointError *ImPlotPointErrorPtr, double v) { ImPlotPointErrorPtr->X = v; }
double wrap_ImPlotPointError_GetX(ImPlotPointError *self) { return self->X; }
void wrap_ImPlotPointError_SetY(ImPlotPointError *ImPlotPointErrorPtr, double v) { ImPlotPointErrorPtr->Y = v; }
double wrap_ImPlotPointError_GetY(ImPlotPointError *self) { return self->Y; }
void wrap_ImPlotPointError_SetNeg(ImPlotPointError *ImPlotPointErrorPtr, double v) { ImPlotPointErrorPtr->Neg = v; }
double wrap_ImPlotPointError_GetNeg(ImPlotPointError *self) { return self->Neg; }
void wrap_ImPlotPointError_SetPos(ImPlotPointError *ImPlotPointErrorPtr, double v) { ImPlotPointErrorPtr->Pos = v; }
double wrap_ImPlotPointError_GetPos(ImPlotPointError *self) { return self->Pos; }
void wrap_ImPlotRange_SetMin(ImPlotRange *ImPlotRangePtr, double v) { ImPlotRangePtr->Min = v; }
double wrap_ImPlotRange_GetMin(ImPlotRange *self) { return self->Min; }
void wrap_ImPlotRange_SetMax(ImPlotRange *ImPlotRangePtr, double v) { ImPlotRangePtr->Max = v; }
double wrap_ImPlotRange_GetMax(ImPlotRange *self) { return self->Max; }
void wrap_ImPlotRect_SetX(ImPlotRect *ImPlotRectPtr, ImPlotRange v) { ImPlotRectPtr->X = v; }
ImPlotRange wrap_ImPlotRect_GetX(ImPlotRect *self) { return self->X; }
void wrap_ImPlotRect_SetY(ImPlotRect *ImPlotRectPtr, ImPlotRange v) { ImPlotRectPtr->Y = v; }
ImPlotRange wrap_ImPlotRect_GetY(ImPlotRect *self) { return self->Y; }
void wrap_ImPlotStyle_SetLineWeight(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->LineWeight = v; }
float wrap_ImPlotStyle_GetLineWeight(ImPlotStyle *self) { return self->LineWeight; }
void wrap_ImPlotStyle_SetMarker(ImPlotStyle *ImPlotStylePtr, int v) { ImPlotStylePtr->Marker = v; }
int wrap_ImPlotStyle_GetMarker(ImPlotStyle *self) { return self->Marker; }
void wrap_ImPlotStyle_SetMarkerSize(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->MarkerSize = v; }
float wrap_ImPlotStyle_GetMarkerSize(ImPlotStyle *self) { return self->MarkerSize; }
void wrap_ImPlotStyle_SetMarkerWeight(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->MarkerWeight = v; }
float wrap_ImPlotStyle_GetMarkerWeight(ImPlotStyle *self) { return self->MarkerWeight; }
void wrap_ImPlotStyle_SetFillAlpha(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->FillAlpha = v; }
float wrap_ImPlotStyle_GetFillAlpha(ImPlotStyle *self) { return self->FillAlpha; }
void wrap_ImPlotStyle_SetErrorBarSize(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->ErrorBarSize = v; }
float wrap_ImPlotStyle_GetErrorBarSize(ImPlotStyle *self) { return self->ErrorBarSize; }
void wrap_ImPlotStyle_SetErrorBarWeight(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->ErrorBarWeight = v; }
float wrap_ImPlotStyle_GetErrorBarWeight(ImPlotStyle *self) { return self->ErrorBarWeight; }
void wrap_ImPlotStyle_SetDigitalBitHeight(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->DigitalBitHeight = v; }
float wrap_ImPlotStyle_GetDigitalBitHeight(ImPlotStyle *self) { return self->DigitalBitHeight; }
void wrap_ImPlotStyle_SetDigitalBitGap(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->DigitalBitGap = v; }
float wrap_ImPlotStyle_GetDigitalBitGap(ImPlotStyle *self) { return self->DigitalBitGap; }
void wrap_ImPlotStyle_SetPlotBorderSize(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->PlotBorderSize = v; }
float wrap_ImPlotStyle_GetPlotBorderSize(ImPlotStyle *self) { return self->PlotBorderSize; }
void wrap_ImPlotStyle_SetMinorAlpha(ImPlotStyle *ImPlotStylePtr, float v) { ImPlotStylePtr->MinorAlpha = v; }
float wrap_ImPlotStyle_GetMinorAlpha(ImPlotStyle *self) { return self->MinorAlpha; }
void wrap_ImPlotStyle_SetMajorTickLen(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MajorTickLen = v; }
ImVec2 wrap_ImPlotStyle_GetMajorTickLen(ImPlotStyle *self) { return self->MajorTickLen; }
void wrap_ImPlotStyle_SetMinorTickLen(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MinorTickLen = v; }
ImVec2 wrap_ImPlotStyle_GetMinorTickLen(ImPlotStyle *self) { return self->MinorTickLen; }
void wrap_ImPlotStyle_SetMajorTickSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MajorTickSize = v; }
ImVec2 wrap_ImPlotStyle_GetMajorTickSize(ImPlotStyle *self) { return self->MajorTickSize; }
void wrap_ImPlotStyle_SetMinorTickSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MinorTickSize = v; }
ImVec2 wrap_ImPlotStyle_GetMinorTickSize(ImPlotStyle *self) { return self->MinorTickSize; }
void wrap_ImPlotStyle_SetMajorGridSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MajorGridSize = v; }
ImVec2 wrap_ImPlotStyle_GetMajorGridSize(ImPlotStyle *self) { return self->MajorGridSize; }
void wrap_ImPlotStyle_SetMinorGridSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MinorGridSize = v; }
ImVec2 wrap_ImPlotStyle_GetMinorGridSize(ImPlotStyle *self) { return self->MinorGridSize; }
void wrap_ImPlotStyle_SetPlotPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->PlotPadding = v; }
ImVec2 wrap_ImPlotStyle_GetPlotPadding(ImPlotStyle *self) { return self->PlotPadding; }
void wrap_ImPlotStyle_SetLabelPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->LabelPadding = v; }
ImVec2 wrap_ImPlotStyle_GetLabelPadding(ImPlotStyle *self) { return self->LabelPadding; }
void wrap_ImPlotStyle_SetLegendPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->LegendPadding = v; }
ImVec2 wrap_ImPlotStyle_GetLegendPadding(ImPlotStyle *self) { return self->LegendPadding; }
void wrap_ImPlotStyle_SetLegendInnerPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->LegendInnerPadding = v; }
ImVec2 wrap_ImPlotStyle_GetLegendInnerPadding(ImPlotStyle *self) { return self->LegendInnerPadding; }
void wrap_ImPlotStyle_SetLegendSpacing(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->LegendSpacing = v; }
ImVec2 wrap_ImPlotStyle_GetLegendSpacing(ImPlotStyle *self) { return self->LegendSpacing; }
void wrap_ImPlotStyle_SetMousePosPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->MousePosPadding = v; }
ImVec2 wrap_ImPlotStyle_GetMousePosPadding(ImPlotStyle *self) { return self->MousePosPadding; }
void wrap_ImPlotStyle_SetAnnotationPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->AnnotationPadding = v; }
ImVec2 wrap_ImPlotStyle_GetAnnotationPadding(ImPlotStyle *self) { return self->AnnotationPadding; }
void wrap_ImPlotStyle_SetFitPadding(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->FitPadding = v; }
ImVec2 wrap_ImPlotStyle_GetFitPadding(ImPlotStyle *self) { return self->FitPadding; }
void wrap_ImPlotStyle_SetPlotDefaultSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->PlotDefaultSize = v; }
ImVec2 wrap_ImPlotStyle_GetPlotDefaultSize(ImPlotStyle *self) { return self->PlotDefaultSize; }
void wrap_ImPlotStyle_SetPlotMinSize(ImPlotStyle *ImPlotStylePtr, ImVec2 v) { ImPlotStylePtr->PlotMinSize = v; }
ImVec2 wrap_ImPlotStyle_GetPlotMinSize(ImPlotStyle *self) { return self->PlotMinSize; }
void wrap_ImPlotStyle_SetColors(ImPlotStyle *ImPlotStylePtr, ImVec4* v) { memcpy(ImPlotStylePtr->Colors, v, sizeof(ImVec4)*21); }
ImVec4* wrap_ImPlotStyle_GetColors(ImPlotStyle *self) { return self->Colors; }
void wrap_ImPlotStyle_SetColormap(ImPlotStyle *ImPlotStylePtr, ImPlotColormap v) { ImPlotStylePtr->Colormap = v; }
ImPlotColormap wrap_ImPlotStyle_GetColormap(ImPlotStyle *self) { return self->Colormap; }
void wrap_ImPlotStyle_SetUseLocalTime(ImPlotStyle *ImPlotStylePtr, bool v) { ImPlotStylePtr->UseLocalTime = v; }
bool wrap_ImPlotStyle_GetUseLocalTime(ImPlotStyle *self) { return self->UseLocalTime; }
void wrap_ImPlotStyle_SetUseISO8601(ImPlotStyle *ImPlotStylePtr, bool v) { ImPlotStylePtr->UseISO8601 = v; }
bool wrap_ImPlotStyle_GetUseISO8601(ImPlotStyle *self) { return self->UseISO8601; }
void wrap_ImPlotStyle_SetUse24HourClock(ImPlotStyle *ImPlotStylePtr, bool v) { ImPlotStylePtr->Use24HourClock = v; }
bool wrap_ImPlotStyle_GetUse24HourClock(ImPlotStyle *self) { return self->Use24HourClock; }
void wrap_ImPlotSubplot_SetID(ImPlotSubplot *ImPlotSubplotPtr, ImGuiID v) { ImPlotSubplotPtr->ID = v; }
ImGuiID wrap_ImPlotSubplot_GetID(ImPlotSubplot *self) { return self->ID; }
void wrap_ImPlotSubplot_SetFlags(ImPlotSubplot *ImPlotSubplotPtr, ImPlotSubplotFlags v) { ImPlotSubplotPtr->Flags = v; }
ImPlotSubplotFlags wrap_ImPlotSubplot_GetFlags(ImPlotSubplot *self) { return self->Flags; }
void wrap_ImPlotSubplot_SetPreviousFlags(ImPlotSubplot *ImPlotSubplotPtr, ImPlotSubplotFlags v) { ImPlotSubplotPtr->PreviousFlags = v; }
ImPlotSubplotFlags wrap_ImPlotSubplot_GetPreviousFlags(ImPlotSubplot *self) { return self->PreviousFlags; }
void wrap_ImPlotSubplot_SetItems(ImPlotSubplot *ImPlotSubplotPtr, ImPlotItemGroup v) { ImPlotSubplotPtr->Items = v; }
ImPlotItemGroup wrap_ImPlotSubplot_GetItems(ImPlotSubplot *self) { return self->Items; }
void wrap_ImPlotSubplot_SetRows(ImPlotSubplot *ImPlotSubplotPtr, int v) { ImPlotSubplotPtr->Rows = v; }
int wrap_ImPlotSubplot_GetRows(ImPlotSubplot *self) { return self->Rows; }
void wrap_ImPlotSubplot_SetCols(ImPlotSubplot *ImPlotSubplotPtr, int v) { ImPlotSubplotPtr->Cols = v; }
int wrap_ImPlotSubplot_GetCols(ImPlotSubplot *self) { return self->Cols; }
void wrap_ImPlotSubplot_SetCurrentIdx(ImPlotSubplot *ImPlotSubplotPtr, int v) { ImPlotSubplotPtr->CurrentIdx = v; }
int wrap_ImPlotSubplot_GetCurrentIdx(ImPlotSubplot *self) { return self->CurrentIdx; }
void wrap_ImPlotSubplot_SetFrameRect(ImPlotSubplot *ImPlotSubplotPtr, ImRect v) { ImPlotSubplotPtr->FrameRect = v; }
ImRect wrap_ImPlotSubplot_GetFrameRect(ImPlotSubplot *self) { return self->FrameRect; }
void wrap_ImPlotSubplot_SetGridRect(ImPlotSubplot *ImPlotSubplotPtr, ImRect v) { ImPlotSubplotPtr->GridRect = v; }
ImRect wrap_ImPlotSubplot_GetGridRect(ImPlotSubplot *self) { return self->GridRect; }
void wrap_ImPlotSubplot_SetCellSize(ImPlotSubplot *ImPlotSubplotPtr, ImVec2 v) { ImPlotSubplotPtr->CellSize = v; }
ImVec2 wrap_ImPlotSubplot_GetCellSize(ImPlotSubplot *self) { return self->CellSize; }
void wrap_ImPlotSubplot_SetRowAlignmentData(ImPlotSubplot *ImPlotSubplotPtr, ImVector_ImPlotAlignmentData v) { ImPlotSubplotPtr->RowAlignmentData = v; }
ImVector_ImPlotAlignmentData wrap_ImPlotSubplot_GetRowAlignmentData(ImPlotSubplot *self) { return self->RowAlignmentData; }
void wrap_ImPlotSubplot_SetColAlignmentData(ImPlotSubplot *ImPlotSubplotPtr, ImVector_ImPlotAlignmentData v) { ImPlotSubplotPtr->ColAlignmentData = v; }
ImVector_ImPlotAlignmentData wrap_ImPlotSubplot_GetColAlignmentData(ImPlotSubplot *self) { return self->ColAlignmentData; }
void wrap_ImPlotSubplot_SetRowRatios(ImPlotSubplot *ImPlotSubplotPtr, ImVector_float v) { ImPlotSubplotPtr->RowRatios = v; }
ImVector_float wrap_ImPlotSubplot_GetRowRatios(ImPlotSubplot *self) { return self->RowRatios; }
void wrap_ImPlotSubplot_SetColRatios(ImPlotSubplot *ImPlotSubplotPtr, ImVector_float v) { ImPlotSubplotPtr->ColRatios = v; }
ImVector_float wrap_ImPlotSubplot_GetColRatios(ImPlotSubplot *self) { return self->ColRatios; }
void wrap_ImPlotSubplot_SetRowLinkData(ImPlotSubplot *ImPlotSubplotPtr, ImVector_ImPlotRange v) { ImPlotSubplotPtr->RowLinkData = v; }
ImVector_ImPlotRange wrap_ImPlotSubplot_GetRowLinkData(ImPlotSubplot *self) { return self->RowLinkData; }
void wrap_ImPlotSubplot_SetColLinkData(ImPlotSubplot *ImPlotSubplotPtr, ImVector_ImPlotRange v) { ImPlotSubplotPtr->ColLinkData = v; }
ImVector_ImPlotRange wrap_ImPlotSubplot_GetColLinkData(ImPlotSubplot *self) { return self->ColLinkData; }
void wrap_ImPlotSubplot_SetTempSizes(ImPlotSubplot *ImPlotSubplotPtr, float* v) { memcpy(ImPlotSubplotPtr->TempSizes, v, sizeof(float)*2); }
float* wrap_ImPlotSubplot_GetTempSizes(ImPlotSubplot *self) { return self->TempSizes; }
float cimplot_float_GetAtIdx(float *self, int index) { return self[index]; }
void wrap_ImPlotSubplot_SetFrameHovered(ImPlotSubplot *ImPlotSubplotPtr, bool v) { ImPlotSubplotPtr->FrameHovered = v; }
bool wrap_ImPlotSubplot_GetFrameHovered(ImPlotSubplot *self) { return self->FrameHovered; }
void wrap_ImPlotSubplot_SetHasTitle(ImPlotSubplot *ImPlotSubplotPtr, bool v) { ImPlotSubplotPtr->HasTitle = v; }
bool wrap_ImPlotSubplot_GetHasTitle(ImPlotSubplot *self) { return self->HasTitle; }
void wrap_ImPlotTag_SetAxis(ImPlotTag *ImPlotTagPtr, ImAxis v) { ImPlotTagPtr->Axis = v; }
ImAxis wrap_ImPlotTag_GetAxis(ImPlotTag *self) { return self->Axis; }
void wrap_ImPlotTag_SetValue(ImPlotTag *ImPlotTagPtr, double v) { ImPlotTagPtr->Value = v; }
double wrap_ImPlotTag_GetValue(ImPlotTag *self) { return self->Value; }
void wrap_ImPlotTag_SetColorBg(ImPlotTag *ImPlotTagPtr, ImU32 v) { ImPlotTagPtr->ColorBg = v; }
ImU32 wrap_ImPlotTag_GetColorBg(ImPlotTag *self) { return self->ColorBg; }
void wrap_ImPlotTag_SetColorFg(ImPlotTag *ImPlotTagPtr, ImU32 v) { ImPlotTagPtr->ColorFg = v; }
ImU32 wrap_ImPlotTag_GetColorFg(ImPlotTag *self) { return self->ColorFg; }
void wrap_ImPlotTag_SetTextOffset(ImPlotTag *ImPlotTagPtr, int v) { ImPlotTagPtr->TextOffset = v; }
int wrap_ImPlotTag_GetTextOffset(ImPlotTag *self) { return self->TextOffset; }
void wrap_ImPlotTagCollection_SetTags(ImPlotTagCollection *ImPlotTagCollectionPtr, ImVector_ImPlotTag v) { ImPlotTagCollectionPtr->Tags = v; }
ImVector_ImPlotTag wrap_ImPlotTagCollection_GetTags(ImPlotTagCollection *self) { return self->Tags; }
void wrap_ImPlotTagCollection_SetTextBuffer(ImPlotTagCollection *ImPlotTagCollectionPtr, ImGuiTextBuffer v) { ImPlotTagCollectionPtr->TextBuffer = v; }
ImGuiTextBuffer wrap_ImPlotTagCollection_GetTextBuffer(ImPlotTagCollection *self) { return self->TextBuffer; }
void wrap_ImPlotTagCollection_SetSize(ImPlotTagCollection *ImPlotTagCollectionPtr, int v) { ImPlotTagCollectionPtr->Size = v; }
int wrap_ImPlotTagCollection_GetSize(ImPlotTagCollection *self) { return self->Size; }
void wrap_ImPlotTick_SetPlotPos(ImPlotTick *ImPlotTickPtr, double v) { ImPlotTickPtr->PlotPos = v; }
double wrap_ImPlotTick_GetPlotPos(ImPlotTick *self) { return self->PlotPos; }
void wrap_ImPlotTick_SetPixelPos(ImPlotTick *ImPlotTickPtr, float v) { ImPlotTickPtr->PixelPos = v; }
float wrap_ImPlotTick_GetPixelPos(ImPlotTick *self) { return self->PixelPos; }
void wrap_ImPlotTick_SetLabelSize(ImPlotTick *ImPlotTickPtr, ImVec2 v) { ImPlotTickPtr->LabelSize = v; }
ImVec2 wrap_ImPlotTick_GetLabelSize(ImPlotTick *self) { return self->LabelSize; }
void wrap_ImPlotTick_SetTextOffset(ImPlotTick *ImPlotTickPtr, int v) { ImPlotTickPtr->TextOffset = v; }
int wrap_ImPlotTick_GetTextOffset(ImPlotTick *self) { return self->TextOffset; }
void wrap_ImPlotTick_SetMajor(ImPlotTick *ImPlotTickPtr, bool v) { ImPlotTickPtr->Major = v; }
bool wrap_ImPlotTick_GetMajor(ImPlotTick *self) { return self->Major; }
void wrap_ImPlotTick_SetShowLabel(ImPlotTick *ImPlotTickPtr, bool v) { ImPlotTickPtr->ShowLabel = v; }
bool wrap_ImPlotTick_GetShowLabel(ImPlotTick *self) { return self->ShowLabel; }
void wrap_ImPlotTick_SetLevel(ImPlotTick *ImPlotTickPtr, int v) { ImPlotTickPtr->Level = v; }
int wrap_ImPlotTick_GetLevel(ImPlotTick *self) { return self->Level; }
void wrap_ImPlotTick_SetIdx(ImPlotTick *ImPlotTickPtr, int v) { ImPlotTickPtr->Idx = v; }
int wrap_ImPlotTick_GetIdx(ImPlotTick *self) { return self->Idx; }
void wrap_ImPlotTicker_SetTicks(ImPlotTicker *ImPlotTickerPtr, ImVector_ImPlotTick v) { ImPlotTickerPtr->Ticks = v; }
ImVector_ImPlotTick wrap_ImPlotTicker_GetTicks(ImPlotTicker *self) { return self->Ticks; }
void wrap_ImPlotTicker_SetTextBuffer(ImPlotTicker *ImPlotTickerPtr, ImGuiTextBuffer v) { ImPlotTickerPtr->TextBuffer = v; }
ImGuiTextBuffer wrap_ImPlotTicker_GetTextBuffer(ImPlotTicker *self) { return self->TextBuffer; }
void wrap_ImPlotTicker_SetMaxSize(ImPlotTicker *ImPlotTickerPtr, ImVec2 v) { ImPlotTickerPtr->MaxSize = v; }
ImVec2 wrap_ImPlotTicker_GetMaxSize(ImPlotTicker *self) { return self->MaxSize; }
void wrap_ImPlotTicker_SetLateSize(ImPlotTicker *ImPlotTickerPtr, ImVec2 v) { ImPlotTickerPtr->LateSize = v; }
ImVec2 wrap_ImPlotTicker_GetLateSize(ImPlotTicker *self) { return self->LateSize; }
void wrap_ImPlotTicker_SetLevels(ImPlotTicker *ImPlotTickerPtr, int v) { ImPlotTickerPtr->Levels = v; }
int wrap_ImPlotTicker_GetLevels(ImPlotTicker *self) { return self->Levels; }
void wrap_ImPlotTime_SetS(ImPlotTime *ImPlotTimePtr, time_t v) { ImPlotTimePtr->S = v; }
time_t wrap_ImPlotTime_GetS(ImPlotTime *self) { return self->S; }
void wrap_ImPlotTime_SetUs(ImPlotTime *ImPlotTimePtr, int v) { ImPlotTimePtr->Us = v; }
int wrap_ImPlotTime_GetUs(ImPlotTime *self) { return self->Us; }