diff --git a/implot.cpp b/implot.cpp
index 5a6cd8b..f13de78 100644
--- a/implot.cpp
+++ b/implot.cpp
@@ -31,6 +31,7 @@ Below is a change-log of API breaking changes only. If you are using one of the
 When you are not sure about a old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all implot files.
 You can read releases logs https://github.com/epezent/implot/releases for more details.
 
+- 2020/05/13 (0.2) - ImMarker was change to ImPlotMarker and ImAxisFlags was changed to ImPlotAxisFlags
 - 2020/05/11 (0.2) - ImPlotFlags_Selection was changed to ImPlotFlags_BoxSelect
 - 2020/05/11 (0.2) - The namespace ImGui:: was replaced with ImPlot::. As a result, the following additional changes were made:
                      - Functions that were prefixed or decorated with the word "Plot" have been truncated. E.g., `ImGui::PlotBar` is now just `ImPlot::Bar`. 
@@ -80,7 +81,7 @@ You can read releases logs https://github.com/epezent/implot/releases for more d
 
 ImPlotStyle::ImPlotStyle() {
     LineWeight = 1;
-    Marker = ImMarker_None;
+    Marker = ImPlotMarker_None;
     MarkerSize = 5;
     MarkerWeight = 1;
     ErrorBarSize = 5;
@@ -276,13 +277,13 @@ struct ImPlotAxis {
         Range.Max = 1;
         Divisions = 3; 
         Subdivisions = 10; 
-        Flags = PreviousFlags = ImAxisFlags_Default; 
+        Flags = PreviousFlags = ImPlotAxisFlags_Default; 
     }
     bool Dragging;
     ImPlotRange Range;
     int Divisions;
     int Subdivisions;
-    ImAxisFlags Flags, PreviousFlags;
+    ImPlotAxisFlags Flags, PreviousFlags;
 };
 
 /// Holds Plot state information that must persist between frames
@@ -426,10 +427,10 @@ inline void UpdateTransformCache() {
     // get pixels for transforms
 
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        gp.PixelRange[i] = ImRect(HasFlag(gp.CurrentPlot->XAxis.Flags, ImAxisFlags_Invert) ? gp.BB_Grid.Max.x : gp.BB_Grid.Min.x,
-                                  HasFlag(gp.CurrentPlot->YAxis[i].Flags, ImAxisFlags_Invert) ? gp.BB_Grid.Min.y : gp.BB_Grid.Max.y,
-                                  HasFlag(gp.CurrentPlot->XAxis.Flags, ImAxisFlags_Invert) ? gp.BB_Grid.Min.x : gp.BB_Grid.Max.x,
-                                  HasFlag(gp.CurrentPlot->YAxis[i].Flags, ImAxisFlags_Invert) ? gp.BB_Grid.Max.y : gp.BB_Grid.Min.y);
+        gp.PixelRange[i] = ImRect(HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_Invert) ? gp.BB_Grid.Max.x : gp.BB_Grid.Min.x,
+                                  HasFlag(gp.CurrentPlot->YAxis[i].Flags, ImPlotAxisFlags_Invert) ? gp.BB_Grid.Min.y : gp.BB_Grid.Max.y,
+                                  HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_Invert) ? gp.BB_Grid.Min.x : gp.BB_Grid.Max.x,
+                                  HasFlag(gp.CurrentPlot->YAxis[i].Flags, ImPlotAxisFlags_Invert) ? gp.BB_Grid.Max.y : gp.BB_Grid.Min.y);
 
         gp.My[i] = (gp.PixelRange[i].Max.y - gp.PixelRange[i].Min.y) / gp.CurrentPlot->YAxis[i].Range.Size();
     }
@@ -446,11 +447,11 @@ inline ImVec2 PixelsToPlot(float x, float y, int y_axis_in = -1) {
     ImVec2 plt;
     plt.x = (x - gp.PixelRange[y_axis].Min.x) / gp.Mx + gp.CurrentPlot->XAxis.Range.Min;
     plt.y = (y - gp.PixelRange[y_axis].Min.y) / gp.My[y_axis] + gp.CurrentPlot->YAxis[y_axis].Range.Min;
-    if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImAxisFlags_LogScale)) {
+    if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
         float t = (plt.x - gp.CurrentPlot->XAxis.Range.Min) / gp.CurrentPlot->XAxis.Range.Size();
         plt.x = pow(10.0f, t * gp.LogDenX) * gp.CurrentPlot->XAxis.Range.Min;
     }
-    if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImAxisFlags_LogScale)) {
+    if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
         float t = (plt.y - gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.CurrentPlot->YAxis[y_axis].Range.Size();
         plt.y = pow(10.0f, t * gp.LogDenY[y_axis]) * gp.CurrentPlot->YAxis[y_axis].Range.Min;
     }
@@ -461,11 +462,11 @@ inline ImVec2 PlotToPixels(float x, float y, int y_axis_in = -1) {
     IM_ASSERT_USER_ERROR(gp.CurrentPlot != NULL, "PlotToPixels() Needs to be called between BeginPlot() and EndPlot()!");
     const int y_axis = y_axis_in >= 0 ? y_axis_in : gp.CurrentPlot->CurrentYAxis;
     ImVec2 pix;
-    if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImAxisFlags_LogScale)) {
+    if (HasFlag(gp.CurrentPlot->XAxis.Flags, ImPlotAxisFlags_LogScale)) {
         float t = log10(x / gp.CurrentPlot->XAxis.Range.Min) / gp.LogDenX;
         x       = ImLerp(gp.CurrentPlot->XAxis.Range.Min, gp.CurrentPlot->XAxis.Range.Max, t);
     }             
-    if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImAxisFlags_LogScale)) {
+    if (HasFlag(gp.CurrentPlot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale)) {
         float t = log10(y / gp.CurrentPlot->YAxis[y_axis].Range.Min) / gp.LogDenY[y_axis];
         y       = ImLerp(gp.CurrentPlot->YAxis[y_axis].Range.Min, gp.CurrentPlot->YAxis[y_axis].Range.Max, t);
     }
@@ -645,9 +646,9 @@ struct AxisState {
               range_cond(range_cond_in),
               present(present_in),
               present_so_far(previous_present + (present ? 1 : 0)),
-              flip(HasFlag(axis->Flags, ImAxisFlags_Invert)),
-              lock_min(HasFlag(axis->Flags, ImAxisFlags_LockMin)),
-              lock_max(HasFlag(axis->Flags, ImAxisFlags_LockMax)),
+              flip(HasFlag(axis->Flags, ImPlotAxisFlags_Invert)),
+              lock_min(HasFlag(axis->Flags, ImPlotAxisFlags_LockMin)),
+              lock_max(HasFlag(axis->Flags, ImPlotAxisFlags_LockMax)),
               lock(present && ((lock_min && lock_max) || (has_range && range_cond == ImGuiCond_Always))) {}
 
     AxisState()
@@ -689,7 +690,7 @@ class YPadCalculator {
         if (AxisStates[y_axis].present_so_far >= 3) {
             pad_result += 6.0f;
         }
-        if (!HasFlag(plot.YAxis[y_axis].Flags, ImAxisFlags_TickLabels)) {
+        if (!HasFlag(plot.YAxis[y_axis].Flags, ImPlotAxisFlags_TickLabels)) {
             return pad_result;
         }
         pad_result += MaxLabelWidths[y_axis] + TxtOff;
@@ -707,7 +708,7 @@ class YPadCalculator {
 // BeginPlot()
 //-----------------------------------------------------------------------------
 
-bool BeginPlot(const char* title, const char* x_label, const char* y_label, const ImVec2& size, ImPlotFlags flags, ImAxisFlags x_flags, ImAxisFlags y_flags, ImAxisFlags y2_flags, ImAxisFlags y3_flags) {
+bool BeginPlot(const char* title, const char* x_label, const char* y_label, const ImVec2& size, ImPlotFlags flags, ImPlotAxisFlags x_flags, ImPlotAxisFlags y_flags, ImPlotAxisFlags y2_flags, ImPlotAxisFlags y3_flags) {
 
     IM_ASSERT_USER_ERROR(gp.CurrentPlot == NULL, "Mismatched BeginPlot()/EndPlot()!");
 
@@ -803,14 +804,14 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
         plot.YAxis[i].Range.Max = ConstrainNan(ConstrainInf(plot.YAxis[i].Range.Max));
     }
 
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_LogScale))
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale))
         plot.XAxis.Range.Min = ConstrainLog(plot.XAxis.Range.Min);
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_LogScale))
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale))
         plot.XAxis.Range.Max = ConstrainLog(plot.XAxis.Range.Max);
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        if (HasFlag(plot.YAxis[i].Flags, ImAxisFlags_LogScale))
+        if (HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
             plot.YAxis[i].Range.Min = ConstrainLog(plot.YAxis[i].Range.Min);
-        if (HasFlag(plot.YAxis[i].Flags, ImAxisFlags_LogScale))
+        if (HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale))
             plot.YAxis[i].Range.Max = ConstrainLog(plot.YAxis[i].Range.Max);
     }
 
@@ -822,13 +823,13 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     }
 
     // adaptive divisions
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_Adaptive)) {
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_Adaptive)) {
         plot.XAxis.Divisions = (int)IM_ROUND(0.003 * gp.BB_Canvas.GetWidth());
         if (plot.XAxis.Divisions < 2)
             plot.XAxis.Divisions = 2; 
     }
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        if (HasFlag(plot.YAxis[i].Flags, ImAxisFlags_Adaptive)) {
+        if (HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_Adaptive)) {
             plot.YAxis[i].Divisions = (int)IM_ROUND(0.003 * gp.BB_Canvas.GetHeight());
             if (plot.YAxis[i].Divisions < 2)
                 plot.YAxis[i].Divisions = 2;
@@ -872,34 +873,34 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     // canvas bb
     gp.BB_Canvas = ImRect(gp.BB_Frame.Min + Style.WindowPadding, gp.BB_Frame.Max - Style.WindowPadding);     
 
-    gp.RenderX = (HasFlag(plot.XAxis.Flags, ImAxisFlags_GridLines) ||
-                    HasFlag(plot.XAxis.Flags, ImAxisFlags_TickMarks) ||
-                    HasFlag(plot.XAxis.Flags, ImAxisFlags_TickLabels)) &&  plot.XAxis.Divisions > 1;
+    gp.RenderX = (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_GridLines) ||
+                    HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickMarks) ||
+                    HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickLabels)) &&  plot.XAxis.Divisions > 1;
     for (int i = 0; i < MAX_Y_AXES; i++) {
         gp.RenderY[i] =
                 y[i].present &&
-                (HasFlag(plot.YAxis[i].Flags, ImAxisFlags_GridLines) || 
-                 HasFlag(plot.YAxis[i].Flags, ImAxisFlags_TickMarks) || 
-                 HasFlag(plot.YAxis[i].Flags, ImAxisFlags_TickLabels)) &&  plot.YAxis[i].Divisions > 1;
+                (HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_GridLines) || 
+                 HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_TickMarks) || 
+                 HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_TickLabels)) &&  plot.YAxis[i].Divisions > 1;
     }
 
     // get ticks
     if (gp.RenderX)
-        GetTicks(plot.XAxis.Range, plot.XAxis.Divisions, plot.XAxis.Subdivisions, HasFlag(plot.XAxis.Flags, ImAxisFlags_LogScale), gp.XTicks);
+        GetTicks(plot.XAxis.Range, plot.XAxis.Divisions, plot.XAxis.Subdivisions, HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LogScale), gp.XTicks);
     for (int i = 0; i < MAX_Y_AXES; i++) {
         if (gp.RenderY[i]) {
-            GetTicks(plot.YAxis[i].Range, plot.YAxis[i].Divisions, plot.YAxis[i].Subdivisions, HasFlag(plot.YAxis[i].Flags, ImAxisFlags_LogScale), gp.YTicks[i]);
+            GetTicks(plot.YAxis[i].Range, plot.YAxis[i].Divisions, plot.YAxis[i].Subdivisions, HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LogScale), gp.YTicks[i]);
         }
     }
 
     // label ticks
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_TickLabels))
-        LabelTicks(gp.XTicks, HasFlag(plot.XAxis.Flags, ImAxisFlags_Scientific), gp.XTickLabels);
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickLabels))
+        LabelTicks(gp.XTicks, HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_Scientific), gp.XTickLabels);
 
     float max_label_width[MAX_Y_AXES] = {};
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImAxisFlags_TickLabels)) {
-            LabelTicks(gp.YTicks[i], HasFlag(plot.YAxis[i].Flags, ImAxisFlags_Scientific), gp.YTickLabels[i]);
+        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_TickLabels)) {
+            LabelTicks(gp.YTicks[i], HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_Scientific), gp.YTickLabels[i]);
             for (ImTick &yt : gp.YTicks[i]) {
                 max_label_width[i] = yt.Size.x > max_label_width[i] ? yt.Size.x : max_label_width[i];
             }
@@ -911,7 +912,7 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     const float txt_off     = 5;
     const float txt_height  = ImGui::GetTextLineHeight();
     const float pad_top     = title_size.x > 0.0f ? txt_height + txt_off : 0;
-    const float pad_bot     = (HasFlag(plot.XAxis.Flags, ImAxisFlags_TickLabels) ? txt_height + txt_off : 0) + (x_label ? txt_height + txt_off : 0);
+    const float pad_bot     = (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickLabels) ? txt_height + txt_off : 0) + (x_label ? txt_height + txt_off : 0);
     YPadCalculator y_axis_pad(y, max_label_width, txt_off);
     const float pad_left    = y_axis_pad(0) + (y_label ? txt_height + txt_off : 0);
     const float pad_right   = y_axis_pad(1) + y_axis_pad(2);
@@ -1219,13 +1220,13 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     }
 
     // render grid
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_GridLines)) {
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_GridLines)) {
         for (ImTick &xt : gp.XTicks)
             DrawList.AddLine({xt.PixelPos, gp.BB_Grid.Min.y}, {xt.PixelPos, gp.BB_Grid.Max.y}, xt.Major ? gp.Col_X.Major : gp.Col_X.Minor, 1);
     }
 
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImAxisFlags_GridLines)) {
+        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_GridLines)) {
             for (ImTick &yt : gp.YTicks[i])
                 DrawList.AddLine({gp.BB_Grid.Min.x, yt.PixelPos}, {gp.BB_Grid.Max.x, yt.PixelPos}, yt.Major ? gp.Col_Y[i].Major : gp.Col_Y[i].Minor, 1);
         }
@@ -1239,7 +1240,7 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     }
 
     // render labels
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_TickLabels)) {
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickLabels)) {
         ImGui::PushClipRect(gp.BB_Frame.Min, gp.BB_Frame.Max, true);
         for (ImTick &xt : gp.XTicks) {
             if (xt.RenderLabel && xt.PixelPos >= gp.BB_Grid.Min.x - 1 && xt.PixelPos <= gp.BB_Grid.Max.x + 1)
@@ -1255,7 +1256,7 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
     }
     ImGui::PushClipRect(gp.BB_Frame.Min, gp.BB_Frame.Max, true);
     for (int i = 0; i < MAX_Y_AXES; i++) {
-        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImAxisFlags_TickLabels)) {
+        if (y[i].present && HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_TickLabels)) {
             const float x_start =
                     gp.AxisLabelReference[i] +
                     ((i == 0) ?
@@ -1303,15 +1304,15 @@ bool BeginPlot(const char* title, const char* x_label, const char* y_label, cons
 
 inline void AxisMenu(ImPlotAxis& Axis) {
      ImGui::PushItemWidth(75);
-    bool lock_min = HasFlag(Axis.Flags, ImAxisFlags_LockMin);
-    bool lock_max = HasFlag(Axis.Flags, ImAxisFlags_LockMax);
-    bool invert   = HasFlag(Axis.Flags, ImAxisFlags_Invert);
-    bool logscale = HasFlag(Axis.Flags, ImAxisFlags_LogScale);
-    bool grid     = HasFlag(Axis.Flags, ImAxisFlags_GridLines);
-    bool ticks    = HasFlag(Axis.Flags, ImAxisFlags_TickMarks);
-    bool labels   = HasFlag(Axis.Flags, ImAxisFlags_TickLabels);
+    bool lock_min = HasFlag(Axis.Flags, ImPlotAxisFlags_LockMin);
+    bool lock_max = HasFlag(Axis.Flags, ImPlotAxisFlags_LockMax);
+    bool invert   = HasFlag(Axis.Flags, ImPlotAxisFlags_Invert);
+    bool logscale = HasFlag(Axis.Flags, ImPlotAxisFlags_LogScale);
+    bool grid     = HasFlag(Axis.Flags, ImPlotAxisFlags_GridLines);
+    bool ticks    = HasFlag(Axis.Flags, ImPlotAxisFlags_TickMarks);
+    bool labels   = HasFlag(Axis.Flags, ImPlotAxisFlags_TickLabels);
     if (ImGui::Checkbox("##LockMin", &lock_min)) 
-        FlipFlag(Axis.Flags, ImAxisFlags_LockMin);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_LockMin);
     ImGui::SameLine();
     if (lock_min) {
         ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
@@ -1323,7 +1324,7 @@ inline void AxisMenu(ImPlotAxis& Axis) {
         ImGui::PopStyleVar();    }
 
     if (ImGui::Checkbox("##LockMax", &lock_max))
-        FlipFlag(Axis.Flags, ImAxisFlags_LockMax);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_LockMax);
     ImGui::SameLine();
     if (lock_max) {
         ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
@@ -1335,16 +1336,16 @@ inline void AxisMenu(ImPlotAxis& Axis) {
     }
     ImGui::Separator();
     if (ImGui::Checkbox("Invert", &invert))
-        FlipFlag(Axis.Flags, ImAxisFlags_Invert);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_Invert);
     if (ImGui::Checkbox("Log Scale", &logscale))
-        FlipFlag(Axis.Flags, ImAxisFlags_LogScale);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_LogScale);
     ImGui::Separator();
     if (ImGui::Checkbox("Grid Lines", &grid))
-        FlipFlag(Axis.Flags, ImAxisFlags_GridLines);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_GridLines);
     if (ImGui::Checkbox("Tick Marks", &ticks))
-        FlipFlag(Axis.Flags, ImAxisFlags_TickMarks);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_TickMarks);
     if (ImGui::Checkbox("Labels", &labels))
-        FlipFlag(Axis.Flags, ImAxisFlags_TickLabels);
+        FlipFlag(Axis.Flags, ImPlotAxisFlags_TickLabels);
 }
 
 void PlotContextMenu(ImPlotState& plot) {
@@ -1469,7 +1470,7 @@ void EndPlot() {
 
     // render ticks
     PushPlotClipRect();
-    if (HasFlag(plot.XAxis.Flags, ImAxisFlags_TickMarks)) {
+    if (HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_TickMarks)) {
         for (ImTick &xt : gp.XTicks)
             DrawList.AddLine({xt.PixelPos, gp.BB_Grid.Max.y},{xt.PixelPos, gp.BB_Grid.Max.y - (xt.Major ? 10.0f : 5.0f)}, gp.Col_Border, 1);
     }
@@ -1481,7 +1482,7 @@ void EndPlot() {
         if (!y[i].present) { continue; }
         axis_count++;
 
-        if (!HasFlag(plot.YAxis[i].Flags, ImAxisFlags_TickMarks)) { continue; }
+        if (!HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_TickMarks)) { continue; }
 
         float x_start = gp.AxisLabelReference[i];
         float direction = (i == 0) ? 1.0f : -1.0f;
@@ -1649,17 +1650,17 @@ void EndPlot() {
     // FIT DATA --------------------------------------------------------------
 
     if (gp.FitThisFrame && (gp.VisibleItemCount > 0 || plot.Queried)) {
-        if (gp.FitX && !HasFlag(plot.XAxis.Flags, ImAxisFlags_LockMin) && !NanOrInf(gp.ExtentsX.Min)) {
+        if (gp.FitX && !HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LockMin) && !NanOrInf(gp.ExtentsX.Min)) {
             plot.XAxis.Range.Min = gp.ExtentsX.Min;
         }
-        if (gp.FitX && !HasFlag(plot.XAxis.Flags, ImAxisFlags_LockMax) && !NanOrInf(gp.ExtentsX.Max)) {
+        if (gp.FitX && !HasFlag(plot.XAxis.Flags, ImPlotAxisFlags_LockMax) && !NanOrInf(gp.ExtentsX.Max)) {
             plot.XAxis.Range.Max = gp.ExtentsX.Max;
         }
         for (int i = 0; i < MAX_Y_AXES; i++) {
-            if (gp.FitY[i] && !HasFlag(plot.YAxis[i].Flags, ImAxisFlags_LockMin) && !NanOrInf(gp.ExtentsY[i].Min)) {
+            if (gp.FitY[i] && !HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LockMin) && !NanOrInf(gp.ExtentsY[i].Min)) {
                 plot.YAxis[i].Range.Min = gp.ExtentsY[i].Min;
             }
-            if (gp.FitY[i] && !HasFlag(plot.YAxis[i].Flags, ImAxisFlags_LockMax) && !NanOrInf(gp.ExtentsY[i].Max)) {
+            if (gp.FitY[i] && !HasFlag(plot.YAxis[i].Flags, ImPlotAxisFlags_LockMax) && !NanOrInf(gp.ExtentsY[i].Max)) {
                 plot.YAxis[i].Range.Max = gp.ExtentsY[i].Max;
             }
         }
@@ -2018,25 +2019,25 @@ int idx = offset;
         idx = (idx + 1) % count;
         if (!cull || gp.BB_Grid.Contains(c)) {
             // TODO: Optimize the loop and if statements, this is atrocious
-            if (HasFlag(gp.Style.Marker, ImMarker_Circle)) 
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Circle)) 
                 MarkerCircle(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);
-            if (HasFlag(gp.Style.Marker, ImMarker_Square))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Square))
                 MarkerSquare(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);     
-            if (HasFlag(gp.Style.Marker, ImMarker_Diamond)) 
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Diamond)) 
                 MarkerDiamond(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);
-            if (HasFlag(gp.Style.Marker, ImMarker_Up))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Up))
                 MarkerUp(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);     
-            if (HasFlag(gp.Style.Marker, ImMarker_Down))    
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Down))    
                 MarkerDown(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);  
-            if (HasFlag(gp.Style.Marker, ImMarker_Left))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Left))
                 MarkerLeft(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);     
-            if (HasFlag(gp.Style.Marker, ImMarker_Right))    
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Right))    
                 MarkerRight(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);  
-            if (HasFlag(gp.Style.Marker, ImMarker_Cross))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Cross))
                 MarkerCross(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight); 
-            if (HasFlag(gp.Style.Marker, ImMarker_Plus))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Plus))
                 MarkerPlus(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight); 
-            if (HasFlag(gp.Style.Marker, ImMarker_Asterisk))
+            if (HasFlag(gp.Style.Marker, ImPlotMarker_Asterisk))
                 MarkerAsterisk(DrawList, c, gp.Style.MarkerSize, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, gp.Style.MarkerWeight);  
         }
     }  
@@ -2212,22 +2213,22 @@ inline void PlotEx(const char* label_id, Getter getter, int count, int offset)
     }
     PushPlotClipRect();
     if (count > 1 && rend_line) {
-        if (HasFlag(plot->XAxis.Flags, ImAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImAxisFlags_LogScale))
+        if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
             RenderLineStrip(Plt2PixLogLog(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull);
-        else if (HasFlag(plot->XAxis.Flags, ImAxisFlags_LogScale))
+        else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale))
             RenderLineStrip(Plt2PixLogLin(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull);
-        else if (HasFlag(plot->YAxis[y_axis].Flags, ImAxisFlags_LogScale))
+        else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
             RenderLineStrip(Plt2PixLinLog(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull);
         else
             RenderLineStrip(Plt2PixLinLin(y_axis), DrawList, getter, count, offset, line_weight, col_line, cull);
     }
     // render markers
-    if (gp.Style.Marker != ImMarker_None) {
-        if (HasFlag(plot->XAxis.Flags, ImAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImAxisFlags_LogScale))
+    if (gp.Style.Marker != ImPlotMarker_None) {
+        if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale) && HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
             RenderMarkers(Plt2PixLogLog(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
-        else if (HasFlag(plot->XAxis.Flags, ImAxisFlags_LogScale))
+        else if (HasFlag(plot->XAxis.Flags, ImPlotAxisFlags_LogScale))
             RenderMarkers(Plt2PixLogLin(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
-        else if (HasFlag(plot->YAxis[y_axis].Flags, ImAxisFlags_LogScale))
+        else if (HasFlag(plot->YAxis[y_axis].Flags, ImPlotAxisFlags_LogScale))
             RenderMarkers(Plt2PixLinLog(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
         else
             RenderMarkers(Plt2PixLinLin(y_axis), DrawList, getter, count, offset, rend_mk_line, col_mk_line, rend_mk_fill, col_mk_fill, cull);
diff --git a/implot.h b/implot.h
index d6c1121..6ad31f7 100644
--- a/implot.h
+++ b/implot.h
@@ -30,10 +30,10 @@
 //-----------------------------------------------------------------------------
 
 typedef int ImPlotFlags;
-typedef int ImAxisFlags;
+typedef int ImPlotAxisFlags;
 typedef int ImPlotCol;
 typedef int ImPlotStyleVar;
-typedef int ImMarker;
+typedef int ImPlotMarker;
 
 // Options for plots
 enum ImPlotFlags_ {
@@ -53,18 +53,18 @@ enum ImPlotFlags_ {
 };
 
 // Options for plot axes (X and Y)
-enum ImAxisFlags_ {
-    ImAxisFlags_GridLines  = 1 << 0, // grid lines will be displayed
-    ImAxisFlags_TickMarks  = 1 << 1, // tick marks will be displayed for each grid line
-    ImAxisFlags_TickLabels = 1 << 2, // text labels will be displayed for each grid line
-    ImAxisFlags_Invert     = 1 << 3, // the axis will be inverted
-    ImAxisFlags_LockMin    = 1 << 4, // the axis minimum value will be locked when panning/zooming
-    ImAxisFlags_LockMax    = 1 << 5, // the axis maximum value will be locked when panning/zooming
-    ImAxisFlags_Adaptive   = 1 << 6, // grid divisions will adapt to the current pixel size the axis
-    ImAxisFlags_LogScale   = 1 << 7, // a logartithmic (base 10) axis scale will be used
-    ImAxisFlags_Scientific = 1 << 8, // scientific notation will be used for tick labels if displayed (WIP, not very good yet)
-    ImAxisFlags_Default    = ImAxisFlags_GridLines | ImAxisFlags_TickMarks | ImAxisFlags_TickLabels | ImAxisFlags_Adaptive,
-    ImAxisFlags_Auxiliary  = ImAxisFlags_Default & ~ImAxisFlags_GridLines,
+enum ImPlotAxisFlags_ {
+    ImPlotAxisFlags_GridLines  = 1 << 0, // grid lines will be displayed
+    ImPlotAxisFlags_TickMarks  = 1 << 1, // tick marks will be displayed for each grid line
+    ImPlotAxisFlags_TickLabels = 1 << 2, // text labels will be displayed for each grid line
+    ImPlotAxisFlags_Invert     = 1 << 3, // the axis will be inverted
+    ImPlotAxisFlags_LockMin    = 1 << 4, // the axis minimum value will be locked when panning/zooming
+    ImPlotAxisFlags_LockMax    = 1 << 5, // the axis maximum value will be locked when panning/zooming
+    ImPlotAxisFlags_Adaptive   = 1 << 6, // grid divisions will adapt to the current pixel size the axis
+    ImPlotAxisFlags_LogScale   = 1 << 7, // a logartithmic (base 10) axis scale will be used
+    ImPlotAxisFlags_Scientific = 1 << 8, // scientific notation will be used for tick labels if displayed (WIP, not very good yet)
+    ImPlotAxisFlags_Default    = ImPlotAxisFlags_GridLines | ImPlotAxisFlags_TickMarks | ImPlotAxisFlags_TickLabels | ImPlotAxisFlags_Adaptive,
+    ImPlotAxisFlags_Auxiliary  = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_GridLines,
 };
 
 // Plot styling colors 
@@ -100,18 +100,18 @@ enum ImPlotStyleVar_ {
 };
 
 // Marker specification
-enum ImMarker_ {
-    ImMarker_None        = 1 << 0,  // no marker
-    ImMarker_Circle      = 1 << 1,  // a circle marker will be rendered at each point 
-    ImMarker_Square      = 1 << 2,  // a square maker will be rendered at each point
-    ImMarker_Diamond     = 1 << 3,  // a diamond marker will be rendered at each point
-    ImMarker_Up          = 1 << 4,  // an upward-pointing triangle marker will up rendered at each point
-    ImMarker_Down        = 1 << 5,  // an downward-pointing triangle marker will up rendered at each point
-    ImMarker_Left        = 1 << 6,  // an leftward-pointing triangle marker will up rendered at each point
-    ImMarker_Right       = 1 << 7,  // an rightward-pointing triangle marker will up rendered at each point
-    ImMarker_Cross       = 1 << 8,  // a cross marker will be rendered at each point (not filled)
-    ImMarker_Plus        = 1 << 9,  // a plus marker will be rendered at each point (not filled)
-    ImMarker_Asterisk    = 1 << 10, // a asterisk marker will be rendered at each point (not filled)
+enum ImPlotMarker_ {
+    ImPlotMarker_None        = 1 << 0,  // no marker
+    ImPlotMarker_Circle      = 1 << 1,  // a circle marker will be rendered at each point 
+    ImPlotMarker_Square      = 1 << 2,  // a square maker will be rendered at each point
+    ImPlotMarker_Diamond     = 1 << 3,  // a diamond marker will be rendered at each point
+    ImPlotMarker_Up          = 1 << 4,  // an upward-pointing triangle marker will up rendered at each point
+    ImPlotMarker_Down        = 1 << 5,  // an downward-pointing triangle marker will up rendered at each point
+    ImPlotMarker_Left        = 1 << 6,  // an leftward-pointing triangle marker will up rendered at each point
+    ImPlotMarker_Right       = 1 << 7,  // an rightward-pointing triangle marker will up rendered at each point
+    ImPlotMarker_Cross       = 1 << 8,  // a cross marker will be rendered at each point (not filled)
+    ImPlotMarker_Plus        = 1 << 9,  // a plus marker will be rendered at each point (not filled)
+    ImPlotMarker_Asterisk    = 1 << 10, // a asterisk marker will be rendered at each point (not filled)
 };
 
 // A range defined by a min/max value. Used for plot axes ranges.
@@ -133,7 +133,7 @@ struct ImPlotLimits {
 // Plot style structure
 struct ImPlotStyle {
     float    LineWeight;              // = 1, line weight in pixels
-    ImMarker Marker;                  // = ImMarker_None, marker specification
+    ImPlotMarker Marker;                  // = ImPlotMarker_None, marker specification
     float    MarkerSize;              // = 5, marker size in pixels (roughly the marker's "radius")
     float    MarkerWeight;            // = 1, outline weight of markers in pixels
     float    ErrorBarSize;            // = 5, error bar whisker width in pixels
@@ -160,10 +160,10 @@ bool BeginPlot(const char* title_id,
                const char* y_label  = NULL, 
                const ImVec2& size   = ImVec2(-1,-1), 
                ImPlotFlags flags    = ImPlotFlags_Default, 
-               ImAxisFlags x_flags  = ImAxisFlags_Default, 
-               ImAxisFlags y_flags  = ImAxisFlags_Default,
-               ImAxisFlags y2_flags = ImAxisFlags_Auxiliary,
-               ImAxisFlags y3_flags = ImAxisFlags_Auxiliary);
+               ImPlotAxisFlags x_flags  = ImPlotAxisFlags_Default, 
+               ImPlotAxisFlags y_flags  = ImPlotAxisFlags_Default,
+               ImPlotAxisFlags y2_flags = ImPlotAxisFlags_Auxiliary,
+               ImPlotAxisFlags y3_flags = ImPlotAxisFlags_Auxiliary);
 // Only call EndPlot() if BeginPlot() returns true! Typically called at the end
 // of an if statement conditioned on BeginPlot().
 void EndPlot();
diff --git a/implot_demo.cpp b/implot_demo.cpp
index 45bd878..e172ebf 100644
--- a/implot_demo.cpp
+++ b/implot_demo.cpp
@@ -149,7 +149,7 @@ void ShowDemoWindow(bool* p_open) {
         }
         if (ImPlot::BeginPlot("Line Plot", "x", "f(x)", {-1,300})) {
             ImPlot::Plot("sin(50*x)", xs1, ys1, 1001);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
             ImPlot::Plot("x^2", xs2, ys2, 11);
             ImPlot::PopStyleVar();
             ImPlot::EndPlot();
@@ -170,11 +170,11 @@ void ShowDemoWindow(bool* p_open) {
         }
         if (ImPlot::BeginPlot("Scatter Plot", NULL, NULL, {-1,300})) {
             ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 0);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Cross);            
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Cross);            
             ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 3);
             ImPlot::Plot("Data 1", xs1, ys1, 100);
             ImPlot::PopStyleVar(2);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
             ImPlot::PushStyleColor(ImPlotCol_MarkerFill, ImVec4{1,0,0,0.25f});
             ImPlot::Plot("Data 2", xs2, ys2, 50);
             ImPlot::PopStyleColor();
@@ -220,7 +220,7 @@ void ShowDemoWindow(bool* p_open) {
             ImPlot::Bar("Bar", xs, bar, 5, 0.5f);
             ImPlot::ErrorBars("Bar", xs, bar, err1, 5);
 
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
             ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 3);
             ImPlot::PushStyleColor(ImPlotCol_ErrorBar, ImVec4(1,0,0,1));
             ImPlot::ErrorBars("Line", xs, lin, err1, err2, 5);
@@ -279,7 +279,7 @@ void ShowDemoWindow(bool* p_open) {
             rdata2.AddPoint(t, mouse.y * 0.0005f);
         }
         ImPlot::SetNextPlotLimitsX(t - 10, t, paused ? ImGuiCond_Once : ImGuiCond_Always);
-        static int rt_axis = ImAxisFlags_Default & ~ImAxisFlags_TickLabels;
+        static int rt_axis = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels;
         if (ImPlot::BeginPlot("##Scrolling", NULL, NULL, {-1,150}, ImPlotFlags_Default, rt_axis, rt_axis)) {
             ImPlot::Plot("Data 1", &sdata1.Data[0].x, &sdata1.Data[0].y, sdata1.Data.size(), sdata1.Offset, 2 * sizeof(float));
             ImPlot::Plot("Data 2", &sdata2.Data[0].x, &sdata2.Data[0].y, sdata2.Data.size(), sdata2.Offset, 2 * sizeof(float));
@@ -299,50 +299,50 @@ void ShowDemoWindow(bool* p_open) {
             float xs[2] = {1,4};
             float ys[2] = {10,11};
             // filled
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
             ImPlot::Plot("Circle##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Square);   ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Square);   ys[0]--; ys[1]--;
             ImPlot::Plot("Square##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Diamond);  ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Diamond);  ys[0]--; ys[1]--;
             ImPlot::Plot("Diamond##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Up);       ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Up);       ys[0]--; ys[1]--;
             ImPlot::Plot("Up##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Down);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Down);     ys[0]--; ys[1]--;
             ImPlot::Plot("Down##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Left);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Left);     ys[0]--; ys[1]--;
             ImPlot::Plot("Left##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Right);    ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Right);    ys[0]--; ys[1]--;
             ImPlot::Plot("Right##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Cross);    ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Cross);    ys[0]--; ys[1]--;
             ImPlot::Plot("Cross##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Plus);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Plus);     ys[0]--; ys[1]--;
             ImPlot::Plot("Plus##Fill", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Asterisk); ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Asterisk); ys[0]--; ys[1]--;
             ImPlot::Plot("Asterisk##Fill", xs, ys, 2);   
             ImPlot::PopStyleVar(10);
 
             xs[0] = 6; xs[1] = 9;
             ys[0] = 10; ys[1] = 11;
             ImPlot::PushStyleColor(ImPlotCol_MarkerFill, ImVec4(0,0,0,0));
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle);
             ImPlot::Plot("Circle", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Square);   ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Square);   ys[0]--; ys[1]--;
             ImPlot::Plot("Square", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Diamond);  ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Diamond);  ys[0]--; ys[1]--;
             ImPlot::Plot("Diamond", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Up);       ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Up);       ys[0]--; ys[1]--;
             ImPlot::Plot("Up", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Down);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Down);     ys[0]--; ys[1]--;
             ImPlot::Plot("Down", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Left);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Left);     ys[0]--; ys[1]--;
             ImPlot::Plot("Left", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Right);    ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Right);    ys[0]--; ys[1]--;
             ImPlot::Plot("Right", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Cross);    ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Cross);    ys[0]--; ys[1]--;
             ImPlot::Plot("Cross", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Plus);     ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Plus);     ys[0]--; ys[1]--;
             ImPlot::Plot("Plus", xs, ys, 2);   
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Asterisk); ys[0]--; ys[1]--;
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Asterisk); ys[0]--; ys[1]--;
             ImPlot::Plot("Asterisk", xs, ys, 2);   
             ImPlot::PopStyleColor();
             ImPlot::PopStyleVar(10);
@@ -353,7 +353,7 @@ void ShowDemoWindow(bool* p_open) {
             ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 2);
             ImPlot::PushStyleVar(ImPlotStyleVar_MarkerSize, 8);
             ImPlot::PushStyleVar(ImPlotStyleVar_MarkerWeight, 2);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Circle | ImMarker_Cross); 
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Circle | ImPlotMarker_Cross); 
             ImPlot::PushStyleColor(ImPlotCol_MarkerOutline, ImVec4(0,0,0,1));
             ImPlot::PushStyleColor(ImPlotCol_MarkerFill, ImVec4(1,1,1,1));
             ImPlot::PushStyleColor(ImPlotCol_Line, ImVec4(0,0,0,1));
@@ -379,7 +379,7 @@ void ShowDemoWindow(bool* p_open) {
             ys3[i] = pow(10.0f, xs[i]);
         }
         ImPlot::SetNextPlotLimits(0.1f, 100, 0, 10);
-        if (ImPlot::BeginPlot("Log Plot", NULL, NULL, ImVec2(-1,300), ImPlotFlags_Default, ImAxisFlags_Default | ImAxisFlags_LogScale )) {
+        if (ImPlot::BeginPlot("Log Plot", NULL, NULL, ImVec2(-1,300), ImPlotFlags_Default, ImPlotAxisFlags_Default | ImPlotAxisFlags_LogScale )) {
             ImPlot::Plot("f(x) = x",      xs, xs,  1001);
             ImPlot::Plot("f(x) = sin(x)+1", xs, ys1, 1001);
             ImPlot::Plot("f(x) = log(x)", xs, ys2, 1001);
@@ -453,11 +453,11 @@ void ShowDemoWindow(bool* p_open) {
         ImGui::Unindent();
         static ImVector<ImVec2> data;
         ImPlotLimits range, query;
-        if (ImPlot::BeginPlot("##Drawing", NULL, NULL, ImVec2(-1,300), ImPlotFlags_Default | ImPlotFlags_Query, ImAxisFlags_GridLines, ImAxisFlags_GridLines)) {
+        if (ImPlot::BeginPlot("##Drawing", NULL, NULL, ImVec2(-1,300), ImPlotFlags_Default | ImPlotFlags_Query, ImPlotAxisFlags_GridLines, ImPlotAxisFlags_GridLines)) {
             if (ImPlot::IsPlotHovered() && ImGui::IsMouseClicked(0) && ImGui::GetIO().KeyCtrl) 
                 data.push_back(ImPlot::GetPlotMousePos());
             ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 0);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Diamond);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Diamond);
             if (data.size() > 0)
                 ImPlot::Plot("Points", &data[0].x, &data[0].y, data.size(), 0, 2 * sizeof(float));
             if (ImPlot::IsPlotQueried() && data.size() > 0) {
@@ -504,7 +504,7 @@ void ShowDemoWindow(bool* p_open) {
         }
         ImGui::BulletText("Query the first plot to render a subview in the second plot (see above for controls).");
         ImPlot::SetNextPlotLimits(0,0.01f,-1,1);
-        ImAxisFlags flgs = ImAxisFlags_Default & ~ImAxisFlags_TickLabels;
+        ImPlotAxisFlags flgs = ImPlotAxisFlags_Default & ~ImPlotAxisFlags_TickLabels;
         ImPlotLimits query;
         if (ImPlot::BeginPlot("##View1",NULL,NULL,ImVec2(-1,150), ImPlotFlags_Default | ImPlotFlags_Query, flgs, flgs)) {
             ImPlot::Plot("Signal 1", x_data, y_data1, 512);
@@ -741,7 +741,7 @@ void ShowDemoWindow(bool* p_open) {
             ImPlot::Bar("Bar", bar, 10, 0.5f);
             ImPlot::Plot("Line", lin, 10);
             ImPlot::PushStyleVar(ImPlotStyleVar_LineWeight, 0);
-            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImMarker_Square);
+            ImPlot::PushStyleVar(ImPlotStyleVar_Marker, ImPlotMarker_Square);
             ImPlot::Plot("Dot", dot, 10);
             ImPlot::PopStyleVar(2);
             ImPlot::EndPlot();