diff --git a/DemoGallery/main.cpp b/DemoGallery/main.cpp
index df5509c..cdc34f5 100644
--- a/DemoGallery/main.cpp
+++ b/DemoGallery/main.cpp
@@ -246,7 +246,7 @@ int main(int argc, char *argv[]) {
 
 
 
-    YSG::startRenderScheduler();
+    YSG::start_render_scheduler();
     qDebug() << "启动耗时 " << timer.elapsed();
 
 
diff --git a/YSGraphic_Core/Axis/AbsAxis.cpp b/YSGraphic_Core/Axis/AbsAxis.cpp
index 3554a9c..81022d9 100644
--- a/YSGraphic_Core/Axis/AbsAxis.cpp
+++ b/YSGraphic_Core/Axis/AbsAxis.cpp
@@ -9,13 +9,13 @@ namespace YSG {
     AbsAxisPrivate* AbsAxis::d() {
         return AbsAxis_Binding::d(this);
     }
-    RenderData* AbsAxis::createRenderData() {
+    RenderData* AbsAxis::create_render_data() {
         return AbsAxis_Binding::create_render_data();
     }
-    RenderState* AbsAxis::createRenderState() {
+    RenderState* AbsAxis::create_render_state() {
         return AbsAxis_Binding::create_render_state();
     }
-    InputData* AbsAxis::createInputData() {
+    InputData* AbsAxis::create_input_data() {
         return AbsAxis_Binding::create_input_data();
     }
     int AbsAxis::x(SRC src) {
@@ -36,23 +36,23 @@ namespace YSG {
     void AbsAxis::set_orientation(Qt::Orientation value) {
         d()->set_state_value(&AbsAxisRenderState::orientation, value);
     }
-    size_t AbsAxis::pixelSize(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::pixelSize, src);
+    size_t AbsAxis::pixel_size(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::pixel_size, src);
     }
-    void AbsAxis::set_pixelSize(size_t value) {
-        d()->set_state_value(&AbsAxisRenderState::pixelSize, value);
+    void AbsAxis::set_pixel_size(size_t value) {
+        d()->set_state_value(&AbsAxisRenderState::pixel_size, value);
     }
-    int AbsAxis::tickLength(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::tickLength, src);
+    int AbsAxis::tick_length(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::tick_length, src);
     }
-    void AbsAxis::set_tickLength(int value) {
-        d()->set_state_value(&AbsAxisRenderState::tickLength, value);
+    void AbsAxis::set_tick_length(int value) {
+        d()->set_state_value(&AbsAxisRenderState::tick_length, value);
     }
-    int AbsAxis::subTickLength(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::subTickLength, src);
+    int AbsAxis::sub_tick_length(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::sub_tick_length, src);
     }
-    void AbsAxis::set_subTickLength(int value) {
-        d()->set_state_value(&AbsAxisRenderState::subTickLength, value);
+    void AbsAxis::set_sub_tick_length(int value) {
+        d()->set_state_value(&AbsAxisRenderState::sub_tick_length, value);
     }
     QColor AbsAxis::color(SRC src) {
         return d()->state_value(&AbsAxisRenderState::color, src);
@@ -60,11 +60,11 @@ namespace YSG {
     void AbsAxis::set_color(QColor value) {
         d()->set_state_value(&AbsAxisRenderState::color, std::move(value));
     }
-    QChar AbsAxis::formatChar(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::formatChar, src);
+    QChar AbsAxis::format_char(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::format_char, src);
     }
-    void AbsAxis::set_formatChar(QChar value) {
-        d()->set_state_value(&AbsAxisRenderState::formatChar, std::move(value));
+    void AbsAxis::set_format_char(QChar value) {
+        d()->set_state_value(&AbsAxisRenderState::format_char, std::move(value));
     }
     QLocale AbsAxis::locale(SRC src) {
         return d()->state_value(&AbsAxisRenderState::locale, src);
@@ -72,29 +72,29 @@ namespace YSG {
     void AbsAxis::set_locale(QLocale value) {
         d()->set_state_value(&AbsAxisRenderState::locale, std::move(value));
     }
-    QString AbsAxis::unitText(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::unitText, src);
+    QString AbsAxis::unit_text(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::unit_text, src);
     }
-    void AbsAxis::set_unitText(QString value) {
-        d()->set_state_value(&AbsAxisRenderState::unitText, std::move(value));
+    void AbsAxis::set_unit_text(QString value) {
+        d()->set_state_value(&AbsAxisRenderState::unit_text, std::move(value));
     }
-    QFont AbsAxis::unitTextFont(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::unitTextFont, src);
+    QFont AbsAxis::unit_text_font(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::unit_text_font, src);
     }
-    void AbsAxis::set_unitTextFont(QFont value) {
-        d()->set_state_value(&AbsAxisRenderState::unitTextFont, std::move(value));
+    void AbsAxis::set_unit_text_font(QFont value) {
+        d()->set_state_value(&AbsAxisRenderState::unit_text_font, std::move(value));
     }
-    QPen AbsAxis::unitTextPen(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::unitTextPen, src);
+    QPen AbsAxis::unit_text_pen(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::unit_text_pen, src);
     }
-    void AbsAxis::set_unitTextPen(QPen value) {
-        d()->set_state_value(&AbsAxisRenderState::unitTextPen, std::move(value));
+    void AbsAxis::set_unit_text_pen(QPen value) {
+        d()->set_state_value(&AbsAxisRenderState::unit_text_pen, std::move(value));
     }
-    QBrush AbsAxis::unitTextBackgroundBrush(SRC src) {
-        return d()->state_value(&AbsAxisRenderState::unitTextBackgroundBrush, src);
+    QBrush AbsAxis::unit_text_background_brush(SRC src) {
+        return d()->state_value(&AbsAxisRenderState::unit_text_background_brush, src);
     }
-    void AbsAxis::set_unitTextBackgroundBrush(QBrush value) {
-        d()->set_state_value(&AbsAxisRenderState::unitTextBackgroundBrush, std::move(value));
+    void AbsAxis::set_unit_text_background_brush(QBrush value) {
+        d()->set_state_value(&AbsAxisRenderState::unit_text_background_brush, std::move(value));
     }
     int AbsAxis::rotate(SRC src) {
         return d()->state_value(&AbsAxisRenderState::rotate, src);
@@ -102,16 +102,16 @@ namespace YSG {
     void AbsAxis::set_rotate(int value) {
         d()->set_state_value(&AbsAxisRenderState::rotate, value);
     }
-    double AbsAxis::pixelToCoord(double pixel, SRC src)  {
-        return d()->pixelToCoord(pixel, src);
+    double AbsAxis::pixel_to_coord(double pixel, SRC src)  {
+        return d()->pixel_to_coord(pixel, src);
     }
 
-    double AbsAxis::coordToPixel(double coord, SRC src)  {
-        return d()->coordToPixel(coord, src);
+    double AbsAxis::coord_to_pixel(double coord, SRC src)  {
+        return d()->coord_to_pixel(coord, src);
     }
 
-    QVector<double> AbsAxisPrivate::createTickVector(double tickStep, const Range &range) {
-        double mTickOrigin = renderState()->coordStart;
+    QVector<double> AbsAxisPrivate::create_tick_vector(double tickStep, const Range &range) {
+        double mTickOrigin = render_state()->coord_start;
         QVector<double> result;
         // Generate tick positions according to tickStep:
         // do not use qFloor here, or we'll lose 64 bit precision
@@ -141,15 +141,15 @@ namespace YSG {
         return result;
     }
 
-    QVector<QString> AbsAxisPrivate::createLabelVector(const QVector<double> &ticks, SRC src) {
+    QVector<QString> AbsAxisPrivate::create_label_vector(const QVector<double> &ticks, SRC src) {
         QVector<QString> result;
         result.reserve(ticks.size());
         foreach (double tickCoord, ticks)
-          result.append(getTickLabel(tickCoord, src));
+          result.append(get_tick_label(tickCoord, src));
         return result;
     }
 
-    QVector<double> AbsAxisPrivate::createSubTickVector(int subTickCount, const QVector<double> &ticks, const Range& range) {
+    QVector<double> AbsAxisPrivate::create_sub_tick_vector(int subTickCount, const QVector<double> &ticks, const Range& range) {
         QVector<double> result;
         if (subTickCount <= 0 || ticks.size() < 2)
             return result;
@@ -170,7 +170,7 @@ namespace YSG {
 
 
 
-    int AbsAxisPrivate::getSubTickCount(double tickStep) {
+    int AbsAxisPrivate::get_sub_tick_count(double tickStep) {
         int result = 1; // default to 1, if no proper value can be found
         // separate integer and fractional part of mantissa:
         double epsilon = 0.01;
@@ -207,7 +207,7 @@ namespace YSG {
                 case 2: result = 4; break; // 2.5 -> 0.5 substep
                 case 3: result = 4; break; // 3.5 -> 0.7 substep
                 case 4: result = 2; break; // 4.5 -> 1.5 substep
-                case 5: result = 4; break; // 5.5 -> 1.1 substep (won't occur with default getTickStep from here on)
+                case 5: result = 4; break; // 5.5 -> 1.1 substep (won't occur with default get_tick_step from here on)
                 case 6: result = 4; break; // 6.5 -> 1.3 substep
                 case 7: result = 2; break; // 7.5 -> 2.5 substep
                 case 8: result = 4; break; // 8.5 -> 1.7 substep
@@ -230,7 +230,7 @@ namespace YSG {
 
 
 
-    double AbsAxisPrivate::cleanMantissa(double input) {
+    double AbsAxisPrivate::clean_mantissa(double input) {
         double magnitude;
         const double mantissa = getMantissa(input, &magnitude);
         return pickClosest(mantissa, QVector<double>() << 1.0 << 2.0 << 2.5 << 5.0 << 10.0)*magnitude;
@@ -251,50 +251,50 @@ namespace YSG {
 
 
 
-    QString AbsAxisPrivate::getTickLabel(double tick, SRC src) {
-        auto renderState = reinterpret_cast<AbsAxisRenderState*>(state(src));
-        return renderState->locale.toString(tick, renderState->formatChar.toLatin1(), renderState->numberPrecision);
+    QString AbsAxisPrivate::get_tick_label(double tick, SRC src) {
+        auto render_state = reinterpret_cast<AbsAxisRenderState*>(state(src));
+        return render_state->locale.toString(tick, render_state->format_char.toLatin1(), render_state->number_precision);
     }
 
-    double AbsAxis::startCoord(SRC src) {
-        auto renderState = d()->state_data(src);
-        return renderState->coordStart;
+    double AbsAxis::start_coord(SRC src) {
+        auto render_state = d()->state_data(src);
+        return render_state->coord_start;
     }
 
-    double AbsAxis::endCoord(SRC src) {
-        auto renderState = d()->state_data(src);
-        return renderState->coordStart + renderState->coordLength;
+    double AbsAxis::end_coord(SRC src) {
+        auto render_state = d()->state_data(src);
+        return render_state->coord_start + render_state->coord_length;
     }
 
-    Range AbsAxis::coordRange(SRC src) {
-        auto renderState = d()->state_data(src);
-        return  {renderState->coordStart, renderState->coordStart + renderState->coordLength};
+    Range AbsAxis::coord_range(SRC src) {
+        auto render_state = d()->state_data(src);
+        return  {render_state->coord_start, render_state->coord_start + render_state->coord_length};
     }
 
-    int AbsAxis::getPixelPointSize(Range range, SRC src) {
-        auto renderState = d()->state_data(src);
-        return static_cast<int>(qAbs(range.length()/coordRange(src).length()) * renderState->pixelSize);
+    int AbsAxis::get_pixel_point_size(Range range, SRC src) {
+        auto render_state = d()->state_data(src);
+        return static_cast<int>(qAbs(range.length()/coord_range(src).length()) * render_state->pixel_size);
     }
 
-    int AbsAxis::getPixelPointSize(SRC src) {
-        auto renderState = d()->state_data(src);
-        return qAbs(renderState->pixelSize);
+    int AbsAxis::get_pixel_point_size(SRC src) {
+        auto render_state = d()->state_data(src);
+        return qAbs(render_state->pixel_size);
     }
 
 
-    double AbsAxis::getTickStep(const Range &range) {return d()->getTickStep(range);}
-    int AbsAxis::getSubTickCount(double tickStep) {return d()->getSubTickCount(tickStep);}
-    QString AbsAxis::getTickLabel(double tick, SRC src) {
-        return d()->getTickLabel(tick, src);
+    double AbsAxis::get_tick_step(const Range &range) {return d()->get_tick_step(range);}
+    int AbsAxis::get_sub_tick_count(double tickStep) {return d()->get_sub_tick_count(tickStep);}
+    QString AbsAxis::get_tick_label(double tick, SRC src) {
+        return d()->get_tick_label(tick, src);
     }
-    QVector<QString> AbsAxis::createLabelVector(const QVector<double> &ticks, SRC src) {
-        return d()->createLabelVector(ticks, src);
+    QVector<QString> AbsAxis::create_label_vector(const QVector<double> &ticks, SRC src) {
+        return d()->create_label_vector(ticks, src);
     }
 
-    QVector<double> AbsAxis::createTickVector(double tickStep, const Range &range) {
-        return d()->createTickVector(tickStep, range);
+    QVector<double> AbsAxis::create_tick_vector(double tickStep, const Range &range) {
+        return d()->create_tick_vector(tickStep, range);
     }
-    QVector<double> AbsAxis::createSubTickVector(int subTickCount, const QVector<double> &ticks, const Range& range) {
-        return d()->createSubTickVector(subTickCount, ticks, range);
+    QVector<double> AbsAxis::create_sub_tick_vector(int subTickCount, const QVector<double> &ticks, const Range& range) {
+        return d()->create_sub_tick_vector(subTickCount, ticks, range);
     }
 }
diff --git a/YSGraphic_Core/Axis/AbsAxis.h b/YSGraphic_Core/Axis/AbsAxis.h
index 7cb87b9..393e17d 100644
--- a/YSGraphic_Core/Axis/AbsAxis.h
+++ b/YSGraphic_Core/Axis/AbsAxis.h
@@ -12,26 +12,26 @@ struct AbsAxis_Prop{
     int x{};
     int y{};
     Qt::Orientation orientation = Qt::Horizontal;
-    int tickLength = 10;
-    int subTickLength = 5;
-    double coordStart = 0;
-    double coordLength = 20;
+    int tick_length = 10;
+    int sub_tick_length = 5;
+    double coord_start = 0;
+    double coord_length = 20;
     QColor color = Qt::white;
-    QChar formatChar = 'f';
+    QChar format_char = 'f';
     QLocale locale;
-    QString unitText = "";
-    QFont unitTextFont;
-    QPen unitTextPen = QPen(Qt::white);
-    QBrush unitTextBackgroundBrush = QBrush(Qt::black);
+    QString unit_text = "";
+    QFont unit_text_font;
+    QPen unit_text_pen = QPen(Qt::white);
+    QBrush unit_text_background_brush = QBrush(Qt::black);
     int rotate = 0; // 不旋转
 };
 struct AbsAxisPrivate;
 class LIB_DECL AbsAxis : public RenderAble {
 public:
     AbsAxisPrivate* d();
-    RenderData* createRenderData() override;
-    RenderState* createRenderState() override;
-    InputData* createInputData() override;
+    RenderData* create_render_data() override;
+    RenderState* create_render_state() override;
+    InputData* create_input_data() override;
 protected:
     AbsAxis();
     friend struct AbsAxisPrivate;
@@ -41,30 +41,30 @@ public:
     PROP(int, x)
     PROP(int, y)
     PROP(Qt::Orientation, orientation)
-    PROP(size_t, pixelSize)
-    PROP(int, tickLength)
-    PROP(int, subTickLength)
+    PROP(size_t, pixel_size)
+    PROP(int, tick_length)
+    PROP(int, sub_tick_length)
     PROP(QColor, color)
-    PROP(QChar, formatChar)
+    PROP(QChar, format_char)
     PROP(QLocale, locale)
-    PROP(QString, unitText)
-    PROP(QFont, unitTextFont)
-    PROP(QPen, unitTextPen)
-    PROP(QBrush, unitTextBackgroundBrush)
+    PROP(QString, unit_text)
+    PROP(QFont, unit_text_font)
+    PROP(QPen, unit_text_pen)
+    PROP(QBrush, unit_text_background_brush)
     PROP(int, rotate) // 不旋转
-    [[nodiscard]] virtual double pixelToCoord(double pixel, SRC src);
-    [[nodiscard]] virtual double coordToPixel(double coord, SRC src);
-    [[nodiscard]] virtual double getTickStep(const Range &range);
-    [[nodiscard]] virtual int getSubTickCount(double tickStep);
-    virtual QString getTickLabel(double tick, SRC);
-    virtual QVector<double> createTickVector(double tickStep, const Range &range);
-    virtual QVector<double> createSubTickVector(int subTickCount, const QVector<double> &ticks, const Range& range);
-    virtual QVector<QString> createLabelVector(const QVector<double> &ticks, SRC);
-    double startCoord(SRC=SRC::Edit);
-    double endCoord(SRC=SRC::Edit);
-    Range coordRange(SRC=SRC::Edit);
-    int getPixelPointSize(Range range, SRC=SRC::Edit);
-    int getPixelPointSize(SRC=SRC::Edit);
+    [[nodiscard]] virtual double pixel_to_coord(double pixel, SRC src);
+    [[nodiscard]] virtual double coord_to_pixel(double coord, SRC src);
+    [[nodiscard]] virtual double get_tick_step(const Range &range);
+    [[nodiscard]] virtual int get_sub_tick_count(double tickStep);
+    virtual QString get_tick_label(double tick, SRC);
+    virtual QVector<double> create_tick_vector(double tickStep, const Range &range);
+    virtual QVector<double> create_sub_tick_vector(int subTickCount, const QVector<double> &ticks, const Range& range);
+    virtual QVector<QString> create_label_vector(const QVector<double> &ticks, SRC);
+    double start_coord(SRC=SRC::Edit);
+    double end_coord(SRC=SRC::Edit);
+    Range coord_range(SRC=SRC::Edit);
+    int get_pixel_point_size(Range range, SRC=SRC::Edit);
+    int get_pixel_point_size(SRC=SRC::Edit);
     template <typename That> struct BuilderT;
 };
 template <typename That>
@@ -72,21 +72,21 @@ struct AbsAxis::BuilderT : protected AbsAxis_Prop {
     PROP_BT(int, x)
     PROP_BT(int, y)
     PROP_BT(Qt::Orientation, orientation)
-    PROP_BT(size_t, pixelSize)
-    PROP_BT(int, tickLength)
-    PROP_BT(int, subTickLength)
+    PROP_BT(size_t, pixel_size)
+    PROP_BT(int, tick_length)
+    PROP_BT(int, sub_tick_length)
     PROP_BT(QColor, color)
-    PROP_BT(QChar, formatChar)
+    PROP_BT(QChar, format_char)
     PROP_BT(QLocale, locale)
-    PROP_BT(QString, unitText)
-    PROP_BT(QFont, unitTextFont)
-    PROP_BT(QPen, unitTextPen)
-    PROP_BT(QBrush, unitTextBackgroundBrush)
+    PROP_BT(QString, unit_text)
+    PROP_BT(QFont, unit_text_font)
+    PROP_BT(QPen, unit_text_pen)
+    PROP_BT(QBrush, unit_text_background_brush)
     PROP_BT(int, rotate) // 不旋转
     SETTER_T(QString, layerName, "axis")
 protected:
     Plot *plot{};
-    size_t pixelSize{};
+    size_t pixel_size{};
     void set(AbsAxis* ret);
 };
 }
diff --git a/YSGraphic_Core/Axis/AbsAxis_p.h b/YSGraphic_Core/Axis/AbsAxis_p.h
index d92a07a..23e463a 100644
--- a/YSGraphic_Core/Axis/AbsAxis_p.h
+++ b/YSGraphic_Core/Axis/AbsAxis_p.h
@@ -5,13 +5,13 @@
 namespace YSG {
     struct AbsAxisRenderState : RenderState, AbsAxis_Prop {
 
-        size_t pixelSize{};
-        int numberPrecision = 2;
-        double coordStart = 0;
-        double coordLength = 20;
+        size_t pixel_size{};
+        int number_precision = 2;
+        double coord_start = 0;
+        double coord_length = 20;
         void scaleRange(double factor, double center) {
-            coordStart = (coordStart - center) * factor + center;
-            coordLength *= factor;
+            coord_start = (coord_start - center) * factor + center;
+            coord_length *= factor;
         }
     };
     struct AbsAxisInputData : InputData {};
@@ -21,24 +21,24 @@ namespace YSG {
         int mTickCount = 2;
         std::atomic<int> pixelStart{};
         double getMantissa(double input, double *magnitude=nullptr);
-        [[nodiscard]] double cleanMantissa(double input);
+        [[nodiscard]] double clean_mantissa(double input);
         [[nodiscard]] double pickClosest(double target, const QVector<double> &candidates);
 
 
-        void prepareData() override {
-            syncStatePipeline();
+        void prepare_data() override {
+            sync_state_pipeline();
         }
 
         void draw(QPainter* painter) override {
-            AbsAxisRenderState* s = renderState();
+            AbsAxisRenderState* s = render_state();
             pixelStart = s->orientation == Qt::Horizontal ? s->x : s->y;
-            Range range = {s->coordStart, s->coordStart + s->coordLength};
+            Range range = {s->coord_start, s->coord_start + s->coord_length};
             AbsAxis* q = this->q();
-            double tickStep = q->getTickStep(range);
-            QVector<double> ticks = q->createTickVector(tickStep, range);
-            int subTickCount = q->getSubTickCount(tickStep);
-            QVector<double> subTicks =  q->createSubTickVector(subTickCount, ticks, range);
-            QVector<QString> labels = q->createLabelVector(ticks, SRC::Render);
+            double tickStep = q->get_tick_step(range);
+            QVector<double> ticks = q->create_tick_vector(tickStep, range);
+            int subTickCount = q->get_sub_tick_count(tickStep);
+            QVector<double> subTicks =  q->create_sub_tick_vector(subTickCount, ticks, range);
+            QVector<QString> labels = q->create_label_vector(ticks, SRC::Render);
             while (!ticks.empty() && !range.contain(ticks.last())) {
                 ticks.removeLast();
             }
@@ -49,84 +49,84 @@ namespace YSG {
             int h = fm.height();
             painter->setPen(s->color);
             if(s->orientation == Qt::Horizontal) {
-                painter->drawLine(s->x, s->y, s->x + s->pixelSize, s->y);
+                painter->drawLine(s->x, s->y, s->x + s->pixel_size, s->y);
                 int n = ticks.size();
                 for(int i = 0; i < n; ++i) {
                     double tick = ticks[i];
-                    double x = q->coordToPixel(tick, SRC::Render);
-                    painter->drawLine((int)x, s->y, (int)x, s->y + s->tickLength);
+                    double x = q->coord_to_pixel(tick, SRC::Render);
+                    painter->drawLine((int)x, s->y, (int)x, s->y + s->tick_length);
                     const QString& label = labels[i];
-                    QPoint start((int)x, s->y + s->tickLength);
+                    QPoint start((int)x, s->y + s->tick_length);
                     painter->translate(start);
                     painter->rotate(s->rotate);
                     painter->drawText(0, 0, label);
                     painter->resetTransform();
                 }
                 for(double tick : subTicks) {
-                    double x = q->coordToPixel(tick, SRC::Render);
-                    painter->drawLine((int)x, s->y, (int)x, s->y + s->subTickLength);
+                    double x = q->coord_to_pixel(tick, SRC::Render);
+                    painter->drawLine((int)x, s->y, (int)x, s->y + s->sub_tick_length);
                 }
             } else if(s->orientation == Qt::Vertical) {
-                painter->drawLine(s->x, s->y, s->x, s->y + s->pixelSize);
+                painter->drawLine(s->x, s->y, s->x, s->y + s->pixel_size);
                 int n = ticks.size();
                 for(int i = 0; i < n; ++i) {
                     double tick = ticks[i];
-                    double y = q->coordToPixel(tick, SRC::Render);
+                    double y = q->coord_to_pixel(tick, SRC::Render);
                     const QString& label = labels[i];
-                    painter->drawLine(s->x, (int)y, s->x + s->tickLength, (int)y);
-                    QPoint start = QPoint(s->x + s->tickLength * 2, (int)y + h/2);
+                    painter->drawLine(s->x, (int)y, s->x + s->tick_length, (int)y);
+                    QPoint start = QPoint(s->x + s->tick_length * 2, (int)y + h/2);
                     painter->translate(start);
                     painter->rotate(s->rotate);
                     painter->drawText(0, 0, label);
                     painter->resetTransform();
                 }
                 for(double tick : subTicks) {
-                    double y = q->coordToPixel(tick, SRC::Render);
-                    painter->drawLine(s->x, (int)y, s->x + s->subTickLength, (int)y);
+                    double y = q->coord_to_pixel(tick, SRC::Render);
+                    painter->drawLine(s->x, (int)y, s->x + s->sub_tick_length, (int)y);
                 }
             } else {
                 qDebug() << "error s->mOrientation == " << s->orientation;
             }
-            if(s->unitText.isEmpty()) return;
-            double w = fm.horizontalAdvance(s->unitText);
+            if(s->unit_text.isEmpty()) return;
+            double w = fm.horizontalAdvance(s->unit_text);
 
             if(s->orientation == Qt::Horizontal) {
-                double x = pixelStart + s->pixelSize - w;
+                double x = pixelStart + s->pixel_size - w;
                 double y = s->y - h;
                 QRectF area(x, y, w, h);
-                painter->fillRect(area, s->unitTextBackgroundBrush);
-                painter->setPen(s->unitTextPen);
-                painter->setFont(s->unitTextFont);
-                painter->drawText(area, Qt::AlignCenter, s->unitText);
+                painter->fillRect(area, s->unit_text_background_brush);
+                painter->setPen(s->unit_text_pen);
+                painter->setFont(s->unit_text_font);
+                painter->drawText(area, Qt::AlignCenter, s->unit_text);
             } else if (s->orientation == Qt::Vertical) {
                 double x = s->x;
                 double y = pixelStart;
                 QRectF area(x, y, w, h);
-                painter->fillRect(area, s->unitTextBackgroundBrush);
-                painter->setPen(s->unitTextPen);
-                painter->setFont(s->unitTextFont);
-                painter->drawText(area, Qt::AlignCenter, s->unitText);
+                painter->fillRect(area, s->unit_text_background_brush);
+                painter->setPen(s->unit_text_pen);
+                painter->setFont(s->unit_text_font);
+                painter->drawText(area, Qt::AlignCenter, s->unit_text);
             }
         }
 
     protected:
-        [[nodiscard]] virtual double pixelToCoord(double pixel, SRC src) {
+        [[nodiscard]] virtual double pixel_to_coord(double pixel, SRC src) {
             auto s = static_cast<AbsAxisRenderState*>(state(src));
-            return s->coordStart + s->coordLength * (pixel - (double)pixelStart)/(double)s->pixelSize;
+            return s->coord_start + s->coord_length * (pixel - (double)pixelStart)/(double)s->pixel_size;
         }
-        [[nodiscard]] virtual double coordToPixel(double coord, SRC src) {
+        [[nodiscard]] virtual double coord_to_pixel(double coord, SRC src) {
             auto s = static_cast<AbsAxisRenderState*>(state(src));
-            return pixelStart + (double)s->pixelSize * (coord - s->coordStart)/s->coordLength;
+            return pixelStart + (double)s->pixel_size * (coord - s->coord_start)/s->coord_length;
         }
-        virtual double getTickStep(const Range &range){
+        virtual double get_tick_step(const Range &range){
             double exactStep = range.size()/double(mTickCount+1e-10); // mTickCount ticks on average, the small addition is to prevent jitter on exact integers
-            return cleanMantissa(exactStep);
+            return clean_mantissa(exactStep);
         }
-        virtual int getSubTickCount(double tickStep);
-        virtual QVector<double> createTickVector(double tickStep, const Range &range);
-        virtual QVector<double> createSubTickVector(int subTickCount, const QVector<double> &ticks, const Range& range);
-        virtual QString getTickLabel(double tick, SRC);
-        virtual QVector<QString> createLabelVector(const QVector<double> &ticks, SRC);
+        virtual int get_sub_tick_count(double tickStep);
+        virtual QVector<double> create_tick_vector(double tickStep, const Range &range);
+        virtual QVector<double> create_sub_tick_vector(int subTickCount, const QVector<double> &ticks, const Range& range);
+        virtual QString get_tick_label(double tick, SRC);
+        virtual QVector<QString> create_label_vector(const QVector<double> &ticks, SRC);
     };
 
     template <typename That>
@@ -137,16 +137,16 @@ namespace YSG {
         sc->x = this->x;
         sc->y = this->y;
         sc->orientation = this->orientation;
-        sc->pixelSize = this->pixelSize;
-        sc->tickLength = this->tickLength;
-        sc->subTickLength = this->subTickLength;
+        sc->pixel_size = this->pixel_size;
+        sc->tick_length = this->tick_length;
+        sc->sub_tick_length = this->sub_tick_length;
         sc->color = this->color;
-        sc->formatChar = this->formatChar;
+        sc->format_char = this->format_char;
         sc->locale = this->locale;
-        sc->unitText = this->unitText;
-        sc->unitTextFont = this->unitTextFont;
-        sc->unitTextPen = this->unitTextPen;
-        sc->unitTextBackgroundBrush = this->unitTextBackgroundBrush;
+        sc->unit_text = this->unit_text;
+        sc->unit_text_font = this->unit_text_font;
+        sc->unit_text_pen = this->unit_text_pen;
+        sc->unit_text_background_brush = this->unit_text_background_brush;
         sc->rotate = this->rotate;
     }
 
diff --git a/YSGraphic_Core/Axis/Axis.cpp b/YSGraphic_Core/Axis/Axis.cpp
index 7c5d0a5..028f300 100644
--- a/YSGraphic_Core/Axis/Axis.cpp
+++ b/YSGraphic_Core/Axis/Axis.cpp
@@ -8,37 +8,37 @@ namespace YSG {
     AxisPrivate* Axis::d() {
         return Axis_Binding::d(this);
     }
-    RenderData* Axis::createRenderData() {
+    RenderData* Axis::create_render_data() {
         return Axis_Binding::create_render_data();
     }
-    RenderState* Axis::createRenderState() {
+    RenderState* Axis::create_render_state() {
         return Axis_Binding::create_render_state();
     }
-    InputData* Axis::createInputData() {
+    InputData* Axis::create_input_data() {
         return Axis_Binding::create_input_data();
     }
-    int Axis::numberPrecision(SRC src) {
-        return d()->state_value(&AxisRenderState::numberPrecision, src);
+    int Axis::number_precision(SRC src) {
+        return d()->state_value(&AxisRenderState::number_precision, src);
     }
-    void Axis::set_numberPrecision(int value) {
-        d()->set_state_value(&AxisRenderState::numberPrecision, value);
+    void Axis::set_number_precision(int value) {
+        d()->set_state_value(&AxisRenderState::number_precision, value);
     }
-    double Axis::coordStart(SRC src) {
-        return d()->state_value(&AxisRenderState::coordStart, src);
+    double Axis::coord_start(SRC src) {
+        return d()->state_value(&AxisRenderState::coord_start, src);
     }
-    void Axis::set_coordStart(double value) {
-        d()->set_state_value(&AxisRenderState::coordStart, value);
+    void Axis::set_coord_start(double value) {
+        d()->set_state_value(&AxisRenderState::coord_start, value);
     }
-    double Axis::coordLength(SRC src) {
-        return d()->state_value(&AxisRenderState::coordLength, src);
+    double Axis::coord_length(SRC src) {
+        return d()->state_value(&AxisRenderState::coord_length, src);
     }
-    void Axis::set_coordLength(double value) {
-        d()->set_state_value(&AxisRenderState::coordLength, value);
+    void Axis::set_coord_length(double value) {
+        d()->set_state_value(&AxisRenderState::coord_length, value);
     }
-    void Axis::set_coordRange(Range range){
+    void Axis::set_coord_range(Range range){
         Render_Edit_Lease<AxisPrivate, AxisRenderState> edit(d());
-        edit->coordStart = range.lower;
-        edit->coordLength = range.upper - range.lower;
+        edit->coord_start = range.lower;
+        edit->coord_length = range.upper - range.lower;
     }
     Axis::Builder::Builder(Plot* plot, Qt::Orientation orientation) {
         this->plot = plot;
diff --git a/YSGraphic_Core/Axis/Axis.h b/YSGraphic_Core/Axis/Axis.h
index 105e471..97fcae3 100644
--- a/YSGraphic_Core/Axis/Axis.h
+++ b/YSGraphic_Core/Axis/Axis.h
@@ -7,32 +7,32 @@ namespace YSG {
     struct AxisPrivate;
     class LIB_DECL Axis : public AbsAxis {
         AxisPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         Axis();
         friend struct AxisPrivate;
         friend struct AxisRenderState;
         friend struct AxisInputData;
     public:
-        PROP(int, numberPrecision)
-        PROP(double, coordStart)
-        PROP(double, coordLength)
-        void set_coordRange(Range range);
+        PROP(int, number_precision)
+        PROP(double, coord_start)
+        PROP(double, coord_length)
+        void set_coord_range(Range range);
         template <typename That> struct BuilderT;
         struct Builder;
     };
 
     template <typename That>
     struct Axis::BuilderT :  AbsAxis::BuilderT<That>{
-        PROP_BT(int, numberPrecision)
-        // PROP_BT(double, coordStart)
-        // PROP_BT(double, coordLength)
-        That& set_coordRange(Range r) {
+        PROP_BT(int, number_precision)
+        // PROP_BT(double, coord_start)
+        // PROP_BT(double, coord_length)
+        That& set_coord_range(Range r) {
             That& t = *static_cast<That*>(this);
-            t.coordStart = std::move(r.lower);
-            t.coordLength = std::move(r.length());
+            t.coord_start = std::move(r.lower);
+            t.coord_length = std::move(r.length());
             return t;
         }
         That& set_use_wheel(bool useWheel) {
@@ -47,7 +47,7 @@ namespace YSG {
         }
     protected:
         void set(Axis* ret);
-        int numberPrecision = 2;
+        int number_precision = 2;
         bool useWheel = false;
         bool useDrag = false;
     };
diff --git a/YSGraphic_Core/Axis/Axis_p.h b/YSGraphic_Core/Axis/Axis_p.h
index 865009c..a54d42f 100644
--- a/YSGraphic_Core/Axis/Axis_p.h
+++ b/YSGraphic_Core/Axis/Axis_p.h
@@ -18,18 +18,18 @@ namespace YSG {
         bool useWheel = false;
         bool useDrag = false;
     protected:
-        bool selectTest(const QPointF& pos) override {return true;}
+        bool select_test(const QPointF& pos) override {return true;}
         void wheelEvent(QWheelEvent* event) override {
             if(useWheel) {
                 Render_Edit_Lease<AxisPrivate, AxisRenderState> edit(this);
                 const double delta = event->angleDelta().y();
                 double wheelSteps = delta / 120.0;
                 double factor = std::pow(0.8, wheelSteps);
-                double cursor_coord = pixelToCoord(event->position().x(), SRC::Edit);
-                double new_coordLength = edit->coordLength * factor;
-                double new_coordStart = cursor_coord - new_coordLength * (cursor_coord - edit->coordStart) / edit->coordLength;
-                edit->coordStart = new_coordStart;
-                edit->coordLength = new_coordLength;
+                double cursor_coord = pixel_to_coord(event->position().x(), SRC::Edit);
+                double new_coordLength = edit->coord_length * factor;
+                double new_coordStart = cursor_coord - new_coordLength * (cursor_coord - edit->coord_start) / edit->coord_length;
+                edit->coord_start = new_coordStart;
+                edit->coord_length = new_coordLength;
             }
         }
         bool dragging = false;
@@ -44,8 +44,8 @@ namespace YSG {
             startGlobalPos = QCursor::pos();
             startPos = event->pos();
             Render_State_Lease<AxisPrivate, AxisRenderState> state(this);
-            startCoordValue = state->coordStart;
-            pixelPreCoord = state->coordLength/static_cast<double>(state->pixelSize);
+            startCoordValue = state->coord_start;
+            pixelPreCoord = state->coord_length/static_cast<double>(state->pixel_size);
         }
         void mouseMoveEvent(QMouseEvent* event) override {
             if(!useDrag) return;
@@ -54,7 +54,7 @@ namespace YSG {
             Render_Edit_Lease<AxisPrivate, AxisRenderState> edit(this);
             QPoint delt = startGlobalPos - QCursor::pos();
             auto coordDelt = pixelPreCoord * (edit->orientation == Qt::Horizontal ? delt.x() :delt.y());
-            edit->coordStart = startCoordValue + coordDelt;
+            edit->coord_start = startCoordValue + coordDelt;
         }
         void mouseReleaseEvent(QMouseEvent* event) override {
             if(!useDrag) return;
@@ -69,9 +69,9 @@ namespace YSG {
         AbsAxis::BuilderT<That>::set(ret);
         AxisPrivate* pd = ret->d();
         AxisRenderState* sc = reinterpret_cast<AxisRenderState*>(pd->state(State_Edit));
-        PROP_RT(int, numberPrecision)
-        PROP_RT(double, coordStart)
-        PROP_RT(double, coordLength)
+        PROP_RT(int, number_precision)
+        PROP_RT(double, coord_start)
+        PROP_RT(double, coord_length)
         pd->useWheel = useWheel;
         pd->useDrag = useDrag;
     }
diff --git a/YSGraphic_Core/Axis/FrequentAxis.cpp b/YSGraphic_Core/Axis/FrequentAxis.cpp
index 72ca429..7e410eb 100644
--- a/YSGraphic_Core/Axis/FrequentAxis.cpp
+++ b/YSGraphic_Core/Axis/FrequentAxis.cpp
@@ -10,13 +10,13 @@ namespace YSG {
     FrequentAxisPrivate* FrequentAxis::d() {
         return FrequentAxis_Binding::d(this);
     }
-    RenderData* FrequentAxis::createRenderData() {
+    RenderData* FrequentAxis::create_render_data() {
         return FrequentAxis_Binding::create_render_data();
     }
-    RenderState* FrequentAxis::createRenderState() {
+    RenderState* FrequentAxis::create_render_state() {
         return FrequentAxis_Binding::create_render_state();
     }
-    InputData* FrequentAxis::createInputData() {
+    InputData* FrequentAxis::create_input_data() {
         return FrequentAxis_Binding::create_input_data();
     }
     FrequentAxis::Builder::Builder(Plot* plot, Qt::Orientation orientation) {
diff --git a/YSGraphic_Core/Axis/FrequentAxis.h b/YSGraphic_Core/Axis/FrequentAxis.h
index d6ce053..7485f01 100644
--- a/YSGraphic_Core/Axis/FrequentAxis.h
+++ b/YSGraphic_Core/Axis/FrequentAxis.h
@@ -6,9 +6,9 @@ namespace YSG {
     class LIB_DECL FrequentAxis : public Axis {
     public:
         FrequentAxisPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         FrequentAxis();
         friend struct FrequentAxisPrivate;
diff --git a/YSGraphic_Core/Axis/FrequentAxis_p.h b/YSGraphic_Core/Axis/FrequentAxis_p.h
index 7824c38..78036a7 100644
--- a/YSGraphic_Core/Axis/FrequentAxis_p.h
+++ b/YSGraphic_Core/Axis/FrequentAxis_p.h
@@ -25,7 +25,7 @@ namespace YSG {
                 return "Unknown";
             }
         }
-        QVector<QString> createLabelVector(const QVector<double> &ticks, SRC src) override {
+        QVector<QString> create_label_vector(const QVector<double> &ticks, SRC src) override {
             if (!ticks.empty()) {
                 double range = ticks.last() - ticks.first();
                 XUnitType beforeUnitType = xUnitType;
@@ -39,13 +39,13 @@ namespace YSG {
                     xUnitType = Hz;
                 }
                 if (beforeUnitType != xUnitType) {
-                    renderState()->unitText = "频率/" + getXUnitTypeString(xUnitType);
+                    render_state()->unit_text = "频率/" + getXUnitTypeString(xUnitType);
                 }
             }
             QVector<QString> result;
             result.reserve(ticks.size());
             for (const double &tickCoord: ticks) {
-                result.append(getTrueValue(getTickLabel(tickCoord, src)));
+                result.append(getTrueValue(get_tick_label(tickCoord, src)));
             }
             return result;
         }
@@ -53,8 +53,8 @@ namespace YSG {
         QString getTrueValue(QString value) {
             value.replace(",", "");
             int moveNum = xUnitType;
-            AbsAxisRenderState* s = renderState();
-            int precision = s->numberPrecision;
+            AbsAxisRenderState* s = render_state();
+            int precision = s->number_precision;
             int dotIndex = value.indexOf('.');
             if (dotIndex == -1) {
                 dotIndex = value.size();
diff --git a/YSGraphic_Core/Axis/TimeAxis.cpp b/YSGraphic_Core/Axis/TimeAxis.cpp
index 1ca6bfa..30801e2 100644
--- a/YSGraphic_Core/Axis/TimeAxis.cpp
+++ b/YSGraphic_Core/Axis/TimeAxis.cpp
@@ -9,32 +9,32 @@ namespace YSG {
     TimeAxisPrivate* TimeAxis::d() {
         return TimeAxis_Binding::d(this);
     }
-    RenderData* TimeAxis::createRenderData() {
+    RenderData* TimeAxis::create_render_data() {
         return TimeAxis_Binding::create_render_data();
     }
-    RenderState* TimeAxis::createRenderState() {
+    RenderState* TimeAxis::create_render_state() {
         return TimeAxis_Binding::create_render_state();
     }
-    InputData* TimeAxis::createInputData() {
+    InputData* TimeAxis::create_input_data() {
         return TimeAxis_Binding::create_input_data();
     }
-    int TimeAxis::timePointSize(SRC src) {
-        return d()->state_value(&TimeAxisRenderState::timePointSize, src);
+    int TimeAxis::time_point_size(SRC src) {
+        return d()->state_value(&TimeAxisRenderState::time_point_size, src);
     }
-    void TimeAxis::set_timePointSize(int value) {
-        d()->set_state_value(&TimeAxisRenderState::timePointSize, value);
+    void TimeAxis::set_time_point_size(int value) {
+        d()->set_state_value(&TimeAxisRenderState::time_point_size, value);
     }
-    int TimeAxis::tickPixelSpace(SRC src) {
-        return d()->state_value(&TimeAxisRenderState::tickPixelSpace, src);
+    int TimeAxis::tick_pixel_space(SRC src) {
+        return d()->state_value(&TimeAxisRenderState::tick_pixel_space, src);
     }
-    void TimeAxis::set_tickPixelSpace(int value) {
-        d()->set_state_value(&TimeAxisRenderState::tickPixelSpace, value);
+    void TimeAxis::set_tick_pixel_space(int value) {
+        d()->set_state_value(&TimeAxisRenderState::tick_pixel_space, value);
     }
-    QString TimeAxis::timeFormat(SRC src) {
-        return d()->state_value(&TimeAxisRenderState::timeFormat, src);
+    QString TimeAxis::time_format(SRC src) {
+        return d()->state_value(&TimeAxisRenderState::time_format, src);
     }
-    void TimeAxis::set_timeFormat(QString value) {
-        d()->set_state_value(&TimeAxisRenderState::timeFormat, std::move(value));
+    void TimeAxis::set_time_format(QString value) {
+        d()->set_state_value(&TimeAxisRenderState::time_format, std::move(value));
     }
     QFont TimeAxis::font(SRC src) {
         return d()->state_value(&TimeAxisRenderState::font, src);
@@ -42,7 +42,7 @@ namespace YSG {
     void TimeAxis::set_font(QFont value) {
         d()->set_state_value(&TimeAxisRenderState::font, std::move(value));
     }
-    int TimeAxis::giveData(QTime time) {
+    int TimeAxis::give_data(QTime time) {
         if(!ok()) return -1;
         TimeAxisPrivate* pd = d();
         std::pair<int, bool> ret = pd->mTimeTicker.getNewDataTickInfo();
@@ -54,10 +54,10 @@ namespace YSG {
         return ret.first;
     }
 
-    QTime TimeAxis::tickToTime(int tick, SRC src) {
-        auto renderState = d()->state_data(src);
-        int offset = tick - (int)renderState->coordStart;
-        return d()->timeByOffset(offset);
+    QTime TimeAxis::tick_to_time(int tick, SRC src) {
+        auto render_state = d()->state_data(src);
+        int offset = tick - (int)render_state->coord_start;
+        return d()->time_by_offset(offset);
     }
     TimeAxis::Builder::Builder(Plot* plot, Qt::Orientation orientation) {
         this->plot = plot;
@@ -68,9 +68,9 @@ namespace YSG {
         set(ret);
         TimeAxisPrivate* pd = ret->d();
         TimeAxisRenderState* sc = reinterpret_cast<TimeAxisRenderState*>(pd->state(State_Edit));
-        PROP_R(int, timePointSize)
-        PROP_R(int, tickPixelSpace)
-        PROP_R(QString, timeFormat)
+        PROP_R(int, time_point_size)
+        PROP_R(int, tick_pixel_space)
+        PROP_R(QString, time_format)
         PROP_R(QFont, font)
         return ret;
     }
diff --git a/YSGraphic_Core/Axis/TimeAxis.h b/YSGraphic_Core/Axis/TimeAxis.h
index 014e991..10f39b6 100644
--- a/YSGraphic_Core/Axis/TimeAxis.h
+++ b/YSGraphic_Core/Axis/TimeAxis.h
@@ -7,35 +7,35 @@ namespace YSG {
     class LIB_DECL TimeAxis : public AbsAxis {
     public:
         TimeAxisPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         TimeAxis();
         friend struct TimeAxisPrivate;
         friend struct TimeAxisRenderState;
         friend struct TimeAxisInputData;
     public:
-        PROP(int, timePointSize)
-        PROP(int, tickPixelSpace)
-        PROP(QString, timeFormat)
+        PROP(int, time_point_size)
+        PROP(int, tick_pixel_space)
+        PROP(QString, time_format)
         PROP(QFont, font)
-        int giveData(QTime time);
-        QTime tickToTime(int tick, SRC=SRC::Edit);
+        int give_data(QTime time);
+        QTime tick_to_time(int tick, SRC=SRC::Edit);
         struct Builder;
     };
 
     struct TimeAxis_Prop {
-        int timePointSize = 100;
-        int tickPixelSpace = 8;
-        QString timeFormat = "mm:ss.zzz";
+        int time_point_size = 100;
+        int tick_pixel_space = 8;
+        QString time_format = "mm:ss.zzz";
         QFont font;
     };
 
     struct LIB_DECL TimeAxis::Builder : AbsAxis::BuilderT<TimeAxis::Builder> , protected TimeAxis_Prop{
-        PROP_B(int, timePointSize)
-        PROP_B(int, tickPixelSpace)
-        PROP_B(QString, timeFormat)
+        PROP_B(int, time_point_size)
+        PROP_B(int, tick_pixel_space)
+        PROP_B(QString, time_format)
         PROP_B(QFont, font)
         Builder(Plot *plot, Qt::Orientation orientation);
         TimeAxis* build();
diff --git a/YSGraphic_Core/Axis/TimeAxis_p.h b/YSGraphic_Core/Axis/TimeAxis_p.h
index 30d8fef..19811b3 100644
--- a/YSGraphic_Core/Axis/TimeAxis_p.h
+++ b/YSGraphic_Core/Axis/TimeAxis_p.h
@@ -24,12 +24,12 @@ namespace YSG {
             mTickStart = 0;
         }
 
-        void setTimePointSize(int timePointSize) {
-            if(mTimePointSize == timePointSize) return;
-            mTimePointSize = timePointSize;
+        void setTimePointSize(int time_point_size) {
+            if(mTimePointSize == time_point_size) return;
+            mTimePointSize = time_point_size;
             // 除2怕溢出
             mLowerMin = std::numeric_limits<int>::min()/2;
-            mLowerMax = std::numeric_limits<int>::max()/2 - timePointSize + 1;
+            mLowerMax = std::numeric_limits<int>::max()/2 - time_point_size + 1;
             mTickStart = 0;
         }
 
@@ -75,8 +75,8 @@ namespace YSG {
         int tickSpace = 4;
         int getTickSpaceHint(SRC src = SRC::Edit) {
             QFontMetrics fm(font);
-            double rate = (double)timePointSize/(double)pixelSize;
-            double ret = rate * (tickPixelSpace + (orientation == Qt::Horizontal ? fm.horizontalAdvance(timeFormat) : fm.height()));
+            double rate = (double)time_point_size/(double)pixel_size;
+            double ret = rate * (tick_pixel_space + (orientation == Qt::Horizontal ? fm.horizontalAdvance(time_format) : fm.height()));
 
             return std::max(1, (int)ret);
         }
@@ -92,12 +92,12 @@ namespace YSG {
         std::vector<QTime> mTimeSnapshot;
         int mTimeDataCount{};
         std::list<TimeTick> mData;
-        void resizeTimeBuffer(int count) {
+        void resize_time_buffer(int count) {
             buffer.init(sizeof(QTime) * count);
             mTimeSnapshot.resize(count);
             mTimeDataCount = 0;
         }
-        void pushTime(const QTime& time) {
+        void push_time(const QTime& time) {
             if(mTimeDataCount == mTimeTicker.mTimePointSize) {
                 QTime ignored;
                 std::size_t len = sizeof(QTime);
@@ -107,38 +107,38 @@ namespace YSG {
             buffer.write(&time, sizeof(QTime));
             ++mTimeDataCount;
         }
-        void snapshotTimeBuffer() {
+        void snapshot_time_buffer() {
             buffer.peek_best_effort(mTimeSnapshot.data(), sizeof(QTime) * mTimeDataCount);
         }
-        QTime timeByOffset(int offset) const {
+        QTime time_by_offset(int offset) const {
             int index = mTimeTicker.mStartCoordToEndCoord ? mTimeDataCount - 1 - offset : offset - (mTimeTicker.mTimePointSize - mTimeDataCount);
             if(index < 0 || index >= mTimeDataCount) return {};
             return mTimeSnapshot[index];
         }
-        void prepareData() override {
-            syncStatePipeline();
-            auto d = renderInputData();
-            auto s = renderState();
+        void prepare_data() override {
+            sync_state_pipeline();
+            auto d = render_input_data();
+            auto s = render_state();
             Triple_Buffer_Lease inputLease = mInputControl.wait_mark_use_role(Input_Edit);
             Triple_Buffer_Lease stateLease = mStateControl.wait_mark_use_role(State_Edit);
-            auto sc = reinterpret_cast<TimeAxisRenderState*>(stateByIndex(stateLease.index));
+            auto sc = reinterpret_cast<TimeAxisRenderState*>(state_by_index(stateLease.index));
             bool refreshSpace = false;
-            if(mTimeTicker.mTimePointSize != s->timePointSize) {
-                mTimeTicker.setTimePointSize(s->timePointSize);
-                resizeTimeBuffer(s->timePointSize);
+            if(mTimeTicker.mTimePointSize != s->time_point_size) {
+                mTimeTicker.setTimePointSize(s->time_point_size);
+                resize_time_buffer(s->time_point_size);
                 mData.clear();
                 refreshSpace = true;
             }
-            if(mTickPixelSpace != s->tickPixelSpace) {
-                mTickPixelSpace = s->tickPixelSpace;
+            if(mTickPixelSpace != s->tick_pixel_space) {
+                mTickPixelSpace = s->tick_pixel_space;
                 refreshSpace = true;
             }
             if(mFont != s->font) {
                 mFont = s->font;
                 refreshSpace = true;
             }
-            if(mTimeFormat != s->timeFormat) {
-                mTimeFormat = s->timeFormat;
+            if(mTimeFormat != s->time_format) {
+                mTimeFormat = s->time_format;
                 if(s->orientation == Qt::Horizontal) {
                     refreshSpace = true;
                 }
@@ -151,10 +151,10 @@ namespace YSG {
                     mData.resize(0);
                 }
             }
-            s->coordStart = mTimeTicker.mLower;
-            s->coordLength = mTimeTicker.mTimePointSize;
-            sc->coordStart = mTimeTicker.mLower;
-            sc->coordLength = mTimeTicker.mTimePointSize;
+            s->coord_start = mTimeTicker.mLower;
+            s->coord_length = mTimeTicker.mTimePointSize;
+            sc->coord_start = mTimeTicker.mLower;
+            sc->coord_length = mTimeTicker.mTimePointSize;
 
             int lowwer = mTimeTicker.mLower;
             int upper = mTimeTicker.upper();
@@ -162,13 +162,13 @@ namespace YSG {
 
 
             for(QTime& time : d->mAllTime) {
-                pushTime(time);
+                push_time(time);
             }
-            snapshotTimeBuffer();
+            snapshot_time_buffer();
             d->mAllTime.clear();
 
             mData.splice(mData.begin(), d->mData);
-            clearRenderInput();
+            clear_render_input();
 
             while (!mData.empty()) {
                 int tick = mData.back().mTick;
@@ -184,7 +184,7 @@ namespace YSG {
             labels.clear();
             for(TimeTick& t : mData) {
                 ticks.append(t.mTick);
-                labels.append(t.mTime.toString(s->timeFormat));
+                labels.append(t.mTime.toString(s->time_format));
                 ++i;
             }
             mStateControl.unmark_use(stateLease);
@@ -192,15 +192,15 @@ namespace YSG {
         }
 
 
-        QVector<QString> createLabelVector(const QVector<double>& ticks, SRC src) override {
+        QVector<QString> create_label_vector(const QVector<double>& ticks, SRC src) override {
             return labels;
         }
 
-        QVector<double> createTickVector(double tickStep, const Range& range) override {
+        QVector<double> create_tick_vector(double tickStep, const Range& range) override {
             return ticks;
         }
 
-        QVector<double> createSubTickVector(int subTickCount, const QVector<double>& ticks, const Range& range) override{return {};}
+        QVector<double> create_sub_tick_vector(int subTickCount, const QVector<double>& ticks, const Range& range) override{return {};}
 
         // 最小值的范围  lower在这里面循环变化
         int mLower = 0, mLowerMin = 0, mLowerMax{};  //闭区间
@@ -213,9 +213,9 @@ namespace YSG {
             AbsAxisPrivate::draw(painter);
         }
 
-        QString getTickLabel(double tick, SRC src) override {
-            auto renderState = reinterpret_cast<TimeAxisRenderState*>(state(src));
-            return q()->tickToTime((int)tick, src).toString(renderState->timeFormat);
+        QString get_tick_label(double tick, SRC src) override {
+            auto render_state = reinterpret_cast<TimeAxisRenderState*>(state(src));
+            return q()->tick_to_time((int)tick, src).toString(render_state->time_format);
         }
     };
 }
diff --git a/YSGraphic_Core/CacheModel.h b/YSGraphic_Core/CacheModel.h
index 0bd8c0b..bbf89eb 100644
--- a/YSGraphic_Core/CacheModel.h
+++ b/YSGraphic_Core/CacheModel.h
@@ -5,7 +5,7 @@ namespace YSG{
     struct CacheModel {
         std::array<T, 3> buffers;
         Triple_Role_Buffer_Control control;
-        void syncStatePipeline() {
+        void sync_state_pipeline() {
             auto lease = control.wait_mark_use_role(State_Ready);
             buffers[lease.index] = *state(SRC::Edit);
             control.unmark_use(lease);
diff --git a/YSGraphic_Core/DemoGallery/AfterglowPlot.h b/YSGraphic_Core/DemoGallery/AfterglowPlot.h
index 08836eb..da02076 100644
--- a/YSGraphic_Core/DemoGallery/AfterglowPlot.h
+++ b/YSGraphic_Core/DemoGallery/AfterglowPlot.h
@@ -15,8 +15,8 @@ static QWidget* createAfterglow() {
             xAxis = YSG::FrequentAxis::Builder(this, Qt::Horizontal).build();
             yAxis = YSG::Axis::Builder(this, Qt::Vertical).build();
             ag =  YSG::Afterglow::Builder(xAxis, yAxis)
-            .set_frequentRange({0, 100})
-            .set_powerRange({0, 100})
+            .set_frequent_range({0, 100})
+            .set_power_range({0, 100})
             .build();
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
         }
@@ -24,12 +24,12 @@ static QWidget* createAfterglow() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height() - 1);
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
-            yAxis->set_pixelSize(height());
-            ag->set_frequentPointSize(ag->frequentAxis()->getPixelPointSize());
-            ag->set_powerPointSize(ag->powerAxis()->getPixelPointSize());
+            yAxis->set_pixel_size(height());
+            ag->set_frequent_point_size(ag->frequent_axis()->get_pixel_point_size());
+            ag->set_power_point_size(ag->power_axis()->get_pixel_point_size());
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/AudioPlot.h b/YSGraphic_Core/DemoGallery/AudioPlot.h
index ea77422..0074636 100644
--- a/YSGraphic_Core/DemoGallery/AudioPlot.h
+++ b/YSGraphic_Core/DemoGallery/AudioPlot.h
@@ -14,8 +14,8 @@ static QWidget* createAudioPlot() {
             Plot::init();
             mObjectName = "AudioPlot";
             xAxis = YSG::TimeAxis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5).build();
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5).build();
             yAxis = YSG::Axis::Builder(this, Qt::Vertical).build();
             audio = YSG::AudioFrequent::Builder(xAxis, yAxis).build();
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
@@ -24,11 +24,11 @@ static QWidget* createAudioPlot() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height() - 1);
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
-            yAxis->set_pixelSize(height());
-            audio->set_timePointSize(xAxis->getPixelPointSize());
+            yAxis->set_pixel_size(height());
+            audio->set_time_point_size(xAxis->get_pixel_point_size());
         }
 
         void contextMenuEvent(QContextMenuEvent* event) override {
diff --git a/YSGraphic_Core/DemoGallery/PlanispherePlot.h b/YSGraphic_Core/DemoGallery/PlanispherePlot.h
index ca554a6..d83bc1e 100644
--- a/YSGraphic_Core/DemoGallery/PlanispherePlot.h
+++ b/YSGraphic_Core/DemoGallery/PlanispherePlot.h
@@ -16,15 +16,15 @@ static QWidget* createPlanispherePlot() {
 
 
             xAxis = YSG::Axis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5).build();
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5).build();
 
             yAxis = YSG::Axis::Builder(this, Qt::Vertical).build();
 
 
             mPlanisphere = YSG::Planisphere::Builder(xAxis, yAxis)
             .set_layerName("plottable")
-            .set_continueMillisecond(2000).build();
+            .set_continue_millisecond(2000).build();
 
 
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
@@ -35,11 +35,11 @@ static QWidget* createPlanispherePlot() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height() - 1);
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
-            yAxis->set_pixelSize(height());
-            mPlanisphere->setToAxisCenter();
+            yAxis->set_pixel_size(height());
+            mPlanisphere->set_to_axis_center();
         }
 
         void contextMenuEvent(QContextMenuEvent* event) override {
diff --git a/YSGraphic_Core/DemoGallery/SpectrumPlot.h b/YSGraphic_Core/DemoGallery/SpectrumPlot.h
index 4f2ebb8..b18c5a5 100644
--- a/YSGraphic_Core/DemoGallery/SpectrumPlot.h
+++ b/YSGraphic_Core/DemoGallery/SpectrumPlot.h
@@ -13,21 +13,21 @@ static QWidget* createSpectrunPlot() {
             Plot::init();
             mObjectName = "SpectrumPlot";
             xAxis = YSG::FrequentAxis::Builder(this, Qt::Horizontal)
-            .set_coordRange({0, 100})
-            .set_tickLength(-10)
-            .set_subTickLength(-5)
+            .set_coord_range({0, 100})
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5)
             .set_use_wheel(true)
             .set_use_drag(true)
             .build();
 
             yAxis = YSG::Axis::Builder(this, Qt::Vertical)
-            .set_coordRange({100, 0})
-            .set_unitText("功率")
+            .set_coord_range({100, 0})
+            .set_unit_text("功率")
             .set_use_drag(true)
             .build();
 
             sp = YSG::Spectrum::Builder(xAxis, yAxis)
-            .set_frequentRange({0, 100})
+            .set_frequent_range({0, 100})
             .build();
 
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
@@ -39,11 +39,11 @@ static QWidget* createSpectrunPlot() {
             int h = height() - topMargin - bottomMargin;
             xAxis->set_x(leftMargin);
             xAxis->set_y(height() - bottomMargin);
-            xAxis->set_pixelSize(w);
+            xAxis->set_pixel_size(w);
             yAxis->set_x(leftMargin);
             yAxis->set_y(topMargin);
-            yAxis->set_pixelSize(h);
-            sp->set_frequentPointSize(sp->frequentAxis()->getPixelPointSize());
+            yAxis->set_pixel_size(h);
+            sp->set_frequent_point_size(sp->frequent_axis()->get_pixel_point_size());
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/SweepFrequentPlot.h b/YSGraphic_Core/DemoGallery/SweepFrequentPlot.h
index d787142..3e097f6 100644
--- a/YSGraphic_Core/DemoGallery/SweepFrequentPlot.h
+++ b/YSGraphic_Core/DemoGallery/SweepFrequentPlot.h
@@ -14,18 +14,18 @@ static QWidget* createSweepFrequentPlot() {
             mObjectName = "AxisTestPlot";
 
             xAxis = YSG::Axis::Builder(this, Qt::Horizontal)
-            .set_coordRange({0, 100})
-            .set_tickLength(-10).build();
+            .set_coord_range({0, 100})
+            .set_tick_length(-10).build();
 
             yAxis = YSG::Axis::Builder(this, Qt::Vertical)
-            .set_coordRange({100, 0})
+            .set_coord_range({100, 0})
             .build();
 
 
             sf = YSG::SweepFrequent::Builder(xAxis, yAxis)
-            .set_blockNum(200)
-            .set_blockFrequentPointSize(20)
-            .set_frequentRange({0, 100}).build();
+            .set_block_num(200)
+            .set_block_frequent_point_size(20)
+            .set_frequent_range({0, 100}).build();
 
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
         }
@@ -33,10 +33,10 @@ static QWidget* createSweepFrequentPlot() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height() - 1);
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
-            yAxis->set_pixelSize(height());
+            yAxis->set_pixel_size(height());
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/Tool.h b/YSGraphic_Core/DemoGallery/Tool.h
index f043f8a..bfcba9a 100644
--- a/YSGraphic_Core/DemoGallery/Tool.h
+++ b/YSGraphic_Core/DemoGallery/Tool.h
@@ -129,8 +129,8 @@ namespace YSG {
 
     static QWidget* createRange(Axis* axis, const QString& text = "更改轴范围") {
         return createEditWidget_List<double>(text, [axis](const QVector<double>& values) {
-          axis->set_coordRange(Range{values[0], values[1]});
-        }, {axis->coordRange().lower, axis->coordRange().upper});
+          axis->set_coord_range(Range{values[0], values[1]});
+        }, {axis->coord_range().lower, axis->coord_range().upper});
     }
 
     static QMenu* findParentMenu(QWidget* widget) {
@@ -167,13 +167,13 @@ namespace YSG {
         button->setStyleSheet(bs);
         QObject::connect(button, &QPushButton::clicked, [button, label]() {
             btn = button;
-            dialog->setCurrentColor(QColor(label->text()));
+            dialog->set_current_color(QColor(label->text()));
             dialog->show();
         });
         QObject::connect(dialog, &QDialog::finished, [ret, button, click, label, showColor](int result) {
             if(btn != button) return;
             if (result == QDialog::Accepted) {
-                QColor selectColor = dialog->currentColor();
+                QColor selectColor = dialog->current_color();
                 click(selectColor);
                 label->setText(selectColor.name(QColor::HexArgb));
                 showColor->setStyleSheet(QString("background-color: %1; border: 2px solid #000000;")
@@ -271,10 +271,10 @@ static QWidget* createPlotRenderScheduleCombo(YSG::Plot* plot) {
     combo->addItem("Chase_Latest", static_cast<int>(YSG::Plot_Render_Schedule_Mode::Chase_Latest));
     combo->addItem("Max_Fps", static_cast<int>(YSG::Plot_Render_Schedule_Mode::Max_Fps));
     combo->addItem("Manual", static_cast<int>(YSG::Plot_Render_Schedule_Mode::Manual));
-    int index = combo->findData(static_cast<int>(plot->renderScheduleMode()));
+    int index = combo->findData(static_cast<int>(plot->render_schedule_mode()));
     combo->setCurrentIndex(index >= 0 ? index : 0);
     QObject::connect(combo, QOverload<int>::of(&QComboBox::currentIndexChanged), [plot, combo](int index) {
-        plot->setRenderScheduleMode(static_cast<YSG::Plot_Render_Schedule_Mode>(combo->itemData(index).toInt()));
+        plot->set_render_schedule_mode(static_cast<YSG::Plot_Render_Schedule_Mode>(combo->itemData(index).toInt()));
     });
     layout->addWidget(label);
     layout->addWidget(combo);
@@ -289,25 +289,25 @@ static QWidget* createControl(YSG::Plot* plot, const QVector<QWidget*>& widgets
     l->setSpacing(0);
     QVector<QWidget*> ws = {
         YSG::createToggleButton("暂停渲染", "开始渲染", [plot]() {
-            plot->isRendering() ? plot->pauseRender() : plot->startRender();
-        }, plot->isRendering()),
+            plot->is_rendering() ? plot->pause_render() : plot->start_render();
+        }, plot->is_rendering()),
         YSG::createToggleButton("停止性能测试", "启动性能测试", [plot]() {
-            plot->set_usePerformanceShower(plot->usePerformanceShower() ? false : true);
-        }, plot->usePerformanceShower()),
+            plot->set_use_performance_shower(plot->use_performance_shower() ? false : true);
+        }, plot->use_performance_shower()),
         YSG::createSelectColor("更改背景色", [plot](const QColor& color) {
-            plot->setBackgroundColor(color);
-        }, plot->backgroundColor()),
+            plot->set_background_color(color);
+        }, plot->background_color()),
         createPlotRenderScheduleCombo(plot),
         YSG::createEditWidget_List<int>("渲染检查FPS", [plot](QVector<int> data) {
             if(data[0] < 0) {
-                plot->pauseRender();
+                plot->pause_render();
             } else {
-                plot->startRender(data[0]);
+                plot->start_render(data[0]);
             }
         }, {30}),
         YSG::createEditWidget_List<double>("最大渲染FPS", [plot](QVector<double> data) {
-            plot->setMaxRenderFps(data[0]);
-        }, {plot->maxRenderFps() > 0.0 ? plot->maxRenderFps() : plot->renderCheckFps()}),
+            plot->set_max_render_fps(data[0]);
+        }, {plot->max_render_fps() > 0.0 ? plot->max_render_fps() : plot->render_check_fps()}),
     };
 
 
@@ -324,22 +324,22 @@ static QVector<QWidget*> cw(YSG::AbsAxis* it) {
             it->set_orientation(it->orientation() == Qt::Horizontal ? Qt::Vertical : Qt::Horizontal);
         }),
         YSG::createEditWidget_List<int>("主刻度值", [it](const QVector<int>& values) {
-            it->set_tickLength(values[0]);
-        }, {it->tickLength()}),
+            it->set_tick_length(values[0]);
+        }, {it->tick_length()}),
         YSG::createEditWidget_List<int>("子刻度值", [it](const QVector<int>& values) {
-            it->set_subTickLength(values[0]);
-        }, {it->subTickLength()}),
+            it->set_sub_tick_length(values[0]);
+        }, {it->sub_tick_length()}),
         YSG::createSelectColor("更改轴颜色", [it](const QColor& color) {
             it->set_color(color);
         }, it->color()),
         YSG::createEditWidget_List<QString>("设置单位", [it](const QVector<QString>& values) {
-            it->set_unitText(values[0]);
-        }, {it->unitText()}),
+            it->set_unit_text(values[0]);
+        }, {it->unit_text()}),
         YSG::createSelectColor("更改UnitText颜色", [it](const QColor& color) {
-            it->set_unitTextPen(QPen(color));
+            it->set_unit_text_pen(QPen(color));
         }, it->color()),
         YSG::createSelectColor("更改UnitText背景色", [it](const QColor& color) {
-            it->set_unitTextBackgroundBrush(QBrush(color));
+            it->set_unit_text_background_brush(QBrush(color));
         }, it->color()),
         YSG::createEditWidget_List<int>("更改刻度斜度", [it](const QVector<int>& values) {
             it->set_rotate(values[0]);
@@ -368,17 +368,17 @@ static QVector<QWidget*> cw(YSG::TimeAxis* it, int numPreSecond = -1) {
     if(it == nullptr) return{};
     auto t = QVector<QWidget*> {
         YSG::createEditWidget_List<QString>("时间格式", [it](QVector<QString> data) {
-            it->set_timeFormat(data[0]);
-        }, {it->timeFormat()}),
+            it->set_time_format(data[0]);
+        }, {it->time_format()}),
         YSG::createEditWidget_List<int>("单位间隔pixel", [it](QVector<int> data) {
-            it->set_tickPixelSpace(data[0]);
-        }, {it->tickPixelSpace()}),
+            it->set_tick_pixel_space(data[0]);
+        }, {it->tick_pixel_space()}),
     };
 
     auto timer = new QTimer(it->mPlot);
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        it->giveData(QTime::currentTime());
+        it->give_data(QTime::currentTime());
     });
     t.append(YSG::createEditWidget_List<double>("推数据Timer（次/s）", [timer](QVector<double> data) {
         if(data[0] < 0) {
@@ -395,18 +395,18 @@ static QVector<QWidget*> cw(YSG::MutiSelectRect* it) {
     if(it == nullptr) return{};
     auto t = QVector<QWidget*>{
         YSG::createSelectColor("更改填充色", [it](const QColor& color) {
-            it->setRectBrush(QBrush(color));
-        }, it->rectBrush().color()),
+            it->set_rect_brush(QBrush(color));
+        }, it->rect_brush().color()),
         YSG::createSelectColor("更改边框色", [it](const QColor& color) {
             qDebug() << " color.isValid() == " << color.isValid();
              QPen pen(color);
              pen.setStyle(Qt::DashLine);
-             it->setBorderPen(pen);
+             it->set_border_pen(pen);
             qDebug() << " color.isValid() == " << pen.color().isValid();
-        }, it->borderPen().color()),
+        }, it->border_pen().color()),
         YSG::createSelectColor("更改字色", [it](const QColor& color) {
-            it->setFontPen(QPen(color));
-        }, it->fontPen().color())
+            it->set_font_pen(QPen(color));
+        }, it->font_pen().color())
     };
     return t;
 }
@@ -417,18 +417,18 @@ static QVector<QWidget*> cw(YSG::HoverInfoRenderAble<T>* it) {
     auto t = QVector<QWidget*>{
         YSG::createLabel("悬浮信息"),
         YSG::createToggleButton("启动悬浮信息", "停止悬浮信息", [it]() {
-            it->setUseHoverInfo(!it->useHoverInfo());
-        }, !it->useHoverInfo()),
+            it->set_use_hover_info(!it->use_hover_info());
+        }, !it->use_hover_info()),
         YSG::createSelectColor("设置文字颜色", [it](const QColor& c) {
-            QPen pen = it->hoverInfoPen();
+            QPen pen = it->hover_info_pen();
             pen.setColor(c);
-            it->setHoverInfoPen(pen);
-        }, it->hoverInfoPen().color()),
+            it->set_hover_info_pen(pen);
+        }, it->hover_info_pen().color()),
         YSG::createSelectColor("设置背景颜色", [it](const QColor& c) {
-            QBrush brush = it->hoverInfoBackgroundBrush();
+            QBrush brush = it->hover_info_background_brush();
             brush.setColor(c);
-            it->setHoverInfoBackgroundBrush(brush);
-        }, it->hoverInfoBackgroundBrush().color())
+            it->set_hover_info_background_brush(brush);
+        }, it->hover_info_background_brush().color())
     };
 
     return t;
@@ -439,9 +439,9 @@ static QVector<QWidget*> cw(YSG::WaterFall* it, int numPreSecond = -1) {
     auto timer = new QTimer(it->mPlot);
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        QVector<double> d = YSG::getData(it->powerRange(), it->frequentPointSize());
-        int tick = it->timeAxis()->giveData(QTime::currentTime());
-        it->giveData(tick,  d);
+        QVector<double> d = YSG::get_data(it->power_range(), it->frequent_point_size());
+        int tick = it->time_axis()->give_data(QTime::currentTime());
+        it->give_data(tick,  d);
     });
     auto t = QVector<QWidget*> {
         YSG::createEditWidget_List<double>("推数据Timer（次/s）", [timer](QVector<double> data) {
@@ -460,8 +460,8 @@ static QVector<QWidget*> cw(YSG::AudioFrequent* it, int numPreSecond = -1) {
     auto timer = new QTimer(it->mPlot);
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        int tick = it->timeAxis()->giveData(QTime::currentTime());
-        it->giveData(tick, YSG::getData({0, 20}));
+        int tick = it->time_axis()->give_data(QTime::currentTime());
+        it->give_data(tick, YSG::get_data({0, 20}));
     });
     auto t = QVector<QWidget*> {
         YSG::createEditWidget_List<double>("推数据Timer（次/s）", [timer](QVector<double> data) {
@@ -480,9 +480,9 @@ static QVector<QWidget*> cw(YSG::Planisphere* it, int numPreSecond = -1) {
     auto timer = new QTimer(it->mPlot);
     QObject::connect(timer, &QTimer::timeout, [it]() {
         for(int i = 0; i < 10; ++i) {
-            double x =  YSG::getData(it->IRange());
-            double y = YSG::getData(it->QRange());
-            it->giveData({x, y});
+            double x =  YSG::get_data(it->i_range());
+            double y = YSG::get_data(it->q_range());
+            it->give_data({x, y});
         }
     });
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
@@ -496,22 +496,22 @@ static QVector<QWidget*> cw(YSG::Planisphere* it, int numPreSecond = -1) {
             }
         }, {timer->interval() > 0 ? 1000.0/timer->interval() : -1}),
         YSG::createEditWidget_List<int>("设置持续时间(ms)", [it](QVector<int> data) {
-            it->set_continueMillisecond(data[0]);
-        }, {it->continueMillisecond()}),
+            it->set_continue_millisecond(data[0]);
+        }, {it->continue_millisecond()}),
         YSG::createSelectColor("更改IQ点颜色", [it](const QColor& color) {
-            it->set_pointColor(color);
-        }, it->pointColor()),
+            it->set_point_color(color);
+        }, it->point_color()),
         YSG::createSelectColor("更改锚点颜色", [it](const QColor& color) {
-            it->set_anchorColor(color);
-        }, it->anchorColor()),
+            it->set_anchor_color(color);
+        }, it->anchor_color()),
         YSG::createEditWidget_List<double>("I范围", [it](QVector<double> data) {
-            it->set_IRange({data[0], data[1]});
-        }, {it->IRange().lower, it->IRange().upper}),
+            it->set_i_range({data[0], data[1]});
+        }, {it->i_range().lower, it->i_range().upper}),
         YSG::createEditWidget_List<double>("Q范围", [it](QVector<double> data) {
-            it->set_QRange({data[0], data[1]});
-        }, {it->QRange().lower, it->QRange().upper}),
+            it->set_q_range({data[0], data[1]});
+        }, {it->q_range().lower, it->q_range().upper}),
         YSG::createButton("设置到轴中心", [it]() {
-            it->setToAxisCenter();
+            it->set_to_axis_center();
         }),
     };
     return t;
@@ -521,16 +521,16 @@ static QVector<QWidget*> cw(YSG::Planisphere* it, int numPreSecond = -1) {
 static QVector<QWidget*> cw(YSG::Afterglow* it, int numPreSecond = -1) {
     if(it == nullptr) return{};
     static auto createBaseData = [it]() {
-        YSG::Range r = it->powerRange();
-        QVector<double> ret(it->frequentPointSize());
-        ret[0] = getData(r);
-        for(int i = 1; i < it->frequentPointSize(); ++i) {
+        YSG::Range r = it->power_range();
+        QVector<double> ret(it->frequent_point_size());
+        ret[0] = get_data(r);
+        for(int i = 1; i < it->frequent_point_size(); ++i) {
             double rate;
             if(i % 20 == 0) {
                 double that = qAbs(ret[i - 1] - r.lower)/r.size() - 0.5;
-                rate = (1.0 - that) * YSG::getData({0.8, 1.2});
+                rate = (1.0 - that) * YSG::get_data({0.8, 1.2});
             } else {
-                rate = YSG::getData({0.8, 1.2});
+                rate = YSG::get_data({0.8, 1.2});
             }
             ret[i] = YSG::clamp(ret[i - 1]*rate, r.lower, r.upper);
         }
@@ -539,14 +539,14 @@ static QVector<QWidget*> cw(YSG::Afterglow* it, int numPreSecond = -1) {
     static QVector<double> baseData = createBaseData();
     auto timer = new QTimer(it->mPlot);
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        YSG::Range r = it->powerRange();
+        YSG::Range r = it->power_range();
         int n = baseData.size();
         QVector<double> curData(n);
         for (int i = 0; i < n; ++i) {
-            double rate = YSG::getData({0.8, 1.2});
+            double rate = YSG::get_data({0.8, 1.2});
             curData[i] = YSG::clamp(baseData[i]*rate, r.lower, r.upper);
         }
-        it->giveData(curData);
+        it->give_data(curData);
     });
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     auto t = QVector<QWidget*>{
@@ -558,11 +558,11 @@ static QVector<QWidget*> cw(YSG::Afterglow* it, int numPreSecond = -1) {
             }
         }, {timer->interval() > 0 ? 1000.0/timer->interval() : -1}),
         YSG::createEditWidget_List<double>("频率范围", [it](QVector<double> data) {
-            it->set_frequentRange({data[0], data[1]});
-        }, {it->frequentRange().lower, it->frequentRange().upper}),
+            it->set_frequent_range({data[0], data[1]});
+        }, {it->frequent_range().lower, it->frequent_range().upper}),
         YSG::createEditWidget_List<double>("功率概率范围", [it](QVector<double> data) {
-            it->set_powerRange({data[0], data[1]});
-        }, {it->powerRange().lower, it->powerRange().upper}),
+            it->set_power_range({data[0], data[1]});
+        }, {it->power_range().lower, it->power_range().upper}),
         YSG::createButton("更改基础线", []() {
             baseData = createBaseData();
         }),
@@ -577,7 +577,7 @@ static QVector<QWidget*> cw(YSG::Spectrum* it, int numPreSecond = -1) {
     auto timer = new QTimer(it->mPlot);
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        it->giveData(YSG::getData(it->powerAxis()->coordRange(), it->frequentPointSize()));
+        it->give_data(YSG::get_data(it->power_axis()->coord_range(), it->frequent_point_size()));
     });
     auto t = QVector<QWidget*> {
         YSG::createEditWidget_List<double>("推数据Timer（次/s）", [timer](QVector<double> data) {
@@ -588,95 +588,95 @@ static QVector<QWidget*> cw(YSG::Spectrum* it, int numPreSecond = -1) {
             }
         }, {timer->interval() > 0 ? 1000.0/timer->interval() : -1}),
         YSG::createEditWidget_List<double>("频率范围", [it](QVector<double> data) {
-            it->set_frequentRange({data[0], data[1]});
-        }, {it->frequentRange().lower, it->frequentRange().upper}),
+            it->set_frequent_range({data[0], data[1]});
+        }, {it->frequent_range().lower, it->frequent_range().upper}),
         YSG::createEditWidget_List<int>("设置频率点数", [it](QVector<int> data) {
-            it->set_frequentPointSize(data[0]);
-        }, {it->frequentPointSize()}),
+            it->set_frequent_point_size(data[0]);
+        }, {it->frequent_point_size()}),
         YSG::createLabel("sweepRect"),
         YSG::createToggleButton("停止sweepRect", "启动sweepRect", [it]() {
-            it->set_useSweepFrequentRect(!it->useSweepFrequentRect());
-        }, it->useSweepFrequentRect()),
+            it->set_use_sweep_frequent_rect(!it->use_sweep_frequent_rect());
+        }, it->use_sweep_frequent_rect()),
         YSG::createEditWidget_List<double>("sweepRect 范围", [it](QVector<double> data) {
-            if(!it->useSweepFrequentRect()) it->set_useSweepFrequentRect(true);
-            it->set_sweepFrequentRange({data[0], data[1]});
-        }, {it->sweepFrequentRange().lower, it->sweepFrequentRange().upper}),
+            if(!it->use_sweep_frequent_rect()) it->set_use_sweep_frequent_rect(true);
+            it->set_sweep_frequent_range({data[0], data[1]});
+        }, {it->sweep_frequent_range().lower, it->sweep_frequent_range().upper}),
         YSG::createEditWidget_List<double>("中频", [it](QVector<double> data) {
-            if(!it->useSweepFrequentRect()) it->set_useSweepFrequentRect(true);
-            it->set_middleSweepFrequent(data[0]);
-        }, {it->middleSweepFrequent()}),
+            if(!it->use_sweep_frequent_rect()) it->set_use_sweep_frequent_rect(true);
+            it->set_middle_sweep_frequent(data[0]);
+        }, {it->middle_sweep_frequent()}),
         YSG::createSelectColor("扫频矩形", [it](const QColor& c) {
-            it->set_sweepRectBrush(QBrush(c));
+            it->set_sweep_rect_brush(QBrush(c));
         }),
         YSG::createSelectColor("中频", [it](const QColor& c) {
           if(!c.isValid()) {
-              it->set_middleFrequentPen(Qt::NoPen);
+              it->set_middle_frequent_pen(Qt::NoPen);
           }
-          it->set_middleFrequentPen(QPen(c));
-        }, it->middleFrequentPen().color()),
+          it->set_middle_frequent_pen(QPen(c));
+        }, it->middle_frequent_pen().color()),
         YSG::createLabel("marker"),
         YSG::createToggleButton("停止最大值marker", "启动最大值marker", [it]() {
-            it->set_useMaxMarker(!it->useMaxMarker());
-        }, it->useMaxMarker()),
+            it->set_use_max_marker(!it->use_max_marker());
+        }, it->use_max_marker()),
         YSG::createToggleButton("停止最小值marker", "启动最小值marker", [it]() {
-            it->set_useMinMarker(!it->useMinMarker());
-        }, it->useMinMarker()),
+            it->set_use_min_marker(!it->use_min_marker());
+        }, it->use_min_marker()),
         YSG::createEditWidget_List<double>("添加自定义marker", [it](QVector<double> data) {
-            it->addCustomMarker(data[0]);
+            it->add_custom_marker(data[0]);
         }, {0}),
         YSG::createEditWidget_List<double>("添加自定义Linemarker", [it](QVector<double> data) {
-            it->addCustomLineMarker(data[0]);
+            it->add_custom_line_marker(data[0]);
         }, {0}),
         YSG::createEditWidget_List<double>("删除marker", [it](QVector<double> data) {
-            it->removeCustomMarker(data[0]);
+            it->remove_custom_marker(data[0]);
         }, {0}),
         YSG::createEditWidget_List<double>("清楚所有marker", [it](QVector<double> data) {
-            it->clearAllCustomMarker();
+            it->clear_all_custom_marker();
         }, {}),
         YSG::createEditWidget_List<int>("选择当前marker", [it](QVector<int> data) {
-            it->setSelectedLineMarker(data[0]);
+            it->set_selected_line_marker(data[0]);
         }, {0}),
         YSG::createEditWidget_List<double>("选择下一个marker", [it](QVector<double> data) {
-            it->selectNext();
+            it->select_next();
         }, {}),
         YSG::createEditWidget_List<double>("选择上一个marker", [it](QVector<double> data) {
-            it->selectPrevious();
+            it->select_previous();
         }, {}),
         YSG::createLabel("当前线"),
         YSG::createSelectColor("当前线色", [it](const QColor& c) {
             if(!c.isValid()) {
-                it->set_curPen(Qt::NoPen);
+                it->set_cur_pen(Qt::NoPen);
                 return;
             }
-            it->set_curPen(c);
-        },  it->curPen().color()),
+            it->set_cur_pen(c);
+        },  it->cur_pen().color()),
         YSG::createSelectColor("当前线填充色", [it](const QColor& c) {
-            it->set_curBrush(c);
-        },  it->curBrush().color()),
+            it->set_cur_brush(c);
+        },  it->cur_brush().color()),
         YSG::createLabel("最大值线"),
         YSG::createToggleButton("停止最大值线", "启动最大值线",[it]() {
-            it->set_useMaxLine(!it->useMaxLine());
-        }, it->useMaxLine()),
+            it->set_use_max_line(!it->use_max_line());
+        }, it->use_max_line()),
         YSG::createSelectColor("最大值线色", [it](const QColor& c) {
             if(c.isValid()) {
-                it->set_maxPen(Qt::NoPen);
+                it->set_max_pen(Qt::NoPen);
                 return;
             }
-            it->set_maxPen(c);
-        },  it->maxPen().color()),
+            it->set_max_pen(c);
+        },  it->max_pen().color()),
         YSG::createSelectColor("最大值线填充色", [it](const QColor& c) {
-            it->set_maxBrush(c);
-        },  it->maxBrush().color()),
+            it->set_max_brush(c);
+        },  it->max_brush().color()),
         YSG::createLabel("最小值线"),
         YSG::createToggleButton("停止最小值线", "启动最小值线", [it]() {
-            it->set_useMinLine(!it->useMinLine());
-        }, it->useMinLine()),
+            it->set_use_min_line(!it->use_min_line());
+        }, it->use_min_line()),
         YSG::createSelectColor("最小值线色", [it](const QColor& c) {
-            it->set_minPen(c);
-        },  it->minPen().color()),
+            it->set_min_pen(c);
+        },  it->min_pen().color()),
         YSG::createSelectColor("最小值线填充色", [it](const QColor& c) {
-            it->set_minBrush(c);
-        }, it->minBrush().color()),
+            it->set_min_brush(c);
+        }, it->min_brush().color()),
     };
 
 
@@ -688,7 +688,7 @@ static QVector<QWidget*> cw(YSG::SweepFrequent* it, int numPreSecond = -1) {
     auto timer = new QTimer(it->mPlot);
     if(numPreSecond > 0) timer->start(static_cast<int>(1000.0/static_cast<double>(numPreSecond)));
     QObject::connect(timer, &QTimer::timeout, [it]() {
-        it->giveData(YSG::getData(it->powerAxis()->coordRange(), it->blockFrequentPointSize()));
+        it->give_data(YSG::get_data(it->power_axis()->coord_range(), it->block_frequent_point_size()));
     });
     auto t = QVector<QWidget*>  {
         YSG::createEditWidget_List<double>("推数据Timer（次/s）", [timer](QVector<double> data) {
@@ -702,13 +702,13 @@ static QVector<QWidget*> cw(YSG::SweepFrequent* it, int numPreSecond = -1) {
             it->set_pen(QPen(color));
         }, it->pen().color()),
         YSG::createSelectColor("扫频线颜色", [it](const QColor& color) {
-            QPen p = it->curFrequentPen();
+            QPen p = it->cur_frequent_pen();
             p.setColor(color);
-            it->set_curFrequentPen(p);
-        }, it->curFrequentPen().color()),
+            it->set_cur_frequent_pen(p);
+        }, it->cur_frequent_pen().color()),
         YSG::createEditWidget_List<double>("频率范围", [it](const QVector<double>& data) {
-            it->set_frequentRange({data[0], data[1]});
-        }, {it->frequentRange().lower, it->frequentRange().upper})
+            it->set_frequent_range({data[0], data[1]});
+        }, {it->frequent_range().lower, it->frequent_range().upper})
     };
     return t;
 }
diff --git a/YSGraphic_Core/DemoGallery/WaterFallPlot.h b/YSGraphic_Core/DemoGallery/WaterFallPlot.h
index 11bd8a2..db9fca9 100644
--- a/YSGraphic_Core/DemoGallery/WaterFallPlot.h
+++ b/YSGraphic_Core/DemoGallery/WaterFallPlot.h
@@ -14,17 +14,17 @@ static QWidget* createWaterFallPlot() {
             mObjectName = "WaterFallPlot";
 
             xAxis = YSG::FrequentAxis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5)
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5)
             .build();
 
             yAxis = YSG::TimeAxis::Builder(this, Qt::Vertical)
-            .set_timePointSize(800).build();
+            .set_time_point_size(800).build();
 
 
             wf = YSG::WaterFall::Builder(xAxis, yAxis)
             .set_layerName("plottable")
-            .set_frequentRange({0, 20})
+            .set_frequent_range({0, 20})
             .build();
 
             msr = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
@@ -33,14 +33,14 @@ static QWidget* createWaterFallPlot() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height());
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
-            yAxis->set_pixelSize(height());
-            yAxis->set_timePointSize(height());
+            yAxis->set_pixel_size(height());
+            yAxis->set_time_point_size(height());
 
-            //wf->set_frequentPointSize(wf->frequentAxis()->getPixelPointSize());
-            wf->set_frequentPointSize(width());
+            //wf->set_frequent_point_size(wf->frequent_axis()->get_pixel_point_size());
+            wf->set_frequent_point_size(width());
 
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
diff --git a/YSGraphic_Core/DemoGallery/base/AxisTest.h b/YSGraphic_Core/DemoGallery/base/AxisTest.h
index 476b35e..21f4208 100644
--- a/YSGraphic_Core/DemoGallery/base/AxisTest.h
+++ b/YSGraphic_Core/DemoGallery/base/AxisTest.h
@@ -10,9 +10,9 @@ static QWidget* createAxisTestPlot() {
             Plot::init();
             mObjectName = "AxisTestPlot";
             axis = YSG::Axis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5)
-            .set_coordRange({-12000, 12000})
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5)
+            .set_coord_range({-12000, 12000})
             .set_use_wheel(true)
             .build();
         }
@@ -21,7 +21,7 @@ static QWidget* createAxisTestPlot() {
             int space = 50;
             axis->set_x(space);
             axis->set_y(height()/2);
-            axis->set_pixelSize(width() - space * 2);
+            axis->set_pixel_size(width() - space * 2);
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/base/FrequentAxisTest.h b/YSGraphic_Core/DemoGallery/base/FrequentAxisTest.h
index 2def7e3..9206749 100644
--- a/YSGraphic_Core/DemoGallery/base/FrequentAxisTest.h
+++ b/YSGraphic_Core/DemoGallery/base/FrequentAxisTest.h
@@ -11,9 +11,9 @@ static QWidget* createFrequentAxisTestPlot() {
             Plot::init();
             mObjectName = "AxisTestPlot";
             axis = YSG::FrequentAxis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5)
-            .set_coordRange({-12000, 12000})
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5)
+            .set_coord_range({-12000, 12000})
             .build();
         }
     protected:
@@ -21,7 +21,7 @@ static QWidget* createFrequentAxisTestPlot() {
             int space = 50;
             axis->set_x(space);
             axis->set_y(height()/2);
-            axis->set_pixelSize(width() - space * 2);
+            axis->set_pixel_size(width() - space * 2);
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/base/MutiSelectTest.h b/YSGraphic_Core/DemoGallery/base/MutiSelectTest.h
index f7025f5..a1d42da 100644
--- a/YSGraphic_Core/DemoGallery/base/MutiSelectTest.h
+++ b/YSGraphic_Core/DemoGallery/base/MutiSelectTest.h
@@ -15,8 +15,8 @@ static QWidget* createMutiSelectPlot() {
             mObjectName = "PlanispherePlot";
 
             xAxis = YSG::Axis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5).build();
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5).build();
 
             yAxis = YSG::Axis::Builder(this, Qt::Vertical).build();
             mMutiSelectRect = YSG::MutiSelectRect::Builder(xAxis, yAxis).build();
@@ -25,11 +25,11 @@ static QWidget* createMutiSelectPlot() {
         void resizeEvent(QResizeEvent* event) override {
             xAxis->set_x(0);
             xAxis->set_y(height() - 1);
-            xAxis->set_pixelSize(width());
+            xAxis->set_pixel_size(width());
             yAxis->set_x(0);
             yAxis->set_y(0);
             //yAxis->setCoordReserve(true);
-            yAxis->set_pixelSize(height());
+            yAxis->set_pixel_size(height());
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/DemoGallery/base/TimeAxisTest.h b/YSGraphic_Core/DemoGallery/base/TimeAxisTest.h
index 1f00693..2ff2737 100644
--- a/YSGraphic_Core/DemoGallery/base/TimeAxisTest.h
+++ b/YSGraphic_Core/DemoGallery/base/TimeAxisTest.h
@@ -11,15 +11,15 @@ static QWidget* createTimeAxisTestPlot() {
             Plot::init();
             mObjectName = "TimeAxisTestPlot";
             axis = YSG::TimeAxis::Builder(this, Qt::Horizontal)
-            .set_tickLength(-10)
-            .set_subTickLength(-5).build();
+            .set_tick_length(-10)
+            .set_sub_tick_length(-5).build();
         }
     protected:
         void resizeEvent(QResizeEvent* event) override {
             int space = 50;
             axis->set_x(space);
             axis->set_y(height()/2);
-            axis->set_pixelSize(width() - space * 2);
+            axis->set_pixel_size(width() - space * 2);
         }
         void contextMenuEvent(QContextMenuEvent* event) override {
             if(!mMenu) {
diff --git a/YSGraphic_Core/GenerateMockData.cpp b/YSGraphic_Core/GenerateMockData.cpp
index cc2aa19..df7ca81 100644
--- a/YSGraphic_Core/GenerateMockData.cpp
+++ b/YSGraphic_Core/GenerateMockData.cpp
@@ -4,7 +4,7 @@
 namespace YSG {
     std::random_device rd;
     std::default_random_engine eng(rd());
-    QVector<double> getData(Range valueRange, int size) {
+    QVector<double> get_data(Range valueRange, int size) {
         if(valueRange.lower > valueRange.upper) {
             std::swap(valueRange.lower, valueRange.upper);
         }
@@ -15,21 +15,21 @@ namespace YSG {
         }
         return ret;
     }
-    double getData(Range valueRange) {
+    double get_data(Range valueRange) {
         if(valueRange.lower > valueRange.upper) {
             std::swap(valueRange.lower, valueRange.upper);
         }
         std::uniform_real_distribution<double> dist(valueRange.lower, valueRange.upper);
         return dist(eng);
     }
-    QVector<double> getData(int value, int size) {
+    QVector<double> get_data(int value, int size) {
         QVector<double> ret(size);
         for (auto &v: ret) {
             v = value;
         }
         return ret;
     }
-    QVector<double> getColoredData(int size) {
+    QVector<double> get_colored_data(int size) {
         QVector<double> ret(size);
         for (int i = 0; i < size; ++i) {
             ret[i] = i;
diff --git a/YSGraphic_Core/GenerateMockData.h b/YSGraphic_Core/GenerateMockData.h
index 8d24e7c..86de51f 100644
--- a/YSGraphic_Core/GenerateMockData.h
+++ b/YSGraphic_Core/GenerateMockData.h
@@ -2,8 +2,8 @@
 #include "GlobalTypes.h"
 
 namespace YSG {
-    QVector<double> LIB_DECL getData(Range valueRange, int size);
-    double LIB_DECL getData(Range valueRange);
-    QVector<double> LIB_DECL getData(int value, int size);
-    QVector<double> LIB_DECL getColoredData(int size);
+    QVector<double> LIB_DECL get_data(Range valueRange, int size);
+    double LIB_DECL get_data(Range valueRange);
+    QVector<double> LIB_DECL get_data(int value, int size);
+    QVector<double> LIB_DECL get_colored_data(int size);
 }
diff --git a/YSGraphic_Core/GlobalTypes.h b/YSGraphic_Core/GlobalTypes.h
index b44274a..8327eeb 100644
--- a/YSGraphic_Core/GlobalTypes.h
+++ b/YSGraphic_Core/GlobalTypes.h
@@ -39,7 +39,7 @@
 #endif
 
 namespace YSG {
-    QVector<QRgb> getTurboColorGradient();
+    QVector<QRgb> get_turbo_color_gradient();
     class AbsAxis;
     class Axis;
     struct RenderData;
diff --git a/YSGraphic_Core/RenderAble.cpp b/YSGraphic_Core/RenderAble.cpp
index 77ce7be..45074c8 100644
--- a/YSGraphic_Core/RenderAble.cpp
+++ b/YSGraphic_Core/RenderAble.cpp
@@ -20,78 +20,78 @@ namespace YSG {
         colorControl.set_stats(&colorBufferStats);
         colorControl.reset();
     }
-    void RenderAble::RenderPipeline::markEditState() {
+    void RenderAble::RenderPipeline::mark_edit_state() {
         editStateVersion.fetch_add(1, std::memory_order_release);
     }
-    bool RenderAble::RenderPipeline::hasNewState() const {
+    bool RenderAble::RenderPipeline::has_new_state() const {
         return RenderAble::version_newer(editStateVersion.load(std::memory_order_acquire), renderStateVersion);
     }
-    RenderAble::ColorBuffer* RenderAble::RenderPipeline::colorByIndex(std::uint8_t index) {
+    RenderAble::ColorBuffer* RenderAble::RenderPipeline::color_by_index(std::uint8_t index) {
         return &colorBuffers[index];
     }
-    RenderAble::ColorBuffer* RenderAble::RenderPipeline::colorByRole(std::uint8_t role) {
-        return colorByIndex(colorControl.read_view()[role]);
+    RenderAble::ColorBuffer* RenderAble::RenderPipeline::color_by_role(std::uint8_t role) {
+        return color_by_index(colorControl.read_view()[role]);
     }
-    RenderAble::ColorBufferLease RenderAble::RenderPipeline::waitRenderColor() {
+    RenderAble::ColorBufferLease RenderAble::RenderPipeline::wait_render_color() {
         auto lease = colorControl.wait_mark_use_role(Color_Render);
-        return {colorByIndex(lease.index), lease};
+        return {color_by_index(lease.index), lease};
     }
-    RenderAble::ColorBufferLease RenderAble::RenderPipeline::waitFrontColor() {
+    RenderAble::ColorBufferLease RenderAble::RenderPipeline::wait_front_color() {
         auto lease = colorControl.wait_mark_use_role(Color_Front);
-        return {colorByIndex(lease.index), lease};
+        return {color_by_index(lease.index), lease};
     }
-    RenderAble::ColorBufferLease RenderAble::RenderPipeline::tryFrontColor() {
+    RenderAble::ColorBufferLease RenderAble::RenderPipeline::try_front_color() {
         auto record = colorControl.try_mark_use_role(Color_Front);
         if(record.result != Triple_Buffer_Result::Success) {
             return {};
         }
-        return {colorByIndex(record.lease.index), record.lease};
+        return {color_by_index(record.lease.index), record.lease};
     }
-    void RenderAble::RenderPipeline::unmarkColor(ColorBufferLease lease) {
+    void RenderAble::RenderPipeline::unmark_color(ColorBufferLease lease) {
         colorControl.unmark_use(lease.lease);
     }
-    Plot_Buffer_Acquire_Mode RenderAble::bufferAcquireMode() const {
-        return dPtr->bufferAcquireMode();
+    Plot_Buffer_Acquire_Mode RenderAble::buffer_acquire_mode() const {
+        return dPtr->buffer_acquire_mode();
     }
-    void RenderAble::setBufferAcquireMode(Plot_Buffer_Acquire_Mode mode) {
-        dPtr->setBufferAcquireMode(mode);
+    void RenderAble::set_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode) {
+        dPtr->set_buffer_acquire_mode(mode);
     }
-    RenderAble_Render_Schedule_Mode RenderAble::renderScheduleMode() const {
-        return dPtr->renderScheduleMode();
+    RenderAble_Render_Schedule_Mode RenderAble::render_schedule_mode() const {
+        return dPtr->render_schedule_mode();
     }
-    void RenderAble::setRenderScheduleMode(RenderAble_Render_Schedule_Mode mode) {
-        dPtr->setRenderScheduleMode(mode);
+    void RenderAble::set_render_schedule_mode(RenderAble_Render_Schedule_Mode mode) {
+        dPtr->set_render_schedule_mode(mode);
     }
-    double RenderAble::renderScheduleMaxFps() const {
-        return dPtr->renderScheduleMaxFps();
+    double RenderAble::render_schedule_max_fps() const {
+        return dPtr->render_schedule_max_fps();
     }
-    void RenderAble::setRenderScheduleMaxFps(double fps) {
-        dPtr->setRenderScheduleMaxFps(fps);
+    void RenderAble::set_render_schedule_max_fps(double fps) {
+        dPtr->set_render_schedule_max_fps(fps);
     }
-    bool RenderAble::independentPixelCache() const {
-        return dPtr->independentPixelCache();
+    bool RenderAble::independent_pixel_cache() const {
+        return dPtr->independent_pixel_cache();
     }
-    void RenderAble::setIndependentPixelCache(bool enabled) {
-        dPtr->setIndependentPixelCache(enabled);
+    void RenderAble::set_independent_pixel_cache(bool enabled) {
+        dPtr->set_independent_pixel_cache(enabled);
     }
-    QRegion RenderAble::RenderPipeline::publishRenderColor() {
+    QRegion RenderAble::RenderPipeline::publish_render_color() {
         colorControl.wait_swap_role(Color_Ready, Color_Render, [this](const Triple_Buffer_View& view) {
-            auto render = colorByIndex(view[Color_Render]);
-            auto ready = colorByIndex(view[Color_Ready]);
+            auto render = color_by_index(view[Color_Render]);
+            auto ready = color_by_index(view[Color_Ready]);
             return RenderAble::version_newer(render->version.load(std::memory_order_acquire), ready->version.load(std::memory_order_acquire));
         });
         auto view = colorControl.read_view();
-        auto ready = colorByIndex(view[Color_Ready]);
-        auto front = colorByIndex(view[Color_Front]);
+        auto ready = color_by_index(view[Color_Ready]);
+        auto front = color_by_index(view[Color_Front]);
         if(RenderAble::version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire)) && !paintRequestPending.exchange(true, std::memory_order_acq_rel)) {
             return ready->dirtyRegion;
         }
         return {};
     }
-    RenderAble::ColorBufferLease RenderAble::RenderPipeline::consumeReadyColor(Triple_Buffer_Mode mode) {
+    RenderAble::ColorBufferLease RenderAble::RenderPipeline::consume_ready_color(Triple_Buffer_Mode mode) {
         auto canSwap = [this](const Triple_Buffer_View& view) {
-            auto ready = colorByIndex(view[Color_Ready]);
-            auto front = colorByIndex(view[Color_Front]);
+            auto ready = color_by_index(view[Color_Ready]);
+            auto front = color_by_index(view[Color_Front]);
             return RenderAble::version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire));
         };
         if(mode == Triple_Buffer_Mode::Wait) {
@@ -101,30 +101,30 @@ namespace YSG {
         }
         paintRequestPending.store(false, std::memory_order_release);
         if(mode == Triple_Buffer_Mode::Wait) {
-            return waitFrontColor();
+            return wait_front_color();
         }
-        return tryFrontColor();
+        return try_front_color();
     }
     RenderEditGuard::RenderEditGuard(RenderData* data, Triple_Buffer_Lease lease) : mData(data), mLease(lease) {
     }
     RenderEditGuard::~RenderEditGuard() {
         if(!mData) return;
-        ++mData->stateByIndex(mLease.index)->version;
-        if(mData->qPtr) mData->qPtr->markRenderDirty();
-        mData->unmarkState(mLease);
+        ++mData->state_by_index(mLease.index)->version;
+        if(mData->qPtr) mData->qPtr->mark_render_dirty();
+        mData->unmark_state(mLease);
     }
     RenderInputGuard::RenderInputGuard(RenderData* data, Triple_Buffer_Lease lease) : mData(data), mLease(lease) {
     }
     RenderInputGuard::~RenderInputGuard() {
         if(!mData) return;
-        mData->markInputDirty(mLease);
+        mData->mark_input_dirty(mLease);
         mData->mInputControl.unmark_use(mLease);
     }
-    void RenderData::markInputDirty(Triple_Buffer_Lease lease, bool notifyRender) {
-        InputBufferSlot& slot = inputSlotByIndex(lease.index);
+    void RenderData::mark_input_dirty(Triple_Buffer_Lease lease, bool notifyRender) {
+        InputBufferSlot& slot = input_slot_by_index(lease.index);
         slot.version = ++mInputVersion;
         slot.pending = true;
-        if(notifyRender && qPtr) qPtr->markRenderDirty();
+        if(notifyRender && qPtr) qPtr->mark_render_dirty();
     }
     void RenderAble::init(Plot* plot, QString layerName) {
         if(layerName.isEmpty()) {
@@ -132,39 +132,39 @@ namespace YSG {
         }
         plot->mLayerMap[layerName]->mRenderAbles.append(this);
         mPlot = plot;
-        if(!dPtr) dPtr = createRenderData();
-        dPtr->setBufferAcquireMode(plot->renderAbleBufferAcquireMode());
-        dPtr->clearStateBuffers();
-        dPtr->clearInputBuffers();
-        dPtr->mStateBuffers[State_Edit] = createRenderState();
-        dPtr->mStateBuffers[State_Ready] = createRenderState();
-        dPtr->mStateBuffers[State_Render] = createRenderState();
-        dPtr->mInputBuffers[Input_Edit].data = createInputData();
-        dPtr->mInputBuffers[Input_Ready].data = createInputData();
-        dPtr->mInputBuffers[Input_Render].data = createInputData();
+        if(!dPtr) dPtr = create_render_data();
+        dPtr->set_buffer_acquire_mode(plot->render_able_buffer_acquire_mode());
+        dPtr->clear_state_buffers();
+        dPtr->clear_input_buffers();
+        dPtr->mStateBuffers[State_Edit] = create_render_state();
+        dPtr->mStateBuffers[State_Ready] = create_render_state();
+        dPtr->mStateBuffers[State_Render] = create_render_state();
+        dPtr->mInputBuffers[Input_Edit].data = create_input_data();
+        dPtr->mInputBuffers[Input_Ready].data = create_input_data();
+        dPtr->mInputBuffers[Input_Render].data = create_input_data();
         for(RenderState* state : dPtr->mStateBuffers) {
             state->dPtr = dPtr;
         }
         dPtr->qPtr = this;
         dPtr->mStateBuffers[State_Edit]->version = 1;
-        if(mPlot) mPlot->markRenderStateDirty();
+        if(mPlot) mPlot->mark_render_state_dirty();
     }
-    void RenderAble::markStateDirty() {
+    void RenderAble::mark_state_dirty() {
         if(dPtr) {
             auto lease = dPtr->mStateControl.wait_mark_use_role(State_Edit);
-            ++dPtr->stateByIndex(lease.index)->version;
+            ++dPtr->state_by_index(lease.index)->version;
             dPtr->mStateControl.unmark_use(lease);
         }
-        markRenderDirty();
+        mark_render_dirty();
     }
-    void RenderAble::markRenderDirty() {
+    void RenderAble::mark_render_dirty() {
         if(!mPlot) return;
-        if(dPtr && dPtr->independentPixelCache()) {
-            dPtr->markPixelDirty();
-            mPlot->markIndependentRenderDirty(this);
+        if(dPtr && dPtr->independent_pixel_cache()) {
+            dPtr->mark_pixel_dirty();
+            mPlot->mark_independent_render_dirty(this);
             return;
         }
-        mPlot->markRenderStateDirty();
+        mPlot->mark_render_state_dirty();
     }
     bool RenderAble::ok() const  {
         return dPtr->mRenderStart && mPlot && !mPlot->mFirstResize && !mPlot->mFirstPrepareData;
@@ -173,7 +173,7 @@ namespace YSG {
     RenderAble::~RenderAble(){
     }
 
-    bool RenderAble::dectCycleRely()  {
+    bool RenderAble::dect_cycle_rely()  {
         QQueue<RenderAble*> queue;
         queue.enqueue(this);
         while (!queue.isEmpty()) {
@@ -181,7 +181,7 @@ namespace YSG {
             QSet<RenderAble*> visited;
             QSet<RenderAble*> recursionStack;
             QVector<RenderAble*> path;
-            bool has = hasCycleRely(current, visited, recursionStack, path);
+            bool has = has_cycle_rely(current, visited, recursionStack, path);
             if(has){
                 return true;
             }
@@ -190,7 +190,7 @@ namespace YSG {
         return false;
     }
 
-    bool RenderAble::hasCycleRely(RenderAble* node, QSet<RenderAble*>& visited, QSet<RenderAble*>& recursionStack,
+    bool RenderAble::has_cycle_rely(RenderAble* node, QSet<RenderAble*>& visited, QSet<RenderAble*>& recursionStack,
     QVector<RenderAble*>& currentPath)  {
         if (!node) return false;
 
@@ -220,7 +220,7 @@ namespace YSG {
 
         // 递归检查所有子节点
         for (RenderAble* child : node->mBeRelyList) {
-            if (hasCycleRely(child, visited, recursionStack, currentPath)) {
+            if (has_cycle_rely(child, visited, recursionStack, currentPath)) {
                 return true;
             }
         }
@@ -236,7 +236,7 @@ namespace YSG {
 
 
 
-    QVector<QRgb> getTurboColorGradient() {
+    QVector<QRgb> get_turbo_color_gradient() {
         QVector<QRgb> colors;
         // std::cout << "11111111111111111111111111111111111111" << std::endl;
         // for (auto s : QDir(":/").entryList())
diff --git a/YSGraphic_Core/RenderAble.h b/YSGraphic_Core/RenderAble.h
index 69a83ef..2e69bdc 100644
--- a/YSGraphic_Core/RenderAble.h
+++ b/YSGraphic_Core/RenderAble.h
@@ -397,34 +397,34 @@ struct RenderData {
     std::atomic<std::uint64_t> mPixelEditVersion{1};
     std::uint64_t mPixelRenderVersion = 0;
     RenderState* state(std::uint8_t role) const {
-        return stateByIndex(mStateControl.read_view()[role]);
+        return state_by_index(mStateControl.read_view()[role]);
     }
     RenderState* state(SRC src) const {
         return state(static_cast<std::uint8_t>(src));
     }
-    RenderState* stateByIndex(std::uint8_t index) const {
+    RenderState* state_by_index(std::uint8_t index) const {
         return mStateBuffers[index];
     }
-    Plot_Buffer_Acquire_Mode bufferAcquireMode() const {
+    Plot_Buffer_Acquire_Mode buffer_acquire_mode() const {
         return mBufferAcquireMode.load(std::memory_order_acquire);
     }
-    void setBufferAcquireMode(Plot_Buffer_Acquire_Mode mode) {
+    void set_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode) {
         mBufferAcquireMode.store(mode, std::memory_order_release);
     }
-    RenderAble_Render_Schedule_Mode renderScheduleMode() const {
+    RenderAble_Render_Schedule_Mode render_schedule_mode() const {
         return mRenderScheduleMode.load(std::memory_order_acquire);
     }
-    void setRenderScheduleMode(RenderAble_Render_Schedule_Mode mode) {
+    void set_render_schedule_mode(RenderAble_Render_Schedule_Mode mode) {
         mRenderScheduleMode.store(mode, std::memory_order_release);
     }
-    double renderScheduleMaxFps() const {
+    double render_schedule_max_fps() const {
         return mRenderScheduleMaxFps.load(std::memory_order_acquire);
     }
-    void setRenderScheduleMaxFps(double fps) {
+    void set_render_schedule_max_fps(double fps) {
         mRenderScheduleMaxFps.store(fps, std::memory_order_release);
     }
-    Triple_Buffer_Lease markStateRole(std::uint8_t role) {
-        if(bufferAcquireMode() == Plot_Buffer_Acquire_Mode::Wait) {
+    Triple_Buffer_Lease mark_state_role(std::uint8_t role) {
+        if(buffer_acquire_mode() == Plot_Buffer_Acquire_Mode::Wait) {
             return mStateControl.wait_mark_use_role(role);
         }
         auto record = mStateControl.try_mark_use_role(role);
@@ -433,58 +433,58 @@ struct RenderData {
         }
         return record.lease;
     }
-    void unmarkState(Triple_Buffer_Lease lease) {
+    void unmark_state(Triple_Buffer_Lease lease) {
         mStateControl.unmark_use(lease);
     }
-    void clearStateBuffers() {
+    void clear_state_buffers() {
         for(RenderState*& state : mStateBuffers) {
             delete state;
             state = nullptr;
         }
         mStateControl.reset();
     }
-    InputData* inputData(std::uint8_t role) const {
-        return inputSlot(role).data;
+    InputData* input_data(std::uint8_t role) const {
+        return input_slot(role).data;
     }
-    InputData* inputDataByIndex(std::uint8_t index) const {
+    InputData* input_data_by_index(std::uint8_t index) const {
         return mInputBuffers[index].data;
     }
-    InputBufferSlot& inputSlot(std::uint8_t role) {
-        return inputSlotByIndex(mInputControl.read_view()[role]);
+    InputBufferSlot& input_slot(std::uint8_t role) {
+        return input_slot_by_index(mInputControl.read_view()[role]);
     }
-    const InputBufferSlot& inputSlot(std::uint8_t role) const {
-        return inputSlotByIndex(mInputControl.read_view()[role]);
+    const InputBufferSlot& input_slot(std::uint8_t role) const {
+        return input_slot_by_index(mInputControl.read_view()[role]);
     }
-    InputBufferSlot& inputSlotByIndex(std::uint8_t index) {
+    InputBufferSlot& input_slot_by_index(std::uint8_t index) {
         return mInputBuffers[index];
     }
-    const InputBufferSlot& inputSlotByIndex(std::uint8_t index) const {
+    const InputBufferSlot& input_slot_by_index(std::uint8_t index) const {
         return mInputBuffers[index];
     }
-    bool hasPendingState() const {
+    bool has_pending_state() const {
         auto view = mStateControl.read_view();
         return buffer_version_newer(mStateBuffers[view[State_Edit]]->version, mStateBuffers[view[State_Render]]->version);
     }
-    bool hasPendingInput() const {
+    bool has_pending_input() const {
         auto view = mInputControl.read_view();
         const InputBufferSlot& edit = mInputBuffers[view[Input_Edit]];
         const InputBufferSlot& ready = mInputBuffers[view[Input_Ready]];
         const InputBufferSlot& render = mInputBuffers[view[Input_Render]];
         return (edit.pending && buffer_version_newer(edit.version, render.version)) || (ready.pending && buffer_version_newer(ready.version, render.version));
     }
-    bool hasPendingRenderData() const {
-        return hasPendingState() || hasPendingInput();
+    bool has_pending_render_data() const {
+        return has_pending_state() || has_pending_input();
     }
-    void markInputDirty(Triple_Buffer_Lease lease, bool notifyRender = true);
-    void clearInputRole(std::uint8_t role) {
-        InputBufferSlot& slot = inputSlot(role);
+    void mark_input_dirty(Triple_Buffer_Lease lease, bool notifyRender = true);
+    void clear_input_role(std::uint8_t role) {
+        InputBufferSlot& slot = input_slot(role);
         slot.data->clear();
         slot.pending = false;
     }
-    void clearRenderInput() {
-        clearInputRole(Input_Render);
+    void clear_render_input() {
+        clear_input_role(Input_Render);
     }
-    void clearInputBuffers() {
+    void clear_input_buffers() {
         for(InputBufferSlot& slot : mInputBuffers) {
             delete slot.data;
             slot.data = nullptr;
@@ -494,49 +494,49 @@ struct RenderData {
         mInputVersion = 0;
         mInputControl.reset();
     }
-    bool independentPixelCache() const {
+    bool independent_pixel_cache() const {
         return mIndependentPixelCache.load(std::memory_order_acquire);
     }
-    void setIndependentPixelCache(bool enabled) {
+    void set_independent_pixel_cache(bool enabled) {
         mIndependentPixelCache.store(enabled, std::memory_order_release);
     }
-    PixelBufferSlot* pixelByIndex(std::uint8_t index) {
+    PixelBufferSlot* pixel_by_index(std::uint8_t index) {
         return &mPixelBuffers[index];
     }
-    PixelBufferLease waitRenderPixel() {
+    PixelBufferLease wait_render_pixel() {
         auto lease = mPixelControl.wait_mark_use_role(Color_Render);
-        return {pixelByIndex(lease.index), lease};
+        return {pixel_by_index(lease.index), lease};
     }
-    PixelBufferLease tryFrontPixel() {
+    PixelBufferLease try_front_pixel() {
         auto record = mPixelControl.try_mark_use_role(Color_Front);
         if(record.result != Triple_Buffer_Result::Success) return {};
-        return {pixelByIndex(record.lease.index), record.lease};
+        return {pixel_by_index(record.lease.index), record.lease};
     }
-    void unmarkPixel(PixelBufferLease lease) {
+    void unmark_pixel(PixelBufferLease lease) {
         mPixelControl.unmark_use(lease.lease);
     }
-    bool hasNewPixelState() const {
+    bool has_new_pixel_state() const {
         return buffer_version_newer(mPixelEditVersion.load(std::memory_order_acquire), mPixelRenderVersion);
     }
-    void markPixelDirty() {
+    void mark_pixel_dirty() {
         mPixelEditVersion.fetch_add(1, std::memory_order_release);
     }
-    QRegion publishRenderPixel() {
+    QRegion publish_render_pixel() {
         mPixelControl.wait_swap_role(Color_Ready, Color_Render, [this](const Triple_Buffer_View& view) {
-            auto render = pixelByIndex(view[Color_Render]);
-            auto ready = pixelByIndex(view[Color_Ready]);
+            auto render = pixel_by_index(view[Color_Render]);
+            auto ready = pixel_by_index(view[Color_Ready]);
             return buffer_version_newer(render->version.load(std::memory_order_acquire), ready->version.load(std::memory_order_acquire));
         });
         auto view = mPixelControl.read_view();
-        auto ready = pixelByIndex(view[Color_Ready]);
-        auto front = pixelByIndex(view[Color_Front]);
+        auto ready = pixel_by_index(view[Color_Ready]);
+        auto front = pixel_by_index(view[Color_Front]);
         if(buffer_version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire))) return ready->dirtyRegion;
         return {};
     }
-    PixelBufferLease consumeReadyPixel(Triple_Buffer_Mode mode) {
+    PixelBufferLease consume_ready_pixel(Triple_Buffer_Mode mode) {
         auto canSwap = [this](const Triple_Buffer_View& view) {
-            auto ready = pixelByIndex(view[Color_Ready]);
-            auto front = pixelByIndex(view[Color_Front]);
+            auto ready = pixel_by_index(view[Color_Ready]);
+            auto front = pixel_by_index(view[Color_Front]);
             return buffer_version_newer(ready->version.load(std::memory_order_acquire), front->version.load(std::memory_order_acquire));
         };
         if(mode == Triple_Buffer_Mode::Wait) {
@@ -544,55 +544,55 @@ struct RenderData {
         } else {
             mPixelControl.try_swap_role(Color_Front, Color_Ready, canSwap);
         }
-        return tryFrontPixel();
+        return try_front_pixel();
     }
 protected:
-    virtual void syncStatePipeline() = 0;
-    virtual RenderState* renderState() = 0;
-    virtual RenderState* readyState() = 0;
-    virtual RenderState* editState() = 0;
-    virtual InputData* renderInputData() = 0;
-    virtual InputData* editInputData() = 0;
+    virtual void sync_state_pipeline() = 0;
+    virtual RenderState* render_state() = 0;
+    virtual RenderState* ready_state() = 0;
+    virtual RenderState* edit_state() = 0;
+    virtual InputData* render_input_data() = 0;
+    virtual InputData* edit_input_data() = 0;
     virtual ~RenderData() {
-        clearStateBuffers();
-        clearInputBuffers();
+        clear_state_buffers();
+        clear_input_buffers();
     }
     virtual void draw(QPainter* painter) {}
-    virtual void prepareData() {
-        syncStatePipeline();
+    virtual void prepare_data() {
+        sync_state_pipeline();
     }
-    virtual bool selectTest(const QPointF& pos) {
+    virtual bool select_test(const QPointF& pos) {
         return false;
     }
-    virtual void plotEvent(QEvent* event) {}
+    virtual void plot_event(QEvent* event) {}
     virtual void mousePressEvent(QMouseEvent* event) {}
     virtual void mouseMoveEvent(QMouseEvent* event) {}
     virtual void mouseReleaseEvent(QMouseEvent* event) {}
-    virtual void setHoverState(const QPoint& pos, bool active) {}
+    virtual void set_hover_state(const QPoint& pos, bool active) {}
     virtual void keyPressEvent(QKeyEvent* event) {}
     virtual void keyReleaseEvent(QKeyEvent* event) {}
-    virtual void firstResizeEvent(QResizeEvent* event) {}
+    virtual void first_resize_event(QResizeEvent* event) {}
     virtual void resizeEvent(QResizeEvent* event) {}
     virtual void wheelEvent(QWheelEvent* event) {}
     friend struct RenderAble;
 };
 struct BaseRenderData : RenderData {
-    RenderState* renderState() override {
+    RenderState* render_state() override {
         return nullptr;
     }
-    RenderState* readyState() override {
+    RenderState* ready_state() override {
         return nullptr;
     }
-    RenderState* editState() override {
+    RenderState* edit_state() override {
         return nullptr;
     }
-    InputData* renderInputData() override {
+    InputData* render_input_data() override {
         return nullptr;
     }
-    InputData* editInputData() override {
+    InputData* edit_input_data() override {
         return nullptr;
     }
-    void syncStatePipeline() override {}
+    void sync_state_pipeline() override {}
 };
 class Plot;
 struct LIB_DECL RenderEditGuard {
@@ -634,38 +634,38 @@ struct RenderAble {
         JobState jobState = JobState::Idle;
         std::atomic_bool paintRequestPending{false};
         RenderPipeline();
-        void markEditState();
-        bool hasNewState() const;
-        ColorBuffer* colorByIndex(std::uint8_t index);
-        ColorBuffer* colorByRole(std::uint8_t role);
-        ColorBufferLease waitRenderColor();
-        ColorBufferLease waitFrontColor();
-        ColorBufferLease tryFrontColor();
-        void unmarkColor(ColorBufferLease lease);
-        QRegion publishRenderColor();
-        ColorBufferLease consumeReadyColor(Triple_Buffer_Mode mode);
+        void mark_edit_state();
+        bool has_new_state() const;
+        ColorBuffer* color_by_index(std::uint8_t index);
+        ColorBuffer* color_by_role(std::uint8_t role);
+        ColorBufferLease wait_render_color();
+        ColorBufferLease wait_front_color();
+        ColorBufferLease try_front_color();
+        void unmark_color(ColorBufferLease lease);
+        QRegion publish_render_color();
+        ColorBufferLease consume_ready_color(Triple_Buffer_Mode mode);
     };
-    virtual RenderData* createRenderData() {
+    virtual RenderData* create_render_data() {
         return new BaseRenderData;
     }
-    virtual RenderState* createRenderState() {
+    virtual RenderState* create_render_state() {
         return new RenderState;
     }
-    virtual InputData* createInputData() {
+    virtual InputData* create_input_data() {
         return new InputData;
     }
     virtual void init(Plot* plot, QString layerName = "");
     virtual void draw(QPainter* painter) {
         dPtr->draw(painter);
     }
-    virtual void prepareData() {
-        dPtr->prepareData();
+    virtual void prepare_data() {
+        dPtr->prepare_data();
     }
-    virtual bool selectTest(const QPointF& pos) {
-        return dPtr->selectTest(pos);
+    virtual bool select_test(const QPointF& pos) {
+        return dPtr->select_test(pos);
     }
-    virtual void plotEvent(QEvent* event) {
-        dPtr->plotEvent(event);
+    virtual void plot_event(QEvent* event) {
+        dPtr->plot_event(event);
     }
     virtual void mousePressEvent(QMouseEvent* event) {
         dPtr->mousePressEvent(event);
@@ -676,8 +676,8 @@ struct RenderAble {
     virtual void mouseReleaseEvent(QMouseEvent* event) {
         dPtr->mouseReleaseEvent(event);
     }
-    virtual void setHoverState(const QPoint& pos, bool active) {
-        dPtr->setHoverState(pos, active);
+    virtual void set_hover_state(const QPoint& pos, bool active) {
+        dPtr->set_hover_state(pos, active);
     }
     virtual void keyPressEvent(QKeyEvent* event) {
         dPtr->keyPressEvent(event);
@@ -685,8 +685,8 @@ struct RenderAble {
     virtual void keyReleaseEvent(QKeyEvent* event) {
         dPtr->keyReleaseEvent(event);
     }
-    virtual void firstResizeEvent(QResizeEvent* event) {
-        dPtr->firstResizeEvent(event);
+    virtual void first_resize_event(QResizeEvent* event) {
+        dPtr->first_resize_event(event);
     }
     virtual void resizeEvent(QResizeEvent* event) {
         dPtr->resizeEvent(event);
@@ -697,16 +697,16 @@ struct RenderAble {
     static bool version_newer(std::uint64_t a, std::uint64_t b) {
         return buffer_version_newer(a, b);
     }
-    Plot_Buffer_Acquire_Mode bufferAcquireMode() const;
-    void setBufferAcquireMode(Plot_Buffer_Acquire_Mode mode);
-    RenderAble_Render_Schedule_Mode renderScheduleMode() const;
-    void setRenderScheduleMode(RenderAble_Render_Schedule_Mode mode);
-    double renderScheduleMaxFps() const;
-    void setRenderScheduleMaxFps(double fps);
-    bool independentPixelCache() const;
-    void setIndependentPixelCache(bool enabled);
-    void markStateDirty();
-    void markRenderDirty();
+    Plot_Buffer_Acquire_Mode buffer_acquire_mode() const;
+    void set_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode);
+    RenderAble_Render_Schedule_Mode render_schedule_mode() const;
+    void set_render_schedule_mode(RenderAble_Render_Schedule_Mode mode);
+    double render_schedule_max_fps() const;
+    void set_render_schedule_max_fps(double fps);
+    bool independent_pixel_cache() const;
+    void set_independent_pixel_cache(bool enabled);
+    void mark_state_dirty();
+    void mark_render_dirty();
     QString mObjectName;
     RenderData* dPtr{};
     Plot* mPlot{};
@@ -720,9 +720,9 @@ struct RenderAble {
     bool mVisable = true;
     RenderAble* mParent{};
     QVector<RenderAble*> mBeRelyList;
-    bool dectCycleRely();
+    bool dect_cycle_rely();
 private:
-    bool hasCycleRely(RenderAble* node, QSet<RenderAble*>& visited, QSet<RenderAble*>& recursionStack, QVector<RenderAble*>& currentPath);
+    bool has_cycle_rely(RenderAble* node, QSet<RenderAble*>& visited, QSet<RenderAble*>& recursionStack, QVector<RenderAble*>& currentPath);
 };
 template <typename T>
 concept Render_State_Type = std::derived_from<T, RenderState> && std::is_copy_assignable_v<T>;
@@ -735,29 +735,29 @@ struct Typed_Render_Data_Base : Base {
     Owner* q() {
         return reinterpret_cast<Owner*>(this->qPtr);
     }
-    State* renderState() override {
+    State* render_state() override {
         return reinterpret_cast<State*>(this->state(State_Render));
     }
-    State* readyState() override {
+    State* ready_state() override {
         return reinterpret_cast<State*>(this->state(State_Ready));
     }
-    State* editState() override {
+    State* edit_state() override {
         return reinterpret_cast<State*>(this->state(State_Edit));
     }
-    Input* renderInputData() override {
-        return reinterpret_cast<Input*>(this->inputData(Input_Render));
+    Input* render_input_data() override {
+        return reinterpret_cast<Input*>(this->input_data(Input_Render));
     }
-    Input* editInputData() override {
-        return reinterpret_cast<Input*>(this->inputData(Input_Edit));
+    Input* edit_input_data() override {
+        return reinterpret_cast<Input*>(this->input_data(Input_Edit));
     }
     State* state_data(SRC src) {
         return reinterpret_cast<State*>(this->state(src));
     }
     State* state_data_by_index(std::uint8_t index) {
-        return reinterpret_cast<State*>(this->stateByIndex(index));
+        return reinterpret_cast<State*>(this->state_by_index(index));
     }
     Input* input_data_by_index(std::uint8_t index) {
-        return reinterpret_cast<Input*>(this->inputDataByIndex(index));
+        return reinterpret_cast<Input*>(Base::input_data_by_index(index));
     }
     template <typename Field>
     Field state_value(Field State::*field, SRC src) {
@@ -770,27 +770,27 @@ struct Typed_Render_Data_Base : Base {
         RenderEditGuard guard(this, lease);
         state->*field = std::move(value);
     }
-    void syncStatePipeline() override {
+    void sync_state_pipeline() override {
         Triple_Buffer_Lease editLease = this->mStateControl.wait_mark_use_role(State_Edit);
         Triple_Buffer_Lease readyLease = this->mStateControl.wait_mark_use_role(State_Ready);
-        auto ready = reinterpret_cast<State*>(this->stateByIndex(readyLease.index));
-        auto edit = reinterpret_cast<State*>(this->stateByIndex(editLease.index));
+        auto ready = reinterpret_cast<State*>(this->state_by_index(readyLease.index));
+        auto edit = reinterpret_cast<State*>(this->state_by_index(editLease.index));
         if(buffer_version_newer(edit->version, ready->version)) *ready = *edit;
         this->mStateControl.unmark_use(readyLease);
         this->mStateControl.unmark_use(editLease);
         this->mStateControl.wait_swap_role(State_Ready, State_Render, [this](const Triple_Buffer_View& view) {
-            auto ready = reinterpret_cast<State*>(this->stateByIndex(view[State_Ready]));
-            auto render = reinterpret_cast<State*>(this->stateByIndex(view[State_Render]));
+            auto ready = reinterpret_cast<State*>(this->state_by_index(view[State_Ready]));
+            auto render = reinterpret_cast<State*>(this->state_by_index(view[State_Render]));
             return buffer_version_newer(ready->version, render->version);
         });
         this->mInputControl.wait_swap_role(Input_Edit, Input_Ready, [this](const Triple_Buffer_View& view) {
-            const InputBufferSlot& edit = this->inputSlotByIndex(view[Input_Edit]);
-            const InputBufferSlot& ready = this->inputSlotByIndex(view[Input_Ready]);
+            const InputBufferSlot& edit = this->input_slot_by_index(view[Input_Edit]);
+            const InputBufferSlot& ready = this->input_slot_by_index(view[Input_Ready]);
             return edit.pending && buffer_version_newer(edit.version, ready.version);
         });
         this->mInputControl.wait_swap_role(Input_Ready, Input_Render, [this](const Triple_Buffer_View& view) {
-            const InputBufferSlot& ready = this->inputSlotByIndex(view[Input_Ready]);
-            const InputBufferSlot& render = this->inputSlotByIndex(view[Input_Render]);
+            const InputBufferSlot& ready = this->input_slot_by_index(view[Input_Ready]);
+            const InputBufferSlot& render = this->input_slot_by_index(view[Input_Render]);
             return ready.pending && buffer_version_newer(ready.version, render.version);
         });
         if(!this->mRenderStart) this->mRenderStart = true;
@@ -819,11 +819,11 @@ struct RenderAble_Binding {
 };
 template <Render_Data_Type Data, Render_State_Type State>
 struct Render_State_Lease {
-    explicit Render_State_Lease(Data* data) : data(data), lease(data->mStateControl.wait_mark_use_role(State_Edit)), state(reinterpret_cast<State*>(data->stateByIndex(lease.index))) {}
+    explicit Render_State_Lease(Data* data) : data(data), lease(data->mStateControl.wait_mark_use_role(State_Edit)), state(reinterpret_cast<State*>(data->state_by_index(lease.index))) {}
     Render_State_Lease(const Render_State_Lease&) = delete;
     Render_State_Lease& operator=(const Render_State_Lease&) = delete;
     ~Render_State_Lease() {
-        data->unmarkState(lease);
+        data->unmark_state(lease);
     }
     State* operator->() {
         return state;
@@ -837,13 +837,13 @@ struct Render_State_Lease {
 };
 template <Render_Data_Type Data, Render_State_Type State>
 struct Render_Edit_Lease {
-    explicit Render_Edit_Lease(Data* data) : data(data), lease(data->mStateControl.wait_mark_use_role(State_Edit)), state(reinterpret_cast<State*>(data->stateByIndex(lease.index))) {}
+    explicit Render_Edit_Lease(Data* data) : data(data), lease(data->mStateControl.wait_mark_use_role(State_Edit)), state(reinterpret_cast<State*>(data->state_by_index(lease.index))) {}
     Render_Edit_Lease(const Render_Edit_Lease&) = delete;
     Render_Edit_Lease& operator=(const Render_Edit_Lease&) = delete;
     ~Render_Edit_Lease() {
-        ++data->stateByIndex(lease.index)->version;
-        if(data->qPtr) data->qPtr->markRenderDirty();
-        data->unmarkState(lease);
+        ++data->state_by_index(lease.index)->version;
+        if(data->qPtr) data->qPtr->mark_render_dirty();
+        data->unmark_state(lease);
     }
     State* operator->() {
         return state;
@@ -857,11 +857,11 @@ struct Render_Edit_Lease {
 };
 template <Render_Data_Type Data, Input_Data_Type Input>
 struct Render_Input_Lease {
-    explicit Render_Input_Lease(Data* data, bool notify_render = true) : data(data), notify_render(notify_render), lease(data->mInputControl.wait_mark_use_role(Input_Edit)), input(reinterpret_cast<Input*>(data->inputDataByIndex(lease.index))) {}
+    explicit Render_Input_Lease(Data* data, bool notify_render = true) : data(data), notify_render(notify_render), lease(data->mInputControl.wait_mark_use_role(Input_Edit)), input(reinterpret_cast<Input*>(data->input_data_by_index(lease.index))) {}
     Render_Input_Lease(const Render_Input_Lease&) = delete;
     Render_Input_Lease& operator=(const Render_Input_Lease&) = delete;
     ~Render_Input_Lease() {
-        data->markInputDirty(lease, notify_render);
+        data->mark_input_dirty(lease, notify_render);
         data->mInputControl.unmark_use(lease);
     }
     Input* operator->() {
diff --git a/YSGraphic_Core/base/CircularLinkedList.hpp b/YSGraphic_Core/base/CircularLinkedList.hpp
index fda5376..5a9c27c 100644
--- a/YSGraphic_Core/base/CircularLinkedList.hpp
+++ b/YSGraphic_Core/base/CircularLinkedList.hpp
@@ -49,7 +49,7 @@ namespace YSG {
             }
             return mCur;
         }
-        void insertNext(const T &t, CircularLinkedListNode<T> *that = nullptr) {
+        void insert_next(const T &t, CircularLinkedListNode<T> *that = nullptr) {
             if (that == nullptr) that = mCur;
             auto node = new CircularLinkedListNode<T>();
             node->data = t;
@@ -57,7 +57,7 @@ namespace YSG {
             node->prev = that;
             that->next = node;
         }
-        void insertPrev(const T &t, CircularLinkedListNode<T> *that = nullptr) {
+        void insert_prev(const T &t, CircularLinkedListNode<T> *that = nullptr) {
             if (that == nullptr) that = mCur;
             auto node = new CircularLinkedListNode<T>();
             node->data = t;
@@ -65,7 +65,7 @@ namespace YSG {
             node->next = that;
             that->prev = node;
         }
-        QVector<CircularLinkedListNode<T> *> toVector() {
+        QVector<CircularLinkedListNode<T> *> to_vector() {
             if (mHead == nullptr) return {};
             QVector<CircularLinkedListNode<T> *> ret;
             CircularLinkedListNode<T> *cur = mHead;
diff --git a/YSGraphic_Core/base/Global.cpp b/YSGraphic_Core/base/Global.cpp
index 4b2a311..b97e4f0 100644
--- a/YSGraphic_Core/base/Global.cpp
+++ b/YSGraphic_Core/base/Global.cpp
@@ -162,13 +162,13 @@ namespace YSG {
         if(!data->mSubmitTimer) data->mSubmitTimer = std::make_unique<asio::steady_timer>(d->mIoContext);
         data->mRenderSize = QSize(data->mPendingRenderWidth.load(std::memory_order_acquire), data->mPendingRenderHeight.load(std::memory_order_acquire));
         if(plot->isVisible()) data->mRenderEnabled.store(true, std::memory_order_release);
-        if(data->mRenderEnabled.load(std::memory_order_acquire)) plot->scheduleRenderTimer();
-        plot->onRenderRequest(Render_Request_Source::Dirty);
+        if(data->mRenderEnabled.load(std::memory_order_acquire)) plot->schedule_render_timer();
+        plot->on_render_request(Render_Request_Source::Dirty);
     }
     RenderScheduler& Global::renderScheduler() {
         return mRenderScheduler;
     }
-    void Global::startRenderScheduler() {
+    void Global::start_render_scheduler() {
         mRenderScheduler.start();
     }
 }
diff --git a/YSGraphic_Core/base/Global.h b/YSGraphic_Core/base/Global.h
index 95e8f60..8f11463 100644
--- a/YSGraphic_Core/base/Global.h
+++ b/YSGraphic_Core/base/Global.h
@@ -42,8 +42,8 @@ namespace YSG {
         int r = qInitResources_resource();
         int mInterval = 10;
         RenderScheduler& renderScheduler();
-        void startRenderScheduler();
-        QVector<QRgb> mColorMap = getTurboColorGradient();
+        void start_render_scheduler();
+        QVector<QRgb> mColorMap = get_turbo_color_gradient();
     private:
         RenderScheduler mRenderScheduler;
     };
diff --git a/YSGraphic_Core/base/Graphic.h b/YSGraphic_Core/base/Graphic.h
index 2b5abc1..359050a 100644
--- a/YSGraphic_Core/base/Graphic.h
+++ b/YSGraphic_Core/base/Graphic.h
@@ -17,7 +17,7 @@ namespace YSG{
             QPainter painter(cur);
             painter.fillRect(cur->rect(), Qt::red);
         }
-        void updateTexture() {
+        void update_texture() {
             QPixmap* cur = it ? mBuffer1 : mBuffer2;
         }
     };
@@ -35,7 +35,7 @@ namespace YSG{
     protected:
         bool event(QEvent*) override;
     public:
-        virtual void createLayers() {
+        virtual void create_layers() {
 
         };
         void render() {
@@ -46,7 +46,7 @@ namespace YSG{
             // 插入opengl同步变量
             for(PainterLayer* b : mPainterBuffers) {
                 b->draw();
-                b->updateTexture();
+                b->update_texture();
             }
             // 等待opengl同步变量
             // opengl汇总绘制
diff --git a/YSGraphic_Core/base/MutiSelectRect.cpp b/YSGraphic_Core/base/MutiSelectRect.cpp
index 1b43471..3015d8e 100644
--- a/YSGraphic_Core/base/MutiSelectRect.cpp
+++ b/YSGraphic_Core/base/MutiSelectRect.cpp
@@ -7,21 +7,21 @@ namespace YSG {
     MutiSelectRectPrivate* MutiSelectRect::d() {
         return MutiSelectRect_Binding::d(this);
     }
-    RenderData* MutiSelectRect::createRenderData() {
+    RenderData* MutiSelectRect::create_render_data() {
         return MutiSelectRect_Binding::create_render_data();
     }
-    RenderState* MutiSelectRect::createRenderState() {
+    RenderState* MutiSelectRect::create_render_state() {
         return MutiSelectRect_Binding::create_render_state();
     }
-    InputData* MutiSelectRect::createInputData() {
+    InputData* MutiSelectRect::create_input_data() {
         return MutiSelectRect_Binding::create_input_data();
     }
-    MutiSelectRect::Builder::Builder(AbsAxis* keyAxis, AbsAxis* valueAxis) {
+    MutiSelectRect::Builder::Builder(AbsAxis* keyAxis, AbsAxis* value_axis) {
         ASSERT(keyAxis->mPlot != nullptr, "Afterglow build error! keyAxis->mPlot == nullptr");
-        ASSERT(keyAxis->mPlot == valueAxis->mPlot, "Afterglow build error! keyAxis->mPlot != valueAxis->mPlot");
+        ASSERT(keyAxis->mPlot == value_axis->mPlot, "Afterglow build error! keyAxis->mPlot != value_axis->mPlot");
         plot = keyAxis->mPlot;
         this->keyAxis = keyAxis;
-        this->valueAxis = valueAxis;
+        this->value_axis = value_axis;
     }
 
     MutiSelectRect* MutiSelectRect::Builder::build() {
@@ -30,20 +30,20 @@ namespace YSG {
         MutiSelectRectPrivate* pd = ret->d();
         MutiSelectRectRenderState* sc = reinterpret_cast<MutiSelectRectRenderState*>(pd->state(State_Edit));
         sc->mHorizontalAxis = keyAxis;
-        sc->mVerticalAxis = valueAxis;
+        sc->mVerticalAxis = value_axis;
         sc->mFont = font;
-        sc->mFontPen = fontPen;
-        sc->mRectBrush = rectBrush;
-        sc->mBorderPen = borderPen;
+        sc->mFontPen = font_pen;
+        sc->mRectBrush = rect_brush;
+        sc->mBorderPen = border_pen;
         return ret;
     }
 
-    void MutiSelectRect::setHorizontalAxis(AbsAxis* axis) {
+    void MutiSelectRect::set_horizontal_axis(AbsAxis* axis) {
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mHorizontalAxis = axis;
     }
 
-    void MutiSelectRect::setVerticalAxis(AbsAxis* axis) {
+    void MutiSelectRect::set_vertical_axis(AbsAxis* axis) {
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mVerticalAxis = axis;
     }
@@ -51,29 +51,29 @@ namespace YSG {
     QFont MutiSelectRect::font(SRC src) {
         return d()->state_data(src)->mFont;
     }
-    QPen MutiSelectRect::fontPen(SRC src) {
+    QPen MutiSelectRect::font_pen(SRC src) {
         return d()->state_data(src)->mFontPen;
     }
-    QBrush MutiSelectRect::rectBrush(SRC src) {
+    QBrush MutiSelectRect::rect_brush(SRC src) {
         return d()->state_data(src)->mRectBrush;
     }
-    QPen MutiSelectRect::borderPen(SRC src) {
+    QPen MutiSelectRect::border_pen(SRC src) {
         return d()->state_data(src)->mBorderPen;
     }
 
-    void MutiSelectRect::setFont(const QFont& font){
+    void MutiSelectRect::set_font(const QFont& font){
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mFont = font;
     }
-    void MutiSelectRect::setFontPen(const QPen& pen){
+    void MutiSelectRect::set_font_pen(const QPen& pen){
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mFontPen = pen.color().isValid() ? pen : Qt::NoPen;
     }
-    void MutiSelectRect::setRectBrush(const QBrush& brush) {
+    void MutiSelectRect::set_rect_brush(const QBrush& brush) {
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mRectBrush = brush.color().isValid() ? brush : Qt::NoBrush;
     }
-    void MutiSelectRect::setBorderPen(const QPen& pen) {
+    void MutiSelectRect::set_border_pen(const QPen& pen) {
         Render_Edit_Lease<MutiSelectRectPrivate, MutiSelectRectRenderState> edit(d());
         edit->mBorderPen = pen.color().isValid() ? pen : Qt::NoPen;
     }
diff --git a/YSGraphic_Core/base/MutiSelectRect.h b/YSGraphic_Core/base/MutiSelectRect.h
index 410bff0..83751b6 100644
--- a/YSGraphic_Core/base/MutiSelectRect.h
+++ b/YSGraphic_Core/base/MutiSelectRect.h
@@ -7,43 +7,43 @@ namespace YSG {
     class LIB_DECL MutiSelectRect : public RenderAble {
     public:
         MutiSelectRectPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         MutiSelectRect();
         friend struct MutiSelectRectPrivate;
         friend struct MutiSelectRectRenderState;
         friend struct MutiSelectRectInputData;
     public:
-        void setHorizontalAxis(AbsAxis* axis);
-        void setVerticalAxis(AbsAxis* axis);
+        void set_horizontal_axis(AbsAxis* axis);
+        void set_vertical_axis(AbsAxis* axis);
         QFont font(SRC=SRC::Edit);
-        QPen fontPen(SRC=SRC::Edit);
-        QBrush rectBrush(SRC=SRC::Edit);
-        QPen borderPen(SRC=SRC::Edit);
-        void setFont(const QFont& font);
-        void setFontPen(const QPen& pen);
-        void setRectBrush(const QBrush& brush);
-        void setBorderPen(const QPen& pen);
+        QPen font_pen(SRC=SRC::Edit);
+        QBrush rect_brush(SRC=SRC::Edit);
+        QPen border_pen(SRC=SRC::Edit);
+        void set_font(const QFont& font);
+        void set_font_pen(const QPen& pen);
+        void set_rect_brush(const QBrush& brush);
+        void set_border_pen(const QPen& pen);
         struct Builder;
     };
 
     struct LIB_DECL MutiSelectRect::Builder {
         SETTER(QFont, font, QFont())
-        SETTER(QPen, fontPen, QPen(Qt::white))
-        SETTER(QBrush, rectBrush, QColor(0, 0, 255, 50))
-        SETTER(QPen, borderPen, []() {
+        SETTER(QPen, font_pen, QPen(Qt::white))
+        SETTER(QBrush, rect_brush, QColor(0, 0, 255, 50))
+        SETTER(QPen, border_pen, []() {
             QPen pen(Qt::white);
             pen.setStyle(Qt::DashLine);
             return pen;
         }())
         SETTER(QString, layerName, "legend")
-        Builder(AbsAxis* keyAxis, AbsAxis* valueAxis);
+        Builder(AbsAxis* keyAxis, AbsAxis* value_axis);
         MutiSelectRect* build();
     protected:
         AbsAxis* keyAxis;
-        AbsAxis* valueAxis{};
+        AbsAxis* value_axis{};
         Plot *plot{};
     };
 }
diff --git a/YSGraphic_Core/base/MutiSelectRect_p.h b/YSGraphic_Core/base/MutiSelectRect_p.h
index e27335e..7a33091 100644
--- a/YSGraphic_Core/base/MutiSelectRect_p.h
+++ b/YSGraphic_Core/base/MutiSelectRect_p.h
@@ -37,7 +37,7 @@ namespace YSG {
         bool mActive = false;
     protected:
 
-        bool selectTest(const QPointF& pos) override {
+        bool select_test(const QPointF& pos) override {
             return true;
         }
 
@@ -58,8 +58,8 @@ namespace YSG {
                     }
                 }
             }
-            double x = edit->mHorizontalAxis->pixelToCoord(event->pos().x(), SRC::Render);
-            double y = edit->mVerticalAxis->pixelToCoord(event->pos().y(), SRC::Render);
+            double x = edit->mHorizontalAxis->pixel_to_coord(event->pos().x(), SRC::Render);
+            double y = edit->mVerticalAxis->pixel_to_coord(event->pos().y(), SRC::Render);
             rectList.append(QRectF(QPointF(x, y), QPointF(x, y)));
             mActive = true;
         }
@@ -71,8 +71,8 @@ namespace YSG {
             if (rectList.empty()) return;
             rectList.last().setBottomRight(event->pos());
             QRectF &r = rectList.last();
-            r.setRight(edit->mHorizontalAxis->pixelToCoord(r.right(), SRC::Render));
-            r.setBottom(edit->mVerticalAxis->pixelToCoord(r.bottom(), SRC::Render));
+            r.setRight(edit->mHorizontalAxis->pixel_to_coord(r.right(), SRC::Render));
+            r.setBottom(edit->mVerticalAxis->pixel_to_coord(r.bottom(), SRC::Render));
         }
 
         void mouseReleaseEvent(QMouseEvent* event) override {}
@@ -92,19 +92,19 @@ namespace YSG {
 
         void draw(QPainter* painter) override {
             if(!mActive) return;
-            MutiSelectRectRenderState* s = renderState();
+            MutiSelectRectRenderState* s = render_state();
             QList<QRectF> drawRectList;
             for (QRectF r: s->mRects) {
                 if (qFuzzyCompare(r.width(), 0.0) || qFuzzyCompare(r.height(), 0.0)) continue;
-                r.setX(s->mHorizontalAxis->coordToPixel(r.x(), SRC::Render));
-                r.setY(s->mVerticalAxis->coordToPixel(r.y(), SRC::Render));
-                r.setRight(s->mHorizontalAxis->coordToPixel(r.right(), SRC::Render));
-                r.setBottom(s->mVerticalAxis->coordToPixel(r.bottom(), SRC::Render));
+                r.setX(s->mHorizontalAxis->coord_to_pixel(r.x(), SRC::Render));
+                r.setY(s->mVerticalAxis->coord_to_pixel(r.y(), SRC::Render));
+                r.setRight(s->mHorizontalAxis->coord_to_pixel(r.right(), SRC::Render));
+                r.setBottom(s->mVerticalAxis->coord_to_pixel(r.bottom(), SRC::Render));
                 drawRectList.append(r);
             }
             painter->save();
-            QFontMetrics xfm(s->mHorizontalAxis->unitTextFont());
-            QFontMetrics yfm(s->mVerticalAxis->unitTextFont());
+            QFontMetrics xfm(s->mHorizontalAxis->unit_text_font());
+            QFontMetrics yfm(s->mVerticalAxis->unit_text_font());
             painter->setPen(s->mBorderPen);
             painter->setBrush(s->mRectBrush);
             for (auto &rect: drawRectList) {
@@ -118,8 +118,8 @@ namespace YSG {
                 QRectF &coordRect = s->mRects[i];
                 double OffsetX = coordRect.right() - coordRect.left();
                 double OffsetY = coordRect.bottom() - coordRect.top();
-                QString text1 = "OffsetX == " + QString::number(OffsetX) + s->mHorizontalAxis->unitText();
-                QString text2 = "OffsetY == " + QString::number(OffsetY) + s->mVerticalAxis->unitText();
+                QString text1 = "OffsetX == " + QString::number(OffsetX) + s->mHorizontalAxis->unit_text();
+                QString text2 = "OffsetY == " + QString::number(OffsetY) + s->mVerticalAxis->unit_text();
                 double width1 = xfm.horizontalAdvance(text1) + 32;
                 double width2 = yfm.horizontalAdvance(text2) + 32;
                 double rect1X = rect.x() + rect.width() / 2 - width1 / 2;
diff --git a/YSGraphic_Core/base/PerformanceShower.cpp b/YSGraphic_Core/base/PerformanceShower.cpp
index 35c85a8..57fcb87 100644
--- a/YSGraphic_Core/base/PerformanceShower.cpp
+++ b/YSGraphic_Core/base/PerformanceShower.cpp
@@ -3,113 +3,113 @@ namespace YSG {
     using PerformanceShower_Binding = RenderAble_Binding<PerformanceShower, PerformanceShowerPrivate, PerformanceShowerRenderState, PerformanceShowerInputData>;
     PerformanceShower::PerformanceShower() {
         PerformanceShower_Binding::init(this, "PerformanceShower");
-        setIndependentPixelCache(true);
+        set_independent_pixel_cache(true);
     }
     PerformanceShowerPrivate* PerformanceShower::d() {
         return PerformanceShower_Binding::d(this);
     }
-    RenderData* PerformanceShower::createRenderData() {
+    RenderData* PerformanceShower::create_render_data() {
         return PerformanceShower_Binding::create_render_data();
     }
-    RenderState* PerformanceShower::createRenderState() {
+    RenderState* PerformanceShower::create_render_state() {
         return PerformanceShower_Binding::create_render_state();
     }
-    InputData* PerformanceShower::createInputData() {
+    InputData* PerformanceShower::create_input_data() {
         return PerformanceShower_Binding::create_input_data();
     }
     void PerformanceShower::setEnabled(bool enabled) {
         mEnabled.store(enabled, std::memory_order_release);
         if(enabled) {
-            appendEvent({PerformanceEventType::Clear});
+            append_event({PerformanceEventType::Clear});
         }
-        markRenderDirty();
+        mark_render_dirty();
     }
     bool PerformanceShower::enabled() const {
         return mEnabled.load(std::memory_order_acquire);
     }
-    void PerformanceShower::refreshCounter() {
-        appendEvent({PerformanceEventType::Clear});
+    void PerformanceShower::refresh_counter() {
+        append_event({PerformanceEventType::Clear});
     }
-    void PerformanceShower::counterIncrease(const QString& counterName) {
-        incrementCounter("General", counterName);
+    void PerformanceShower::counter_increase(const QString& counterName) {
+        increment_counter("General", counterName);
     }
-    void PerformanceShower::incrementCounter(const QString& scope, const QString& name) {
+    void PerformanceShower::increment_counter(const QString& scope, const QString& name) {
         PerformanceEvent event;
         event.type = PerformanceEventType::Counter;
         event.scope = scope;
         event.key = name;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::setPerformanceLine(const QString& key, const PerformanceLine& line) {
+    void PerformanceShower::set_performance_line(const QString& key, const PerformanceLine& line) {
         PerformanceEvent event;
         event.type = PerformanceEventType::Line;
         event.scope = "General";
         event.key = key;
         event.line = line;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::setInfo(const QString& key, const QString& value) {
-        setState("General", key, value);
+    void PerformanceShower::set_info(const QString& key, const QString& value) {
+        set_state("General", key, value);
     }
-    void PerformanceShower::setState(const QString& scope, const QString& name, const QString& value) {
+    void PerformanceShower::set_state(const QString& scope, const QString& name, const QString& value) {
         PerformanceEvent event;
         event.type = PerformanceEventType::State;
         event.scope = scope;
         event.key = name;
         event.value = value;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::setGauge(const QString& scope, const QString& name, double value) {
+    void PerformanceShower::set_gauge(const QString& scope, const QString& name, double value) {
         PerformanceEvent event;
         event.type = PerformanceEventType::Gauge;
         event.scope = scope;
         event.key = name;
         event.number = value;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::recordCost(const QString& key, double value) {
-        recordDuration("General", key, value);
+    void PerformanceShower::record_cost(const QString& key, double value) {
+        record_duration("General", key, value);
     }
-    void PerformanceShower::recordDuration(const QString& scope, const QString& name, double value) {
+    void PerformanceShower::record_duration(const QString& scope, const QString& name, double value) {
         PerformanceEvent event;
         event.type = PerformanceEventType::Duration;
         event.scope = scope;
         event.key = name;
         event.number = value;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::setViewFilter(const QString& name) {
-        setViewFilter(name, {});
+    void PerformanceShower::set_view_filter(const QString& name) {
+        set_view_filter(name, {});
     }
-    void PerformanceShower::setViewFilter(const QString& group, const QString& name) {
+    void PerformanceShower::set_view_filter(const QString& group, const QString& name) {
         PerformanceEvent event;
         event.type = PerformanceEventType::SelectView;
         event.scope = group;
         event.key = name;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::scrollView(int lines) {
+    void PerformanceShower::scroll_view(int lines) {
         PerformanceEvent event;
         event.type = PerformanceEventType::ScrollView;
         event.number = lines;
-        appendEvent(event);
+        append_event(event);
     }
-    void PerformanceShower::appendEvent(const PerformanceEvent& event) {
+    void PerformanceShower::append_event(const PerformanceEvent& event) {
         if(!enabled() && event.type != PerformanceEventType::Clear) return;
         auto pd = d();
         Render_Input_Lease<PerformanceShowerPrivate, PerformanceShowerInputData> input(pd, false);
         input->events.append(event);
-        notifyObservedUpdate(event.type == PerformanceEventType::Clear || event.type == PerformanceEventType::SelectView || event.type == PerformanceEventType::ScrollView);
+        notify_observed_update(event.type == PerformanceEventType::Clear || event.type == PerformanceEventType::SelectView || event.type == PerformanceEventType::ScrollView);
     }
-    void PerformanceShower::notifyObservedUpdate(bool force) {
+    void PerformanceShower::notify_observed_update(bool force) {
         std::uint64_t now = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
         std::uint64_t last = mLastNotifyNs.load(std::memory_order_acquire);
         if(!force && now - last < 100000000) return;
         if(force) {
             mLastNotifyNs.store(now, std::memory_order_release);
-            markRenderDirty();
+            mark_render_dirty();
             return;
         }
-        if(force || mLastNotifyNs.compare_exchange_strong(last, now, std::memory_order_acq_rel, std::memory_order_acquire)) markRenderDirty();
+        if(force || mLastNotifyNs.compare_exchange_strong(last, now, std::memory_order_acq_rel, std::memory_order_acquire)) mark_render_dirty();
     }
 }
diff --git a/YSGraphic_Core/base/PerformanceShower_p.h b/YSGraphic_Core/base/PerformanceShower_p.h
index 695cf46..0c492bc 100644
--- a/YSGraphic_Core/base/PerformanceShower_p.h
+++ b/YSGraphic_Core/base/PerformanceShower_p.h
@@ -6,16 +6,16 @@
 #include <chrono>
 #include <QSet>
 namespace YSG {
-    inline QString performanceAlignText(const QString& text, int& width) {
+    inline QString performance_align_text(const QString& text, int& width) {
         width = qMax(width, static_cast<int>(text.size()));
         return QString("%1").arg(text, width);
     }
-    inline QString performanceNumber(double value, int& width, int precision = 2) {
-        return performanceAlignText(QString::number(value, 'f', precision), width);
+    inline QString performance_number(double value, int& width, int precision = 2) {
+        return performance_align_text(QString::number(value, 'f', precision), width);
     }
     template <typename T>
-    inline QString performanceCount(T value, int& width) {
-        return performanceAlignText(QString::number(static_cast<qulonglong>(value)), width);
+    inline QString performance_count(T value, int& width) {
+        return performance_align_text(QString::number(static_cast<qulonglong>(value)), width);
     }
     struct PerformanceLine {
         PerformanceLine() = default;
@@ -40,15 +40,15 @@ namespace YSG {
             if(mValues.size() > 1) mValues[1] = mStatistics.smooth;
             if(mValues.size() > 2) mValues[2] = mStatistics.variation;
         }
-        int& widthAt(int index) {
+        int& width_at(int index) {
             if(mValueWidths.size() <= index) mValueWidths.resize(index + 1);
             return mValueWidths[index];
         }
-        QString toString() {
+        QString to_string() {
             QString ret = mData;
             int argIndex = 1;
             for(const double& value : mValues) {
-                ret = ret.replace("%" + QString::number(argIndex), performanceNumber(value, widthAt(argIndex - 1)));
+                ret = ret.replace("%" + QString::number(argIndex), performance_number(value, width_at(argIndex - 1)));
                 argIndex++;
             }
             return ret;
@@ -88,32 +88,32 @@ namespace YSG {
         double gauge{};
         std::uint64_t count{};
         QVector<int> widths;
-        int& widthAt(int index) {
+        int& width_at(int index) {
             if(widths.size() <= index) widths.resize(index + 1);
             return widths[index];
         }
-        [[nodiscard]] QString toString(const QString& name) {
+        [[nodiscard]] QString to_string(const QString& name) {
             switch(type) {
             case PerformanceMetricType::Duration:
                 if(name.contains("%1")) {
                     QString ret = name;
-                    ret = ret.replace("%1", performanceNumber(value.instant, widthAt(0)));
-                    ret = ret.replace("%2", performanceNumber(value.smooth, widthAt(1)));
-                    ret = ret.replace("%3", performanceNumber(value.variation, widthAt(2)));
-                    ret = ret.replace("%4", performanceNumber(value.p95, widthAt(3)));
+                    ret = ret.replace("%1", performance_number(value.instant, width_at(0)));
+                    ret = ret.replace("%2", performance_number(value.smooth, width_at(1)));
+                    ret = ret.replace("%3", performance_number(value.variation, width_at(2)));
+                    ret = ret.replace("%4", performance_number(value.p95, width_at(3)));
                     return ret;
                 }
                 return QString("%1 last:%2ms srtt:%3ms rttvar:%4ms min:%5ms max:%6ms p95:%7ms count:%8")
-                .arg(name, performanceNumber(value.instant, widthAt(0)), performanceNumber(value.smooth, widthAt(1)), performanceNumber(value.variation, widthAt(2)), performanceNumber(value.min, widthAt(3)), performanceNumber(value.max, widthAt(4)), performanceNumber(value.p95, widthAt(5)), performanceCount(value.times, widthAt(6)));
+                .arg(name, performance_number(value.instant, width_at(0)), performance_number(value.smooth, width_at(1)), performance_number(value.variation, width_at(2)), performance_number(value.min, width_at(3)), performance_number(value.max, width_at(4)), performance_number(value.p95, width_at(5)), performance_count(value.times, width_at(6)));
             case PerformanceMetricType::Counter:
                 return QString("%1 speed:%2/s avg:%3/s count:%4")
-                .arg(name, performanceNumber(speed.instant_speed, widthAt(0)), performanceNumber(speed.average_speed, widthAt(1)), performanceCount(speed.times, widthAt(2)));
+                .arg(name, performance_number(speed.instant_speed, width_at(0)), performance_number(speed.average_speed, width_at(1)), performance_count(speed.times, width_at(2)));
             case PerformanceMetricType::Gauge:
-                return QString("%1: %2").arg(name, performanceNumber(gauge, widthAt(0)));
+                return QString("%1: %2").arg(name, performance_number(gauge, width_at(0)));
             case PerformanceMetricType::State:
                 return QString("%1: %2").arg(name, text);
             case PerformanceMetricType::Line:
-                return line.toString();
+                return line.to_string();
             }
             return {};
         }
@@ -145,26 +145,26 @@ namespace YSG {
     public:
         PerformanceShower();
         PerformanceShowerPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
         void setEnabled(bool enabled);
         bool enabled() const;
-        void refreshCounter();
-        void counterIncrease(const QString& counterName);
-        void incrementCounter(const QString& scope, const QString& name);
-        void setPerformanceLine(const QString& key, const PerformanceLine& line);
-        void setInfo(const QString& key, const QString& value);
-        void setState(const QString& scope, const QString& name, const QString& value);
-        void setGauge(const QString& scope, const QString& name, double value);
-        void recordCost(const QString& key, double value);
-        void recordDuration(const QString& scope, const QString& name, double value);
-        void setViewFilter(const QString& name);
-        void setViewFilter(const QString& group, const QString& name);
-        void scrollView(int lines);
+        void refresh_counter();
+        void counter_increase(const QString& counterName);
+        void increment_counter(const QString& scope, const QString& name);
+        void set_performance_line(const QString& key, const PerformanceLine& line);
+        void set_info(const QString& key, const QString& value);
+        void set_state(const QString& scope, const QString& name, const QString& value);
+        void set_gauge(const QString& scope, const QString& name, double value);
+        void record_cost(const QString& key, double value);
+        void record_duration(const QString& scope, const QString& name, double value);
+        void set_view_filter(const QString& name);
+        void set_view_filter(const QString& group, const QString& name);
+        void scroll_view(int lines);
     private:
-        void appendEvent(const PerformanceEvent& event);
-        void notifyObservedUpdate(bool force);
+        void append_event(const PerformanceEvent& event);
+        void notify_observed_update(bool force);
         std::atomic_bool mEnabled{false};
         std::atomic<std::uint64_t> mLastNotifyNs{0};
     };
@@ -186,28 +186,28 @@ namespace YSG {
         bool mContentWidthDirty = true;
         QString mSelectedGroup = "Plot";
         QString mSelectedTarget = "Overview";
-        void prepareData() override {
-            syncStatePipeline();
-            auto input = renderInputData();
+        void prepare_data() override {
+            sync_state_pipeline();
+            auto input = render_input_data();
             for(const PerformanceEvent& event : input->events) {
-                applyEvent(event);
+                apply_event(event);
             }
-            clearRenderInput();
-            rebuildLines();
+            clear_render_input();
+            rebuild_lines();
         }
-        bool selectTest(const QPointF& pos) override {
+        bool select_test(const QPointF& pos) override {
             return q()->enabled() && mPanelRect.contains(pos.toPoint());
         }
         void mousePressEvent(QMouseEvent* event) override {
             for(int i = 0; i < mGroupRects.size(); ++i) {
                 if(mGroupRects[i].contains(event->pos())) {
-                    q()->setViewFilter(mGroupItems[i], {});
+                    q()->set_view_filter(mGroupItems[i], {});
                     return;
                 }
             }
             for(int i = 0; i < mTargetRects.size(); ++i) {
                 if(mTargetRects[i].contains(event->pos())) {
-                    q()->setViewFilter(mSelectedGroup, mTargetItems[i]);
+                    q()->set_view_filter(mSelectedGroup, mTargetItems[i]);
                     return;
                 }
             }
@@ -215,16 +215,16 @@ namespace YSG {
         void wheelEvent(QWheelEvent* event) override {
             if(!mPanelRect.contains(event->pos())) return;
             int steps = event->angleDelta().y() > 0 ? -3 : 3;
-            q()->scrollView(steps);
+            q()->scroll_view(steps);
         }
         void draw(QPainter* painter) override {
             if(!q()->enabled() || mGroupItems.isEmpty()) return;
-            auto s = renderState();
+            auto s = render_state();
             painter->save();
             painter->setFont(s->font);
             QFontMetrics fm(s->font);
-            if(mSidebarWidthDirty) updateSidebarWidth(fm, s);
-            if(mContentWidthDirty) updateContentWidth(fm, s);
+            if(mSidebarWidthDirty) update_sidebar_width(fm, s);
+            if(mContentWidthDirty) update_content_width(fm, s);
             int sideLineCount = qMax(mGroupItems.size(), mTargetItems.size());
             int lineCount = qMax(mAllInfo.size(), sideLineCount);
             int maxHeight = painter->device()->height();
@@ -261,10 +261,10 @@ namespace YSG {
                 if(mTargetItems[i] == mSelectedTarget) painter->fillRect(itemRect, s->selectedBackground);
                 painter->drawText(QPointF(itemRect.left() + s->leftMargin, itemRect.top() + fm.lineSpacing()), mTargetItems[i]);
             }
-            if(mMaxScrollLine > 0) drawScrollbar(painter, s, QRect(width - 8, 0, 8, height), visibleLines);
+            if(mMaxScrollLine > 0) draw_scrollbar(painter, s, QRect(width - 8, 0, 8, height), visibleLines);
             painter->restore();
         }
-        void drawScrollbar(QPainter* painter, PerformanceShowerRenderState* state, const QRect& rect, int visibleLines) {
+        void draw_scrollbar(QPainter* painter, PerformanceShowerRenderState* state, const QRect& rect, int visibleLines) {
             painter->fillRect(rect, state->scrollbarBackground);
             double ratio = static_cast<double>(visibleLines) / static_cast<double>(mAllInfo.size());
             int handleHeight = qMax(16, qRound(rect.height() * ratio));
@@ -272,7 +272,7 @@ namespace YSG {
             int top = qRound(static_cast<double>(travel) * static_cast<double>(mScrollLine) / static_cast<double>(mMaxScrollLine));
             painter->fillRect(QRect(rect.left(), rect.top() + top, rect.width(), handleHeight), state->scrollbarHandle);
         }
-        void updateSidebarWidth(const QFontMetrics& fm, PerformanceShowerRenderState* state) {
+        void update_sidebar_width(const QFontMetrics& fm, PerformanceShowerRenderState* state) {
             int groupWidth = 0;
             int targetWidth = 0;
             for(const QString& item : mGroupItems) groupWidth = qMax(groupWidth, fm.horizontalAdvance(item));
@@ -281,13 +281,13 @@ namespace YSG {
             mTargetSidebarWidth = qMax(state->targetSidebarWidth, targetWidth + state->leftMargin + state->rightMargin);
             mSidebarWidthDirty = false;
         }
-        void updateContentWidth(const QFontMetrics& fm, PerformanceShowerRenderState* state) {
+        void update_content_width(const QFontMetrics& fm, PerformanceShowerRenderState* state) {
             int maxWidth = 0;
             for(const QString& line : mAllInfo) maxWidth = qMax(maxWidth, fm.horizontalAdvance(line));
             mContentWidth = maxWidth + state->leftMargin + state->rightMargin;
             mContentWidthDirty = false;
         }
-        void applyEvent(const PerformanceEvent& event) {
+        void apply_event(const PerformanceEvent& event) {
             switch(event.type) {
             case PerformanceEventType::Clear:
                 mScopes.clear();
@@ -333,26 +333,26 @@ namespace YSG {
                 break;
             }
         }
-        static QString objectNameFromMetric(const QString& key) {
+        static QString object_name_from_metric(const QString& key) {
             int stateIndex = key.indexOf(".State.");
             if(stateIndex > 0) return key.left(stateIndex);
             int inputIndex = key.indexOf(".Input.");
             if(inputIndex > 0) return key.left(inputIndex);
-            int prepareIndex = key.indexOf(".prepareData");
+            int prepareIndex = key.indexOf(".prepare_data");
             if(prepareIndex > 0) return key.left(prepareIndex);
             int drawIndex = key.indexOf(".draw");
             if(drawIndex > 0) return key.left(drawIndex);
             int leaseIndex = key.indexOf(".stateLeaseMiss");
             if(leaseIndex > 0) return key.left(leaseIndex);
-            int modeIndex = key.indexOf(".bufferAcquireMode");
+            int modeIndex = key.indexOf(".buffer_acquire_mode");
             if(modeIndex > 0) return key.left(modeIndex);
-            int scheduleModeIndex = key.indexOf(".renderScheduleMode");
+            int scheduleModeIndex = key.indexOf(".render_schedule_mode");
             if(scheduleModeIndex > 0) return key.left(scheduleModeIndex);
-            int scheduleMaxFpsIndex = key.indexOf(".renderScheduleMaxFps");
+            int scheduleMaxFpsIndex = key.indexOf(".render_schedule_max_fps");
             if(scheduleMaxFpsIndex > 0) return key.left(scheduleMaxFpsIndex);
             return {};
         }
-        void rebuildViews() {
+        void rebuild_views() {
             QSet<QString> objectItems;
             QVector<QString> oldGroupItems = mGroupItems;
             QVector<QString> oldTargetItems = mTargetItems;
@@ -360,7 +360,7 @@ namespace YSG {
             auto renderAbleScope = mScopes.constFind("RenderAble");
             if(renderAbleScope != mScopes.cend()) {
                 for(auto metricIt = renderAbleScope.value().cbegin(); metricIt != renderAbleScope.value().cend(); ++metricIt) {
-                    QString objectName = objectNameFromMetric(metricIt.key());
+                    QString objectName = object_name_from_metric(metricIt.key());
                     if(!objectName.isEmpty()) objectItems.insert(objectName);
                 }
             }
@@ -368,7 +368,7 @@ namespace YSG {
             if(bufferScope != mScopes.cend()) {
                 for(auto metricIt = bufferScope.value().cbegin(); metricIt != bufferScope.value().cend(); ++metricIt) {
                     if(!metricIt.key().startsWith("Color.")) {
-                        QString objectName = objectNameFromMetric(metricIt.key());
+                        QString objectName = object_name_from_metric(metricIt.key());
                         if(!objectName.isEmpty()) objectItems.insert(objectName);
                     }
                 }
@@ -383,12 +383,12 @@ namespace YSG {
                 mTargetItems.clear();
                 if(mScopes.contains("Pipeline")) mTargetItems.append("Pipeline");
                 if(mScopes.contains("General")) mTargetItems.append("General");
-                if(hasColorBufferMetrics()) mTargetItems.append("Color");
+                if(has_color_buffer_metrics()) mTargetItems.append("Color");
             } else {
                 mTargetItems.clear();
-                if(hasRenderAbleMetrics(mSelectedGroup)) mTargetItems.append("RenderAble");
-                if(hasObjectBufferMetrics(mSelectedGroup, "State")) mTargetItems.append("State");
-                if(hasObjectBufferMetrics(mSelectedGroup, "Input")) mTargetItems.append("Input");
+                if(has_render_able_metrics(mSelectedGroup)) mTargetItems.append("RenderAble");
+                if(has_object_buffer_metrics(mSelectedGroup, "State")) mTargetItems.append("State");
+                if(has_object_buffer_metrics(mSelectedGroup, "Input")) mTargetItems.append("Input");
             }
             if(mTargetItems.isEmpty()) mTargetItems.append("None");
             if(mSelectedTarget.isEmpty() || !mTargetItems.contains(mSelectedTarget)) mSelectedTarget = mTargetItems.front();
@@ -399,7 +399,7 @@ namespace YSG {
             }
             if(oldGroupItems != mGroupItems || oldTargetItems != mTargetItems) mSidebarWidthDirty = true;
         }
-        bool hasColorBufferMetrics() const {
+        bool has_color_buffer_metrics() const {
             auto bufferScope = mScopes.constFind("Buffer");
             if(bufferScope == mScopes.cend()) return false;
             for(auto metricIt = bufferScope.value().cbegin(); metricIt != bufferScope.value().cend(); ++metricIt) {
@@ -407,15 +407,15 @@ namespace YSG {
             }
             return false;
         }
-        bool hasRenderAbleMetrics(const QString& objectName) const {
+        bool has_render_able_metrics(const QString& objectName) const {
             auto renderAbleScope = mScopes.constFind("RenderAble");
             if(renderAbleScope == mScopes.cend()) return false;
             for(auto metricIt = renderAbleScope.value().cbegin(); metricIt != renderAbleScope.value().cend(); ++metricIt) {
-                if(objectNameFromMetric(metricIt.key()) == objectName) return true;
+                if(object_name_from_metric(metricIt.key()) == objectName) return true;
             }
             return false;
         }
-        bool hasObjectBufferMetrics(const QString& objectName, const QString& bufferName) const {
+        bool has_object_buffer_metrics(const QString& objectName, const QString& bufferName) const {
             auto bufferScope = mScopes.constFind("Buffer");
             if(bufferScope == mScopes.cend()) return false;
             QString prefix = objectName + "." + bufferName + ".";
@@ -424,28 +424,28 @@ namespace YSG {
             }
             return false;
         }
-        bool metricVisible(const QString& scope, const QString& key) const {
+        bool metric_visible(const QString& scope, const QString& key) const {
             if(mSelectedGroup == "Plot") {
                 if(mSelectedTarget == "Pipeline") return scope == "Pipeline";
                 if(mSelectedTarget == "General") return scope == "General";
                 return mSelectedTarget == "Color" && scope == "Buffer" && key.startsWith("Color.");
             }
-            if(mSelectedTarget == "RenderAble") return scope == "RenderAble" && objectNameFromMetric(key) == mSelectedGroup;
+            if(mSelectedTarget == "RenderAble") return scope == "RenderAble" && object_name_from_metric(key) == mSelectedGroup;
             return scope == "Buffer" && key.startsWith(mSelectedGroup + "." + mSelectedTarget + ".");
         }
-        QString displayMetricName(const QString& key) const {
+        QString display_metric_name(const QString& key) const {
             if(mSelectedGroup == "Plot" && mSelectedTarget == "Color") return key.mid(QString("Color.").size());
             if(mSelectedGroup != "Plot" && mSelectedTarget == "RenderAble") return key.mid(mSelectedGroup.size() + 1);
             if(mSelectedGroup != "Plot") return key.mid((mSelectedGroup + "." + mSelectedTarget + ".").size());
             return key;
         }
-        void rebuildLines() {
-            rebuildViews();
+        void rebuild_lines() {
+            rebuild_views();
             QVector<QString> lines;
             for(auto scopeIt = mScopes.begin(); scopeIt != mScopes.end(); ++scopeIt) {
                 for(auto metricIt = scopeIt.value().begin(); metricIt != scopeIt.value().end(); ++metricIt) {
-                    if(metricVisible(scopeIt.key(), metricIt.key())) {
-                        lines.append(metricIt.value().toString(displayMetricName(metricIt.key())));
+                    if(metric_visible(scopeIt.key(), metricIt.key())) {
+                        lines.append(metricIt.value().to_string(display_metric_name(metricIt.key())));
                     }
                 }
             }
@@ -473,7 +473,7 @@ namespace YSG {
         ~Cacl() {
             if(!mPerformanceShower || !mPerformanceShower->enabled()) return;
             double useTime = std::chrono::duration<double>(std::chrono::steady_clock::now() - mStart).count() * 1000;
-            mPerformanceShower->recordDuration(mScope, mName, useTime);
+            mPerformanceShower->record_duration(mScope, mName, useTime);
         }
     };
 }
diff --git a/YSGraphic_Core/base/Plot.cpp b/YSGraphic_Core/base/Plot.cpp
index 288918e..e164bc1 100644
--- a/YSGraphic_Core/base/Plot.cpp
+++ b/YSGraphic_Core/base/Plot.cpp
@@ -5,13 +5,13 @@
 #include <chrono>
 
 namespace YSG {
-    static std::uint64_t steadyNowNs() {
+    static std::uint64_t steady_now_ns() {
         return static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count());
     }
-    static double elapsedMs(std::uint64_t startNs, std::uint64_t endNs) {
+    static double elapsed_ms(std::uint64_t startNs, std::uint64_t endNs) {
         return static_cast<double>(endNs - startNs) / 1000000.0;
     }
-    static QString jobStateText(RenderAble::JobState state) {
+    static QString job_state_text(RenderAble::JobState state) {
         switch(state) {
         case RenderAble::JobState::Idle:
             return "Idle";
@@ -22,14 +22,14 @@ namespace YSG {
         }
         return {};
     }
-    static QString renderAbleName(RenderAble* able) {
+    static QString render_able_name(RenderAble* able) {
         if(!able->mObjectName.isEmpty()) return able->mObjectName;
         return QString::number(reinterpret_cast<std::uintptr_t>(able), 16);
     }
-    static QString acquireModeText(Plot_Buffer_Acquire_Mode mode) {
+    static QString acquire_mode_text(Plot_Buffer_Acquire_Mode mode) {
         return mode == Plot_Buffer_Acquire_Mode::Wait ? "Wait" : "Try";
     }
-    static QString plotScheduleModeText(Plot_Render_Schedule_Mode mode) {
+    static QString plot_schedule_mode_text(Plot_Render_Schedule_Mode mode) {
         switch(mode) {
         case Plot_Render_Schedule_Mode::Timer_Check:
             return "Timer_Check";
@@ -42,7 +42,7 @@ namespace YSG {
         }
         return {};
     }
-    static QString renderAbleScheduleModeText(RenderAble_Render_Schedule_Mode mode) {
+    static QString render_able_schedule_mode_text(RenderAble_Render_Schedule_Mode mode) {
         switch(mode) {
         case RenderAble_Render_Schedule_Mode::Inherit:
             return "Inherit";
@@ -57,50 +57,50 @@ namespace YSG {
         }
         return {};
     }
-    static void publishTripleBufferStats(PerformanceShower* shower, const QString& name, const Triple_Buffer_Stats& stats) {
+    static void publish_triple_buffer_stats(PerformanceShower* shower, const QString& name, const Triple_Buffer_Stats& stats) {
         if(!shower || !shower->enabled()) return;
-        shower->setGauge("Buffer", name + ".markSuccess", static_cast<double>(stats.mark_success.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".markBusy", static_cast<double>(stats.mark_busy.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".markStateChanged", static_cast<double>(stats.mark_state_changed.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".swapSuccess", static_cast<double>(stats.swap_success.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".swapBusy", static_cast<double>(stats.swap_busy.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".swapStateChanged", static_cast<double>(stats.swap_state_changed.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".swapNoNeed", static_cast<double>(stats.swap_condition_failed.load(std::memory_order_relaxed)));
-        shower->setGauge("Buffer", name + ".wait", static_cast<double>(stats.wait_count.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".markSuccess", static_cast<double>(stats.mark_success.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".markBusy", static_cast<double>(stats.mark_busy.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".markStateChanged", static_cast<double>(stats.mark_state_changed.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".swapSuccess", static_cast<double>(stats.swap_success.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".swapBusy", static_cast<double>(stats.swap_busy.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".swapStateChanged", static_cast<double>(stats.swap_state_changed.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".swapNoNeed", static_cast<double>(stats.swap_condition_failed.load(std::memory_order_relaxed)));
+        shower->set_gauge("Buffer", name + ".wait", static_cast<double>(stats.wait_count.load(std::memory_order_relaxed)));
     }
-    static void publishRenderAbleBufferStats(PerformanceShower* shower, RenderAble* able) {
+    static void publish_render_able_buffer_stats(PerformanceShower* shower, RenderAble* able) {
         if(!shower || !shower->enabled()) return;
         if(able == shower) return;
-        QString name = renderAbleName(able);
-        shower->setState("RenderAble", name + ".bufferAcquireMode", acquireModeText(able->bufferAcquireMode()));
-        shower->setState("RenderAble", name + ".renderScheduleMode", renderAbleScheduleModeText(able->renderScheduleMode()));
-        shower->setGauge("RenderAble", name + ".renderScheduleMaxFps", able->renderScheduleMaxFps());
-        publishTripleBufferStats(shower, name + ".State", able->dPtr->mStateBufferStats);
-        publishTripleBufferStats(shower, name + ".Input", able->dPtr->mInputBufferStats);
+        QString name = render_able_name(able);
+        shower->set_state("RenderAble", name + ".buffer_acquire_mode", acquire_mode_text(able->buffer_acquire_mode()));
+        shower->set_state("RenderAble", name + ".render_schedule_mode", render_able_schedule_mode_text(able->render_schedule_mode()));
+        shower->set_gauge("RenderAble", name + ".render_schedule_max_fps", able->render_schedule_max_fps());
+        publish_triple_buffer_stats(shower, name + ".State", able->dPtr->mStateBufferStats);
+        publish_triple_buffer_stats(shower, name + ".Input", able->dPtr->mInputBufferStats);
     }
-    static void publishPipelineStats(PlotPrivate* data) {
+    static void publish_pipeline_stats(PlotPrivate* data) {
         PerformanceShower* shower = data->mShower;
         if(!shower || !shower->enabled()) return;
         RenderAble::RenderPipeline& pipeline = data->mPipeline;
-        shower->setState("Pipeline", "jobState", jobStateText(pipeline.jobState));
-        shower->setState("Pipeline", "renderScheduleMode", plotScheduleModeText(data->mRenderScheduleMode.load(std::memory_order_acquire)));
-        shower->setState("Pipeline", "paintBufferAcquireMode", acquireModeText(data->mPaintBufferAcquireMode.load(std::memory_order_acquire)));
-        shower->setState("Pipeline", "renderAbleDefaultAcquireMode", acquireModeText(data->mRenderAbleBufferAcquireMode.load(std::memory_order_acquire)));
-        shower->setGauge("Pipeline", "renderCheckFps", static_cast<double>(data->mRefreshTimesPreSecond));
-        shower->setGauge("Pipeline", "maxRenderFps", data->mMaxRenderFps.load(std::memory_order_acquire));
-        shower->setGauge("Pipeline", "activeRenderTasks", data->mActiveRenderTasks.load(std::memory_order_acquire));
-        shower->setGauge("Pipeline", "renderEnabled", data->mRenderEnabled.load(std::memory_order_acquire) ? 1.0 : 0.0);
-        shower->setGauge("Pipeline", "renderSubmitPending", data->mRenderSubmitPending.load(std::memory_order_acquire) ? 1.0 : 0.0);
-        shower->setGauge("Pipeline", "paintRequestPending", pipeline.paintRequestPending.load(std::memory_order_acquire) ? 1.0 : 0.0);
-        shower->setGauge("Pipeline", "editStateVersion", static_cast<double>(pipeline.editStateVersion.load(std::memory_order_acquire)));
-        shower->setGauge("Pipeline", "renderStateVersion", static_cast<double>(pipeline.renderStateVersion));
-        publishTripleBufferStats(shower, "Color", pipeline.colorBufferStats);
+        shower->set_state("Pipeline", "jobState", job_state_text(pipeline.jobState));
+        shower->set_state("Pipeline", "render_schedule_mode", plot_schedule_mode_text(data->mRenderScheduleMode.load(std::memory_order_acquire)));
+        shower->set_state("Pipeline", "paint_buffer_acquire_mode", acquire_mode_text(data->mPaintBufferAcquireMode.load(std::memory_order_acquire)));
+        shower->set_state("Pipeline", "renderAbleDefaultAcquireMode", acquire_mode_text(data->mRenderAbleBufferAcquireMode.load(std::memory_order_acquire)));
+        shower->set_gauge("Pipeline", "render_check_fps", static_cast<double>(data->mRefreshTimesPreSecond));
+        shower->set_gauge("Pipeline", "max_render_fps", data->mMaxRenderFps.load(std::memory_order_acquire));
+        shower->set_gauge("Pipeline", "activeRenderTasks", data->mActiveRenderTasks.load(std::memory_order_acquire));
+        shower->set_gauge("Pipeline", "renderEnabled", data->mRenderEnabled.load(std::memory_order_acquire) ? 1.0 : 0.0);
+        shower->set_gauge("Pipeline", "renderSubmitPending", data->mRenderSubmitPending.load(std::memory_order_acquire) ? 1.0 : 0.0);
+        shower->set_gauge("Pipeline", "paintRequestPending", pipeline.paintRequestPending.load(std::memory_order_acquire) ? 1.0 : 0.0);
+        shower->set_gauge("Pipeline", "editStateVersion", static_cast<double>(pipeline.editStateVersion.load(std::memory_order_acquire)));
+        shower->set_gauge("Pipeline", "renderStateVersion", static_cast<double>(pipeline.renderStateVersion));
+        publish_triple_buffer_stats(shower, "Color", pipeline.colorBufferStats);
     }
-    static void notifyRenderTaskDone(PlotPrivate* data) {
+    static void notify_render_task_done(PlotPrivate* data) {
         if(data->mActiveRenderTasks.fetch_sub(1, std::memory_order_acq_rel) == 1) data->mRenderTaskDone.notify_all();
     }
-    void startRenderScheduler() {
-        Global::instance()->startRenderScheduler();
+    void start_render_scheduler() {
+        Global::instance()->start_render_scheduler();
     }
 
     Plot::Plot() {
@@ -110,10 +110,10 @@ namespace YSG {
         setFocusPolicy(Qt::NoFocus);
         Global::instance()->renderScheduler().registerPlot(this);
     }
-    bool Plot::usePerformanceShower() {
+    bool Plot::use_performance_shower() {
         return d->mShower && d->mShower->enabled();
     }
-    void Plot::set_usePerformanceShower(bool use) {
+    void Plot::set_use_performance_shower(bool use) {
         if(!d->mShower) {
             d->mShower = new PerformanceShower;
             d->mShower->init(this, "legend");
@@ -136,16 +136,16 @@ namespace YSG {
         delete d;
     }
 
-    bool Plot::isRendering() {
+    bool Plot::is_rendering() {
         return d->mRenderEnabled.load(std::memory_order_acquire);
     }
 
-    void Plot::startRender(int refreshTimesPreSecond) {
-        setRenderCheckFps(refreshTimesPreSecond);
-        startRender();
+    void Plot::start_render(int refreshTimesPreSecond) {
+        set_render_check_fps(refreshTimesPreSecond);
+        start_render();
     }
 
-    void Plot::startRender() const {
+    void Plot::start_render() const {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
         d->mRenderEnabled.store(true, std::memory_order_release);
         Plot* self = const_cast<Plot*>(this);
@@ -156,15 +156,15 @@ namespace YSG {
             if(!d->mDestroying.load(std::memory_order_acquire)) {
                 if(d->mRenderTimer) {
                     d->mRenderTimer->cancel();
-                    self->scheduleRenderTimer();
+                    self->schedule_render_timer();
                 }
-                self->onRenderRequest(Render_Request_Source::Dirty);
+                self->on_render_request(Render_Request_Source::Dirty);
             }
-            notifyRenderTaskDone(privateData);
+            notify_render_task_done(privateData);
         });
     }
 
-    void Plot::pauseRender() const {
+    void Plot::pause_render() const {
         d->mRenderEnabled.store(false, std::memory_order_release);
         if(d->mDestroying.load(std::memory_order_acquire)) return;
         Plot* self = const_cast<Plot*>(this);
@@ -182,136 +182,136 @@ namespace YSG {
                     d->mRenderSubmitPending.store(false, std::memory_order_release);
                 }
             }
-            notifyRenderTaskDone(privateData);
+            notify_render_task_done(privateData);
         });
     }
 
     void Plot::paintEvent(QPaintEvent* event) {
         Q_UNUSED(event)
         Cacl paintData("Pipeline", "paintEvent", d->mShower);
-        std::uint64_t paintNs = steadyNowNs();
+        std::uint64_t paintNs = steady_now_ns();
         std::uint64_t updateRequestNs = d->mLastUpdateRequestNs.exchange(0, std::memory_order_acq_rel);
-        if(updateRequestNs && d->mShower) d->mShower->recordDuration("Pipeline", "updateToPaint", elapsedMs(updateRequestNs, paintNs));
+        if(updateRequestNs && d->mShower) d->mShower->record_duration("Pipeline", "updateToPaint", elapsed_ms(updateRequestNs, paintNs));
         QPainter painter(this);
         auto mode = to_triple_buffer_mode(d->mPaintBufferAcquireMode.load(std::memory_order_acquire));
         RenderAble::ColorBufferLease colorLease;
         {
             Cacl consumeData("Buffer", "Color.consumeReady", d->mShower);
-            colorLease = d->mPipeline.consumeReadyColor(mode);
+            colorLease = d->mPipeline.consume_ready_color(mode);
         }
         RenderAble::ColorBuffer* color = colorLease.buffer;
         if(color && !color->image.isNull()) painter.drawImage(QPoint(0, 0), color->image);
         else painter.fillRect(rect(), d->mBackground);
-        if(colorLease) d->mPipeline.unmarkColor(colorLease);
+        if(colorLease) d->mPipeline.unmark_color(colorLease);
         for(Layer* layer : mLayerList) {
             for(RenderAble* able : layer->mRenderAbles) {
-                if(!able->mVisable || !able->dPtr->independentPixelCache()) continue;
-                auto pixelLease = able->dPtr->consumeReadyPixel(Triple_Buffer_Mode::Try);
+                if(!able->mVisable || !able->dPtr->independent_pixel_cache()) continue;
+                auto pixelLease = able->dPtr->consume_ready_pixel(Triple_Buffer_Mode::Try);
                 if(pixelLease && !pixelLease.buffer->image.isNull()) painter.drawImage(QPoint(0, 0), pixelLease.buffer->image);
-                if(pixelLease) able->dPtr->unmarkPixel(pixelLease);
+                if(pixelLease) able->dPtr->unmark_pixel(pixelLease);
             }
         }
         painter.end();
         if(d->mShower) {
-            if(colorLease) d->mShower->incrementCounter("Buffer", "Color.frontLeaseSuccess");
-            else d->mShower->incrementCounter("Buffer", "Color.frontLeaseMiss");
-            d->mShower->incrementCounter("Pipeline", "paint");
-            publishPipelineStats(d);
+            if(colorLease) d->mShower->increment_counter("Buffer", "Color.frontLeaseSuccess");
+            else d->mShower->increment_counter("Buffer", "Color.frontLeaseMiss");
+            d->mShower->increment_counter("Pipeline", "paint");
+            publish_pipeline_stats(d);
         }
     }
     void Plot::render() {
-        requestRender(Render_Request_Source::Manual);
+        request_render(Render_Request_Source::Manual);
     }
-    Plot_Buffer_Acquire_Mode Plot::paintBufferAcquireMode() const {
+    Plot_Buffer_Acquire_Mode Plot::paint_buffer_acquire_mode() const {
         return d->mPaintBufferAcquireMode.load(std::memory_order_acquire);
     }
-    void Plot::setPaintBufferAcquireMode(Plot_Buffer_Acquire_Mode mode) {
+    void Plot::set_paint_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode) {
         d->mPaintBufferAcquireMode.store(mode, std::memory_order_release);
     }
-    Plot_Buffer_Acquire_Mode Plot::renderAbleBufferAcquireMode() const {
+    Plot_Buffer_Acquire_Mode Plot::render_able_buffer_acquire_mode() const {
         return d->mRenderAbleBufferAcquireMode.load(std::memory_order_acquire);
     }
-    void Plot::setRenderAbleBufferAcquireMode(Plot_Buffer_Acquire_Mode mode) {
+    void Plot::set_render_able_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode) {
         d->mRenderAbleBufferAcquireMode.store(mode, std::memory_order_release);
     }
-    Plot_Render_Schedule_Mode Plot::renderScheduleMode() const {
+    Plot_Render_Schedule_Mode Plot::render_schedule_mode() const {
         return d->mRenderScheduleMode.load(std::memory_order_acquire);
     }
-    void Plot::setRenderScheduleMode(Plot_Render_Schedule_Mode mode) {
+    void Plot::set_render_schedule_mode(Plot_Render_Schedule_Mode mode) {
         d->mRenderScheduleMode.store(mode, std::memory_order_release);
-        if(mode == Plot_Render_Schedule_Mode::Max_Fps && d->mMaxRenderFps.load(std::memory_order_acquire) <= 0.0) d->mMaxRenderFps.store(renderCheckFps(), std::memory_order_release);
-        requestRender(Render_Request_Source::Dirty);
+        if(mode == Plot_Render_Schedule_Mode::Max_Fps && d->mMaxRenderFps.load(std::memory_order_acquire) <= 0.0) d->mMaxRenderFps.store(render_check_fps(), std::memory_order_release);
+        request_render(Render_Request_Source::Dirty);
     }
-    double Plot::renderCheckFps() const {
+    double Plot::render_check_fps() const {
         return static_cast<double>(d->mRefreshTimesPreSecond);
     }
-    void Plot::setRenderCheckFps(double fps) {
+    void Plot::set_render_check_fps(double fps) {
         d->mRefreshTimesPreSecond = qMax(1, qRound(fps));
     }
-    double Plot::maxRenderFps() const {
+    double Plot::max_render_fps() const {
         return d->mMaxRenderFps.load(std::memory_order_acquire);
     }
-    void Plot::setMaxRenderFps(double fps) {
+    void Plot::set_max_render_fps(double fps) {
         d->mMaxRenderFps.store(fps, std::memory_order_release);
     }
-    bool Plot::submitRenderOnce() {
+    bool Plot::submit_render_once() {
         RenderScheduler& scheduler = Global::instance()->renderScheduler();
         if(!scheduler.isSchedulerThread()) {
             PlotPrivate* privateData = d;
-            std::uint64_t postNs = steadyNowNs();
+            std::uint64_t postNs = steady_now_ns();
             privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
             scheduler.post([this, privateData, postNs]() {
-                if(privateData->mShower) privateData->mShower->recordDuration("Pipeline", "schedulerQueueWait", elapsedMs(postNs, steadyNowNs()));
-                if(!privateData->mDestroying.load(std::memory_order_acquire)) submitRenderOnce();
-                notifyRenderTaskDone(privateData);
+                if(privateData->mShower) privateData->mShower->record_duration("Pipeline", "schedulerQueueWait", elapsed_ms(postNs, steady_now_ns()));
+                if(!privateData->mDestroying.load(std::memory_order_acquire)) submit_render_once();
+                notify_render_task_done(privateData);
             });
             return false;
         }
         if(d->mDestroying.load(std::memory_order_acquire)) return false;
-        std::uint64_t submitNs = steadyNowNs();
+        std::uint64_t submitNs = steady_now_ns();
         Render_Request_Source source = d->mSubmitSource;
         std::uint64_t requestNs = d->mLastRequestNs.exchange(0, std::memory_order_acq_rel);
-        if(requestNs && d->mShower) d->mShower->recordDuration("Pipeline", "requestToSubmit", elapsedMs(requestNs, submitNs));
+        if(requestNs && d->mShower) d->mShower->record_duration("Pipeline", "requestToSubmit", elapsed_ms(requestNs, submitNs));
         if(mFirstResize) return false;
         if(!d->mRenderEnabled.load(std::memory_order_acquire)) return false;
         QSize renderSize = d->mRenderSize;
         if(renderSize.width() <= 0 || renderSize.height() <= 0) return false;
         RenderAble::RenderPipeline& pipeline = d->mPipeline;
         if(pipeline.jobState != RenderAble::JobState::Idle) return false;
-        if(!hasSubmitCandidate(source, submitNs)) return false;
+        if(!has_submit_candidate(source, submitNs)) return false;
         pipeline.jobState = RenderAble::JobState::Queued;
         pipeline.renderStateVersion = pipeline.editStateVersion.load(std::memory_order_acquire);
         if(d->mShower) {
-            d->mShower->incrementCounter("Pipeline", "renderFrame");
-            d->mShower->setInfo("interval", QString("渲染：%1, global：%2").arg(qRound(1000.0 / (double)d->mRefreshTimesPreSecond)).arg(Global::instance()->mInterval));
-            publishPipelineStats(d);
+            d->mShower->increment_counter("Pipeline", "renderFrame");
+            d->mShower->set_info("interval", QString("渲染：%1, global：%2").arg(qRound(1000.0 / (double)d->mRefreshTimesPreSecond)).arg(Global::instance()->mInterval));
+            publish_pipeline_stats(d);
         }
         {
-            Cacl prepareData("Pipeline", "prepareData", d->mShower);
+            Cacl prepare_data("Pipeline", "prepare_data", d->mShower);
             for(Layer* layer : mLayerList) {
                 for(RenderAble *cur : layer->mRenderAbles) {
                     for(auto rely : cur->mBeRelyList) {
-                        if(rely->dPtr->independentPixelCache()) continue;
-                        if(!renderAbleReadyForSubmit(rely, source, submitNs, false)) continue;
+                        if(rely->dPtr->independent_pixel_cache()) continue;
+                        if(!render_able_ready_for_submit(rely, source, submitNs, false)) continue;
                         if(!rely->mPrepared){
                             {
-                                Cacl renderAblePrepare("RenderAble", renderAbleName(rely) + ".prepareData", d->mShower);
-                                rely->prepareData();
+                                Cacl renderAblePrepare("RenderAble", render_able_name(rely) + ".prepare_data", d->mShower);
+                                rely->prepare_data();
                             }
-                            markRenderAbleSubmitted(rely, submitNs);
-                            publishRenderAbleBufferStats(d->mShower, rely);
+                            mark_render_able_submitted(rely, submitNs);
+                            publish_render_able_buffer_stats(d->mShower, rely);
                             rely->mPrepared = true;
                         }
                     }
-                    if(cur->dPtr->independentPixelCache()) continue;
-                    if(!renderAbleReadyForSubmit(cur, source, submitNs, false)) continue;
+                    if(cur->dPtr->independent_pixel_cache()) continue;
+                    if(!render_able_ready_for_submit(cur, source, submitNs, false)) continue;
                     if(!cur->mPrepared){
                         {
-                            Cacl renderAblePrepare("RenderAble", renderAbleName(cur) + ".prepareData", d->mShower);
-                            cur->prepareData();
+                            Cacl renderAblePrepare("RenderAble", render_able_name(cur) + ".prepare_data", d->mShower);
+                            cur->prepare_data();
                             }
-                            markRenderAbleSubmitted(cur, submitNs);
-                            publishRenderAbleBufferStats(d->mShower, cur);
+                            mark_render_able_submitted(cur, submitNs);
+                            publish_render_able_buffer_stats(d->mShower, cur);
                         cur->mPrepared = true;
                     }
                 }
@@ -325,86 +325,86 @@ namespace YSG {
         }
         RenderAble::ColorBufferLease colorLease;
         {
-            Cacl waitRenderColor("Buffer", "Color.waitRenderLease", d->mShower);
-            colorLease = pipeline.waitRenderColor();
+            Cacl wait_render_color("Buffer", "Color.waitRenderLease", d->mShower);
+            colorLease = pipeline.wait_render_color();
         }
         RenderAble::ColorBuffer* color = colorLease.buffer;
         QColor background = d->mBackground;
         std::uint64_t version = pipeline.renderStateVersion;
         pipeline.jobState = RenderAble::JobState::Running;
-        if(d->mShower) publishPipelineStats(d);
+        if(d->mShower) publish_pipeline_stats(d);
         PlotPrivate* privateData = d;
-        std::uint64_t cpuPostNs = steadyNowNs();
+        std::uint64_t cpuPostNs = steady_now_ns();
         privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
         scheduler.postCpu([this, privateData, colorLease, color, renderSize, background, version, cpuPostNs]() {
-            if(privateData->mShower) privateData->mShower->recordDuration("Pipeline", "cpuQueueWait", elapsedMs(cpuPostNs, steadyNowNs()));
+            if(privateData->mShower) privateData->mShower->record_duration("Pipeline", "cpuQueueWait", elapsed_ms(cpuPostNs, steady_now_ns()));
             if(privateData->mDestroying.load(std::memory_order_acquire)) {
-                privateData->mPipeline.unmarkColor(colorLease);
-                notifyRenderTaskDone(privateData);
+                privateData->mPipeline.unmark_color(colorLease);
+                notify_render_task_done(privateData);
                 return;
             }
-            renderColor(color, renderSize, background, version);
-            privateData->mPipeline.unmarkColor(colorLease);
+            render_color(color, renderSize, background, version);
+            privateData->mPipeline.unmark_color(colorLease);
             if(privateData->mDestroying.load(std::memory_order_acquire)) {
-                notifyRenderTaskDone(privateData);
+                notify_render_task_done(privateData);
                 return;
             }
             Global::instance()->renderScheduler().post([this, privateData]() {
-                if(!privateData->mDestroying.load(std::memory_order_acquire)) finishRender();
-                notifyRenderTaskDone(privateData);
+                if(!privateData->mDestroying.load(std::memory_order_acquire)) finish_render();
+                notify_render_task_done(privateData);
             });
         });
         return true;
     }
-    void Plot::onRenderRequest(Render_Request_Source source) {
+    void Plot::on_render_request(Render_Request_Source source) {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
         Plot_Render_Schedule_Mode mode = d->mRenderScheduleMode.load(std::memory_order_acquire);
         d->mSubmitSource = source;
         switch(mode) {
         case Plot_Render_Schedule_Mode::Timer_Check:
-            if(source == Render_Request_Source::Timer) submitRenderOnce();
+            if(source == Render_Request_Source::Timer) submit_render_once();
             break;
         case Plot_Render_Schedule_Mode::Chase_Latest:
-            submitRenderOnce();
+            submit_render_once();
             break;
         case Plot_Render_Schedule_Mode::Max_Fps:
-            submitRenderWithFpsLimit();
+            submit_render_with_fps_limit();
             break;
         case Plot_Render_Schedule_Mode::Manual:
-            if(source == Render_Request_Source::Manual) submitRenderOnce();
+            if(source == Render_Request_Source::Manual) submit_render_once();
             break;
         }
         for(Layer* layer : mLayerList) {
             for(RenderAble* able : layer->mRenderAbles) {
-                if(able->mVisable && able->dPtr->independentPixelCache() && able->dPtr->hasNewPixelState()) submitIndependentRender(able, source);
+                if(able->mVisable && able->dPtr->independent_pixel_cache() && able->dPtr->has_new_pixel_state()) submit_independent_render(able, source);
             }
         }
-        if(d->mShower) publishPipelineStats(d);
+        if(d->mShower) publish_pipeline_stats(d);
     }
-    bool Plot::submitRenderWithFpsLimit() {
+    bool Plot::submit_render_with_fps_limit() {
         double fps = d->mMaxRenderFps.load(std::memory_order_acquire);
-        if(fps <= 0.0) return submitRenderOnce();
-        std::uint64_t now = steadyNowNs();
+        if(fps <= 0.0) return submit_render_once();
+        std::uint64_t now = steady_now_ns();
         std::uint64_t intervalNs = static_cast<std::uint64_t>(1000000000.0 / fps);
         if(now < d->mNextSubmitNs) {
             d->mRenderSubmitPending.store(true, std::memory_order_release);
-            scheduleMaxFpsSubmit(d->mNextSubmitNs);
+            schedule_max_fps_submit(d->mNextSubmitNs);
             return false;
         }
-        bool submitted = submitRenderOnce();
+        bool submitted = submit_render_once();
         if(submitted) {
             d->mNextSubmitNs = now + intervalNs;
             d->mRenderSubmitPending.store(false, std::memory_order_release);
-        } else if(!d->mPipeline.hasNewState()) {
+        } else if(!d->mPipeline.has_new_state()) {
             d->mRenderSubmitPending.store(false, std::memory_order_release);
         }
         return submitted;
     }
-    void Plot::scheduleMaxFpsSubmit(std::uint64_t targetNs) {
+    void Plot::schedule_max_fps_submit(std::uint64_t targetNs) {
         if(!d->mSubmitTimer || !d->mRenderEnabled.load(std::memory_order_acquire)) return;
         if(d->mSubmitTimerTargetNs && d->mSubmitTimerTargetNs <= targetNs) return;
         d->mSubmitTimerTargetNs = targetNs;
-        std::uint64_t now = steadyNowNs();
+        std::uint64_t now = steady_now_ns();
         std::uint64_t delayNs = targetNs > now ? targetNs - now : 0;
         d->mSubmitTimer->expires_after(std::chrono::nanoseconds(delayNs));
         PlotPrivate* privateData = d;
@@ -412,24 +412,24 @@ namespace YSG {
         d->mSubmitTimer->async_wait([this, privateData, targetNs](const asio::error_code& error) {
             if(!error && !privateData->mDestroying.load(std::memory_order_acquire) && privateData->mSubmitTimerTargetNs == targetNs) {
                 privateData->mSubmitTimerTargetNs = 0;
-                if(privateData->mRenderSubmitPending.load(std::memory_order_acquire)) onRenderRequest(privateData->mSubmitSource);
+                if(privateData->mRenderSubmitPending.load(std::memory_order_acquire)) on_render_request(privateData->mSubmitSource);
             }
-            notifyRenderTaskDone(privateData);
+            notify_render_task_done(privateData);
         });
     }
-    bool Plot::hasSubmitCandidate(Render_Request_Source source, std::uint64_t nowNs) {
+    bool Plot::has_submit_candidate(Render_Request_Source source, std::uint64_t nowNs) {
         if(mFirstPrepareData) return true;
         for(Layer* layer : mLayerList) {
             for(RenderAble* able : layer->mRenderAbles) {
-                if(!able->mVisable || able->dPtr->independentPixelCache()) continue;
-                if(able->dPtr->hasPendingRenderData() && renderAbleReadyForSubmit(able, source, nowNs, false)) return true;
+                if(!able->mVisable || able->dPtr->independent_pixel_cache()) continue;
+                if(able->dPtr->has_pending_render_data() && render_able_ready_for_submit(able, source, nowNs, false)) return true;
             }
         }
         return false;
     }
-    bool Plot::renderAbleReadyForSubmit(RenderAble* able, Render_Request_Source source, std::uint64_t nowNs, bool independent) {
+    bool Plot::render_able_ready_for_submit(RenderAble* able, Render_Request_Source source, std::uint64_t nowNs, bool independent) {
         Q_UNUSED(independent)
-        RenderAble_Render_Schedule_Mode mode = able->renderScheduleMode();
+        RenderAble_Render_Schedule_Mode mode = able->render_schedule_mode();
         if(mode == RenderAble_Render_Schedule_Mode::Inherit) {
             switch(d->mRenderScheduleMode.load(std::memory_order_acquire)) {
             case Plot_Render_Schedule_Mode::Timer_Check:
@@ -448,12 +448,12 @@ namespace YSG {
         case RenderAble_Render_Schedule_Mode::Chase_Latest:
             return true;
         case RenderAble_Render_Schedule_Mode::Max_Fps: {
-            double fps = able->renderScheduleMaxFps();
+            double fps = able->render_schedule_max_fps();
             if(fps <= 0.0) return true;
             std::uint64_t nextNs = able->dPtr->mNextRenderSubmitNs.load(std::memory_order_acquire);
             if(nowNs >= nextNs) return true;
             d->mRenderSubmitPending.store(true, std::memory_order_release);
-            scheduleMaxFpsSubmit(nextNs);
+            schedule_max_fps_submit(nextNs);
             return false;
         }
         case RenderAble_Render_Schedule_Mode::On_Dirty:
@@ -463,27 +463,27 @@ namespace YSG {
         }
         return true;
     }
-    void Plot::markRenderAbleSubmitted(RenderAble* able, std::uint64_t nowNs) {
-        if(able->renderScheduleMode() != RenderAble_Render_Schedule_Mode::Max_Fps) return;
-        double fps = able->renderScheduleMaxFps();
+    void Plot::mark_render_able_submitted(RenderAble* able, std::uint64_t nowNs) {
+        if(able->render_schedule_mode() != RenderAble_Render_Schedule_Mode::Max_Fps) return;
+        double fps = able->render_schedule_max_fps();
         if(fps <= 0.0) return;
         able->dPtr->mNextRenderSubmitNs.store(nowNs + static_cast<std::uint64_t>(1000000000.0 / fps), std::memory_order_release);
     }
-    void Plot::finishRender() {
+    void Plot::finish_render() {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
         RenderAble::RenderPipeline& pipeline = d->mPipeline;
         QRegion updateRegion;
         {
-            Cacl publishData("Pipeline", "publishRenderColor", d->mShower);
-            updateRegion = pipeline.publishRenderColor();
+            Cacl publishData("Pipeline", "publish_render_color", d->mShower);
+            updateRegion = pipeline.publish_render_color();
         }
         pipeline.jobState = RenderAble::JobState::Idle;
-        if(d->mShower) publishPipelineStats(d);
-        if(!updateRegion.isEmpty()) requestUpdate(updateRegion);
-        onRenderRequest(Render_Request_Source::Finish);
+        if(d->mShower) publish_pipeline_stats(d);
+        if(!updateRegion.isEmpty()) request_update(updateRegion);
+        on_render_request(Render_Request_Source::Finish);
     }
-    void Plot::renderColor(RenderAble::ColorBuffer* color, QSize size, QColor background, std::uint64_t version) {
-        Cacl renderData("Pipeline", "renderColor", d->mShower);
+    void Plot::render_color(RenderAble::ColorBuffer* color, QSize size, QColor background, std::uint64_t version) {
+        Cacl renderData("Pipeline", "render_color", d->mShower);
         if(color->image.size() != size || color->image.format() != QImage::Format_ARGB32) {
             color->image = QImage(size, QImage::Format_ARGB32);
         }
@@ -496,10 +496,10 @@ namespace YSG {
             Cacl drawData("Pipeline", "draw", d->mShower);
             for(Layer* layer : mLayerList) {
                 for(RenderAble* cur : layer->mRenderAbles) {
-                    if(!cur->mVisable || cur->dPtr->independentPixelCache()) continue;
-                    auto lease = cur->dPtr->markStateRole(State_Render);
+                    if(!cur->mVisable || cur->dPtr->independent_pixel_cache()) continue;
+                    auto lease = cur->dPtr->mark_state_role(State_Render);
                     if(!lease) {
-                        if(d->mShower) d->mShower->incrementCounter("RenderAble", renderAbleName(cur) + ".stateLeaseMiss");
+                        if(d->mShower) d->mShower->increment_counter("RenderAble", render_able_name(cur) + ".stateLeaseMiss");
                         continue;
                     }
                     leasedAbles.append(cur);
@@ -507,37 +507,37 @@ namespace YSG {
                 }
             }
             for(RenderAble* able : leasedAbles) {
-                Cacl renderAbleDraw("RenderAble", renderAbleName(able) + ".draw", d->mShower);
+                Cacl renderAbleDraw("RenderAble", render_able_name(able) + ".draw", d->mShower);
                 able->draw(&painter);
             }
         }
         for(int i = 0; i < leasedAbles.size(); ++i) {
-            leasedAbles[i]->dPtr->unmarkState(stateLeases[i]);
+            leasedAbles[i]->dPtr->unmark_state(stateLeases[i]);
         }
         painter.end();
         color->version.store(version, std::memory_order_release);
         color->dirtyRegion = QRegion(QRect(QPoint(0, 0), size));
     }
-    void Plot::markIndependentRenderDirty(RenderAble* able, Render_Request_Source source) {
+    void Plot::mark_independent_render_dirty(RenderAble* able, Render_Request_Source source) {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
         PlotPrivate* privateData = d;
         privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
         Global::instance()->renderScheduler().post([this, privateData, able, source]() {
-            if(!privateData->mDestroying.load(std::memory_order_acquire)) submitIndependentRender(able, source);
-            notifyRenderTaskDone(privateData);
+            if(!privateData->mDestroying.load(std::memory_order_acquire)) submit_independent_render(able, source);
+            notify_render_task_done(privateData);
         });
     }
-    void Plot::submitIndependentRender(RenderAble* able, Render_Request_Source source) {
+    void Plot::submit_independent_render(RenderAble* able, Render_Request_Source source) {
         RenderScheduler& scheduler = Global::instance()->renderScheduler();
         if(!scheduler.isSchedulerThread()) {
-            markIndependentRenderDirty(able, source);
+            mark_independent_render_dirty(able, source);
             return;
         }
         if(d->mDestroying.load(std::memory_order_acquire)) return;
-        if(!able || !able->mVisable || !able->dPtr->independentPixelCache()) return;
+        if(!able || !able->mVisable || !able->dPtr->independent_pixel_cache()) return;
         if(able->dPtr->mIndependentRenderQueued.exchange(true, std::memory_order_acq_rel)) return;
-        std::uint64_t now = steadyNowNs();
-        if(!renderAbleReadyForSubmit(able, source, now, true)) {
+        std::uint64_t now = steady_now_ns();
+        if(!render_able_ready_for_submit(able, source, now, true)) {
             able->dPtr->mIndependentRenderQueued.store(false, std::memory_order_release);
             return;
         }
@@ -546,55 +546,55 @@ namespace YSG {
             able->dPtr->mIndependentRenderQueued.store(false, std::memory_order_release);
             return;
         }
-        if(!able->dPtr->hasNewPixelState()) {
+        if(!able->dPtr->has_new_pixel_state()) {
             able->dPtr->mIndependentRenderQueued.store(false, std::memory_order_release);
             return;
         }
-        able->prepareData();
-        markRenderAbleSubmitted(able, now);
-        auto pixelLease = able->dPtr->waitRenderPixel();
+        able->prepare_data();
+        mark_render_able_submitted(able, now);
+        auto pixelLease = able->dPtr->wait_render_pixel();
         PixelBufferSlot* pixel = pixelLease.buffer;
         std::uint64_t version = able->dPtr->mPixelEditVersion.load(std::memory_order_acquire);
         PlotPrivate* privateData = d;
         privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
         scheduler.postCpu([this, privateData, able, pixelLease, pixel, renderSize, version]() {
             if(privateData->mDestroying.load(std::memory_order_acquire)) {
-                able->dPtr->unmarkPixel(pixelLease);
-                notifyRenderTaskDone(privateData);
+                able->dPtr->unmark_pixel(pixelLease);
+                notify_render_task_done(privateData);
                 return;
             }
-            renderIndependentColor(able, pixel, renderSize, version);
-            able->dPtr->unmarkPixel(pixelLease);
+            render_independent_color(able, pixel, renderSize, version);
+            able->dPtr->unmark_pixel(pixelLease);
             Global::instance()->renderScheduler().post([this, privateData, able]() {
-                if(!privateData->mDestroying.load(std::memory_order_acquire)) finishIndependentRender(able);
-                notifyRenderTaskDone(privateData);
+                if(!privateData->mDestroying.load(std::memory_order_acquire)) finish_independent_render(able);
+                notify_render_task_done(privateData);
             });
         });
     }
-    void Plot::renderIndependentColor(RenderAble* able, PixelBufferSlot* pixel, QSize size, std::uint64_t version) {
+    void Plot::render_independent_color(RenderAble* able, PixelBufferSlot* pixel, QSize size, std::uint64_t version) {
         if(pixel->image.size() != size || pixel->image.format() != QImage::Format_ARGB32) {
             pixel->image = QImage(size, QImage::Format_ARGB32);
         }
         pixel->image.detach();
         pixel->image.fill(Qt::transparent);
         QPainter painter(&pixel->image);
-        auto lease = able->dPtr->markStateRole(State_Render);
+        auto lease = able->dPtr->mark_state_role(State_Render);
         if(lease) {
             able->draw(&painter);
-            able->dPtr->unmarkState(lease);
+            able->dPtr->unmark_state(lease);
         }
         painter.end();
         pixel->version.store(version, std::memory_order_release);
         pixel->dirtyRegion = QRegion(QRect(QPoint(0, 0), size));
         able->dPtr->mPixelRenderVersion = version;
     }
-    void Plot::finishIndependentRender(RenderAble* able) {
-        QRegion updateRegion = able->dPtr->publishRenderPixel();
+    void Plot::finish_independent_render(RenderAble* able) {
+        QRegion updateRegion = able->dPtr->publish_render_pixel();
         able->dPtr->mIndependentRenderQueued.store(false, std::memory_order_release);
-        if(!updateRegion.isEmpty()) requestUpdate(updateRegion);
-        if(able->dPtr->hasNewPixelState()) submitIndependentRender(able, Render_Request_Source::Finish);
+        if(!updateRegion.isEmpty()) request_update(updateRegion);
+        if(able->dPtr->has_new_pixel_state()) submit_independent_render(able, Render_Request_Source::Finish);
     }
-    void Plot::scheduleRenderTimer() {
+    void Plot::schedule_render_timer() {
         if(d->mDestroying.load(std::memory_order_acquire) || !d->mRenderTimer || !d->mRenderEnabled.load(std::memory_order_acquire)) return;
         int interval = std::max(1, qRound(1000.0 / (double)d->mRefreshTimesPreSecond));
         d->mRenderTimer->expires_after(std::chrono::milliseconds(interval));
@@ -602,30 +602,30 @@ namespace YSG {
         privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
         d->mRenderTimer->async_wait([this, privateData](const asio::error_code& error) {
             if(!error && !d->mDestroying.load(std::memory_order_acquire)) {
-                if(d->mShower) d->mShower->incrementCounter("Pipeline", "timerTick");
-                onRenderRequest(Render_Request_Source::Timer);
-                scheduleRenderTimer();
+                if(d->mShower) d->mShower->increment_counter("Pipeline", "timerTick");
+                on_render_request(Render_Request_Source::Timer);
+                schedule_render_timer();
             }
-            notifyRenderTaskDone(privateData);
+            notify_render_task_done(privateData);
         });
     }
-    void Plot::markRenderStateDirty() {
+    void Plot::mark_render_state_dirty() {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
-        d->mPipeline.markEditState();
-        requestRender();
+        d->mPipeline.mark_edit_state();
+        request_render();
     }
-    void Plot::requestRender(Render_Request_Source source) {
+    void Plot::request_render(Render_Request_Source source) {
         if(d->mDestroying.load(std::memory_order_acquire)) return;
-        d->mLastRequestNs.store(steadyNowNs(), std::memory_order_release);
+        d->mLastRequestNs.store(steady_now_ns(), std::memory_order_release);
         PlotPrivate* privateData = d;
         privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
         Global::instance()->renderScheduler().post([this, privateData, source]() {
-            if(!d->mDestroying.load(std::memory_order_acquire)) onRenderRequest(source);
-            notifyRenderTaskDone(privateData);
+            if(!d->mDestroying.load(std::memory_order_acquire)) on_render_request(source);
+            notify_render_task_done(privateData);
         });
     }
-    void Plot::requestUpdate(const QRegion& region) {
-        d->mLastUpdateRequestNs.store(steadyNowNs(), std::memory_order_release);
+    void Plot::request_update(const QRegion& region) {
+        d->mLastUpdateRequestNs.store(steady_now_ns(), std::memory_order_release);
         QTimer::singleShot(0, this, [this, region]() {
             if(d->mDestroying.load(std::memory_order_acquire)) return;
             if(region.isEmpty()) update();
@@ -633,11 +633,11 @@ namespace YSG {
         });
     }
 
-    QColor Plot::backgroundColor() {
+    QColor Plot::background_color() {
         return d->mBackground;
     }
 
-    void Plot::setBackgroundColor(const QColor& color) const {
+    void Plot::set_background_color(const QColor& color) const {
         d->mBackground = color;
     }
 
@@ -653,12 +653,12 @@ namespace YSG {
             privateData->mActiveRenderTasks.fetch_add(1, std::memory_order_acq_rel);
             Global::instance()->renderScheduler().post([privateData, renderSize]() {
                 if(!privateData->mDestroying.load(std::memory_order_acquire)) privateData->mRenderSize = renderSize;
-                notifyRenderTaskDone(privateData);
+                notify_render_task_done(privateData);
             });
             if(mFirstResize) {
                 for(Layer* layer : mLayerList) {
                     for(RenderAble* able : layer->mRenderAbles) {
-                        able->firstResizeEvent(e);
+                        able->first_resize_event(e);
                     }
                 }
             }
@@ -668,15 +668,15 @@ namespace YSG {
                 }
             }
             if(mFirstResize) mFirstResize = false;
-            markRenderStateDirty();
+            mark_render_state_dirty();
             break;
         }
         case QEvent::Show: {
-            startRender();
+            start_render();
             break;
         }
         case QEvent::Hide: {
-            pauseRender();
+            pause_render();
             break;
         }
         case QEvent::Enter: {
@@ -685,7 +685,7 @@ namespace YSG {
         case QEvent::Leave: {
             for(Layer* layer : mLayerList) {
                 for(RenderAble* able : layer->mRenderAbles) {
-                    able->setHoverState(QPoint(), false);
+                    able->set_hover_state(QPoint(), false);
                 }
             }
             break;
@@ -703,8 +703,8 @@ namespace YSG {
             auto e = reinterpret_cast<QMouseEvent*>(event);
             for(Layer* layer : mLayerList) {
                 for(RenderAble* able : layer->mRenderAbles) {
-                    bool selected = able->selectTest(e->pos());
-                    able->setHoverState(e->pos(), selected);
+                    bool selected = able->select_test(e->pos());
+                    able->set_hover_state(e->pos(), selected);
                     if(selected) {
                         able->mouseMoveEvent(e);
                     }
@@ -716,7 +716,7 @@ namespace YSG {
             auto e = reinterpret_cast<QMouseEvent*>(event);
             for(Layer* layer : mLayerList) {
                 for(RenderAble* able : layer->mRenderAbles) {
-                    if(able->selectTest(e->pos())) {
+                    if(able->select_test(e->pos())) {
                         able->mousePressEvent(e);
                     }
                 }
@@ -727,7 +727,7 @@ namespace YSG {
             auto e = reinterpret_cast<QMouseEvent*>(event);
             for(Layer* layer : mLayerList) {
                 for(RenderAble* able : layer->mRenderAbles) {
-                    if(able->selectTest(e->pos())) {
+                    if(able->select_test(e->pos())) {
                         able->mouseReleaseEvent(e);
                     }
                 }
@@ -756,7 +756,7 @@ namespace YSG {
         }
         for(Layer* layer : mLayerList) {
             for(RenderAble* able : layer->mRenderAbles) {
-                able->plotEvent(event);
+                able->plot_event(event);
             }
         }
         return ret;
diff --git a/YSGraphic_Core/base/Plot.h b/YSGraphic_Core/base/Plot.h
index 2209d4e..1727ee9 100644
--- a/YSGraphic_Core/base/Plot.h
+++ b/YSGraphic_Core/base/Plot.h
@@ -3,35 +3,35 @@
 #include <QTime>
 #include "../RenderAble.h"
 namespace YSG {
-    void LIB_DECL startRenderScheduler();
+    void LIB_DECL start_render_scheduler();
     class RenderScheduler;
     struct PlotPrivate;
     class PerformanceShower;
     class LIB_DECL Plot : public QWidget {
         Q_OBJECT
     public:
-        bool usePerformanceShower();
-        void set_usePerformanceShower(bool use);
+        bool use_performance_shower();
+        void set_use_performance_shower(bool use);
 
         virtual void init() {
-            initLayer();
+            init_layer();
         }
         void render();
-        QColor backgroundColor();
+        QColor background_color();
         bool mFirstResize = true, mFirstPrepareData = true;
-        void setBackgroundColor(const QColor& color) const;
-        Plot_Buffer_Acquire_Mode paintBufferAcquireMode() const;
-        void setPaintBufferAcquireMode(Plot_Buffer_Acquire_Mode mode);
-        Plot_Buffer_Acquire_Mode renderAbleBufferAcquireMode() const;
-        void setRenderAbleBufferAcquireMode(Plot_Buffer_Acquire_Mode mode);
-        Plot_Render_Schedule_Mode renderScheduleMode() const;
-        void setRenderScheduleMode(Plot_Render_Schedule_Mode mode);
-        double renderCheckFps() const;
-        void setRenderCheckFps(double fps);
-        double maxRenderFps() const;
-        void setMaxRenderFps(double fps);
-        void markRenderStateDirty();
-        void requestRender(Render_Request_Source source = Render_Request_Source::Dirty);
+        void set_background_color(const QColor& color) const;
+        Plot_Buffer_Acquire_Mode paint_buffer_acquire_mode() const;
+        void set_paint_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode);
+        Plot_Buffer_Acquire_Mode render_able_buffer_acquire_mode() const;
+        void set_render_able_buffer_acquire_mode(Plot_Buffer_Acquire_Mode mode);
+        Plot_Render_Schedule_Mode render_schedule_mode() const;
+        void set_render_schedule_mode(Plot_Render_Schedule_Mode mode);
+        double render_check_fps() const;
+        void set_render_check_fps(double fps);
+        double max_render_fps() const;
+        void set_max_render_fps(double fps);
+        void mark_render_state_dirty();
+        void request_render(Render_Request_Source source = Render_Request_Source::Dirty);
         struct Layer {
             QString mLayerName;
             QVector<RenderAble*> mRenderAbles;
@@ -39,7 +39,7 @@ namespace YSG {
         QString mObjectName;
         QList<Layer*> mLayerList;
         QString mDefaultLayerName;
-        virtual void initLayer() {
+        virtual void init_layer() {
             auto addLayer = [this](QString&& name) {
                 auto layer = new Layer;
                 layer->mLayerName = name;
@@ -52,10 +52,10 @@ namespace YSG {
             addLayer("legend");
             mDefaultLayerName = "plottable";
         }
-        bool isRendering();
-        void startRender(int refreshTimesPreSecond);
-        void startRender() const;
-        void pauseRender() const;
+        bool is_rendering();
+        void start_render(int refreshTimesPreSecond);
+        void start_render() const;
+        void pause_render() const;
         Plot();
         ~Plot() override;
         PlotPrivate *d{};
@@ -63,21 +63,21 @@ namespace YSG {
         QHash<QString, Layer*> mLayerMap;
         bool event(QEvent* event) final;
         void paintEvent(QPaintEvent* event) final;
-        void scheduleRenderTimer();
-        bool submitRenderOnce();
-        void onRenderRequest(Render_Request_Source source);
-        bool submitRenderWithFpsLimit();
-        void scheduleMaxFpsSubmit(std::uint64_t targetNs);
-        bool hasSubmitCandidate(Render_Request_Source source, std::uint64_t nowNs);
-        bool renderAbleReadyForSubmit(RenderAble* able, Render_Request_Source source, std::uint64_t nowNs, bool independent);
-        void markRenderAbleSubmitted(RenderAble* able, std::uint64_t nowNs);
-        void finishRender();
-        void requestUpdate(const QRegion& region);
-        void renderColor(RenderAble::ColorBuffer* color, QSize size, QColor background, std::uint64_t version);
-        void markIndependentRenderDirty(RenderAble* able, Render_Request_Source source = Render_Request_Source::Dirty);
-        void submitIndependentRender(RenderAble* able, Render_Request_Source source);
-        void renderIndependentColor(RenderAble* able, PixelBufferSlot* pixel, QSize size, std::uint64_t version);
-        void finishIndependentRender(RenderAble* able);
+        void schedule_render_timer();
+        bool submit_render_once();
+        void on_render_request(Render_Request_Source source);
+        bool submit_render_with_fps_limit();
+        void schedule_max_fps_submit(std::uint64_t targetNs);
+        bool has_submit_candidate(Render_Request_Source source, std::uint64_t nowNs);
+        bool render_able_ready_for_submit(RenderAble* able, Render_Request_Source source, std::uint64_t nowNs, bool independent);
+        void mark_render_able_submitted(RenderAble* able, std::uint64_t nowNs);
+        void finish_render();
+        void request_update(const QRegion& region);
+        void render_color(RenderAble::ColorBuffer* color, QSize size, QColor background, std::uint64_t version);
+        void mark_independent_render_dirty(RenderAble* able, Render_Request_Source source = Render_Request_Source::Dirty);
+        void submit_independent_render(RenderAble* able, Render_Request_Source source);
+        void render_independent_color(RenderAble* able, PixelBufferSlot* pixel, QSize size, std::uint64_t version);
+        void finish_independent_render(RenderAble* able);
         friend class RenderScheduler;
         friend struct RenderAble;
     };
diff --git a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.cpp b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.cpp
index 2f916d6..4bafa0a 100644
--- a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.cpp
+++ b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.cpp
@@ -15,10 +15,10 @@ namespace YSG {
         int cy = r.y();
         int ch = r.height();
         int cw = r.width();
-        int colfirst = columnAt(cx);
-        int collast = columnAt(cx + cw);
-        int rowfirst = rowAt(cy);
-        int rowlast = rowAt(cy + ch);
+        int colfirst = column_at(cx);
+        int collast = column_at(cx + cw);
+        int rowfirst = row_at(cy);
+        int rowlast = row_at(cy + ch);
         if (isRightToLeft())
         {
             int t = colfirst;
@@ -34,14 +34,14 @@ namespace YSG {
         for (int r = rowfirst; r <= rowlast; ++r)
         {
             // get row position and height
-            int rowp = rowY(r);
+            int rowp = row_y(r);
             // Go through the columns in the row r
             // if we know from where to where, go through [colfirst, collast],
             // else go through all of them
             for (int c = colfirst; c <= collast; ++c)
             {
                 // get position and width of column c
-                int colp = columnX(c);
+                int colp = column_x(c);
                 // Translate painter and draw the cell
                 rect.translate(colp, rowp);
                 paintCell(p, r, c, rect);
@@ -99,8 +99,8 @@ namespace YSG {
         int oldCol = curCol;
         curRow = row;
         curCol = col;
-        updateCell(oldRow, oldCol);
-        updateCell(curRow, curCol);
+        update_cell(oldRow, oldCol);
+        update_cell(curRow, curCol);
         emit currentChanged(curRow, curCol);
     }
     /*
@@ -115,8 +115,8 @@ namespace YSG {
         if (row < 0 || col < 0) row = col = -1;
         selCol = col;
         selRow = row;
-        updateCell(oldRow, oldCol);
-        updateCell(selRow, selCol);
+        update_cell(oldRow, oldCol);
+        update_cell(selRow, selCol);
         if (row >= 0) {
             emit selected(row, col);
         }
@@ -125,11 +125,11 @@ namespace YSG {
 #endif
     }
     void QColorWell::focusInEvent(QFocusEvent*) {
-        updateCell(curRow, curCol);
+        update_cell(curRow, curCol);
         emit currentChanged(curRow, curCol);
     }
     void QColorWell::focusOutEvent(QFocusEvent*) {
-        updateCell(curRow, curCol);
+        update_cell(curRow, curCol);
     }
     void QColorWell::keyPressEvent(QKeyEvent* e) {
         switch (e->key())
@@ -164,11 +164,11 @@ namespace YSG {
             return;
         }
     }
-    int QColorLuminancePicker::y2val(int y) {
+    int QColorLuminancePicker::y_to_val(int y) {
         int d = height() - 2 * coff - 1;
         return 255 - (y - coff) * 255 / d;
     }
-    int QColorLuminancePicker::val2y(int v) {
+    int QColorLuminancePicker::val_to_y(int v) {
         int d = height() - 2 * coff - 1;
         return coff + (255 - v) * d / 255;
     }
@@ -183,23 +183,23 @@ namespace YSG {
         delete pix;
     }
     void QColorLuminancePicker::mouseMoveEvent(QMouseEvent* m) {
-        setVal(y2val(m->y()));
+        set_val(y_to_val(m->y()));
     }
     void QColorLuminancePicker::mousePressEvent(QMouseEvent* m) {
-        setVal(y2val(m->y()));
+        set_val(y_to_val(m->y()));
     }
-    void QColorLuminancePicker::setVal(int v) {
+    void QColorLuminancePicker::set_val(int v) {
         if (val == v) return;
         val = qMax(0, qMin(v, 255));
         delete pix;
         pix = nullptr;
         repaint();
-        emit newHsv(hue, sat, val);
+        emit new_hsv(hue, sat, val);
     }
     //receives from a hue,sat chooser and relays.
-    void QColorLuminancePicker::setCol(int h, int s) {
-        setCol(h, s, val);
-        emit newHsv(h, s, val);
+    void QColorLuminancePicker::set_col(int h, int s) {
+        set_col(h, s, val);
+        emit new_hsv(h, s, val);
     }
     void QColorLuminancePicker::paintEvent(QPaintEvent*) {
         int w = width() - 5;
@@ -215,7 +215,7 @@ namespace YSG {
             for (y = 0; y < hi; y++)
             {
                 uint* end = pixel + wi;
-                std::fill(pixel, end, QColor::fromHsv(hue, sat, y2val(y + coff)).rgb());
+                std::fill(pixel, end, QColor::fromHsv(hue, sat, y_to_val(y + coff)).rgb());
                 pixel = end;
             }
             pix = new QPixmap(QPixmap::fromImage(img));
@@ -227,12 +227,12 @@ namespace YSG {
         p.setPen(g.windowText().color());
         p.setBrush(g.windowText());
         QPolygon a;
-        int y = val2y(val);
+        int y = val_to_y(val);
         a.setPoints(3, w, y, w + 5, y + 5, w + 5, y - 5);
         p.eraseRect(w, 0, 5, height());
         p.drawPolygon(a);
     }
-    void QColorLuminancePicker::setCol(int h, int s, int v) {
+    void QColorLuminancePicker::set_col(int h, int s, int v) {
         val = v;
         hue = h;
         sat = s;
@@ -240,7 +240,7 @@ namespace YSG {
         pix = nullptr;
         repaint();
     }
-    QPoint QColorPicker::colPt() {
+    QPoint QColorPicker::col_pt() {
         QRect r = contentsRect();
         return QPoint((360 - hue) * (r.width() - 1) / 360, (255 - sat) * (r.height() - 1) / 255);
     }
@@ -252,18 +252,18 @@ namespace YSG {
         QRect r = contentsRect();
         return 255 - pt.y() * 255 / (r.height() - 1);
     }
-    void QColorPicker::setCol(const QPoint& pt) {
-        setCol(huePt(pt), satPt(pt));
+    void QColorPicker::set_col(const QPoint& pt) {
+        set_col(huePt(pt), satPt(pt));
     }
     QColorPicker::QColorPicker(QWidget* parent) : QFrame(parent), crossVisible(true) {
         hue = 0;
         sat = 0;
-        setCol(150, 255);
+        set_col(150, 255);
         setAttribute(Qt::WA_NoSystemBackground);
         //setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     }
     QColorPicker::~QColorPicker() = default;
-    void QColorPicker::setCrossVisible(bool visible) {
+    void QColorPicker::set_cross_visible(bool visible) {
         if (crossVisible != visible)
         {
             crossVisible = visible;
@@ -271,27 +271,27 @@ namespace YSG {
         }
     }
 
-    void QColorPicker::setCol(int h, int s) {
+    void QColorPicker::set_col(int h, int s) {
         int nhue = qMin(qMax(0, h), 359);
         int nsat = qMin(qMax(0, s), 255);
         if (nhue == hue && nsat == sat) return;
-        QRect r(colPt(), QSize(20, 20));
+        QRect r(col_pt(), QSize(20, 20));
         hue = nhue;
         sat = nsat;
-        r = r.united(QRect(colPt(), QSize(20, 20)));
+        r = r.united(QRect(col_pt(), QSize(20, 20)));
         r.translate(contentsRect().x() - 9, contentsRect().y() - 9);
         //    update(r);
         repaint(r);
     }
     void QColorPicker::mouseMoveEvent(QMouseEvent* m) {
         QPoint p = m->pos() - contentsRect().topLeft();
-        setCol(p);
-        emit newCol(hue, sat);
+        set_col(p);
+        emit new_col(hue, sat);
     }
     void QColorPicker::mousePressEvent(QMouseEvent* m) {
         QPoint p = m->pos() - contentsRect().topLeft();
-        setCol(p);
-        emit newCol(hue, sat);
+        set_col(p);
+        emit new_col(hue, sat);
     }
     void QColorPicker::paintEvent(QPaintEvent*) {
         QPainter p(this);
@@ -300,7 +300,7 @@ namespace YSG {
         p.drawPixmap(r.topLeft(), pix);
         if (crossVisible)
         {
-            QPoint pt = colPt() + r.topLeft();
+            QPoint pt = col_pt() + r.topLeft();
             p.setPen(Qt::black);
             p.fillRect(pt.x() - 9, pt.y(), 20, 2, Qt::black);
             p.fillRect(pt.x(), pt.y() - 9, 2, 20, Qt::black);
@@ -334,11 +334,11 @@ namespace YSG {
         drawFrame(&p);
         p.fillRect(contentsRect() & e->rect(), col);
     }
-    void QColorShower::showAlpha(bool b) {
+    void QColorShower::show_alpha(bool b) {
         alphaLab->setVisible(b);
         alphaEd->setVisible(b);
     }
-    inline bool QColorShower::isAlphaVisible() const {
+    inline bool QColorShower::is_alpha_visible() const {
         return alphaLab->isVisible();
     }
     void QColorShowLabel::mousePressEvent(QMouseEvent* e) {
@@ -380,30 +380,30 @@ namespace YSG {
         {
             col = color;
             repaint();
-            emit colorDropped(col.rgb());
+            emit color_dropped(col.rgb());
             e->accept();
         } else
         {
             e->ignore();
         }
     }
-    void QColorPickingEventFilter::updatePos()  {
+    void QColorPickingEventFilter::update_pos()  {
         QPoint mousePos = QCursor::pos();
         setPosition(mousePos + QPoint{-100, -100});
         //move(mousePos + QPoint{-100, -100});
-        QColor color = grabScreenColor(mousePos);
+        QColor color = grab_screen_color(mousePos);
         //qDebug() << color;
-        m_dp->cs->setRgb(color.rgb());
+        m_dp->cs->set_rgb(color.rgb());
     }
     bool QColorPickingEventFilter::eventFilter(QObject* object, QEvent* event) {
         switch (event->type()) {
         case QEvent::MouseMove: {
-            updatePos();
+            update_pos();
             return true;
             break;
         }
         case QEvent::MouseButtonPress: {
-            stopGetScreen();
+            stop_get_screen();
             return true;
             break;
         }
@@ -411,7 +411,7 @@ namespace YSG {
             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
             if (keyEvent->key() == Qt::Key_Escape) {
                 //qDebug() << "Escape pressed, stopping color picking";
-                stopGetScreen();
+                stop_get_screen();
             }
             break;
         }
@@ -421,7 +421,7 @@ namespace YSG {
         return false;  // Don't block the event from reaching the rest of the application
     }
 
-    void QColorPickingEventFilter::startGetScreen() {
+    void QColorPickingEventFilter::start_get_screen() {
         auto q = m_dp->q;
         q->setMouseTracking(true);
         q->grabKeyboard();
@@ -430,9 +430,9 @@ namespace YSG {
 #ifdef WIN32
        this->show();
 #endif
-        updatePos();
+        update_pos();
     }
-    void QColorPickingEventFilter::stopGetScreen() {
+    void QColorPickingEventFilter::stop_get_screen() {
         auto q = m_dp->q;
         q->setMouseTracking(false);
         q->releaseKeyboard();
@@ -479,14 +479,14 @@ namespace YSG {
         auto addCusBt = new QPushButton("添加当前颜色为自定义颜色");
         QObject::connect(addCusBt,  &QPushButton::clicked, [this]() {
             const int i = custom->curRow + customColorRows * custom->curCol;
-            customRgb[i] = cs->currentColor();
-            custom->updateCell(custom->curRow, custom->curCol);
+            customRgb[i] = cs->current_color();
+            custom->update_cell(custom->curRow, custom->curCol);
         });
         auto addCurrent = new QPushButton("添加自定义为当前颜色");
         QObject::connect(addCurrent,  &QPushButton::clicked, [this]() {
             const int i = custom->curRow + customColorRows * custom->curCol;
             if(i > 0 && i < customColorRows * colorColumns) {
-                cs->setRgb(customRgb[i]);
+                cs->set_rgb(customRgb[i]);
             }
         });
         leftLay->addWidget(addCusBt);
@@ -518,19 +518,19 @@ namespace YSG {
         });
 
         QObject::connect(screenColorPickerButton,  &QPushButton::clicked, [this]() {
-            mQColorPickingEventFilter->startGetScreen();
+            mQColorPickingEventFilter->start_get_screen();
         });
 
         QObject::connect(standard, &QColorWell::currentChanged, [this](int r, int c) {
              const int i = r + standardColorRows * c;
-             setCurrentColor(standardRgb[i]);
+             set_current_color(standardRgb[i]);
         });
 
-        QObject::connect(cp, SIGNAL(newCol(int,int)), lp, SLOT(setCol(int,int)));
-        QObject::connect(lp, &QColorLuminancePicker::newHsv, q, [this](int h, int s, int v) {
-            cs->setHsv(h, s, v);
-            cp->setCol(h, s);
-            lp->setCol(h, s, v);
+        QObject::connect(cp, SIGNAL(new_col(int,int)), lp, SLOT(set_col(int,int)));
+        QObject::connect(lp, &QColorLuminancePicker::new_hsv, q, [this](int h, int s, int v) {
+            cs->set_hsv(h, s, v);
+            cp->set_col(h, s);
+            lp->set_col(h, s, v);
         });
     }
     void QColorShowLabel::mouseReleaseEvent(QMouseEvent*) {
@@ -557,8 +557,8 @@ namespace YSG {
 #else
         gl->addWidget(lab, 0, 0, 1, -1);
 #endif
-        connect(lab, SIGNAL(colorDropped(QRgb)), this, SIGNAL(newCol(QRgb)));
-        connect(lab, SIGNAL(colorDropped(QRgb)), this, SLOT(setRgb(QRgb)));
+        connect(lab, SIGNAL(color_dropped(QRgb)), this, SIGNAL(new_col(QRgb)));
+        connect(lab, SIGNAL(color_dropped(QRgb)), this, SLOT(set_rgb(QRgb)));
         hEd = new QColSpinBox(this);
         hEd->setRange(0, 359);
         lblHue = new QLabel(this);
@@ -678,15 +678,15 @@ namespace YSG {
         gl->addWidget(lblHtml, 5, 1);
         gl->addWidget(htEd, 5, 2, 1, /*colspan=*/ 3);
 #endif
-        connect(hEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
-        connect(sEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
-        connect(vEd, SIGNAL(valueChanged(int)), this, SLOT(hsvEd()));
-        connect(rEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
-        connect(gEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
-        connect(bEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
-        connect(alphaEd, SIGNAL(valueChanged(int)), this, SLOT(rgbEd()));
-        connect(htEd, SIGNAL(textEdited(QString)), this, SLOT(htmlEd()));
-        retranslateStrings();
+        connect(hEd, SIGNAL(valueChanged(int)), this, SLOT(hsv_ed()));
+        connect(sEd, SIGNAL(valueChanged(int)), this, SLOT(hsv_ed()));
+        connect(vEd, SIGNAL(valueChanged(int)), this, SLOT(hsv_ed()));
+        connect(rEd, SIGNAL(valueChanged(int)), this, SLOT(rgb_ed()));
+        connect(gEd, SIGNAL(valueChanged(int)), this, SLOT(rgb_ed()));
+        connect(bEd, SIGNAL(valueChanged(int)), this, SLOT(rgb_ed()));
+        connect(alphaEd, SIGNAL(valueChanged(int)), this, SLOT(rgb_ed()));
+        connect(htEd, SIGNAL(textEdited(QString)), this, SLOT(html_ed()));
+        retranslate_strings();
     }
     void QColorWell::paintCellContents(QPainter* p, int row, int col, const QRect& r) {
         int i = row + col * nrows;
@@ -695,7 +695,7 @@ namespace YSG {
     void QColorWell::mousePressEvent(QMouseEvent* e) {
         oldCurrent = QPoint(selectedRow(), selectedColumn());
         QPoint pos = e->pos();
-        setCurrent(rowAt(pos.y()), columnAt(pos.x()));
+        setCurrent(row_at(pos.y()), column_at(pos.x()));
         mousePressed = true;
         pressPos = e->pos();
     }
@@ -705,7 +705,7 @@ namespace YSG {
         if ((pressPos - e->pos()).manhattanLength() > QApplication::startDragDistance())
         {
             setCurrent(oldCurrent.x(), oldCurrent.y());
-            int i = rowAt(pressPos.y()) + columnAt(pressPos.x()) * nrows;
+            int i = row_at(pressPos.y()) + column_at(pressPos.x()) * nrows;
             QColor col(values[i]);
             QMimeData* mime = new QMimeData;
             mime->setColorData(col);
@@ -733,7 +733,7 @@ namespace YSG {
     void QColorWell::dragMoveEvent(QDragMoveEvent* e) {
         if (qvariant_cast<QColor>(e->mimeData()->colorData()).isValid())
         {
-            setCurrent(rowAt(e->pos().y()), columnAt(e->pos().x()));
+            setCurrent(row_at(e->pos().y()), column_at(e->pos().x()));
             e->accept();
         } else
         {
@@ -744,8 +744,8 @@ namespace YSG {
         QColor col = qvariant_cast<QColor>(e->mimeData()->colorData());
         if (col.isValid())
         {
-            int i = rowAt(e->pos().y()) + columnAt(e->pos().x()) * nrows;
-            emit colorChanged(i, col.rgb());
+            int i = row_at(e->pos().y()) + column_at(e->pos().x()) * nrows;
+            emit color_changed(i, col.rgb());
             e->accept();
         } else
         {
@@ -758,19 +758,19 @@ namespace YSG {
         setSelected(curRow, curCol);
         mousePressed = false;
     }
-    void QColorShower::rgbEd() {
+    void QColorShower::rgb_ed() {
         rgbOriginal = true;
-        curCol = qRgba(rEd->value(), gEd->value(), bEd->value(), currentAlpha());
-        rgb2hsv(currentColor(), hue, sat, val);
+        curCol = qRgba(rEd->value(), gEd->value(), bEd->value(), current_alpha());
+        rgb2hsv(current_color(), hue, sat, val);
         hEd->setValue(hue);
         sEd->setValue(sat);
         vEd->setValue(val);
         htEd->setText(QColor(curCol).name());
-        showCurrentColor();
-        emit newCol(currentColor());
-        updateQColor();
+        show_current_color();
+        emit new_col(current_color());
+        update_q_color();
     }
-    void QColorShower::hsvEd() {
+    void QColorShower::hsv_ed() {
         rgbOriginal = false;
         hue = hEd->value();
         sat = sEd->value();
@@ -778,46 +778,46 @@ namespace YSG {
         QColor c;
         c.setHsv(hue, sat, val);
         curCol = c.rgb();
-        rEd->setValue(qRed(currentColor()));
-        gEd->setValue(qGreen(currentColor()));
-        bEd->setValue(qBlue(currentColor()));
+        rEd->setValue(qRed(current_color()));
+        gEd->setValue(qGreen(current_color()));
+        bEd->setValue(qBlue(current_color()));
         htEd->setText(c.name());
-        showCurrentColor();
-        emit newCol(currentColor());
-        updateQColor();
+        show_current_color();
+        emit new_col(current_color());
+        update_q_color();
     }
-    void QColorShower::htmlEd() {
+    void QColorShower::html_ed() {
         QColor c;
         QString t = htEd->text();
         c.setNamedColor(t);
         if (!c.isValid()) return;
-        curCol = qRgba(c.red(), c.green(), c.blue(), currentAlpha());
+        curCol = qRgba(c.red(), c.green(), c.blue(), current_alpha());
         rgb2hsv(curCol, hue, sat, val);
         hEd->setValue(hue);
         sEd->setValue(sat);
         vEd->setValue(val);
-        rEd->setValue(qRed(currentColor()));
-        gEd->setValue(qGreen(currentColor()));
-        bEd->setValue(qBlue(currentColor()));
-        showCurrentColor();
-        emit newCol(currentColor());
-        updateQColor();
+        rEd->setValue(qRed(current_color()));
+        gEd->setValue(qGreen(current_color()));
+        bEd->setValue(qBlue(current_color()));
+        show_current_color();
+        emit new_col(current_color());
+        update_q_color();
     }
-    void QColorShower::setRgb(QRgb rgb) {
+    void QColorShower::set_rgb(QRgb rgb) {
         rgbOriginal = true;
         curCol = rgb;
-        rgb2hsv(currentColor(), hue, sat, val);
+        rgb2hsv(current_color(), hue, sat, val);
         hEd->setValue(hue);
         sEd->setValue(sat);
         vEd->setValue(val);
-        rEd->setValue(qRed(currentColor()));
-        gEd->setValue(qGreen(currentColor()));
-        bEd->setValue(qBlue(currentColor()));
+        rEd->setValue(qRed(current_color()));
+        gEd->setValue(qGreen(current_color()));
+        bEd->setValue(qBlue(current_color()));
         htEd->setText(QColor(rgb).name());
-        showCurrentColor();
-        updateQColor();
+        show_current_color();
+        update_q_color();
     }
-    void QColorShower::setHsv(int h, int s, int v) {
+    void QColorShower::set_hsv(int h, int s, int v) {
         if (h < -1 || (uint)s > 255 || (uint)v > 255) return;
         rgbOriginal = false;
         hue = h;
@@ -829,14 +829,14 @@ namespace YSG {
         hEd->setValue(hue);
         sEd->setValue(sat);
         vEd->setValue(val);
-        rEd->setValue(qRed(currentColor()));
-        gEd->setValue(qGreen(currentColor()));
-        bEd->setValue(qBlue(currentColor()));
+        rEd->setValue(qRed(current_color()));
+        gEd->setValue(qGreen(current_color()));
+        bEd->setValue(qBlue(current_color()));
         htEd->setText(c.name());
-        showCurrentColor();
-        updateQColor();
+        show_current_color();
+        update_q_color();
     }
-    void QColorShower::retranslateStrings() {
+    void QColorShower::retranslate_strings() {
         lblHue->setText(SelectColorDialog::tr("Hu&e:"));
         lblSat->setText(SelectColorDialog::tr("&Sat:"));
         lblVal->setText(SelectColorDialog::tr("&Val:"));
@@ -846,13 +846,13 @@ namespace YSG {
         alphaLab->setText(SelectColorDialog::tr("A&lpha channel:"));
         lblHtml->setText(SelectColorDialog::tr("&HTML:"));
     }
-    void QColorShower::updateQColor() {
+    void QColorShower::update_q_color() {
         QColor oldQColor(curQColor);
-        curQColor.setRgba(qRgba(qRed(curCol), qGreen(curCol), qBlue(curCol), currentAlpha()));
-        if (curQColor != oldQColor) emit currentColorChanged(curQColor);
+        curQColor.setRgba(qRgba(qRed(curCol), qGreen(curCol), qBlue(curCol), current_alpha()));
+        if (curQColor != oldQColor) emit current_color_changed(curQColor);
     }
-    void QColorShower::showCurrentColor() {
-        lab->setColor(currentColor());
+    void QColorShower::show_current_color() {
+        lab->set_color(current_color());
         lab->repaint();
     }
     SelectColorDialog::SelectColorDialog() {
@@ -861,10 +861,10 @@ namespace YSG {
     SelectColorDialog::~SelectColorDialog() {
         delete d_ptr;
     }
-    void SelectColorDialog::setCurrentColor(const QColor& color) const {
-        d_ptr->setCurrentColor(color);
+    void SelectColorDialog::set_current_color(const QColor& color) const {
+        d_ptr->set_current_color(color);
     }
-    QColor SelectColorDialog::currentColor() const {
-        return d_ptr->currentColor();
+    QColor SelectColorDialog::current_color() const {
+        return d_ptr->current_color();
     }
 }
diff --git a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.h b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.h
index 915165c..e7b5dd8 100644
--- a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.h
+++ b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog.h
@@ -10,8 +10,8 @@ namespace YSG {
         SelectColorDialog();
         ~SelectColorDialog() override;
         SelectColorDialogPrivate* d_ptr{};
-        void setCurrentColor(const QColor &color) const;
-        [[nodiscard]] QColor currentColor() const;
+        void set_current_color(const QColor &color) const;
+        [[nodiscard]] QColor current_color() const;
     };
 }
 
diff --git a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog_p.h b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog_p.h
index a3c021b..2270930 100644
--- a/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog_p.h
+++ b/YSGraphic_Core/base/SelectColorDialog/SelectColorDialog_p.h
@@ -42,25 +42,25 @@ namespace YSG {
         [[nodiscard]] int selectedRow() const { return selRow; }
         virtual void setCurrent(int row, int col);
         virtual void setSelected(int row, int col);
-        [[nodiscard]] inline int rowAt(int y) const { return y / cellh; }
-        [[nodiscard]] inline int columnAt(int x) const {
+        [[nodiscard]] inline int row_at(int y) const { return y / cellh; }
+        [[nodiscard]] inline int column_at(int x) const {
             if (isRightToLeft()) return ncols - (x / cellw) - 1;
             return x / cellw;
         }
-        [[nodiscard]] inline int rowY(int row) const { return cellh * row; }
-        [[nodiscard]] inline int columnX(int column) const {
+        [[nodiscard]] inline int row_y(int row) const { return cellh * row; }
+        [[nodiscard]] inline int column_x(int column) const {
             if (isRightToLeft()) return cellw * (ncols - column - 1);
             return cellw * column;
         }
-        [[nodiscard]] inline QRect cellRect() const { return {0, 0, cellw, cellh}; }
+        [[nodiscard]] inline QRect cell_rect() const { return {0, 0, cellw, cellh}; }
         [[nodiscard]] inline QSize gridSize() const { return {ncols * cellw, nrows * cellh}; }
-        [[nodiscard]] QRect cellGeometry(int row, int column) const {
+        [[nodiscard]] QRect cell_geometry(int row, int column) const {
             QRect r;
             if (row >= 0 && row < nrows && column >= 0 && column < ncols)
-                r.setRect(columnX(column), rowY(row), cellw, cellh);
+                r.setRect(column_x(column), row_y(row), cellw, cellh);
             return r;
         }
-        inline void updateCell(int row, int column) { update(cellGeometry(row, column)); }
+        inline void update_cell(int row, int column) { update(cell_geometry(row, column)); }
         void paintCell(QPainter*, int row, int col, const QRect&);
         const QRgb* values;
         bool mousePressed = false;
@@ -76,7 +76,7 @@ namespace YSG {
         int selCol = -1;
         int cellMargin = 3; //margin
     signals:
-        void colorChanged(int index, QRgb color);
+        void color_changed(int index, QRgb color);
         void selected(int row, int col);
         void currentChanged(int row, int col);
     protected:
@@ -100,11 +100,11 @@ namespace YSG {
         Q_OBJECT public:
         explicit QColorPicker(QWidget* parent);
         ~QColorPicker() override;
-        void setCrossVisible(bool visible);
+        void set_cross_visible(bool visible);
     public slots:
-        void setCol(int h, int s);
+        void set_col(int h, int s);
     signals:
-        void newCol(int h, int s);
+        void new_col(int h, int s);
     protected:
         void paintEvent(QPaintEvent*) override;
         void mouseMoveEvent(QMouseEvent*) override;
@@ -112,10 +112,10 @@ namespace YSG {
         void resizeEvent(QResizeEvent*) override;
         int hue;
         int sat;
-        QPoint colPt();
+        QPoint col_pt();
         int huePt(const QPoint& pt);
         int satPt(const QPoint& pt);
-        void setCol(const QPoint& pt);
+        void set_col(const QPoint& pt);
         QPixmap pix;
         bool crossVisible;
     };
@@ -124,10 +124,10 @@ namespace YSG {
         explicit QColorLuminancePicker(QWidget* parent = nullptr);
         ~QColorLuminancePicker() override;
     public slots:
-        void setCol(int h, int s, int v);
-        void setCol(int h, int s);
+        void set_col(int h, int s, int v);
+        void set_col(int h, int s);
     signals:
-        void newHsv(int h, int s, int v);
+        void new_hsv(int h, int s, int v);
     protected:
         void paintEvent(QPaintEvent*) override;
         void mouseMoveEvent(QMouseEvent*) override;
@@ -136,9 +136,9 @@ namespace YSG {
         int val;
         int hue;
         int sat;
-        int y2val(int y);
-        int val2y(int val);
-        void setVal(int v);
+        int y_to_val(int y);
+        int val_to_y(int val);
+        void set_val(int v);
         QPixmap* pix;
     };
     class QColSpinBox : public QSpinBox {
@@ -153,29 +153,29 @@ namespace YSG {
     class QColorShower : public QWidget {
         Q_OBJECT public:
         explicit QColorShower(SelectColorDialog* parent);
-        void setHsv(int h, int s, int v);
-        [[nodiscard]] int currentAlpha() const { return alphaEd->value(); }
+        void set_hsv(int h, int s, int v);
+        [[nodiscard]] int current_alpha() const { return alphaEd->value(); }
         void setCurrentAlpha(int a) {
             alphaEd->setValue(a);
-            rgbEd();
+            rgb_ed();
         }
-        void showAlpha(bool b);
-        [[nodiscard]] bool isAlphaVisible() const;
-        [[nodiscard]] QRgb currentColor() const { return curCol; }
-        [[nodiscard]] QColor currentQColor() const { return curQColor; }
-        void retranslateStrings();
-        void updateQColor();
+        void show_alpha(bool b);
+        [[nodiscard]] bool is_alpha_visible() const;
+        [[nodiscard]] QRgb current_color() const { return curCol; }
+        [[nodiscard]] QColor current_q_color() const { return curQColor; }
+        void retranslate_strings();
+        void update_q_color();
     public slots:
-        void setRgb(QRgb rgb);
+        void set_rgb(QRgb rgb);
     signals:
-        void newCol(QRgb rgb);
-        void currentColorChanged(const QColor& color);
+        void new_col(QRgb rgb);
+        void current_color_changed(const QColor& color);
     private slots:
-        void rgbEd();
-        void hsvEd();
-        void htmlEd();
+        void rgb_ed();
+        void hsv_ed();
+        void html_ed();
     private:
-        void showCurrentColor();
+        void show_current_color();
         int hue{}, sat{}, val{};
         QRgb curCol;
         QColor curQColor;
@@ -208,9 +208,9 @@ namespace YSG {
             setAcceptDrops(true);
             mousePressed = false;
         }
-        void setColor(QColor c) { col = std::move(c); }
+        void set_color(QColor c) { col = std::move(c); }
     signals:
-        void colorDropped(QRgb);
+        void color_dropped(QRgb);
     protected:
         void paintEvent(QPaintEvent*) override;
         void mousePressEvent(QMouseEvent* e) override;
@@ -229,7 +229,7 @@ namespace YSG {
     public:
         // #如果出现黑屏的情况可能是开启了wayland,
             // sudo nano /etc/gdm3/custom.conf
-       QColor grabScreenColor(const QPoint &p) {
+       QColor grab_screen_color(const QPoint &p) {
             // 获取当前的屏幕对象
             QScreen *screen = QGuiApplication::screenAt(p);  // 获取光标所在的屏幕
             if (!screen) {
@@ -254,10 +254,10 @@ namespace YSG {
             // setWindowOpacity(0.0);
             setVisible(false);
         }
-        void updatePos();
+        void update_pos();
         bool eventFilter(QObject *, QEvent *event) override;
-        void startGetScreen();
-        void stopGetScreen();
+        void start_get_screen();
+        void stop_get_screen();
     protected:
         SelectColorDialogPrivate *m_dp;
     };
@@ -286,16 +286,16 @@ namespace YSG {
             delete mQColorPickingEventFilter;
         }
         explicit SelectColorDialogPrivate(SelectColorDialog* mSelectColorDialog);
-        void setCurrentColor(const QColor &color) const {
+        void set_current_color(const QColor &color) const {
             auto rgb = color.rgb();
             int h, s, v;
             rgb2hsv(rgb, h, s, v);
-            cp->setCol(h, s);
-            lp->setCol(h, s, v);
-            cs->setRgb(rgb);
+            cp->set_col(h, s);
+            lp->set_col(h, s, v);
+            cs->set_rgb(rgb);
         }
-        QColor currentColor() {
-            return cs->currentColor();
+        QColor current_color() {
+            return cs->current_color();
         }
     };
 }
diff --git a/YSGraphic_Core/component/Background.h b/YSGraphic_Core/component/Background.h
index 4a17e62..eab1579 100644
--- a/YSGraphic_Core/component/Background.h
+++ b/YSGraphic_Core/component/Background.h
@@ -92,7 +92,7 @@ struct Background : PaintAble {
         int halfPenWidth = 0;
         QRect adjustedRect = rect.adjusted(halfPenWidth, halfPenWidth, -halfPenWidth, -halfPenWidth);
         qreal xRadius, yRadius;
-        getRoundedRectRadius(adjustedRect, xRadius, yRadius);
+        get_rounded_rect_radius(adjustedRect, xRadius, yRadius);
         QPainterPath borderPath;
         borderPath.addRoundedRect(adjustedRect, xRadius, yRadius);
         QRect innerRect = adjustedRect;
@@ -132,7 +132,7 @@ struct Background : PaintAble {
 
 protected:
 
-    void getRoundedRectRadius(const QRect& rect, qreal& xRadius, qreal& yRadius) const {
+    void get_rounded_rect_radius(const QRect& rect, qreal& xRadius, qreal& yRadius) const {
         if (mode == Qt::RelativeSize) {
             xRadius = rect.width() * radius;
             yRadius = rect.height() * radius;
diff --git a/YSGraphic_Core/component/Table/Base_Info.cpp b/YSGraphic_Core/component/Table/Base_Info.cpp
index 762b301..d3c99c3 100644
--- a/YSGraphic_Core/component/Table/Base_Info.cpp
+++ b/YSGraphic_Core/component/Table/Base_Info.cpp
@@ -6,7 +6,7 @@
 namespace Psc {
     Base_Info::Base_Info(int len, QString content) : len(len), content(std::move(content)) {
         YSG::Range r{155, 255};
-        QColor random_color(YSG::getData(r), YSG::getData(r), YSG::getData(r));
+        QColor random_color(YSG::get_data(r), YSG::get_data(r), YSG::get_data(r));
         background_color = random_color;
     }
     void Base_Info::paint(QPainter* painter, QRect rect)  {
diff --git a/YSGraphic_Core/component/Table/Base_Table_Data.cpp b/YSGraphic_Core/component/Table/Base_Table_Data.cpp
index e9af3b0..f72d730 100644
--- a/YSGraphic_Core/component/Table/Base_Table_Data.cpp
+++ b/YSGraphic_Core/component/Table/Base_Table_Data.cpp
@@ -10,7 +10,7 @@ namespace Psc {
 
     Table_Paint_Data::Table_Paint_Data(QIcon ic, QString t) {
         YSG::Range r{155, 255};
-        QColor random_color(YSG::getData(r), YSG::getData(r), YSG::getData(r));
+        QColor random_color(YSG::get_data(r), YSG::get_data(r), YSG::get_data(r));
         background_color = random_color;
         icon = Icon2(ic);
         text.text = t;
@@ -19,7 +19,7 @@ namespace Psc {
     }
     Table_Paint_Data::Table_Paint_Data(QString t) {
         YSG::Range r{155, 255};
-        QColor random_color(YSG::getData(r), YSG::getData(r), YSG::getData(r));
+        QColor random_color(YSG::get_data(r), YSG::get_data(r), YSG::get_data(r));
         background_color = random_color;
         text.text = t;
         layout.items.append(&text);
diff --git a/YSGraphic_Core/component/Table/Table_View.cpp b/YSGraphic_Core/component/Table/Table_View.cpp
index 8de8e0b..6fc83d3 100644
--- a/YSGraphic_Core/component/Table/Table_View.cpp
+++ b/YSGraphic_Core/component/Table/Table_View.cpp
@@ -252,7 +252,7 @@ namespace Psc {
             e->type() == QEvent::MouseButtonDblClick
         ) {
             auto event = static_cast<QMouseEvent*>(e);
-            mouseEvent(event, event->type());
+            mouse_event(event, event->type());
             return true;
         }
         return QWidget::event(e);
@@ -263,7 +263,7 @@ namespace Psc {
     }
 
 
-    void Table_View::mouseEvent(QMouseEvent* event, QEvent::Type type) {
+    void Table_View::mouse_event(QMouseEvent* event, QEvent::Type type) {
         QRect cells_widget_rect = get_view_rect();
         auto pos = event->pos();
         auto abs_pos = to_inside_pos(pos);
@@ -331,7 +331,7 @@ namespace Psc {
                 }
             }
             // qDebug() << log;
-            if (isCtrlPressed())
+            if (is_ctrl_pressed())
             {
                 isDragging = true;
                 drag_type = Table_Move;
@@ -390,7 +390,7 @@ namespace Psc {
             }
         } else if (type == QEvent::MouseMove)
         {
-            if (isCtrlPressed())
+            if (is_ctrl_pressed())
             {
                 if (isDragging) {
                     setCursor(Qt::ClosedHandCursor);
@@ -425,7 +425,7 @@ namespace Psc {
             QPoint cur_pos = event->pos();
             int deltaX = cur_pos.x() - start_pos.x(); // 计算X轴的拖动距离
             int deltaY = cur_pos.y() - start_pos.y(); // 计算Y轴的拖动距离
-            if (drag_type == Table_Move && isCtrlPressed())
+            if (drag_type == Table_Move && is_ctrl_pressed())
             {
                 int end_x = save_pos.x() - deltaX;
                 int end_y = save_pos.y() - deltaY;
diff --git a/YSGraphic_Core/component/Table/Table_View.h b/YSGraphic_Core/component/Table/Table_View.h
index 3b19477..2c07feb 100644
--- a/YSGraphic_Core/component/Table/Table_View.h
+++ b/YSGraphic_Core/component/Table/Table_View.h
@@ -71,7 +71,7 @@ namespace Psc {
         QPoint to_widget_pos(QPoint inside_pos);
         QRect get_view_rect();
 
-        static bool isCtrlPressed() {
+        static bool is_ctrl_pressed() {
             if (Qt::ControlModifier & QApplication::keyboardModifiers())
             {
                 return true;
@@ -103,7 +103,7 @@ namespace Psc {
         void paintEvent(QPaintEvent* event) override;
         void resizeEvent(QResizeEvent* event) override;
         void wheelEvent(QWheelEvent* event) override;
-        void mouseEvent(QMouseEvent* event, QEvent::Type type);
+        void mouse_event(QMouseEvent* event, QEvent::Type type);
         void leaveEvent(QEvent* event) override;
     };
 }
diff --git a/YSGraphic_Core/component/Tree/Tree_Model.h b/YSGraphic_Core/component/Tree/Tree_Model.h
index dfcaffe..20d5467 100644
--- a/YSGraphic_Core/component/Tree/Tree_Model.h
+++ b/YSGraphic_Core/component/Tree/Tree_Model.h
@@ -29,7 +29,7 @@ namespace Psc {
         bool expand = true;
         int height = 20;
 
-        void addChild(Node *child) {
+        void add_child(Node *child) {
             sons.append(child);
             child->par = this;
         }
diff --git a/YSGraphic_Core/component/Tree/Tree_View.cpp b/YSGraphic_Core/component/Tree/Tree_View.cpp
index cac74bb..12ff76d 100644
--- a/YSGraphic_Core/component/Tree/Tree_View.cpp
+++ b/YSGraphic_Core/component/Tree/Tree_View.cpp
@@ -31,9 +31,9 @@ namespace Psc {
                 {
                     QString t3 = t2 + QString("_%1").arg(i3);
                     auto n3 = cn(t3);
-                    n2->addChild(n3);
+                    n2->add_child(n3);
                 }
-                n1->addChild(n2);
+                n1->add_child(n2);
             }
             roots.append(n1);
         }
@@ -104,7 +104,7 @@ namespace Psc {
     }
 
 
-    void Tree_View::mouseEvent(QMouseEvent* event, QEvent::Type type) {
+    void Tree_View::mouse_event(QMouseEvent* event, QEvent::Type type) {
         QRect view_rect = get_view_rect();
         QPoint pos = event->pos();
         bool on_h_slider = h_bar.get_slider_rect(width(), height()).contains(event->pos());
@@ -202,7 +202,7 @@ namespace Psc {
             e->type() == QEvent::MouseButtonRelease || e->type() == QEvent::MouseButtonDblClick)
         {
             auto event = static_cast<QMouseEvent*>(e);
-            mouseEvent(event, event->type());
+            mouse_event(event, event->type());
             return true;
         }
         return QWidget::event(e);
diff --git a/YSGraphic_Core/component/Tree/Tree_View.h b/YSGraphic_Core/component/Tree/Tree_View.h
index 74978e8..382fb39 100644
--- a/YSGraphic_Core/component/Tree/Tree_View.h
+++ b/YSGraphic_Core/component/Tree/Tree_View.h
@@ -31,7 +31,7 @@ namespace Psc {
     protected:
         void paintEvent(QPaintEvent* event) override;
         bool event(QEvent* event) override;
-        void mouseEvent(QMouseEvent* event, QEvent::Type type);
+        void mouse_event(QMouseEvent* event, QEvent::Type type);
         void resizeEvent(QResizeEvent* event) override;
         void wheelEvent(QWheelEvent* event) override;
     };
diff --git a/YSGraphic_Core/component/frameless/FrameLessWidget.cpp b/YSGraphic_Core/component/frameless/FrameLessWidget.cpp
index b8df4ca..46fed3c 100644
--- a/YSGraphic_Core/component/frameless/FrameLessWidget.cpp
+++ b/YSGraphic_Core/component/frameless/FrameLessWidget.cpp
@@ -1,4 +1,4 @@
-#include "FrameLessWidget.h"
+#include "FrameLessWidget.h"
 #include <QMouseEvent>
 #include <QPainter>
 #include <qmath.h>
@@ -34,31 +34,31 @@ FrameLessWidget::FrameLessWidget(QWidget *parent) : QWidget(parent) {
   changeSizes.append
       ({
            [this]() { //R11
-             setGeometry(startX + dx, startY + dy, qMax(startW - dx, getMinWidth()), qMax(startH - dy, getMinHeight()));
+             setGeometry(startX + dx, startY + dy, qMax(startW - dx, get_min_width()), qMax(startH - dy, get_min_height()));
            },
            [this]() { //R12
-             setGeometry(startX, startY + dy, qMax(startW, getMinWidth()), qMax(startH - dy, getMinHeight()));
+             setGeometry(startX, startY + dy, qMax(startW, get_min_width()), qMax(startH - dy, get_min_height()));
            },
            [this]() { //R13
-             setGeometry(startX, startY + dy, qMax(startW + dx, getMinWidth()), qMax(startH - dy, getMinHeight()));
+             setGeometry(startX, startY + dy, qMax(startW + dx, get_min_width()), qMax(startH - dy, get_min_height()));
            },
            [this]() { //R21
-             setGeometry(startX + dx, startY, qMax(startW - dx, getMinWidth()), qMax(startH, getMinHeight()));
+             setGeometry(startX + dx, startY, qMax(startW - dx, get_min_width()), qMax(startH, get_min_height()));
            },
            []() {
              //R22
            },
            [this]() { //R23
-             setGeometry(startX, startY, qMax(startW + dx, getMinWidth()), qMax(startH, getMinHeight()));
+             setGeometry(startX, startY, qMax(startW + dx, get_min_width()), qMax(startH, get_min_height()));
            },
            [this]() { //R31
-             setGeometry(startX + dx, startY, qMax(startW - dx, getMinWidth()), qMax(startH + dy, getMinHeight()));
+             setGeometry(startX + dx, startY, qMax(startW - dx, get_min_width()), qMax(startH + dy, get_min_height()));
            },
            [this]() { //R32
-             setGeometry(startX, startY, qMax(startW, getMinWidth()), qMax(startH + dy, getMinHeight()));
+             setGeometry(startX, startY, qMax(startW, get_min_width()), qMax(startH + dy, get_min_height()));
            },
            [this]() { //R33
-             setGeometry(startX, startY, qMax(startW + dx, getMinWidth()), qMax(startH + dy, getMinHeight()));
+             setGeometry(startX, startY, qMax(startW + dx, get_min_width()), qMax(startH + dy, get_min_height()));
            },
            []() {
              //null
@@ -66,11 +66,11 @@ FrameLessWidget::FrameLessWidget(QWidget *parent) : QWidget(parent) {
        });
 }
 
-int FrameLessWidget::getMinWidth() {
+int FrameLessWidget::get_min_width() {
   return 0;
 }
 
-int FrameLessWidget::getMinHeight() {
+int FrameLessWidget::get_min_height() {
   return 0;
 }
 
@@ -133,14 +133,14 @@ bool FrameLessWidget::event(QEvent *event) {
   if (event->type() == QEvent::HoverMove) {
     auto *hoverEvent = static_cast<QHoverEvent *>(event);
    // qDebug() << hoverEvent->pos();
-    QMouseEvent mouseEvent(QEvent::MouseMove, hoverEvent->pos(),
+    QMouseEvent mouse_event(QEvent::MouseMove, hoverEvent->pos(),
                            Qt::NoButton, Qt::NoButton, Qt::NoModifier);
-    mouseMoveEvent(&mouseEvent);
+    mouseMoveEvent(&mouse_event);
   }
   return QWidget::event(event);
 }
 
-void FrameLessWidget::setPos() {
+void FrameLessWidget::set_pos() {
   x1 = 0;
   x2 = x1 + leftMargin + space;
   x3 = width() - rightMargin - space;
@@ -149,7 +149,7 @@ void FrameLessWidget::setPos() {
   y3 = height() - bottomMargin - space;
 }
 
-void FrameLessWidget::setRs() {
+void FrameLessWidget::set_rs() {
   int w1 = x2 - x1, w2 = x3 - x2, w3 = width() - x3;
   int h1 = y2 - y1, h2 = y3 - y2, h3 = height() - y3;
   r11.setRect(x1, y1, w1, h1);
@@ -170,7 +170,7 @@ void FrameLessWidget::mousePressEvent(QMouseEvent *event) {
     if (event->button() != Qt::LeftButton) return;
     if (changingSize) return;
     if (drag_moving) return;
-    curR = getRectType(pos);
+    curR = get_rect_type(pos);
     if (curR != Drag_R)
     {
         changingSize = true;
@@ -204,7 +204,7 @@ void FrameLessWidget::mouseReleaseEvent(QMouseEvent *event) {
 }
 
 void FrameLessWidget::mouseMoveEvent(QMouseEvent *event) {
-    RectType ret = getRectType(event->pos());
+    RectType ret = get_rect_type(event->pos());
     if (ret == Drag_R)
     {
         if (!drag_moving)
@@ -230,7 +230,7 @@ void FrameLessWidget::mouseMoveEvent(QMouseEvent *event) {
     }
 }
 
-RectType FrameLessWidget::getRectType(const QPoint &p) const {
+RectType FrameLessWidget::get_rect_type(const QPoint &p) const {
     if (p.y() < y2) {
         if (p.x() < x2) return R11;
         if (p.x() > x3) return R13;
@@ -253,8 +253,8 @@ void FrameLessWidget::resizeEvent(QResizeEvent *event) {
      .adjusted(-leftMargin, -topMargin, rightMargin, bottomMargin);
      setGeometry(screenSize);
   }
-  setPos();
-  setRs();
+  set_pos();
+  set_rs();
 }
 
 void FrameLessWidget::showEvent(QShowEvent *event) {
diff --git a/YSGraphic_Core/component/frameless/FrameLessWidget.h b/YSGraphic_Core/component/frameless/FrameLessWidget.h
index ba7a252..f6202fc 100644
--- a/YSGraphic_Core/component/frameless/FrameLessWidget.h
+++ b/YSGraphic_Core/component/frameless/FrameLessWidget.h
@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 #include <QColor>
 #include <QDebug>
 #include <QLinearGradient>
@@ -35,12 +35,12 @@ public:
     QList<changeSize> changeSizes;
     int radius;
     QColor background_color = QColor(150, 150, 150, 130);
-    virtual int getMinWidth();
-    virtual int getMinHeight();
-    void setPos();
-    void setRs();
+    virtual int get_min_width();
+    virtual int get_min_height();
+    void set_pos();
+    void set_rs();
 
-    [[nodiscard]] RectType getRectType(const QPoint& pos) const;
+    [[nodiscard]] RectType get_rect_type(const QPoint& pos) const;
     // window->showFullScreen();
     // window->showNormal();
     // window->showMinimized();
diff --git a/YSGraphic_Core/component/simple_widget.h b/YSGraphic_Core/component/simple_widget.h
index bddece3..e523d22 100644
--- a/YSGraphic_Core/component/simple_widget.h
+++ b/YSGraphic_Core/component/simple_widget.h
@@ -76,7 +76,7 @@ public:
 
         // 定时器：每隔一段时间更新一次动画
         m_timer = new QTimer(this);
-        connect(m_timer, &QTimer::timeout, this, &WaveWidget::updateWave);
+        connect(m_timer, &QTimer::timeout, this, &WaveWidget::update_wave);
         m_timer->start(16);  // 约60fps
 
         // 初始化动画
@@ -100,7 +100,7 @@ protected:
     }
 
     private slots:
-        void updateWave() {
+        void update_wave() {
         // 每次更新时间，更新 m_offset 以形成波动效果
         m_offset += 0.1;
         if (m_offset > 2 * (3.14159265358979323846)) {
diff --git a/YSGraphic_Core/export.cpp b/YSGraphic_Core/export.cpp
index 9157966..2d1081e 100644
--- a/YSGraphic_Core/export.cpp
+++ b/YSGraphic_Core/export.cpp
@@ -1,7 +1,7 @@
 #include "export.h"
 #include <QGuiApplication>
 
-ScreenInfo getScreenInfo()
+ScreenInfo get_screen_info()
 {
   ScreenInfo info;
 
diff --git a/YSGraphic_Core/export.h b/YSGraphic_Core/export.h
index c6f3f9c..713e132 100644
--- a/YSGraphic_Core/export.h
+++ b/YSGraphic_Core/export.h
@@ -29,7 +29,7 @@ struct ScreenInfo
   QSize availableSize; // 不包含任务栏
 };
 
-ScreenInfo getScreenInfo();
+ScreenInfo get_screen_info();
 
 
 
diff --git a/YSGraphic_Core/plottable/Afterglow.cpp b/YSGraphic_Core/plottable/Afterglow.cpp
index b7de743..60bb0fe 100644
--- a/YSGraphic_Core/plottable/Afterglow.cpp
+++ b/YSGraphic_Core/plottable/Afterglow.cpp
@@ -8,50 +8,50 @@ namespace YSG {
     AfterglowPrivate* Afterglow::d() {
         return Afterglow_Binding::d(this);
     }
-    RenderData* Afterglow::createRenderData() {
+    RenderData* Afterglow::create_render_data() {
         return Afterglow_Binding::create_render_data();
     }
-    RenderState* Afterglow::createRenderState() {
+    RenderState* Afterglow::create_render_state() {
         return Afterglow_Binding::create_render_state();
     }
-    InputData* Afterglow::createInputData() {
+    InputData* Afterglow::create_input_data() {
         return Afterglow_Binding::create_input_data();
     }
-    FrequentAxis* Afterglow::frequentAxis(SRC src) {
-        return d()->state_value(&AfterglowRenderState::frequentAxis, src);
+    FrequentAxis* Afterglow::frequent_axis(SRC src) {
+        return d()->state_value(&AfterglowRenderState::frequent_axis, src);
     }
-    void Afterglow::set_frequentAxis(FrequentAxis* value) {
-        d()->set_state_value(&AfterglowRenderState::frequentAxis, value);
+    void Afterglow::set_frequent_axis(FrequentAxis* value) {
+        d()->set_state_value(&AfterglowRenderState::frequent_axis, value);
     }
-    Axis* Afterglow::powerAxis(SRC src) {
-        return d()->state_value(&AfterglowRenderState::powerAxis, src);
+    Axis* Afterglow::power_axis(SRC src) {
+        return d()->state_value(&AfterglowRenderState::power_axis, src);
     }
-    void Afterglow::set_powerAxis(Axis* value) {
-        d()->set_state_value(&AfterglowRenderState::powerAxis, value);
+    void Afterglow::set_power_axis(Axis* value) {
+        d()->set_state_value(&AfterglowRenderState::power_axis, value);
     }
-    Range Afterglow::frequentRange(SRC src) {
-        return d()->state_value(&AfterglowRenderState::frequentRange, src);
+    Range Afterglow::frequent_range(SRC src) {
+        return d()->state_value(&AfterglowRenderState::frequent_range, src);
     }
-    void Afterglow::set_frequentRange(Range value) {
-        d()->set_state_value(&AfterglowRenderState::frequentRange, std::move(value));
+    void Afterglow::set_frequent_range(Range value) {
+        d()->set_state_value(&AfterglowRenderState::frequent_range, std::move(value));
     }
-    Range Afterglow::powerRange(SRC src) {
-        return d()->state_value(&AfterglowRenderState::powerRange, src);
+    Range Afterglow::power_range(SRC src) {
+        return d()->state_value(&AfterglowRenderState::power_range, src);
     }
-    void Afterglow::set_powerRange(Range value) {
-        d()->set_state_value(&AfterglowRenderState::powerRange, std::move(value));
+    void Afterglow::set_power_range(Range value) {
+        d()->set_state_value(&AfterglowRenderState::power_range, std::move(value));
     }
-    int Afterglow::frequentPointSize(SRC src) {
-        return d()->state_value(&AfterglowRenderState::frequentPointSize, src);
+    int Afterglow::frequent_point_size(SRC src) {
+        return d()->state_value(&AfterglowRenderState::frequent_point_size, src);
     }
-    int Afterglow::powerPointSize(SRC src) {
-        return d()->state_value(&AfterglowRenderState::powerPointSize, src);
+    int Afterglow::power_point_size(SRC src) {
+        return d()->state_value(&AfterglowRenderState::power_point_size, src);
     }
-    int Afterglow::bufferSize(SRC src) {
-        return d()->state_value(&AfterglowRenderState::bufferSize, src);
+    int Afterglow::buffer_size(SRC src) {
+        return d()->state_value(&AfterglowRenderState::buffer_size, src);
     }
-    void Afterglow::set_bufferSize(int value) {
-        d()->set_state_value(&AfterglowRenderState::bufferSize, value);
+    void Afterglow::set_buffer_size(int value) {
+        d()->set_state_value(&AfterglowRenderState::buffer_size, value);
     }
     bool Afterglow::interpolate(SRC src) {
         return d()->state_value(&AfterglowRenderState::interpolate, src);
@@ -59,34 +59,34 @@ namespace YSG {
     void Afterglow::set_interpolate(bool value) {
         d()->set_state_value(&AfterglowRenderState::interpolate, value);
     }
-    double Afterglow::attenuationRate(SRC src) {
-        return d()->state_value(&AfterglowRenderState::attenuationRate, src);
+    double Afterglow::attenuation_rate(SRC src) {
+        return d()->state_value(&AfterglowRenderState::attenuation_rate, src);
     }
-    void Afterglow::set_attenuationRate(double value) {
-        d()->set_state_value(&AfterglowRenderState::attenuationRate, value);
+    void Afterglow::set_attenuation_rate(double value) {
+        d()->set_state_value(&AfterglowRenderState::attenuation_rate, value);
     }
-    int Afterglow::initStrongValue(SRC src) {
-        return d()->state_value(&AfterglowRenderState::initStrongValue, src);
+    int Afterglow::init_strong_value(SRC src) {
+        return d()->state_value(&AfterglowRenderState::init_strong_value, src);
     }
-    void Afterglow::set_initStrongValue(int value) {
-        d()->set_state_value(&AfterglowRenderState::initStrongValue, value);
+    void Afterglow::set_init_strong_value(int value) {
+        d()->set_state_value(&AfterglowRenderState::init_strong_value, value);
     }
-    void Afterglow::set_frequentPointSize(int t) {
+    void Afterglow::set_frequent_point_size(int t) {
         AfterglowPrivate* pd = d();
         Render_Edit_Lease<AfterglowPrivate, AfterglowRenderState> edit(pd);
-        edit->frequentPointSize = std::move(t);
-        edit->bufferSize = edit->frequentPointSize * edit->powerPointSize;
+        edit->frequent_point_size = std::move(t);
+        edit->buffer_size = edit->frequent_point_size * edit->power_point_size;
     }
-    void Afterglow::set_powerPointSize(int t) {
+    void Afterglow::set_power_point_size(int t) {
         AfterglowPrivate* pd = d();
         Render_Edit_Lease<AfterglowPrivate, AfterglowRenderState> edit(pd);
-        edit->powerPointSize = std::move(t);
-        edit->bufferSize = edit->frequentPointSize * edit->powerPointSize;
+        edit->power_point_size = std::move(t);
+        edit->buffer_size = edit->frequent_point_size * edit->power_point_size;
     }
 
 
-    Afterglow::Builder::Builder(FrequentAxis* frequentAxis, Axis* powerAxis){
-        init(frequentAxis, powerAxis);
+    Afterglow::Builder::Builder(FrequentAxis* frequent_axis, Axis* power_axis){
+        init(frequent_axis, power_axis);
     }
     Afterglow* Afterglow::Builder::build() {
         auto ret = new Afterglow();
@@ -95,25 +95,25 @@ namespace YSG {
     }
 
 
-    void Afterglow::giveData(const QVector<double> &powerRangeData) {
+    void Afterglow::give_data(const QVector<double> &powerRangeData) {
         if(!ok()) return;
         AfterglowPrivate* pd = d();
         Render_State_Lease<AfterglowPrivate, AfterglowRenderState> state(pd);
-        int frequentPointSize = state->frequentPointSize;
-        if(powerRangeData.size() != frequentPointSize) {
-            qDebug() << QString("pushData(const QVector<double> &powerRangeData) error 数组大小不匹配 需要%1, 实际为%2")
-                .arg(frequentPointSize).arg(powerRangeData.size());
+        int frequent_point_size = state->frequent_point_size;
+        if(powerRangeData.size() != frequent_point_size) {
+            qDebug() << QString("push_data(const QVector<double> &powerRangeData) error 数组大小不匹配 需要%1, 实际为%2")
+                .arg(frequent_point_size).arg(powerRangeData.size());
             return;
         }
         Render_Input_Lease<AfterglowPrivate, AfterglowInputData> input(pd);
         input->mDataList.push_back(powerRangeData);
     }
 
-    void AfterglowPrivate::pushData(const QVector<double>& powerRangeData, const AfterglowRenderState* s) {
-        if(curIndex == s->initStrongValue) {
+    void AfterglowPrivate::push_data(const QVector<double>& powerRangeData, const AfterglowRenderState* s) {
+        if(curIndex == s->init_strong_value) {
             curIndex = 0;
-            double oldRemain = 1.0 - s->attenuationRate;
-            double cacheRemain = s->attenuationRate / (double)s->initStrongValue;
+            double oldRemain = 1.0 - s->attenuation_rate;
+            double cacheRemain = s->attenuation_rate / (double)s->init_strong_value;
             for(int i = 0; i < cacheBufferSize; ++i) {
                 mergedPowerData[i] = oldRemain*oldCachePowerData[i] + cacheRemain*cachedPowerData[i];
                 cachedPowerData[i] = 0;
@@ -121,27 +121,27 @@ namespace YSG {
             std::memmove(oldCachePowerData.data(), mergedPowerData.data(), cacheBufferSize * sizeof(double));
             cacheImageDirty = true;
         }
-        QVector<int> indexList(s->frequentPointSize);
-        double rate = (double)s->powerPointSize/s->powerRange.size();
-        for(int i = 0; i < s->frequentPointSize; ++i) {
-            int lineIndex = (int)((powerRangeData[i] - s->powerRange.lower) * rate);
+        QVector<int> indexList(s->frequent_point_size);
+        double rate = (double)s->power_point_size/s->power_range.size();
+        for(int i = 0; i < s->frequent_point_size; ++i) {
+            int lineIndex = (int)((powerRangeData[i] - s->power_range.lower) * rate);
             if (lineIndex < 0) lineIndex = 0;
-            if (lineIndex > s->powerPointSize - 1) lineIndex = s->powerPointSize - 1;
+            if (lineIndex > s->power_point_size - 1) lineIndex = s->power_point_size - 1;
             indexList[i] = lineIndex;
         }
         if(!s->interpolate) {
-            for(int i = 0; i < s->frequentPointSize; ++i) {
-                int index = indexList[i] * s->frequentPointSize + i;
+            for(int i = 0; i < s->frequent_point_size; ++i) {
+                int index = indexList[i] * s->frequent_point_size + i;
                 cachedPowerData[index]++;
             }
         } else {
             int lastLower = -1, lastUpper = -1;
-            for(int i = 0; i < s->frequentPointSize; ++i) {
+            for(int i = 0; i < s->frequent_point_size; ++i) {
                 int y = indexList[i];
-                cachedPowerData[y * s->frequentPointSize + i]++;
+                cachedPowerData[y * s->frequent_point_size + i]++;
                 if (y - lastUpper >= 2) {
                     for (int curY = lastUpper + 1; curY < y; ++curY) {
-                        cachedPowerData[curY * s->frequentPointSize + i]++;
+                        cachedPowerData[curY * s->frequent_point_size + i]++;
                     }
                     lastUpper = y;
                     lastLower = lastLower + 1;
@@ -149,7 +149,7 @@ namespace YSG {
                 }
                 if (lastLower - y >= 2) {
                     for (int curY = y + 1; curY < lastLower; ++curY) {
-                        cachedPowerData[curY * s->frequentPointSize + i]++;
+                        cachedPowerData[curY * s->frequent_point_size + i]++;
                     }
                     lastUpper = lastLower - 1;
                     lastLower = y;
diff --git a/YSGraphic_Core/plottable/Afterglow.h b/YSGraphic_Core/plottable/Afterglow.h
index 4c7c096..6538e73 100644
--- a/YSGraphic_Core/plottable/Afterglow.h
+++ b/YSGraphic_Core/plottable/Afterglow.h
@@ -10,57 +10,57 @@ namespace YSG {
     class LIB_DECL Afterglow : public RenderAble {
     public:
         AfterglowPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         Afterglow();
         friend struct AfterglowPrivate;
         friend struct AfterglowRenderState;
         friend struct AfterglowInputData;
     public:
-        PROP(FrequentAxis*, frequentAxis)
-        PROP(Axis*, powerAxis)
-        PROP(Range, frequentRange)
-        PROP(Range, powerRange)
-        PROP(int, frequentPointSize)
-        PROP(int, powerPointSize)
-        PROP(int, bufferSize)
+        PROP(FrequentAxis*, frequent_axis)
+        PROP(Axis*, power_axis)
+        PROP(Range, frequent_range)
+        PROP(Range, power_range)
+        PROP(int, frequent_point_size)
+        PROP(int, power_point_size)
+        PROP(int, buffer_size)
         PROP(bool, interpolate)
-        PROP(double, attenuationRate)
-        PROP(int, initStrongValue)
-        void giveData(const QVector<double> &powerRangeData);
+        PROP(double, attenuation_rate)
+        PROP(int, init_strong_value)
+        void give_data(const QVector<double> &powerRangeData);
         template <typename That> struct BuilderT;
         struct Builder;
     };
 
 
     struct Afterglow_Prop {
-        FrequentAxis *frequentAxis{};
-        Axis *powerAxis{};
-        Range frequentRange{0,10};
-        Range powerRange{0, 10};
-        int frequentPointSize{};
-        int powerPointSize{};
-        int bufferSize{};
+        FrequentAxis *frequent_axis{};
+        Axis *power_axis{};
+        Range frequent_range{0,10};
+        Range power_range{0, 10};
+        int frequent_point_size{};
+        int power_point_size{};
+        int buffer_size{};
         bool interpolate = true;  //线性插值
-        double attenuationRate = 0.2;  //衰减率  衰减率为 1.0代表 不使用衰减
-        int initStrongValue = 100; //初始强度
+        double attenuation_rate = 0.2;  //衰减率  衰减率为 1.0代表 不使用衰减
+        int init_strong_value = 100; //初始强度
     };
     template <typename That>
     struct Afterglow::BuilderT {
-        PROP_BT(FrequentAxis*, frequentAxis)
-        PROP_BT(Axis*, powerAxis)
-        PROP_BT(Range, frequentRange)
-        PROP_BT(Range, powerRange)
-        PROP_BT(int, frequentPointSize)
-        PROP_BT(int, powerPointSize)
-        PROP_BT(int, bufferSize)
+        PROP_BT(FrequentAxis*, frequent_axis)
+        PROP_BT(Axis*, power_axis)
+        PROP_BT(Range, frequent_range)
+        PROP_BT(Range, power_range)
+        PROP_BT(int, frequent_point_size)
+        PROP_BT(int, power_point_size)
+        PROP_BT(int, buffer_size)
         PROP_BT(bool, interpolate)
-        PROP_BT(double, attenuationRate)
-        PROP_BT(int, initStrongValue)
+        PROP_BT(double, attenuation_rate)
+        PROP_BT(int, init_strong_value)
         SETTER_T(QString, layerName, "plottable")
-        void init(FrequentAxis* frequentAxis, Axis* powerAxis);
+        void init(FrequentAxis* frequent_axis, Axis* power_axis);
         void set(Afterglow* t);
     protected:
         Plot *plot{};
@@ -68,7 +68,7 @@ namespace YSG {
 
     struct LIB_DECL Afterglow::Builder : Afterglow::BuilderT<Afterglow::Builder>,  Afterglow_Prop {
         Afterglow* build();
-        Builder(FrequentAxis* frequentAxis, Axis* powerAxis);
+        Builder(FrequentAxis* frequent_axis, Axis* power_axis);
     };
 
 }
diff --git a/YSGraphic_Core/plottable/Afterglow_p.h b/YSGraphic_Core/plottable/Afterglow_p.h
index b838eaa..f65d4b2 100644
--- a/YSGraphic_Core/plottable/Afterglow_p.h
+++ b/YSGraphic_Core/plottable/Afterglow_p.h
@@ -29,11 +29,11 @@ namespace YSG {
         QVector<double> cachedPowerData;
         QVector<double> oldCachePowerData;
         QVector<double> mergedPowerData;
-        [[nodiscard]] int strengthValue(const AfterglowRenderState* s) const {return (int)((double)s->initStrongValue / (1.0 - s->attenuationRate));}
-        void updateCacheSize(int frequentPointSize, int powerPointSize) {
-            cacheFrequentPointSize = frequentPointSize;
-            cachePowerPointSize = powerPointSize;
-            cacheBufferSize = frequentPointSize * powerPointSize;
+        [[nodiscard]] int strength_value(const AfterglowRenderState* s) const {return (int)((double)s->init_strong_value / (1.0 - s->attenuation_rate));}
+        void update_cache_size(int frequent_point_size, int power_point_size) {
+            cacheFrequentPointSize = frequent_point_size;
+            cachePowerPointSize = power_point_size;
+            cacheBufferSize = frequent_point_size * power_point_size;
             cachedPowerData.resize(cacheBufferSize);
             cachedPowerData.fill(0);
             oldCachePowerData.resize(cacheBufferSize);
@@ -42,17 +42,17 @@ namespace YSG {
             mergedPowerData.fill(0);
             curIndex = 0;
         }
-        void pushData(const QVector<double>& powerRangeData, const AfterglowRenderState* s);
+        void push_data(const QVector<double>& powerRangeData, const AfterglowRenderState* s);
         void draw(QPainter* painter) override {
-            AfterglowRenderState* s = renderState();
+            AfterglowRenderState* s = render_state();
             PerformanceShower *shower = q()->mPlot->d->mShower;
             if(shower) {
-                shower->setPerformanceLine("colCount, rowCount", PerformanceLine(QString("colCount:%1, rowCount:%2").arg(s->frequentPointSize).arg(s->powerPointSize)));
+                shower->set_performance_line("colCount, rowCount", PerformanceLine(QString("colCount:%1, rowCount:%2").arg(s->frequent_point_size).arg(s->power_point_size)));
             }
-            AbsAxis *hAxis = s->frequentAxis, *vAxis = s->powerAxis, *valueAxis = s->powerAxis;
-            Range &hRange = s->frequentRange, &vRange = s->powerRange;
+            AbsAxis *hAxis = s->frequent_axis, *vAxis = s->power_axis, *value_axis = s->power_axis;
+            Range &hRange = s->frequent_range, &vRange = s->power_range;
 
-            int colCount = s->frequentPointSize, rowCount = s->powerPointSize;
+            int colCount = s->frequent_point_size, rowCount = s->power_point_size;
             if(image.width() != colCount || image.height() != rowCount) {
                 image = QImage(colCount, rowCount, QImage::Format_ARGB32_Premultiplied);
                 image.fill(0);
@@ -61,7 +61,7 @@ namespace YSG {
                 if(cacheImageDirty) {
                     QVector<QRgb>& mColorMap = Global::instance()->mColorMap;
                     Cacl c("Afterglow setTime:%1 SRTT:%2 RTTVAR:%3", q()->mPlot->d->mShower);
-                    //double rate =  1.0/s->strengthValue() * 256.0;
+                    //double rate =  1.0/s->strength_value() * 256.0;
                     for (int row = 0; row < rowCount; ++row) {
                         QRgb* scanLine = reinterpret_cast<QRgb*>(image.scanLine(row));
                         double* list = oldCachePowerData.data() + row*colCount;
@@ -69,7 +69,7 @@ namespace YSG {
                             int colorOffset = (int)(list[col] * 255);
                             if (colorOffset < 0 || colorOffset > 255) {
                                 qDebug() << "colorOffset:" << colorOffset << " value: " << list[col]
-                                         << " startCoord:" << valueAxis->startCoord() << " endCoord:" << valueAxis->endCoord();
+                                         << " start_coord:" << value_axis->start_coord() << " end_coord:" << value_axis->end_coord();
                             }
                             //std::cout << "   " << list[col];
                             scanLine[col] = mColorMap.at(colorOffset);
@@ -79,12 +79,12 @@ namespace YSG {
                     cacheImageDirty = false;
                 }
             }
-            double x = hAxis->coordToPixel(hRange.lower, SRC::Render);
-            double y = vAxis->coordToPixel(vRange.lower, SRC::Render);
-            double w = hAxis->coordToPixel(hRange.upper, SRC::Render) - x;
-            double h = vAxis->coordToPixel(vRange.upper, SRC::Render) - y;
+            double x = hAxis->coord_to_pixel(hRange.lower, SRC::Render);
+            double y = vAxis->coord_to_pixel(vRange.lower, SRC::Render);
+            double w = hAxis->coord_to_pixel(hRange.upper, SRC::Render) - x;
+            double h = vAxis->coord_to_pixel(vRange.upper, SRC::Render) - y;
 
-            Range &&hAxisRange = hAxis->coordRange(), &&vAxisRange = vAxis->coordRange();
+            Range &&hAxisRange = hAxis->coord_range(), &&vAxisRange = vAxis->coord_range();
             double hr = ((hAxisRange.lower < hAxisRange.upper) ^ (hRange.lower < hRange.upper)) ? -1 : 1;
             double vr = ((vAxisRange.lower < vAxisRange.upper) ^ (vRange.lower < vRange.upper)) ? -1 : 1;
 
@@ -94,42 +94,42 @@ namespace YSG {
             painter->restore();
         }
 
-        void prepareData() override {
-            syncStatePipeline();
-            AfterglowRenderState* s = renderState();
-            if(cacheFrequentPointSize != s->frequentPointSize || cachePowerPointSize != s->powerPointSize) {
-                updateCacheSize(s->frequentPointSize, s->powerPointSize);
+        void prepare_data() override {
+            sync_state_pipeline();
+            AfterglowRenderState* s = render_state();
+            if(cacheFrequentPointSize != s->frequent_point_size || cachePowerPointSize != s->power_point_size) {
+                update_cache_size(s->frequent_point_size, s->power_point_size);
             }
-            AfterglowInputData* input = renderInputData();
+            AfterglowInputData* input = render_input_data();
             for(const QVector<double>& data : input->mDataList) {
-                pushData(data, s);
+                push_data(data, s);
             }
-            clearRenderInput();
+            clear_render_input();
         }
     };
     template <typename That>
-    void Afterglow::BuilderT<That>::init(FrequentAxis* frequentAxis, Axis* powerAxis) {
-        ASSERT(frequentAxis->mPlot != nullptr, "Afterglow build error! frequentAxis->mPlot == nullptr");
-        ASSERT(frequentAxis->mPlot == powerAxis->mPlot, "Afterglow build error! frequentAxis->mPlot != powerAxis->mPlot");
-        plot = frequentAxis->mPlot;
-        static_cast<That*>(this)->frequentAxis = frequentAxis;
-        static_cast<That*>(this)->powerAxis = powerAxis;
+    void Afterglow::BuilderT<That>::init(FrequentAxis* frequent_axis, Axis* power_axis) {
+        ASSERT(frequent_axis->mPlot != nullptr, "Afterglow build error! frequent_axis->mPlot == nullptr");
+        ASSERT(frequent_axis->mPlot == power_axis->mPlot, "Afterglow build error! frequent_axis->mPlot != power_axis->mPlot");
+        plot = frequent_axis->mPlot;
+        static_cast<That*>(this)->frequent_axis = frequent_axis;
+        static_cast<That*>(this)->power_axis = power_axis;
     }
     template <typename That>
     void Afterglow::BuilderT<That>::set(Afterglow* ret) {
         ret->init(plot, layerName);
         AfterglowPrivate* pd = ret->d();
         AfterglowRenderState* sc = reinterpret_cast<AfterglowRenderState*>(pd->state(State_Edit));
-        PROP_RT(FrequentAxis*, frequentAxis)
-        PROP_RT(Axis*, powerAxis)
-        PROP_RT(Range, frequentRange)
-        PROP_RT(Range, powerRange)
-        PROP_RT(int, frequentPointSize)
-        PROP_RT(int, powerPointSize)
-        PROP_RT(int, bufferSize)
+        PROP_RT(FrequentAxis*, frequent_axis)
+        PROP_RT(Axis*, power_axis)
+        PROP_RT(Range, frequent_range)
+        PROP_RT(Range, power_range)
+        PROP_RT(int, frequent_point_size)
+        PROP_RT(int, power_point_size)
+        PROP_RT(int, buffer_size)
         PROP_RT(bool, interpolate)
-        PROP_RT(double, attenuationRate)
-        PROP_RT(int, initStrongValue)
+        PROP_RT(double, attenuation_rate)
+        PROP_RT(int, init_strong_value)
     }
 
 }
diff --git a/YSGraphic_Core/plottable/AudioFrequent.cpp b/YSGraphic_Core/plottable/AudioFrequent.cpp
index 644d95d..419e9fa 100644
--- a/YSGraphic_Core/plottable/AudioFrequent.cpp
+++ b/YSGraphic_Core/plottable/AudioFrequent.cpp
@@ -10,38 +10,38 @@ namespace YSG {
     AudioFrequentPrivate* AudioFrequent::d() {
         return AudioFrequent_Binding::d(this);
     }
-    RenderData* AudioFrequent::createRenderData() {
+    RenderData* AudioFrequent::create_render_data() {
         return AudioFrequent_Binding::create_render_data();
     }
-    RenderState* AudioFrequent::createRenderState() {
+    RenderState* AudioFrequent::create_render_state() {
         return AudioFrequent_Binding::create_render_state();
     }
-    InputData* AudioFrequent::createInputData() {
+    InputData* AudioFrequent::create_input_data() {
         return AudioFrequent_Binding::create_input_data();
     }
-    int AudioFrequent::timePointSize(SRC src) {
-        return d()->state_value(&AudioFrequentRenderState::timePointSize, src);
+    int AudioFrequent::time_point_size(SRC src) {
+        return d()->state_value(&AudioFrequentRenderState::time_point_size, src);
     }
-    void AudioFrequent::set_timePointSize(int value) {
-        d()->set_state_value(&AudioFrequentRenderState::timePointSize, value);
+    void AudioFrequent::set_time_point_size(int value) {
+        d()->set_state_value(&AudioFrequentRenderState::time_point_size, value);
     }
-    TimeAxis* AudioFrequent::timeAxis(SRC src) {
-        return d()->state_value(&AudioFrequentRenderState::timeAxis, src);
+    TimeAxis* AudioFrequent::time_axis(SRC src) {
+        return d()->state_value(&AudioFrequentRenderState::time_axis, src);
     }
-    void AudioFrequent::set_timeAxis(TimeAxis* value) {
-        d()->set_state_value(&AudioFrequentRenderState::timeAxis, value);
+    void AudioFrequent::set_time_axis(TimeAxis* value) {
+        d()->set_state_value(&AudioFrequentRenderState::time_axis, value);
     }
-    Axis* AudioFrequent::valueAxis(SRC src) {
-        return d()->state_value(&AudioFrequentRenderState::valueAxis, src);
+    Axis* AudioFrequent::value_axis(SRC src) {
+        return d()->state_value(&AudioFrequentRenderState::value_axis, src);
     }
-    void AudioFrequent::set_valueAxis(Axis* value) {
-        d()->set_state_value(&AudioFrequentRenderState::valueAxis, value);
+    void AudioFrequent::set_value_axis(Axis* value) {
+        d()->set_state_value(&AudioFrequentRenderState::value_axis, value);
     }
-    Range AudioFrequent::keyRange(SRC src) {
-        return d()->state_value(&AudioFrequentRenderState::keyRange, src);
+    Range AudioFrequent::key_range(SRC src) {
+        return d()->state_value(&AudioFrequentRenderState::key_range, src);
     }
-    void AudioFrequent::set_keyRange(Range value) {
-        d()->set_state_value(&AudioFrequentRenderState::keyRange, std::move(value));
+    void AudioFrequent::set_key_range(Range value) {
+        d()->set_state_value(&AudioFrequentRenderState::key_range, std::move(value));
     }
     QColor AudioFrequent::color(SRC src) {
         return d()->state_value(&AudioFrequentRenderState::color, src);
@@ -49,26 +49,26 @@ namespace YSG {
     void AudioFrequent::set_color(QColor value) {
         d()->set_state_value(&AudioFrequentRenderState::color, std::move(value));
     }
-    AudioFrequent::Builder::Builder(TimeAxis* timeAxis, Axis* valueAxis) {
-        ASSERT(timeAxis->mPlot != nullptr, "AudioFrequent build error! timeAxis->mPlot == nullptr");
-        ASSERT(timeAxis->mPlot == valueAxis->mPlot, "AudioFrequent build error! timeAxis->mPlot != valueAxis->mPlot");
-        plot = timeAxis->mPlot;
-        this->timeAxis = timeAxis;
-        this->valueAxis = valueAxis;
+    AudioFrequent::Builder::Builder(TimeAxis* time_axis, Axis* value_axis) {
+        ASSERT(time_axis->mPlot != nullptr, "AudioFrequent build error! time_axis->mPlot == nullptr");
+        ASSERT(time_axis->mPlot == value_axis->mPlot, "AudioFrequent build error! time_axis->mPlot != value_axis->mPlot");
+        plot = time_axis->mPlot;
+        this->time_axis = time_axis;
+        this->value_axis = value_axis;
     }
     AudioFrequent* AudioFrequent::Builder::build() {
         auto ret = new AudioFrequent();
         ret->init(plot, layerName);
         AudioFrequentPrivate* pd = ret->d();
         AudioFrequentRenderState* sc = reinterpret_cast<AudioFrequentRenderState*>(pd->state(State_Edit));
-        PROP_R(int, timePointSize)
-        PROP_R(TimeAxis*, timeAxis)
-        PROP_R(Axis*, valueAxis)
-        PROP_R(Range, keyRange)
+        PROP_R(int, time_point_size)
+        PROP_R(TimeAxis*, time_axis)
+        PROP_R(Axis*, value_axis)
+        PROP_R(Range, key_range)
         PROP_R(QColor, color)
         return ret;
     }
-    void AudioFrequent::giveData(int tick, double data) {
+    void AudioFrequent::give_data(int tick, double data) {
         Q_UNUSED(tick)
         if(!ok()) return;
         Render_Input_Lease<AudioFrequentPrivate, AudioFrequentInputData> input(d());
diff --git a/YSGraphic_Core/plottable/AudioFrequent.h b/YSGraphic_Core/plottable/AudioFrequent.h
index 3638cad..57919cf 100644
--- a/YSGraphic_Core/plottable/AudioFrequent.h
+++ b/YSGraphic_Core/plottable/AudioFrequent.h
@@ -12,42 +12,42 @@ namespace YSG {
     class LIB_DECL AudioFrequent : public RenderAble {
     public:
         AudioFrequentPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         AudioFrequent();
         friend struct AudioFrequentPrivate;
         friend struct AudioFrequentRenderState;
         friend struct AudioFrequentInputData;
     public:
-        void giveData(int tick, double data);
-        PROP(int, timePointSize)
-        PROP(TimeAxis*, timeAxis)
-        PROP(Axis*, valueAxis)
-        PROP(Range, keyRange)
+        void give_data(int tick, double data);
+        PROP(int, time_point_size)
+        PROP(TimeAxis*, time_axis)
+        PROP(Axis*, value_axis)
+        PROP(Range, key_range)
         PROP(QColor, color)
         struct Builder;
     };
     struct AudioFrequent_Prop {
-        int timePointSize = 100;
-        TimeAxis *timeAxis;
-        Axis *valueAxis{};
-        Range keyRange = {0, 20};
+        int time_point_size = 100;
+        TimeAxis *time_axis;
+        Axis *value_axis{};
+        Range key_range = {0, 20};
         QColor color = Qt::yellow;
     };
     struct LIB_DECL AudioFrequent::Builder : AudioFrequent_Prop {
-        PROP_B(int, timePointSize)
-        PROP_B(TimeAxis*, timeAxis)
-        PROP_B(Axis*, valueAxis)
-        PROP_B(Range, keyRange)
+        PROP_B(int, time_point_size)
+        PROP_B(TimeAxis*, time_axis)
+        PROP_B(Axis*, value_axis)
+        PROP_B(Range, key_range)
         PROP_B(QColor, color)
         SETTER(QString, layerName, "plottable")
-        Builder(TimeAxis* timeAxis, Axis* valueAxis);
+        Builder(TimeAxis* time_axis, Axis* value_axis);
         AudioFrequent* build();
     protected:
-        Axis* valueAxis;
-        TimeAxis* timeAxis{};
+        Axis* value_axis;
+        TimeAxis* time_axis{};
         Plot *plot{};
     };
 }
diff --git a/YSGraphic_Core/plottable/AudioFrequent_p.h b/YSGraphic_Core/plottable/AudioFrequent_p.h
index 3e7962e..16e77cc 100644
--- a/YSGraphic_Core/plottable/AudioFrequent_p.h
+++ b/YSGraphic_Core/plottable/AudioFrequent_p.h
@@ -41,43 +41,43 @@ namespace YSG {
         void snapshotPowerBuffer() {
             buffer.peek_best_effort(powerSnapshot.data(), sizeof(double) * dataCount);
         }
-        void prepareData() override {
-            syncStatePipeline();
-            AudioFrequentRenderState *s = renderState();
-            AudioFrequentInputData *d = renderInputData();
-            if(pointCount != s->timePointSize) {
-                resizePowerBuffer(s->timePointSize);
+        void prepare_data() override {
+            sync_state_pipeline();
+            AudioFrequentRenderState *s = render_state();
+            AudioFrequentInputData *d = render_input_data();
+            if(pointCount != s->time_point_size) {
+                resizePowerBuffer(s->time_point_size);
                 PerformanceShower *shower = q()->mPlot->d->mShower;
                 if(shower) {
-                    shower->setPerformanceLine("TimePointSize", PerformanceLine(QString("timePointSize:%1").arg(s->timePointSize)));
+                    shower->set_performance_line("TimePointSize", PerformanceLine(QString("time_point_size:%1").arg(s->time_point_size)));
                 }
             }
             for(double& power : d->mDataList) {
                 pushPower(power);
             }
             snapshotPowerBuffer();
-            clearRenderInput();
+            clear_render_input();
         }
 
 
         void draw(QPainter* painter) override {
-            AudioFrequentRenderState *s = renderState();
+            AudioFrequentRenderState *s = render_state();
             PerformanceShower *shower = q()->mPlot->d->mShower;
             if(shower) {
-                shower->setPerformanceLine("timePointSize", PerformanceLine(QString("timePointSize:%1").arg(s->timeAxis->timePointSize())));
+                shower->set_performance_line("time_point_size", PerformanceLine(QString("time_point_size:%1").arg(s->time_axis->time_point_size())));
             }
             painter->save();
             QPolygonF polyline;
-            int start = (int)s->timeAxis->startCoord();
+            int start = (int)s->time_axis->start_coord();
             QPen newPen = QPen(s->color);
             newPen.setWidth(0);
             painter->setPen(newPen);
             for(int i = 0; i < dataCount; ++i) {
                 double* power = powerSnapshot.data() + dataCount - 1 - i;
-                int index =  s->timeAxis->d()->mTimeTicker.mStartCoordToEndCoord ? start + i :
-                start + s->timeAxis->d()->mTimeTicker.mTimePointSize - i;
-                double x = s->timeAxis->coordToPixel(index, SRC::Render);
-                double y = s->valueAxis->coordToPixel(*power, SRC::Render);
+                int index =  s->time_axis->d()->mTimeTicker.mStartCoordToEndCoord ? start + i :
+                start + s->time_axis->d()->mTimeTicker.mTimePointSize - i;
+                double x = s->time_axis->coord_to_pixel(index, SRC::Render);
+                double y = s->value_axis->coord_to_pixel(*power, SRC::Render);
                 polyline.append({x, y});
             }
             painter->drawPolyline(polyline);
diff --git a/YSGraphic_Core/plottable/HoverInfo.cpp b/YSGraphic_Core/plottable/HoverInfo.cpp
index 054763e..c2f641c 100644
--- a/YSGraphic_Core/plottable/HoverInfo.cpp
+++ b/YSGraphic_Core/plottable/HoverInfo.cpp
@@ -3,20 +3,20 @@
 #include "../base/Plot.h"
 
 namespace YSG {
-    void HoverInfoRenderState::drawHover(QPainter* painter, AbsAxis* h, AbsAxis* v) {
+    void HoverInfoRenderState::draw_hover(QPainter* painter, AbsAxis* h, AbsAxis* v) {
         QPoint pos = hoverInfoPos;
         if(!renderAble) {
             auto that = dynamic_cast<RenderState*>(this);
             renderAble = dynamic_cast<HoverInfoRenderAbleInterFace*>(that->dPtr->qPtr);
         }
-        QVector<QString> lines = renderAble->createHoverString(h, v, pos);
+        QVector<QString> lines = renderAble->create_hover_string(h, v, pos);
         QFontMetrics fm(hoverInfoFont);
         int width = std::numeric_limits<int>::min();
         for(QString& s : lines) width = qMax(width, fm.horizontalAdvance(s));
         QRect r = QRect(pos.x() + hoverInfoLeft, pos.y() + hoverInfoTop,
         (int)width  + hoverInfoRight + hoverInfoLeft, fm.height() * lines.size() + hoverInfoBottom);
         painter->fillRect(r, hoverInfoBrush);
-        painter->setPen(hoverInfoPen);
+        painter->setPen(hover_info_pen);
         painter->setFont(hoverInfoFont);
         int lineHeight = fm.height();
         for (int i = 0; i < lines.size(); ++i) {
@@ -25,16 +25,16 @@ namespace YSG {
         }
     }
 
-    bool HoverInfoRenderState::hoverOK(RenderAble* able) const {
+    bool HoverInfoRenderState::hover_ok(RenderAble* able) const {
         auto tmp = dynamic_cast<HoverInfoRenderAbleInterFace*>(able);
-        return useHoverInfo && hoverInfoActive && tmp->hoverTest(hoverInfoPos);
+        return use_hover_info && hoverInfoActive && tmp->hover_test(hoverInfoPos);
     }
 
-    QVector<QString> HoverInfoRenderAbleInterFace::createHoverString(AbsAxis* h, AbsAxis* v, QPoint pos) {
-        double tick1 = h->pixelToCoord(pos.x(), SRC::Render);
-        double tick2 = v->pixelToCoord(pos.y(), SRC::Render);
-        QString line1 = h->getTickLabel(tick1, SRC::Render) + h->unitText();
-        QString line2 = v->getTickLabel(tick2, SRC::Render) + v->unitText();
+    QVector<QString> HoverInfoRenderAbleInterFace::create_hover_string(AbsAxis* h, AbsAxis* v, QPoint pos) {
+        double tick1 = h->pixel_to_coord(pos.x(), SRC::Render);
+        double tick2 = v->pixel_to_coord(pos.y(), SRC::Render);
+        QString line1 = h->get_tick_label(tick1, SRC::Render) + h->unit_text();
+        QString line2 = v->get_tick_label(tick2, SRC::Render) + v->unit_text();
         return {line1, line2};
     }
 }
diff --git a/YSGraphic_Core/plottable/HoverInfo.h b/YSGraphic_Core/plottable/HoverInfo.h
index fdc14c9..5623b7a 100644
--- a/YSGraphic_Core/plottable/HoverInfo.h
+++ b/YSGraphic_Core/plottable/HoverInfo.h
@@ -13,99 +13,99 @@ namespace YSG {
         int hoverInfoLeft = 4, hoverInfoTop = 4, hoverInfoRight = 4, hoverInfoBottom = 4;
         QBrush hoverInfoBrush;
         QFont hoverInfoFont;
-        QPen hoverInfoPen;
-        bool useHoverInfo = true;
+        QPen hover_info_pen;
+        bool use_hover_info = true;
         bool hoverInfoActive = false;
         QPoint hoverInfoPos;
         HoverInfoRenderAbleInterFace *renderAble{};
-        void drawHover(QPainter* painter, AbsAxis *h, AbsAxis *v);
-        bool hoverOK(RenderAble* able) const;
+        void draw_hover(QPainter* painter, AbsAxis *h, AbsAxis *v);
+        bool hover_ok(RenderAble* able) const;
     };
     struct LIB_DECL HoverInfoRenderAbleInterFace {
-        virtual QVector<QString> createHoverString(AbsAxis* h, AbsAxis* v, QPoint pos);
+        virtual QVector<QString> create_hover_string(AbsAxis* h, AbsAxis* v, QPoint pos);
         virtual ~HoverInfoRenderAbleInterFace() = default;
-        virtual void drawHover(QPainter* painter, AbsAxis *h, AbsAxis *v) {
-            return hoverState(SRC::Render)->drawHover(painter, h, v);
+        virtual void draw_hover(QPainter* painter, AbsAxis *h, AbsAxis *v) {
+            return hover_state(SRC::Render)->draw_hover(painter, h, v);
         }
-        virtual bool hoverOK(RenderAble* able) {
-            return hoverState(SRC::Render)->hoverOK(able);
+        virtual bool hover_ok(RenderAble* able) {
+            return hover_state(SRC::Render)->hover_ok(able);
         }
-        virtual bool hoverTest(QPoint pos) {
+        virtual bool hover_test(QPoint pos) {
             return true;
         }
-        bool useHoverInfo(SRC src = SRC::Edit) {
-            return hoverState(src)->useHoverInfo;
+        bool use_hover_info(SRC src = SRC::Edit) {
+            return hover_state(src)->use_hover_info;
         }
-        void setUseHoverInfo(bool use) {
-            HoverInfoRenderState* sc = beginHoverEdit();
-            sc->useHoverInfo = use;
-            finishHoverEdit();
+        void set_use_hover_info(bool use) {
+            HoverInfoRenderState* sc = begin_hover_edit();
+            sc->use_hover_info = use;
+            finish_hover_edit();
         }
-        void setHoverInfoFont(const QFont& font) {
-            HoverInfoRenderState* sc = beginHoverEdit();
+        void set_hover_info_font(const QFont& font) {
+            HoverInfoRenderState* sc = begin_hover_edit();
             sc->hoverInfoFont = font;
-            finishHoverEdit();
+            finish_hover_edit();
         }
-        QFont HoverInfoFont(SRC src = SRC::Edit) {
-            return hoverState(src)->hoverInfoFont;
+        QFont hover_info_font(SRC src = SRC::Edit) {
+            return hover_state(src)->hoverInfoFont;
         }
-        QBrush hoverInfoBackgroundBrush(SRC src = SRC::Edit) {
-            return hoverState(src)->hoverInfoBrush;
+        QBrush hover_info_background_brush(SRC src = SRC::Edit) {
+            return hover_state(src)->hoverInfoBrush;
         }
-        void setHoverInfoBackgroundBrush(const QBrush& brush) {
-            HoverInfoRenderState* sc = beginHoverEdit();
+        void set_hover_info_background_brush(const QBrush& brush) {
+            HoverInfoRenderState* sc = begin_hover_edit();
             sc->hoverInfoBrush = brush.color().isValid() ? brush : Qt::NoBrush;
-            finishHoverEdit();
+            finish_hover_edit();
         }
-        QPen hoverInfoPen(SRC src = SRC::Edit) {
-            return hoverState(src)->hoverInfoPen;
+        QPen hover_info_pen(SRC src = SRC::Edit) {
+            return hover_state(src)->hover_info_pen;
         }
-        void setHoverInfoPen(const QPen& pen) {
-            HoverInfoRenderState* sc = beginHoverEdit();
-            sc->hoverInfoPen = pen.color().isValid() ? pen : Qt::NoPen;
-            finishHoverEdit();
+        void set_hover_info_pen(const QPen& pen) {
+            HoverInfoRenderState* sc = begin_hover_edit();
+            sc->hover_info_pen = pen.color().isValid() ? pen : Qt::NoPen;
+            finish_hover_edit();
         }
-        void getHoverInfoContentsMargins(int& left, int& top, int& right, int& bottom, SRC src) {
-            auto s = hoverState(src);
+        void get_hover_info_contents_margins(int& left, int& top, int& right, int& bottom, SRC src) {
+            auto s = hover_state(src);
             left = s->hoverInfoLeft;
             top = s->hoverInfoTop;
             right = s->hoverInfoRight;
             bottom = s->hoverInfoBottom;
         }
 
-        void setHoverInfoContentsMargins(int left, int top, int right, int bottom) {
-            HoverInfoRenderState* sc = beginHoverEdit();
+        void set_hover_info_contents_margins(int left, int top, int right, int bottom) {
+            HoverInfoRenderState* sc = begin_hover_edit();
             sc->hoverInfoLeft = left;
             sc->hoverInfoTop = top;
             sc->hoverInfoRight = right;
             sc->hoverInfoBottom = bottom;
-            finishHoverEdit();
+            finish_hover_edit();
         }
     protected:
-        virtual HoverInfoRenderState* hoverState(SRC src) = 0;
-        virtual HoverInfoRenderState* beginHoverEdit() = 0;
-        virtual void finishHoverEdit() = 0;
+        virtual HoverInfoRenderState* hover_state(SRC src) = 0;
+        virtual HoverInfoRenderState* begin_hover_edit() = 0;
+        virtual void finish_hover_edit() = 0;
     };
     struct LIB_DECL HoverInfoIndependRenderAble : HoverInfoRenderAbleInterFace {
     private:
         HoverInfoRenderState s, sc;
-        HoverInfoRenderState* hoverState(SRC src) override {
+        HoverInfoRenderState* hover_state(SRC src) override {
             if(src == SRC::Edit) {
                 return &sc;
             }
             return &s;
         }
-        HoverInfoRenderState* beginHoverEdit() override {
+        HoverInfoRenderState* begin_hover_edit() override {
             return &sc;
         }
-        void finishHoverEdit() override {
+        void finish_hover_edit() override {
         }
     public:
-        void drawHover(QPainter* painter, AbsAxis* h, AbsAxis* v) override {
+        void draw_hover(QPainter* painter, AbsAxis* h, AbsAxis* v) override {
             s.renderAble = this;
             sc.renderAble = this;
             s = sc;
-            HoverInfoRenderAbleInterFace::drawHover(painter, h, v);
+            HoverInfoRenderAbleInterFace::draw_hover(painter, h, v);
         }
     };
     template <typename That>
@@ -115,19 +115,19 @@ namespace YSG {
             return static_cast<That*>(this);
         }
         Triple_Buffer_Lease mHoverLease{};
-        HoverInfoRenderState* hoverState(SRC src) override {
+        HoverInfoRenderState* hover_state(SRC src) override {
             auto t = that();
             return dynamic_cast<HoverInfoRenderState*>(t->dPtr->state(src));
         }
-        HoverInfoRenderState* beginHoverEdit() override {
+        HoverInfoRenderState* begin_hover_edit() override {
             auto t = that();
             mHoverLease = t->dPtr->mStateControl.wait_mark_use_role(State_Edit);
-            return dynamic_cast<HoverInfoRenderState*>(t->dPtr->stateByIndex(mHoverLease.index));
+            return dynamic_cast<HoverInfoRenderState*>(t->dPtr->state_by_index(mHoverLease.index));
         }
-        void finishHoverEdit() override {
+        void finish_hover_edit() override {
             auto t = that();
-            ++t->dPtr->stateByIndex(mHoverLease.index)->version;
-            t->markRenderDirty();
+            ++t->dPtr->state_by_index(mHoverLease.index)->version;
+            t->mark_render_dirty();
             t->dPtr->mStateControl.unmark_use(mHoverLease);
             mHoverLease = {};
         }
diff --git a/YSGraphic_Core/plottable/Planisphere.cpp b/YSGraphic_Core/plottable/Planisphere.cpp
index c9cab98..15e3748 100644
--- a/YSGraphic_Core/plottable/Planisphere.cpp
+++ b/YSGraphic_Core/plottable/Planisphere.cpp
@@ -12,56 +12,56 @@ namespace YSG {
     PlanispherePrivate* Planisphere::d() {
         return Planisphere_Binding::d(this);
     }
-    RenderData* Planisphere::createRenderData() {
+    RenderData* Planisphere::create_render_data() {
         return Planisphere_Binding::create_render_data();
     }
-    RenderState* Planisphere::createRenderState() {
+    RenderState* Planisphere::create_render_state() {
         return Planisphere_Binding::create_render_state();
     }
-    InputData* Planisphere::createInputData() {
+    InputData* Planisphere::create_input_data() {
         return Planisphere_Binding::create_input_data();
     }
-    Axis* Planisphere::IAxis(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::IAxis, src);
+    Axis* Planisphere::i_axis(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::i_axis, src);
     }
-    void Planisphere::set_IAxis(Axis* value) {
-        d()->set_state_value(&PlanisphereRenderState::IAxis, value);
+    void Planisphere::set_i_axis(Axis* value) {
+        d()->set_state_value(&PlanisphereRenderState::i_axis, value);
     }
-    Axis* Planisphere::QAxis(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::QAxis, src);
+    Axis* Planisphere::q_axis(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::q_axis, src);
     }
-    void Planisphere::set_QAxis(Axis* value) {
-        d()->set_state_value(&PlanisphereRenderState::QAxis, value);
+    void Planisphere::set_q_axis(Axis* value) {
+        d()->set_state_value(&PlanisphereRenderState::q_axis, value);
     }
-    Range Planisphere::IRange(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::IRange, src);
+    Range Planisphere::i_range(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::i_range, src);
     }
-    void Planisphere::set_IRange(Range value) {
-        d()->set_state_value(&PlanisphereRenderState::IRange, std::move(value));
+    void Planisphere::set_i_range(Range value) {
+        d()->set_state_value(&PlanisphereRenderState::i_range, std::move(value));
     }
-    Range Planisphere::QRange(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::QRange, src);
+    Range Planisphere::q_range(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::q_range, src);
     }
-    void Planisphere::set_QRange(Range value) {
-        d()->set_state_value(&PlanisphereRenderState::QRange, std::move(value));
+    void Planisphere::set_q_range(Range value) {
+        d()->set_state_value(&PlanisphereRenderState::q_range, std::move(value));
     }
-    QColor Planisphere::pointColor(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::pointColor, src);
+    QColor Planisphere::point_color(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::point_color, src);
     }
-    void Planisphere::set_pointColor(QColor value) {
-        d()->set_state_value(&PlanisphereRenderState::pointColor, std::move(value));
+    void Planisphere::set_point_color(QColor value) {
+        d()->set_state_value(&PlanisphereRenderState::point_color, std::move(value));
     }
-    QColor Planisphere::anchorColor(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::anchorColor, src);
+    QColor Planisphere::anchor_color(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::anchor_color, src);
     }
-    void Planisphere::set_anchorColor(QColor value) {
-        d()->set_state_value(&PlanisphereRenderState::anchorColor, std::move(value));
+    void Planisphere::set_anchor_color(QColor value) {
+        d()->set_state_value(&PlanisphereRenderState::anchor_color, std::move(value));
     }
-    int Planisphere::continueMillisecond(SRC src) {
-        return d()->state_value(&PlanisphereRenderState::continueMillisecond, src);
+    int Planisphere::continue_millisecond(SRC src) {
+        return d()->state_value(&PlanisphereRenderState::continue_millisecond, src);
     }
-    void Planisphere::set_continueMillisecond(int value) {
-        d()->set_state_value(&PlanisphereRenderState::continueMillisecond, value);
+    void Planisphere::set_continue_millisecond(int value) {
+        d()->set_state_value(&PlanisphereRenderState::continue_millisecond, value);
     }
     Planisphere_Type Planisphere::type(SRC src) {
         return d()->state_value(&PlanisphereRenderState::type, src);
@@ -69,44 +69,44 @@ namespace YSG {
     void Planisphere::set_type(Planisphere_Type value) {
         d()->set_state_value(&PlanisphereRenderState::type, value);
     }
-    void Planisphere::giveData(QPointF pos) {
+    void Planisphere::give_data(QPointF pos) {
         if(!ok()) return;
         if(!mPlot->isVisible()) return;
         Render_Input_Lease<PlanispherePrivate, PlanisphereInputData> input(d());
         input->mDataList.push_back({pos});
     }
 
-    Planisphere::Builder::Builder(Axis* IAxis, Axis* QAxis) {
-        ASSERT(IAxis->mPlot != nullptr, "Afterglow build error!  IAxis->mPlot == nullptr");
-        ASSERT(IAxis->mPlot == QAxis->mPlot, "Afterglow build error!  IAxis->mPlot != QAxis->mPlot");
-        plot = IAxis->mPlot;
-        this->IAxis = IAxis;
-        this->QAxis = QAxis;
+    Planisphere::Builder::Builder(Axis* i_axis, Axis* q_axis) {
+        ASSERT(i_axis->mPlot != nullptr, "Afterglow build error!  i_axis->mPlot == nullptr");
+        ASSERT(i_axis->mPlot == q_axis->mPlot, "Afterglow build error!  i_axis->mPlot != q_axis->mPlot");
+        plot = i_axis->mPlot;
+        this->i_axis = i_axis;
+        this->q_axis = q_axis;
     }
     Planisphere* Planisphere::Builder::build() {
         auto ret = new Planisphere();
         ret->init(plot, layerName);
         PlanispherePrivate* pd = ret->d();
         PlanisphereRenderState* sc = reinterpret_cast<PlanisphereRenderState*>(pd->state(State_Edit));
-        PROP_R(Axis*, IAxis)
-        PROP_R(Axis*, QAxis)
-        PROP_R(Range, IRange)
-        PROP_R(Range, QRange)
-        PROP_R(QColor, pointColor)
-        PROP_R(QColor, anchorColor)
-        PROP_R(int, continueMillisecond)
+        PROP_R(Axis*, i_axis)
+        PROP_R(Axis*, q_axis)
+        PROP_R(Range, i_range)
+        PROP_R(Range, q_range)
+        PROP_R(QColor, point_color)
+        PROP_R(QColor, anchor_color)
+        PROP_R(int, continue_millisecond)
         PROP_R(Planisphere_Type, type)
         return ret;
     }
 
-    void Planisphere::setToAxisCenter() {
+    void Planisphere::set_to_axis_center() {
         PlanisphereRenderState *s = reinterpret_cast<PlanisphereRenderState*>(d()->state(State_Edit));
         double w = mPlot->width(), h = mPlot->height();
         double l = w < h ? w : h;
-        double iL = s->IAxis->coordRange().size()/w * l/2;
-        double qL = s->QAxis->coordRange().size()/h * l/2;
-        double im =  s->IAxis->coordRange().middle(), qm =  s->IAxis->coordRange().middle();
-        set_IRange({im-iL, im+iL});
-        set_QRange({qm-qL, qm+qL});
+        double iL = s->i_axis->coord_range().size()/w * l/2;
+        double qL = s->q_axis->coord_range().size()/h * l/2;
+        double im =  s->i_axis->coord_range().middle(), qm =  s->i_axis->coord_range().middle();
+        set_i_range({im-iL, im+iL});
+        set_q_range({qm-qL, qm+qL});
     }
 }
diff --git a/YSGraphic_Core/plottable/Planisphere.h b/YSGraphic_Core/plottable/Planisphere.h
index 6e046e8..3d275d6 100644
--- a/YSGraphic_Core/plottable/Planisphere.h
+++ b/YSGraphic_Core/plottable/Planisphere.h
@@ -7,49 +7,49 @@ namespace YSG {
     class LIB_DECL Planisphere : public RenderAble {
     public:
         PlanispherePrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         Planisphere();
         friend struct PlanispherePrivate;
         friend struct PlanisphereRenderState;
         friend struct PlanisphereInputData;
     public:
-        void giveData(QPointF pos);
-        PROP(Axis*, IAxis)
-        PROP(Axis*, QAxis)
-        PROP(Range, IRange)
-        PROP(Range, QRange)
-        PROP(QColor, pointColor)
-        PROP(QColor, anchorColor)
-        PROP(int, continueMillisecond)
+        void give_data(QPointF pos);
+        PROP(Axis*, i_axis)
+        PROP(Axis*, q_axis)
+        PROP(Range, i_range)
+        PROP(Range, q_range)
+        PROP(QColor, point_color)
+        PROP(QColor, anchor_color)
+        PROP(int, continue_millisecond)
         PROP(Planisphere_Type, type)
-        void setToAxisCenter();
+        void set_to_axis_center();
         struct Builder;
     };
 
     struct Planisphere_Prop {
-        Axis *IAxis{};
-        Axis *QAxis{};
-        Range IRange{0, 100};
-        Range QRange{0, 100};
-        QColor pointColor = Qt::red;
-        QColor anchorColor = Qt::yellow;
-        int continueMillisecond = 1000;
+        Axis *i_axis{};
+        Axis *q_axis{};
+        Range i_range{0, 100};
+        Range q_range{0, 100};
+        QColor point_color = Qt::red;
+        QColor anchor_color = Qt::yellow;
+        int continue_millisecond = 1000;
         Planisphere_Type type = Planisphere_Type::Psk8;
     };
     struct LIB_DECL Planisphere::Builder : Planisphere_Prop {
-        PROP_B(Axis*, IAxis)
-        PROP_B(Axis*, QAxis)
-        PROP_B(Range, IRange)
-        PROP_B(Range, QRange)
-        PROP_B(QColor, pointColor)
-        PROP_B(QColor, anchorColor)
-        PROP_B(int, continueMillisecond)
+        PROP_B(Axis*, i_axis)
+        PROP_B(Axis*, q_axis)
+        PROP_B(Range, i_range)
+        PROP_B(Range, q_range)
+        PROP_B(QColor, point_color)
+        PROP_B(QColor, anchor_color)
+        PROP_B(int, continue_millisecond)
         PROP_B(Planisphere_Type, type)
         SETTER(QString, layerName, "plottable")
-        Builder(Axis* IAxis, Axis* QAxis);
+        Builder(Axis* i_axis, Axis* q_axis);
         Planisphere* build();
     protected:
         Plot *plot{};
diff --git a/YSGraphic_Core/plottable/Planisphere_p.h b/YSGraphic_Core/plottable/Planisphere_p.h
index 8894186..d868377 100644
--- a/YSGraphic_Core/plottable/Planisphere_p.h
+++ b/YSGraphic_Core/plottable/Planisphere_p.h
@@ -25,14 +25,14 @@ namespace YSG {
         std::list<PlanisphereData> dataList;
         QVector<double> xs, ys;
         QVector<QPointF> fixedPoints;
-        void update_FixedPoints() {
-            PlanisphereRenderState *s = renderState();
+        void update_fixed_points() {
+            PlanisphereRenderState *s = render_state();
             fixedPoints.clear();
             if(s->type == Planisphere_Type::Psk8) {
-                double xS = s->IAxis->coordToPixel(s->IRange.lower, SRC::Render);
-                double yS = s->QAxis->coordToPixel(s->QRange.lower, SRC::Render);
-                double xL = s->IAxis->coordToPixel(s->IRange.upper, SRC::Render) - xS;
-                double yL = s->QAxis->coordToPixel(s->QRange.upper, SRC::Render) - yS;
+                double xS = s->i_axis->coord_to_pixel(s->i_range.lower, SRC::Render);
+                double yS = s->q_axis->coord_to_pixel(s->q_range.lower, SRC::Render);
+                double xL = s->i_axis->coord_to_pixel(s->i_range.upper, SRC::Render) - xS;
+                double yL = s->q_axis->coord_to_pixel(s->q_range.upper, SRC::Render) - yS;
                 double xSpace = xL/ 6.0;
                 double ySpace = yL/ 6.0;
                 double xLineSpace = xL / 4.0;
@@ -66,23 +66,23 @@ namespace YSG {
         }
 
 
-        void prepareData() override {
-            syncStatePipeline();
-            PlanisphereInputData *d = renderInputData();
-            PlanisphereRenderState *s = renderState();
-            int times = qMax(5, (s->continueMillisecond * q()->mPlot->d->mRefreshTimesPreSecond) / 1000);
+        void prepare_data() override {
+            sync_state_pipeline();
+            PlanisphereInputData *d = render_input_data();
+            PlanisphereRenderState *s = render_state();
+            int times = qMax(5, (s->continue_millisecond * q()->mPlot->d->mRefreshTimesPreSecond) / 1000);
             for(PlanisphereData& data : d->mDataList) {
                 data.maxTotalTimes = times;
                 data.mRemainTimes = times;
             }
             dataList.splice(dataList.end(), d->mDataList);
-            clearRenderInput();
+            clear_render_input();
             refresh();
         }
 
         void draw(QPainter *painter) override {
-            update_FixedPoints();
-            PlanisphereRenderState *s = renderState();
+            update_fixed_points();
+            PlanisphereRenderState *s = render_state();
             {
                 double xS = xs.first(), xE = xs.last();
                 double yS = ys.first(), yE = ys.last();
@@ -96,17 +96,17 @@ namespace YSG {
             {
                 painter->setPen(Qt::NoPen);
                 for(PlanisphereData &data : dataList) {
-                    QColor c = s->pointColor;
+                    QColor c = s->point_color;
                     c.setAlphaF(c.alphaF() * data.mRemainTimes / data.maxTotalTimes);
                     painter->setBrush(c);
-                    double centerX = s->IAxis->coordToPixel(data.mPos.x(), SRC::Render);
-                    double centerY = s->QAxis->coordToPixel(data.mPos.y(), SRC::Render);
+                    double centerX = s->i_axis->coord_to_pixel(data.mPos.x(), SRC::Render);
+                    double centerY = s->q_axis->coord_to_pixel(data.mPos.y(), SRC::Render);
                     double radius = 2;
                     painter->drawEllipse({centerX - radius, centerY - radius}, 2 * radius, 2 * radius);
                 }
             }
             {
-                painter->setPen(QPen(s->anchorColor, 2));
+                painter->setPen(QPen(s->anchor_color, 2));
                 painter->setBrush(Qt::NoBrush);
                 QVector<QPointF> &fixedPoints = this->fixedPoints;
                 for (auto &point: fixedPoints) {
@@ -119,7 +119,7 @@ namespace YSG {
 
 
 
-        void plotEvent(QEvent* event) override {
+        void plot_event(QEvent* event) override {
             if(event->type() == QEvent::Resize){
                 auto e = reinterpret_cast<QResizeEvent*>(event);
 
diff --git a/YSGraphic_Core/plottable/Spectrum.cpp b/YSGraphic_Core/plottable/Spectrum.cpp
index 6508656..16015dc 100644
--- a/YSGraphic_Core/plottable/Spectrum.cpp
+++ b/YSGraphic_Core/plottable/Spectrum.cpp
@@ -10,203 +10,203 @@ namespace YSG {
     SpectrumPrivate* Spectrum::d() {
         return Spectrum_Binding::d(this);
     }
-    RenderData* Spectrum::createRenderData() {
+    RenderData* Spectrum::create_render_data() {
         return Spectrum_Binding::create_render_data();
     }
-    RenderState* Spectrum::createRenderState() {
+    RenderState* Spectrum::create_render_state() {
         return Spectrum_Binding::create_render_state();
     }
-    InputData* Spectrum::createInputData() {
+    InputData* Spectrum::create_input_data() {
         return Spectrum_Binding::create_input_data();
     }
-    FrequentAxis* Spectrum::frequentAxis(SRC src) {
-        return d()->state_value(&SpectrumRenderState::frequentAxis, src);
+    FrequentAxis* Spectrum::frequent_axis(SRC src) {
+        return d()->state_value(&SpectrumRenderState::frequent_axis, src);
     }
-    void Spectrum::set_frequentAxis(FrequentAxis* value) {
-        d()->set_state_value(&SpectrumRenderState::frequentAxis, value);
+    void Spectrum::set_frequent_axis(FrequentAxis* value) {
+        d()->set_state_value(&SpectrumRenderState::frequent_axis, value);
     }
-    Axis* Spectrum::powerAxis(SRC src) {
-        return d()->state_value(&SpectrumRenderState::powerAxis, src);
+    Axis* Spectrum::power_axis(SRC src) {
+        return d()->state_value(&SpectrumRenderState::power_axis, src);
     }
-    void Spectrum::set_powerAxis(Axis* value) {
-        d()->set_state_value(&SpectrumRenderState::powerAxis, value);
+    void Spectrum::set_power_axis(Axis* value) {
+        d()->set_state_value(&SpectrumRenderState::power_axis, value);
     }
-    int Spectrum::frequentPointSize(SRC src) {
-        return d()->state_value(&SpectrumRenderState::frequentPointSize, src);
+    int Spectrum::frequent_point_size(SRC src) {
+        return d()->state_value(&SpectrumRenderState::frequent_point_size, src);
     }
-    Range Spectrum::frequentRange(SRC src) {
-        return d()->state_value(&SpectrumRenderState::frequentRange, src);
+    Range Spectrum::frequent_range(SRC src) {
+        return d()->state_value(&SpectrumRenderState::frequent_range, src);
     }
-    double Spectrum::middleSweepFrequent(SRC src) {
-        return d()->state_value(&SpectrumRenderState::middleSweepFrequent, src);
+    double Spectrum::middle_sweep_frequent(SRC src) {
+        return d()->state_value(&SpectrumRenderState::middle_sweep_frequent, src);
     }
-    void Spectrum::set_middleSweepFrequent(double value) {
-        d()->set_state_value(&SpectrumRenderState::middleSweepFrequent, value);
+    void Spectrum::set_middle_sweep_frequent(double value) {
+        d()->set_state_value(&SpectrumRenderState::middle_sweep_frequent, value);
     }
-    Range Spectrum::sweepFrequentRange(SRC src) {
-        return d()->state_value(&SpectrumRenderState::sweepFrequentRange, src);
+    Range Spectrum::sweep_frequent_range(SRC src) {
+        return d()->state_value(&SpectrumRenderState::sweep_frequent_range, src);
     }
-    void Spectrum::set_sweepFrequentRange(Range value) {
-        d()->set_state_value(&SpectrumRenderState::sweepFrequentRange, std::move(value));
+    void Spectrum::set_sweep_frequent_range(Range value) {
+        d()->set_state_value(&SpectrumRenderState::sweep_frequent_range, std::move(value));
     }
-    bool Spectrum::useMaxLine(SRC src) {
-        return d()->state_value(&SpectrumRenderState::useMaxLine, src);
+    bool Spectrum::use_max_line(SRC src) {
+        return d()->state_value(&SpectrumRenderState::use_max_line, src);
     }
-    void Spectrum::set_useMaxLine(bool value) {
-        d()->set_state_value(&SpectrumRenderState::useMaxLine, value);
+    void Spectrum::set_use_max_line(bool value) {
+        d()->set_state_value(&SpectrumRenderState::use_max_line, value);
     }
-    bool Spectrum::useMinLine(SRC src) {
-        return d()->state_value(&SpectrumRenderState::useMinLine, src);
+    bool Spectrum::use_min_line(SRC src) {
+        return d()->state_value(&SpectrumRenderState::use_min_line, src);
     }
-    void Spectrum::set_useMinLine(bool value) {
-        d()->set_state_value(&SpectrumRenderState::useMinLine, value);
+    void Spectrum::set_use_min_line(bool value) {
+        d()->set_state_value(&SpectrumRenderState::use_min_line, value);
     }
-    bool Spectrum::useMaxMarker(SRC src) {
-        return d()->state_value(&SpectrumRenderState::useMaxMarker, src);
+    bool Spectrum::use_max_marker(SRC src) {
+        return d()->state_value(&SpectrumRenderState::use_max_marker, src);
     }
-    void Spectrum::set_useMaxMarker(bool value) {
-        d()->set_state_value(&SpectrumRenderState::useMaxMarker, value);
+    void Spectrum::set_use_max_marker(bool value) {
+        d()->set_state_value(&SpectrumRenderState::use_max_marker, value);
     }
-    bool Spectrum::useMinMarker(SRC src) {
-        return d()->state_value(&SpectrumRenderState::useMinMarker, src);
+    bool Spectrum::use_min_marker(SRC src) {
+        return d()->state_value(&SpectrumRenderState::use_min_marker, src);
     }
-    void Spectrum::set_useMinMarker(bool value) {
-        d()->set_state_value(&SpectrumRenderState::useMinMarker, value);
+    void Spectrum::set_use_min_marker(bool value) {
+        d()->set_state_value(&SpectrumRenderState::use_min_marker, value);
     }
-    bool Spectrum::useSweepFrequentRect(SRC src) {
-        return d()->state_value(&SpectrumRenderState::useSweepFrequentRect, src);
+    bool Spectrum::use_sweep_frequent_rect(SRC src) {
+        return d()->state_value(&SpectrumRenderState::use_sweep_frequent_rect, src);
     }
-    void Spectrum::set_useSweepFrequentRect(bool value) {
-        d()->set_state_value(&SpectrumRenderState::useSweepFrequentRect, value);
+    void Spectrum::set_use_sweep_frequent_rect(bool value) {
+        d()->set_state_value(&SpectrumRenderState::use_sweep_frequent_rect, value);
     }
-    QBrush Spectrum::maxBrush(SRC src) {
-        return d()->state_value(&SpectrumRenderState::maxBrush, src);
+    QBrush Spectrum::max_brush(SRC src) {
+        return d()->state_value(&SpectrumRenderState::max_brush, src);
     }
-    void Spectrum::set_maxBrush(QBrush value) {
-        d()->set_state_value(&SpectrumRenderState::maxBrush, std::move(value));
+    void Spectrum::set_max_brush(QBrush value) {
+        d()->set_state_value(&SpectrumRenderState::max_brush, std::move(value));
     }
-    QBrush Spectrum::curBrush(SRC src) {
-        return d()->state_value(&SpectrumRenderState::curBrush, src);
+    QBrush Spectrum::cur_brush(SRC src) {
+        return d()->state_value(&SpectrumRenderState::cur_brush, src);
     }
-    void Spectrum::set_curBrush(QBrush value) {
-        d()->set_state_value(&SpectrumRenderState::curBrush, std::move(value));
+    void Spectrum::set_cur_brush(QBrush value) {
+        d()->set_state_value(&SpectrumRenderState::cur_brush, std::move(value));
     }
-    QBrush Spectrum::minBrush(SRC src) {
-        return d()->state_value(&SpectrumRenderState::minBrush, src);
+    QBrush Spectrum::min_brush(SRC src) {
+        return d()->state_value(&SpectrumRenderState::min_brush, src);
     }
-    void Spectrum::set_minBrush(QBrush value) {
-        d()->set_state_value(&SpectrumRenderState::minBrush, std::move(value));
+    void Spectrum::set_min_brush(QBrush value) {
+        d()->set_state_value(&SpectrumRenderState::min_brush, std::move(value));
     }
-    QPen Spectrum::maxPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::maxPen, src);
+    QPen Spectrum::max_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::max_pen, src);
     }
-    void Spectrum::set_maxPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::maxPen, std::move(value));
+    void Spectrum::set_max_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::max_pen, std::move(value));
     }
-    QPen Spectrum::curPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::curPen, src);
+    QPen Spectrum::cur_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::cur_pen, src);
     }
-    void Spectrum::set_curPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::curPen, std::move(value));
+    void Spectrum::set_cur_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::cur_pen, std::move(value));
     }
-    QPen Spectrum::minPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::minPen, src);
+    QPen Spectrum::min_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::min_pen, src);
     }
-    void Spectrum::set_minPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::minPen, std::move(value));
+    void Spectrum::set_min_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::min_pen, std::move(value));
     }
-    QPen Spectrum::selectMarkerPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::selectMarkerPen, src);
+    QPen Spectrum::select_marker_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::select_marker_pen, src);
     }
-    void Spectrum::set_selectMarkerPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::selectMarkerPen, std::move(value));
+    void Spectrum::set_select_marker_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::select_marker_pen, std::move(value));
     }
-    QPen Spectrum::markerPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::markerPen, src);
+    QPen Spectrum::marker_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::marker_pen, src);
     }
-    void Spectrum::set_markerPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::markerPen, std::move(value));
+    void Spectrum::set_marker_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::marker_pen, std::move(value));
     }
-    QPen Spectrum::middleFrequentPen(SRC src) {
-        return d()->state_value(&SpectrumRenderState::middleFrequentPen, src);
+    QPen Spectrum::middle_frequent_pen(SRC src) {
+        return d()->state_value(&SpectrumRenderState::middle_frequent_pen, src);
     }
-    void Spectrum::set_middleFrequentPen(QPen value) {
-        d()->set_state_value(&SpectrumRenderState::middleFrequentPen, std::move(value));
+    void Spectrum::set_middle_frequent_pen(QPen value) {
+        d()->set_state_value(&SpectrumRenderState::middle_frequent_pen, std::move(value));
     }
-    QBrush Spectrum::sweepRectBrush(SRC src) {
-        return d()->state_value(&SpectrumRenderState::sweepRectBrush, src);
+    QBrush Spectrum::sweep_rect_brush(SRC src) {
+        return d()->state_value(&SpectrumRenderState::sweep_rect_brush, src);
     }
-    void Spectrum::set_sweepRectBrush(QBrush value) {
-        d()->set_state_value(&SpectrumRenderState::sweepRectBrush, std::move(value));
+    void Spectrum::set_sweep_rect_brush(QBrush value) {
+        d()->set_state_value(&SpectrumRenderState::sweep_rect_brush, std::move(value));
     }
-    void Spectrum::set_frequentPointSize(int frequentPointSize) {
+    void Spectrum::set_frequent_point_size(int frequent_point_size) {
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->frequentPointSize =  frequentPointSize;
+        edit->frequent_point_size =  frequent_point_size;
     }
 
-    void Spectrum::set_frequentRange(Range frequentRange){
+    void Spectrum::set_frequent_range(Range frequent_range){
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->frequentRange = frequentRange;
+        edit->frequent_range = frequent_range;
     }
 
 
-    Spectrum::Builder::Builder(FrequentAxis* frequentAxis, Axis* powerAxis) {
-        ASSERT(frequentAxis->mPlot != nullptr, "Afterglow build error!  frequentAxis->mPlot == nullptr");
-        ASSERT(frequentAxis->mPlot == powerAxis->mPlot, "Afterglow build error!  frequentAxis->mPlot != powerAxis->mPlot");
-        plot = frequentAxis->mPlot;
-        this->frequentAxis = frequentAxis;
-        this->powerAxis = powerAxis;
+    Spectrum::Builder::Builder(FrequentAxis* frequent_axis, Axis* power_axis) {
+        ASSERT(frequent_axis->mPlot != nullptr, "Afterglow build error!  frequent_axis->mPlot == nullptr");
+        ASSERT(frequent_axis->mPlot == power_axis->mPlot, "Afterglow build error!  frequent_axis->mPlot != power_axis->mPlot");
+        plot = frequent_axis->mPlot;
+        this->frequent_axis = frequent_axis;
+        this->power_axis = power_axis;
     }
     Spectrum* Spectrum::Builder::build() {
         auto ret = new Spectrum;
         ret->init(plot, layerName);
         SpectrumPrivate* pd = ret->d();
         SpectrumRenderState* sc = reinterpret_cast<SpectrumRenderState*>(pd->state(State_Edit));
-        PROP_R(FrequentAxis*, frequentAxis)
-        PROP_R(Axis*, powerAxis);
-        PROP_R(int, frequentPointSize);
-        PROP_R(Range, frequentRange);
-        PROP_R(double, middleSweepFrequent);
-        PROP_R(Range, sweepFrequentRange);
-        PROP_R(bool, useMaxLine);
-        PROP_R(bool, useMinLine);
-        PROP_R(bool, useMaxMarker);
-        PROP_R(bool, useMinMarker);
-        PROP_R(bool, useSweepFrequentRect);
-        PROP_R(QBrush, maxBrush);
-        PROP_R(QBrush, curBrush);
-        PROP_R(QBrush, minBrush);
-        PROP_R(QPen, maxPen);
-        PROP_R(QPen, curPen);
-        PROP_R(QPen, minPen);
-        PROP_R(QPen, selectMarkerPen);
-        PROP_R(QPen, markerPen);
-        PROP_R(QPen, middleFrequentPen);
-        PROP_R(QBrush, sweepRectBrush);
+        PROP_R(FrequentAxis*, frequent_axis)
+        PROP_R(Axis*, power_axis);
+        PROP_R(int, frequent_point_size);
+        PROP_R(Range, frequent_range);
+        PROP_R(double, middle_sweep_frequent);
+        PROP_R(Range, sweep_frequent_range);
+        PROP_R(bool, use_max_line);
+        PROP_R(bool, use_min_line);
+        PROP_R(bool, use_max_marker);
+        PROP_R(bool, use_min_marker);
+        PROP_R(bool, use_sweep_frequent_rect);
+        PROP_R(QBrush, max_brush);
+        PROP_R(QBrush, cur_brush);
+        PROP_R(QBrush, min_brush);
+        PROP_R(QPen, max_pen);
+        PROP_R(QPen, cur_pen);
+        PROP_R(QPen, min_pen);
+        PROP_R(QPen, select_marker_pen);
+        PROP_R(QPen, marker_pen);
+        PROP_R(QPen, middle_frequent_pen);
+        PROP_R(QBrush, sweep_rect_brush);
         return ret;
     }
 
-    void SpectrumPrivate::updateFrequentPointSize(int frequentPointSize, Range frequentRange) {
-        if(frequentPointSize == 0) return;
-        cacheFrequentPointSize = frequentPointSize;
-        cacheFrequentRange = frequentRange;
-        maxPowers.resize(frequentPointSize);
-        curPowers.resize(frequentPointSize);
-        minPowers.resize(frequentPointSize);
-        frequents.resize(frequentPointSize);
-        double cur = frequentRange.lower;
-        double step = frequentRange.length() / (frequentPointSize - 1);
-        frequents[0] = frequentRange.lower;
-        for(int i = 1; i < frequentPointSize; ++i) {
+    void SpectrumPrivate::update_frequent_point_size(int frequent_point_size, Range frequent_range) {
+        if(frequent_point_size == 0) return;
+        cacheFrequentPointSize = frequent_point_size;
+        cacheFrequentRange = frequent_range;
+        maxPowers.resize(frequent_point_size);
+        curPowers.resize(frequent_point_size);
+        minPowers.resize(frequent_point_size);
+        frequents.resize(frequent_point_size);
+        double cur = frequent_range.lower;
+        double step = frequent_range.length() / (frequent_point_size - 1);
+        frequents[0] = frequent_range.lower;
+        for(int i = 1; i < frequent_point_size; ++i) {
             cur += step;
             frequents[i] = cur;
         }
-        maxPowers.fill(frequentRange.lower);
-        minPowers.fill(frequentRange.upper);
+        maxPowers.fill(frequent_range.lower);
+        minPowers.fill(frequent_range.upper);
     }
-    void SpectrumPrivate::setFrequentData(const QVector<double>& lineData, const SpectrumRenderState* s) {
-        if(lineData.size() != s->frequentPointSize) {
-            qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << s->frequentPointSize;
+    void SpectrumPrivate::set_frequent_data(const QVector<double>& lineData, const SpectrumRenderState* s) {
+        if(lineData.size() != s->frequent_point_size) {
+            qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << s->frequent_point_size;
             return;
         }
         curPowers = lineData;
@@ -214,19 +214,19 @@ namespace YSG {
         double min = std::numeric_limits<double>::max();
         double max = std::numeric_limits<double>::min();
         int minIndex = 0, maxIndex = 0;
-        for(int i = 0; i < s->frequentPointSize; ++i) {
+        for(int i = 0; i < s->frequent_point_size; ++i) {
             double& curData = curPowers[i];
-            if(s->useMaxLine && curData > maxPowers.at(i)) {
+            if(s->use_max_line && curData > maxPowers.at(i)) {
                 maxPowers[i] = curData;
             }
-            if(s->useMinLine && curData < minPowers.at(i)) {
+            if(s->use_min_line && curData < minPowers.at(i)) {
                 minPowers[i] = curData;
             }
-            if(s->useMaxMarker && curData > max) {
+            if(s->use_max_marker && curData > max) {
                 max = curData;
                 maxIndex = i;
             }
-            if(s->useMinMarker && curData < min) {
+            if(s->use_min_marker && curData < min) {
                 min = curData;
                 minIndex = i;
             }
@@ -236,7 +236,7 @@ namespace YSG {
         minMarkerKey = frequents[minIndex];
         minMarkerValue = curPowers[minIndex];
     }
-    double SpectrumPrivate::getY(const double& x, bool& ok) {
+    double SpectrumPrivate::get_y(const double& x, bool& ok) {
         int i = binary_search(x, frequents, ok);
         if(!ok) return -1;
         const double& x1 = frequents.at(i);
@@ -247,16 +247,16 @@ namespace YSG {
         double b = y1 - k * x1;
         return (int)(k * x + b);
     }
-    void SpectrumPrivate::drawLine(QPainter* painter, const SpectrumRenderState* s, const QVector<double>& ys, const QPen& pen, const QBrush& brush) {
+    void SpectrumPrivate::draw_line(QPainter* painter, const SpectrumRenderState* s, const QVector<double>& ys, const QPen& pen, const QBrush& brush) {
         if(frequents.empty()) return;
         int n = frequents.size();
         QVector<QPointF> points(n+2);
-        double upperBoundPixel = s->powerAxis->coordToPixel(s->powerAxis->coordRange().upper, SRC::Render);
-        points.first() = QPointF(s->frequentAxis->coordToPixel(frequents.first(), SRC::Render), upperBoundPixel);
-        points.last() = QPointF(s->frequentAxis->coordToPixel(frequents.last(), SRC::Render), upperBoundPixel);
+        double upperBoundPixel = s->power_axis->coord_to_pixel(s->power_axis->coord_range().upper, SRC::Render);
+        points.first() = QPointF(s->frequent_axis->coord_to_pixel(frequents.first(), SRC::Render), upperBoundPixel);
+        points.last() = QPointF(s->frequent_axis->coord_to_pixel(frequents.last(), SRC::Render), upperBoundPixel);
         for(int i = 0; i < n; ++i) {
-            double x = s->frequentAxis->coordToPixel(frequents.at(i), SRC::Render);
-            double y = s->powerAxis->coordToPixel(ys.at(i), SRC::Render);
+            double x = s->frequent_axis->coord_to_pixel(frequents.at(i), SRC::Render);
+            double y = s->power_axis->coord_to_pixel(ys.at(i), SRC::Render);
             points[i + 1] = QPointF(x, y);
         }
         painter->setPen(pen);
@@ -264,58 +264,58 @@ namespace YSG {
         painter->setBrush(brush);
         if(brush.style() != Qt::NoBrush) painter->drawPolygon(points.data(), n + 2);
     }
-    void SpectrumPrivate::drawSpectrum(QPainter* painter, SpectrumRenderState* s) {
-        if(s->useMaxLine) drawLine(painter, s, maxPowers, s->maxPen, s->maxBrush);
-        drawLine(painter, s, curPowers, s->curPen, s->curBrush);
-        if(s->useMinLine) drawLine(painter, s, minPowers, s->minPen, s->minBrush);
-        if(s->useMaxMarker) s->drawMarker(painter, maxMarkerKey, maxMarkerValue, false, false);
-        if(s->useMinMarker) s->drawMarker(painter, minMarkerKey, minMarkerValue, false, false);
+    void SpectrumPrivate::draw_spectrum(QPainter* painter, SpectrumRenderState* s) {
+        if(s->use_max_line) draw_line(painter, s, maxPowers, s->max_pen, s->max_brush);
+        draw_line(painter, s, curPowers, s->cur_pen, s->cur_brush);
+        if(s->use_min_line) draw_line(painter, s, minPowers, s->min_pen, s->min_brush);
+        if(s->use_max_marker) s->draw_marker(painter, maxMarkerKey, maxMarkerValue, false, false);
+        if(s->use_min_marker) s->draw_marker(painter, minMarkerKey, minMarkerValue, false, false);
         for(Marker& customMarker : s->markerList) {
             bool ok;
-            double value = getY(customMarker.frequent, ok);
-            if(ok) s->drawMarker(painter, customMarker.frequent, value, customMarker.drawLine, s->markerList.indexOf(customMarker) == s->curSelectIndex);
+            double value = get_y(customMarker.frequent, ok);
+            if(ok) s->draw_marker(painter, customMarker.frequent, value, customMarker.drawLine, s->markerList.indexOf(customMarker) == s->curSelectIndex);
         }
-        if(s->useSweepFrequentRect) {
-            s->drawAxisRect(painter, s->sweepFrequentRange, s->middleSweepFrequent);
+        if(s->use_sweep_frequent_rect) {
+            s->draw_axis_rect(painter, s->sweep_frequent_range, s->middle_sweep_frequent);
         }
     }
     void SpectrumPrivate::draw(QPainter* painter) {
-        auto s = renderState();
+        auto s = render_state();
         PerformanceShower *shower = q()->mPlot->d->mShower;
         if(shower) {
-            shower->setPerformanceLine("mFrequentPointSize", PerformanceLine(QString("mFrequentPointSize:%1").arg(s->frequentPointSize)));
+            shower->set_performance_line("mFrequentPointSize", PerformanceLine(QString("mFrequentPointSize:%1").arg(s->frequent_point_size)));
         }
-        drawSpectrum(painter, s);
-        if(q()->hoverOK(q())) {
-            q()->drawHover(painter, s->frequentAxis, s->powerAxis);
+        draw_spectrum(painter, s);
+        if(q()->hover_ok(q())) {
+            q()->draw_hover(painter, s->frequent_axis, s->power_axis);
         }
     }
 
 
-    void Spectrum::giveData(const QVector<double> &lineData){
+    void Spectrum::give_data(const QVector<double> &lineData){
         if(!ok()) return;
         SpectrumPrivate* pd = d();
         Render_State_Lease<SpectrumPrivate, SpectrumRenderState> state(pd);
-        int frequentPointSize = state->frequentPointSize;
-        if(lineData.size() != frequentPointSize) {
-            qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << frequentPointSize;
+        int frequent_point_size = state->frequent_point_size;
+        if(lineData.size() != frequent_point_size) {
+            qDebug() << "setFrenquentData 数据大小不对 " << lineData.size() << "  mFrequentPointSize == " << frequent_point_size;
             return;
         }
         Render_Input_Lease<SpectrumPrivate, SpectrumInputData> input(pd);
         input->mDataList.push_back(lineData);
     }
 
-    void Spectrum::addCustomMarker(double frequent){
+    void Spectrum::add_custom_marker(double frequent){
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         edit->markerList.append(Marker{frequent, false});
     }
 
-    void Spectrum::addCustomLineMarker(double frequent){
+    void Spectrum::add_custom_line_marker(double frequent){
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         edit->markerList.append(Marker{frequent, true});
     }
 
-    void Spectrum::removeCustomMarker(double frequent){
+    void Spectrum::remove_custom_marker(double frequent){
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         for (Marker &marker: edit->markerList) {
             if (qFuzzyCompare(marker.frequent, frequent)) {
@@ -325,26 +325,26 @@ namespace YSG {
         }
     }
 
-    void Spectrum::removeCurrentMarker(SRC src) {
+    void Spectrum::remove_current_marker(SRC src) {
         Q_UNUSED(src)
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         edit->markerList.removeAt(edit->curSelectIndex);
     }
 
-    void Spectrum::clearAllCustomMarker(SRC src) {
+    void Spectrum::clear_all_custom_marker(SRC src) {
         Q_UNUSED(src)
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         edit->markerList.clear();
     }
 
-    double Spectrum::getMarkFrequent(int markIndex, SRC src) {
-        auto renderState = d()->state_data(src);
-        if (markIndex < 0 || markIndex >= renderState->markerList.size())
+    double Spectrum::get_mark_frequent(int markIndex, SRC src) {
+        auto render_state = d()->state_data(src);
+        if (markIndex < 0 || markIndex >= render_state->markerList.size())
             return -1;
-        return renderState->markerList[markIndex].frequent;
+        return render_state->markerList[markIndex].frequent;
     }
 
-    void Spectrum::setMarkerFrequent(int markerIndex, double frequent) {
+    void Spectrum::set_marker_frequent(int markerIndex, double frequent) {
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
         QVector<Marker> &markers = edit->markerList;
         if (markerIndex < 0 || markerIndex >= markers.size())
@@ -352,47 +352,47 @@ namespace YSG {
         markers[markerIndex].frequent = frequent;
     }
 
-    void Spectrum::setCurrentMarkerFrequent(double frequent) {
+    void Spectrum::set_current_marker_frequent(double frequent) {
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->setCurFrequent(frequent);
+        edit->set_cur_frequent(frequent);
     }
 
-    int Spectrum::selectLineMarkerSize(SRC src) {
-        auto renderState = d()->state_data(src);
-        return renderState->markerList.size();
+    int Spectrum::select_line_marker_size(SRC src) {
+        auto render_state = d()->state_data(src);
+        return render_state->markerList.size();
     }
 
-    int Spectrum::curSelectMarkerIndex(SRC src) {
-        auto renderState = d()->state_data(src);
-        return renderState->curSelectIndex;
+    int Spectrum::cur_select_marker_index(SRC src) {
+        auto render_state = d()->state_data(src);
+        return render_state->curSelectIndex;
     }
 
-    void Spectrum::setSelectedLineMarker(int markerIndex){
+    void Spectrum::set_selected_line_marker(int markerIndex){
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->setSelectIndex(markerIndex);
+        edit->set_select_index(markerIndex);
     }
 
-    void Spectrum::selectNext(SRC src) {
+    void Spectrum::select_next(SRC src) {
         Q_UNUSED(src)
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->selectNextMarker();
+        edit->select_next_marker();
     }
 
-    void Spectrum::selectPrevious(SRC src) {
+    void Spectrum::select_previous(SRC src) {
         Q_UNUSED(src)
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->selectPrevMarker();
+        edit->select_prev_marker();
     }
 
-    void Spectrum::unSelectMarker(SRC src) {
+    void Spectrum::un_select_marker(SRC src) {
         Q_UNUSED(src)
         Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(d());
-        edit->unSelect();
+        edit->un_select();
     }
 
-    double Spectrum::getPower(double frequent, bool& ok, SRC src) {
+    double Spectrum::get_power(double frequent, bool& ok, SRC src) {
         Q_UNUSED(src)
-        return d()->getY(frequent, ok);
+        return d()->get_y(frequent, ok);
     }
 
 }
diff --git a/YSGraphic_Core/plottable/Spectrum.h b/YSGraphic_Core/plottable/Spectrum.h
index c330383..1202e4f 100644
--- a/YSGraphic_Core/plottable/Spectrum.h
+++ b/YSGraphic_Core/plottable/Spectrum.h
@@ -9,107 +9,107 @@ namespace YSG {
     class LIB_DECL Spectrum : public RenderAble, public HoverInfoRenderAble<Spectrum> {
     public:
         SpectrumPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         Spectrum();
         friend struct SpectrumPrivate;
         friend struct SpectrumRenderState;
         friend struct SpectrumInputData;
     public:
-        PROP(FrequentAxis*, frequentAxis)
-        PROP(Axis*, powerAxis);
-        PROP(int, frequentPointSize);
-        PROP(Range, frequentRange);
-        PROP(double, middleSweepFrequent);
-        PROP(Range, sweepFrequentRange);
-        PROP(bool, useMaxLine);
-        PROP(bool, useMinLine);
-        PROP(bool, useMaxMarker);
-        PROP(bool, useMinMarker);
-        PROP(bool, useSweepFrequentRect);
-        PROP(QBrush, maxBrush);
-        PROP(QBrush, curBrush);
-        PROP(QBrush, minBrush);
-        PROP(QPen, maxPen);
-        PROP(QPen, curPen);
-        PROP(QPen, minPen);
-        PROP(QPen, selectMarkerPen);
-        PROP(QPen, markerPen);
-        PROP(QPen, middleFrequentPen);
-        PROP(QBrush, sweepRectBrush);
-        void giveData(const QVector<double> &lineData);
-        double getPower(double frequent, bool& ok, SRC=SRC::Edit);
-        void addCustomMarker(double frequent);
-        void addCustomLineMarker(double frequent);
-        void removeCustomMarker(double frequent);
-        void removeCurrentMarker(SRC=SRC::Edit);
-        void clearAllCustomMarker(SRC=SRC::Edit);
-        int selectLineMarkerSize(SRC=SRC::Edit);
-        int curSelectMarkerIndex(SRC=SRC::Edit);
-        void setSelectedLineMarker(int markerIndex);
-        void selectNext(SRC=SRC::Edit);
-        void unSelectMarker(SRC=SRC::Edit);
-        void selectPrevious(SRC=SRC::Edit);
-        double getMarkFrequent(int markIndex, SRC=SRC::Edit);
-        void setMarkerFrequent(int markerIndex, double frequent);
-        void setCurrentMarkerFrequent(double frequent);
+        PROP(FrequentAxis*, frequent_axis)
+        PROP(Axis*, power_axis);
+        PROP(int, frequent_point_size);
+        PROP(Range, frequent_range);
+        PROP(double, middle_sweep_frequent);
+        PROP(Range, sweep_frequent_range);
+        PROP(bool, use_max_line);
+        PROP(bool, use_min_line);
+        PROP(bool, use_max_marker);
+        PROP(bool, use_min_marker);
+        PROP(bool, use_sweep_frequent_rect);
+        PROP(QBrush, max_brush);
+        PROP(QBrush, cur_brush);
+        PROP(QBrush, min_brush);
+        PROP(QPen, max_pen);
+        PROP(QPen, cur_pen);
+        PROP(QPen, min_pen);
+        PROP(QPen, select_marker_pen);
+        PROP(QPen, marker_pen);
+        PROP(QPen, middle_frequent_pen);
+        PROP(QBrush, sweep_rect_brush);
+        void give_data(const QVector<double> &lineData);
+        double get_power(double frequent, bool& ok, SRC=SRC::Edit);
+        void add_custom_marker(double frequent);
+        void add_custom_line_marker(double frequent);
+        void remove_custom_marker(double frequent);
+        void remove_current_marker(SRC=SRC::Edit);
+        void clear_all_custom_marker(SRC=SRC::Edit);
+        int select_line_marker_size(SRC=SRC::Edit);
+        int cur_select_marker_index(SRC=SRC::Edit);
+        void set_selected_line_marker(int markerIndex);
+        void select_next(SRC=SRC::Edit);
+        void un_select_marker(SRC=SRC::Edit);
+        void select_previous(SRC=SRC::Edit);
+        double get_mark_frequent(int markIndex, SRC=SRC::Edit);
+        void set_marker_frequent(int markerIndex, double frequent);
+        void set_current_marker_frequent(double frequent);
         struct Builder;
     };
 
     struct Spectrum_PROP {
-        FrequentAxis *frequentAxis{};
-        Axis *powerAxis{};
-        int frequentPointSize{};
-        Range frequentRange{};
-        double middleSweepFrequent = 50;
-        Range sweepFrequentRange{40, 60};
-        bool useMaxLine = false;
-        bool useMinLine = false;
-        bool useMaxMarker = false;
-        bool useMinMarker = false;
-        bool useSweepFrequentRect = false;
-        QBrush maxBrush;
-        QBrush curBrush;
-        QBrush minBrush;
-        QPen maxPen = QPen(Qt::red);
-        QPen curPen = QPen(Qt::green);
-        QPen minPen = QPen(Qt::white);
-        QPen selectMarkerPen = QPen(Qt::darkBlue, 2);
-        QPen markerPen = QPen(Qt::red);
-        QPen middleFrequentPen = QPen(Qt::red);
-        QBrush sweepRectBrush = QBrush(QColor(255, 255, 0, 100));
+        FrequentAxis *frequent_axis{};
+        Axis *power_axis{};
+        int frequent_point_size{};
+        Range frequent_range{};
+        double middle_sweep_frequent = 50;
+        Range sweep_frequent_range{40, 60};
+        bool use_max_line = false;
+        bool use_min_line = false;
+        bool use_max_marker = false;
+        bool use_min_marker = false;
+        bool use_sweep_frequent_rect = false;
+        QBrush max_brush;
+        QBrush cur_brush;
+        QBrush min_brush;
+        QPen max_pen = QPen(Qt::red);
+        QPen cur_pen = QPen(Qt::green);
+        QPen min_pen = QPen(Qt::white);
+        QPen select_marker_pen = QPen(Qt::darkBlue, 2);
+        QPen marker_pen = QPen(Qt::red);
+        QPen middle_frequent_pen = QPen(Qt::red);
+        QBrush sweep_rect_brush = QBrush(QColor(255, 255, 0, 100));
         Spectrum_PROP() {
-            maxBrush = QBrush(QColor(), Qt::NoBrush);
-            curBrush = QBrush(QColor(), Qt::NoBrush);
-            minBrush = QBrush(QColor(), Qt::NoBrush);
+            max_brush = QBrush(QColor(), Qt::NoBrush);
+            cur_brush = QBrush(QColor(), Qt::NoBrush);
+            min_brush = QBrush(QColor(), Qt::NoBrush);
         }
     };
     struct LIB_DECL Spectrum::Builder : Spectrum_PROP {
-        PROP_B(FrequentAxis*, frequentAxis)
-        PROP_B(Axis*, powerAxis);
-        PROP_B(int, frequentPointSize);
-        PROP_B(Range, frequentRange);
-        PROP_B(double, middleSweepFrequent);
-        PROP_B(Range, sweepFrequentRange);
-        PROP_B(bool, useMaxLine);
-        PROP_B(bool, useMinLine);
-        PROP_B(bool, useMaxMarker);
-        PROP_B(bool, useMinMarker);
-        PROP_B(bool, useSweepFrequentRect);
-        PROP_B(QBrush, maxBrush);
-        PROP_B(QBrush, curBrush);
-        PROP_B(QBrush, minBrush);
-        PROP_B(QPen, maxPen);
-        PROP_B(QPen, curPen);
-        PROP_B(QPen, minPen);
-        PROP_B(QPen, selectMarkerPen);
-        PROP_B(QPen, markerPen);
-        PROP_B(QPen, middleFrequentPen);
-        PROP_B(QBrush, sweepRectBrush);
+        PROP_B(FrequentAxis*, frequent_axis)
+        PROP_B(Axis*, power_axis);
+        PROP_B(int, frequent_point_size);
+        PROP_B(Range, frequent_range);
+        PROP_B(double, middle_sweep_frequent);
+        PROP_B(Range, sweep_frequent_range);
+        PROP_B(bool, use_max_line);
+        PROP_B(bool, use_min_line);
+        PROP_B(bool, use_max_marker);
+        PROP_B(bool, use_min_marker);
+        PROP_B(bool, use_sweep_frequent_rect);
+        PROP_B(QBrush, max_brush);
+        PROP_B(QBrush, cur_brush);
+        PROP_B(QBrush, min_brush);
+        PROP_B(QPen, max_pen);
+        PROP_B(QPen, cur_pen);
+        PROP_B(QPen, min_pen);
+        PROP_B(QPen, select_marker_pen);
+        PROP_B(QPen, marker_pen);
+        PROP_B(QPen, middle_frequent_pen);
+        PROP_B(QBrush, sweep_rect_brush);
         SETTER(QString, layerName, "plottable")
-        Builder(FrequentAxis* frequentAxis, Axis* axis);
+        Builder(FrequentAxis* frequent_axis, Axis* axis);
         Spectrum* build();
     protected:
         Plot *plot{};
diff --git a/YSGraphic_Core/plottable/Spectrum_p.h b/YSGraphic_Core/plottable/Spectrum_p.h
index 8f06341..c2a0bde 100644
--- a/YSGraphic_Core/plottable/Spectrum_p.h
+++ b/YSGraphic_Core/plottable/Spectrum_p.h
@@ -30,43 +30,43 @@ namespace YSG {
     struct SpectrumRenderState : RenderState, HoverInfoRenderState, Spectrum_PROP {
         QVector<Marker> markerList;
         int curSelectIndex = -1;
-        void unSelect() {
+        void un_select() {
             curSelectIndex = -1;
         }
-        void selectNextMarker() {
+        void select_next_marker() {
             if(markerList.empty()) return;
             curSelectIndex = (curSelectIndex + 1) % markerList.size();
         }
-        void selectPrevMarker() {
+        void select_prev_marker() {
             if(markerList.empty()) return;
             curSelectIndex = (curSelectIndex - 1 + markerList.size()) % markerList.size();
         }
-        void setSelectIndex(int index) {
+        void set_select_index(int index) {
             if (index < 0 || index >= markerList.size()) {
-                qDebug() << "SpectrogramLineCache::setSelectIndex index out of range";
+                qDebug() << "SpectrogramLineCache::set_select_index index out of range";
                 return;
             }
             curSelectIndex = index;
         }
 
-        void setCurFrequent(double frequent) {
-            setFrequent(curSelectIndex, frequent);
+        void set_cur_frequent(double frequent) {
+            set_frequent(curSelectIndex, frequent);
         }
 
-        void setFrequent(int index, double frequent) {
+        void set_frequent(int index, double frequent) {
             if (index < 0 || index >= markerList.size()) {
-                qDebug() << "SpectrogramLineCache::setSelectIndex index out of range";
+                qDebug() << "SpectrogramLineCache::set_select_index index out of range";
                 return;
             }
            markerList[index].frequent = frequent;
         }
 
-        void drawMarker(QPainter *painter, double key, double value, bool isLine = false, bool isSelected = false) {
-            double x = frequentAxis->coordToPixel(key, SRC::Render);
-            double y = powerAxis->coordToPixel(value, SRC::Render);
-            painter->setPen(isSelected ? selectMarkerPen : markerPen);
-            QString text1 = QString::number(key, 'f', 2) + frequentAxis->unitText();
-            QString text2 = QString::number(value, 'f', 2) + powerAxis->unitText();
+        void draw_marker(QPainter *painter, double key, double value, bool isLine = false, bool isSelected = false) {
+            double x = frequent_axis->coord_to_pixel(key, SRC::Render);
+            double y = power_axis->coord_to_pixel(value, SRC::Render);
+            painter->setPen(isSelected ? select_marker_pen : marker_pen);
+            QString text1 = QString::number(key, 'f', 2) + frequent_axis->unit_text();
+            QString text2 = QString::number(value, 'f', 2) + power_axis->unit_text();
             QFontMetrics fm(painter->font());
             int h = fm.height();
             int w = qMax(fm.horizontalAdvance(text1), fm.horizontalAdvance(text2));
@@ -75,22 +75,22 @@ namespace YSG {
             if (!isLine) {
                 painter->drawEllipse(QPointF(x, y), 2, 2);
             } else {
-                painter->drawLine(QPointF(x, powerAxis->y()), QPointF(x, powerAxis->pixelSize()));
+                painter->drawLine(QPointF(x, power_axis->y()), QPointF(x, power_axis->pixel_size()));
             }
         }
 
-        void drawAxisRect(QPainter *painter, Range range, double middleX) const {
+        void draw_axis_rect(QPainter *painter, Range range, double middleX) const {
             painter->save();
             painter->setPen(Qt::NoPen);
-            painter->setBrush(sweepRectBrush);
-            double pixelMin = frequentAxis->coordToPixel(range.lower, SRC::Render);
-            double pixelMax = frequentAxis->coordToPixel(range.upper, SRC::Render);
-            double pixelMiddle = frequentAxis->coordToPixel(middleX, SRC::Render);
-            Range r = powerAxis->coordRange();
-            double min = powerAxis->coordToPixel(r.lower, SRC::Render);
-            double max = powerAxis->coordToPixel(r.upper, SRC::Render);
+            painter->setBrush(sweep_rect_brush);
+            double pixelMin = frequent_axis->coord_to_pixel(range.lower, SRC::Render);
+            double pixelMax = frequent_axis->coord_to_pixel(range.upper, SRC::Render);
+            double pixelMiddle = frequent_axis->coord_to_pixel(middleX, SRC::Render);
+            Range r = power_axis->coord_range();
+            double min = power_axis->coord_to_pixel(r.lower, SRC::Render);
+            double max = power_axis->coord_to_pixel(r.upper, SRC::Render);
             painter->drawRect(QRectF(pixelMin, min, pixelMax - pixelMin, max - min));
-            painter->setPen(middleFrequentPen);
+            painter->setPen(middle_frequent_pen);
             painter->setPen(QPen(QColor(255, 0, 0)));
             painter->drawLine(QPointF(pixelMiddle, min), QPointF(pixelMiddle, max));
             painter->restore();
@@ -107,34 +107,34 @@ namespace YSG {
         Range cacheFrequentRange{};
         QVector<double> frequents;
         QVector<double> maxPowers, curPowers, minPowers;
-        void updateFrequentPointSize(int frequentPointSize, Range frequentRange);
-        void setFrequentData(const QVector<double>& lineData, const SpectrumRenderState* s);
-        [[nodiscard]] double getY(const double& x, bool& ok);
-        void drawLine(QPainter* painter, const SpectrumRenderState* s, const QVector<double>& ys, const QPen& pen, const QBrush& brush);
-        void drawSpectrum(QPainter* painter, SpectrumRenderState* s);
+        void update_frequent_point_size(int frequent_point_size, Range frequent_range);
+        void set_frequent_data(const QVector<double>& lineData, const SpectrumRenderState* s);
+        [[nodiscard]] double get_y(const double& x, bool& ok);
+        void draw_line(QPainter* painter, const SpectrumRenderState* s, const QVector<double>& ys, const QPen& pen, const QBrush& brush);
+        void draw_spectrum(QPainter* painter, SpectrumRenderState* s);
         void draw(QPainter* painter) override;
-        void prepareData() override {
-            syncStatePipeline();
-            auto s = renderState();
-            if(cacheFrequentPointSize != s->frequentPointSize || cacheFrequentRange != s->frequentRange) {
-                updateFrequentPointSize(s->frequentPointSize, s->frequentRange);
+        void prepare_data() override {
+            sync_state_pipeline();
+            auto s = render_state();
+            if(cacheFrequentPointSize != s->frequent_point_size || cacheFrequentRange != s->frequent_range) {
+                update_frequent_point_size(s->frequent_point_size, s->frequent_range);
             }
-            auto input = renderInputData();
+            auto input = render_input_data();
             for(const QVector<double>& data : input->mDataList) {
-                setFrequentData(data, s);
+                set_frequent_data(data, s);
             }
-            clearRenderInput();
+            clear_render_input();
         }
 
-        bool selectTest(const QPointF& pos) override {
-            auto sc = editState();
-            double frequent = sc->frequentAxis->pixelToCoord(pos.x(), SRC::Render);
+        bool select_test(const QPointF& pos) override {
+            auto sc = edit_state();
+            double frequent = sc->frequent_axis->pixel_to_coord(pos.x(), SRC::Render);
             bool ok;
-            double power = getY(frequent, ok);
+            double power = get_y(frequent, ok);
             if(!ok) return false;
-            return qAbs(power - sc->powerAxis->pixelToCoord(pos.y(), SRC::Render)) < 4;
+            return qAbs(power - sc->power_axis->pixel_to_coord(pos.y(), SRC::Render)) < 4;
         }
-        void setHoverState(const QPoint& pos, bool active) override {
+        void set_hover_state(const QPoint& pos, bool active) override {
             Render_Edit_Lease<SpectrumPrivate, SpectrumRenderState> edit(this);
             edit->hoverInfoPos = pos;
             edit->hoverInfoActive = active;
diff --git a/YSGraphic_Core/plottable/SweepFrequent.cpp b/YSGraphic_Core/plottable/SweepFrequent.cpp
index 635e6b1..ce84d2d 100644
--- a/YSGraphic_Core/plottable/SweepFrequent.cpp
+++ b/YSGraphic_Core/plottable/SweepFrequent.cpp
@@ -12,44 +12,44 @@ namespace YSG {
     SweepFrequentPrivate* SweepFrequent::d() {
         return SweepFrequent_Binding::d(this);
     }
-    RenderData* SweepFrequent::createRenderData() {
+    RenderData* SweepFrequent::create_render_data() {
         return SweepFrequent_Binding::create_render_data();
     }
-    RenderState* SweepFrequent::createRenderState() {
+    RenderState* SweepFrequent::create_render_state() {
         return SweepFrequent_Binding::create_render_state();
     }
-    InputData* SweepFrequent::createInputData() {
+    InputData* SweepFrequent::create_input_data() {
         return SweepFrequent_Binding::create_input_data();
     }
-    Axis* SweepFrequent::frequentAxis(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::frequentAxis, src);
+    Axis* SweepFrequent::frequent_axis(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::frequent_axis, src);
     }
-    void SweepFrequent::set_frequentAxis(Axis* value) {
-        d()->set_state_value(&SweepFrequentRenderState::frequentAxis, value);
+    void SweepFrequent::set_frequent_axis(Axis* value) {
+        d()->set_state_value(&SweepFrequentRenderState::frequent_axis, value);
     }
-    Axis* SweepFrequent::powerAxis(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::powerAxis, src);
+    Axis* SweepFrequent::power_axis(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::power_axis, src);
     }
-    void SweepFrequent::set_powerAxis(Axis* value) {
-        d()->set_state_value(&SweepFrequentRenderState::powerAxis, value);
+    void SweepFrequent::set_power_axis(Axis* value) {
+        d()->set_state_value(&SweepFrequentRenderState::power_axis, value);
     }
-    Range SweepFrequent::frequentRange(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::frequentRange, src);
+    Range SweepFrequent::frequent_range(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::frequent_range, src);
     }
-    void SweepFrequent::set_frequentRange(Range value) {
-        d()->set_state_value(&SweepFrequentRenderState::frequentRange, std::move(value));
+    void SweepFrequent::set_frequent_range(Range value) {
+        d()->set_state_value(&SweepFrequentRenderState::frequent_range, std::move(value));
     }
-    int SweepFrequent::blockFrequentPointSize(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::blockFrequentPointSize, src);
+    int SweepFrequent::block_frequent_point_size(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::block_frequent_point_size, src);
     }
-    void SweepFrequent::set_blockFrequentPointSize(int value) {
-        d()->set_state_value(&SweepFrequentRenderState::blockFrequentPointSize, value);
+    void SweepFrequent::set_block_frequent_point_size(int value) {
+        d()->set_state_value(&SweepFrequentRenderState::block_frequent_point_size, value);
     }
-    int SweepFrequent::blockNum(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::blockNum, src);
+    int SweepFrequent::block_num(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::block_num, src);
     }
-    void SweepFrequent::set_blockNum(int value) {
-        d()->set_state_value(&SweepFrequentRenderState::blockNum, value);
+    void SweepFrequent::set_block_num(int value) {
+        d()->set_state_value(&SweepFrequentRenderState::block_num, value);
     }
     QPen SweepFrequent::pen(SRC src) {
         return d()->state_value(&SweepFrequentRenderState::pen, src);
@@ -57,19 +57,19 @@ namespace YSG {
     void SweepFrequent::set_pen(QPen value) {
         d()->set_state_value(&SweepFrequentRenderState::pen, std::move(value));
     }
-    QPen SweepFrequent::curFrequentPen(SRC src) {
-        return d()->state_value(&SweepFrequentRenderState::curFrequentPen, src);
+    QPen SweepFrequent::cur_frequent_pen(SRC src) {
+        return d()->state_value(&SweepFrequentRenderState::cur_frequent_pen, src);
     }
-    void SweepFrequent::set_curFrequentPen(QPen value) {
-        d()->set_state_value(&SweepFrequentRenderState::curFrequentPen, std::move(value));
+    void SweepFrequent::set_cur_frequent_pen(QPen value) {
+        d()->set_state_value(&SweepFrequentRenderState::cur_frequent_pen, std::move(value));
     }
-    void SweepFrequent::giveData(const QVector<double>& data) {
+    void SweepFrequent::give_data(const QVector<double>& data) {
         if(!ok()) return;
         SweepFrequentPrivate* pd = d();
         Render_State_Lease<SweepFrequentPrivate, SweepFrequentRenderState> state(pd);
-        int blockFrequentPointSize = state->blockFrequentPointSize;
-        if(data.size() != blockFrequentPointSize) {
-            qDebug() << "error data size == " << data.size() << "  BlockFrquentPointSize" << blockFrequentPointSize;
+        int block_frequent_point_size = state->block_frequent_point_size;
+        if(data.size() != block_frequent_point_size) {
+            qDebug() << "error data size == " << data.size() << "  BlockFrquentPointSize" << block_frequent_point_size;
             return;
         }
         Render_Input_Lease<SweepFrequentPrivate, SweepFrequentInputData> input(pd);
@@ -77,25 +77,25 @@ namespace YSG {
     }
 
 
-    SweepFrequent::Builder::Builder(Axis* frequentAxis, Axis* powerAxis) {
-        ASSERT(frequentAxis->mPlot != nullptr, "Afterglow build error!  frequentAxis->mPlot == nullptr");
-        ASSERT(frequentAxis->mPlot == powerAxis->mPlot, "Afterglow build error!  frequentAxis->mPlot != powerAxis->mPlot");
-        plot = frequentAxis->mPlot;
-        this->frequentAxis = frequentAxis;
-        this->powerAxis = powerAxis;
+    SweepFrequent::Builder::Builder(Axis* frequent_axis, Axis* power_axis) {
+        ASSERT(frequent_axis->mPlot != nullptr, "Afterglow build error!  frequent_axis->mPlot == nullptr");
+        ASSERT(frequent_axis->mPlot == power_axis->mPlot, "Afterglow build error!  frequent_axis->mPlot != power_axis->mPlot");
+        plot = frequent_axis->mPlot;
+        this->frequent_axis = frequent_axis;
+        this->power_axis = power_axis;
     }
     SweepFrequent* SweepFrequent::Builder::build() {
         auto ret = new SweepFrequent();
         ret->init(plot, layerName);
         SweepFrequentPrivate* pd = ret->d();
         SweepFrequentRenderState* sc = reinterpret_cast<SweepFrequentRenderState*>(pd->state(State_Edit));
-        PROP_R(Axis*, frequentAxis)
-        PROP_R(Axis*, powerAxis)
-        PROP_R(Range, frequentRange)
-        PROP_R(int, blockFrequentPointSize)
-        PROP_R(int, blockNum)
+        PROP_R(Axis*, frequent_axis)
+        PROP_R(Axis*, power_axis)
+        PROP_R(Range, frequent_range)
+        PROP_R(int, block_frequent_point_size)
+        PROP_R(int, block_num)
         PROP_R(QPen, pen)
-        PROP_R(QPen, curFrequentPen)
+        PROP_R(QPen, cur_frequent_pen)
         return ret;
     }
 }
diff --git a/YSGraphic_Core/plottable/SweepFrequent.h b/YSGraphic_Core/plottable/SweepFrequent.h
index 93ae369..86e4f10 100644
--- a/YSGraphic_Core/plottable/SweepFrequent.h
+++ b/YSGraphic_Core/plottable/SweepFrequent.h
@@ -7,50 +7,50 @@ namespace YSG {
     class LIB_DECL SweepFrequent : public RenderAble {
     public:
         SweepFrequentPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         SweepFrequent();
         friend struct SweepFrequentPrivate;
         friend struct SweepFrequentRenderState;
         friend struct SweepFrequentInputData;
     public:
-        void giveData(const QVector<double>& data);
-        PROP(Axis*, frequentAxis)
-        PROP(Axis*, powerAxis)
-        PROP(Range, frequentRange)
-        PROP(int, blockFrequentPointSize)
-        PROP(int, blockNum)
+        void give_data(const QVector<double>& data);
+        PROP(Axis*, frequent_axis)
+        PROP(Axis*, power_axis)
+        PROP(Range, frequent_range)
+        PROP(int, block_frequent_point_size)
+        PROP(int, block_num)
         PROP(QPen, pen)
-        PROP(QPen, curFrequentPen)
+        PROP(QPen, cur_frequent_pen)
         struct Builder;
     };
 
     struct SweepFrequent_Prop {
-        Axis *frequentAxis{};
-        Axis *powerAxis{};
-        Range frequentRange{};
-        int blockFrequentPointSize{};
-        int blockNum{};
+        Axis *frequent_axis{};
+        Axis *power_axis{};
+        Range frequent_range{};
+        int block_frequent_point_size{};
+        int block_num{};
         QPen pen;
-        QPen curFrequentPen;
+        QPen cur_frequent_pen;
         SweepFrequent_Prop() {
             pen = QPen(Qt::yellow);
-            curFrequentPen = QPen(Qt::red);
-            curFrequentPen.setWidth(2);
+            cur_frequent_pen = QPen(Qt::red);
+            cur_frequent_pen.setWidth(2);
         }
     };
     struct LIB_DECL SweepFrequent::Builder : SweepFrequent_Prop {
-        PROP_B(Axis*, frequentAxis)
-        PROP_B(Axis*, powerAxis)
-        PROP_B(Range, frequentRange)
-        PROP_B(int, blockFrequentPointSize)
-        PROP_B(int, blockNum)
+        PROP_B(Axis*, frequent_axis)
+        PROP_B(Axis*, power_axis)
+        PROP_B(Range, frequent_range)
+        PROP_B(int, block_frequent_point_size)
+        PROP_B(int, block_num)
         PROP_B(QPen, pen)
-        PROP_B(QPen, curFrequentPen)
+        PROP_B(QPen, cur_frequent_pen)
         SETTER(QString, layerName, "plottable")
-        Builder(Axis* frequentAxis, Axis* powerAxis);
+        Builder(Axis* frequent_axis, Axis* power_axis);
         SweepFrequent* build();
     protected:
         Plot *plot{};
diff --git a/YSGraphic_Core/plottable/SweepFrequent_p.h b/YSGraphic_Core/plottable/SweepFrequent_p.h
index 4c6798d..c3987d3 100644
--- a/YSGraphic_Core/plottable/SweepFrequent_p.h
+++ b/YSGraphic_Core/plottable/SweepFrequent_p.h
@@ -27,34 +27,34 @@ namespace YSG {
         int mBlockNum;
         Range mFrequentRange;
         bool mFristLoop = true;
-        void setUpFrequents(int blockFrquentPointSize, int blockNum, Range frequentRange) {
+        void set_up_frequents(int blockFrquentPointSize, int block_num, Range frequent_range) {
             mBlockFrquentPointSize = blockFrquentPointSize;
-            mBlockNum = blockNum;
-            mFrequentRange = frequentRange;
-            SweepFrequentRenderState *s = renderState();
-            int pointSize = blockNum * blockFrquentPointSize;
+            mBlockNum = block_num;
+            mFrequentRange = frequent_range;
+            SweepFrequentRenderState *s = render_state();
+            int pointSize = block_num * blockFrquentPointSize;
             mFrequents.resize(pointSize);
             int spaceSize = pointSize - 1;
-            double step = frequentRange.length() / spaceSize;
-            double cur = frequentRange.lower;
+            double step = frequent_range.length() / spaceSize;
+            double cur = frequent_range.lower;
             for(int i = 0; i < spaceSize; ++i) {
                 mFrequents[i].setX(cur);
                 cur += step;
             }
-            mFrequents.last().setX(frequentRange.upper);
+            mFrequents.last().setX(frequent_range.upper);
             mFristLoop = true;
         }
     protected:
-        void prepareData() override {
-            syncStatePipeline();
-            SweepFrequentRenderState *s = renderState();
-            SweepFrequentInputData *d = renderInputData();
+        void prepare_data() override {
+            sync_state_pipeline();
+            SweepFrequentRenderState *s = render_state();
+            SweepFrequentInputData *d = render_input_data();
             if(
-                mBlockFrquentPointSize != s->blockFrequentPointSize ||
-                mBlockNum != s->blockNum ||
-                mFrequentRange != s->frequentRange
+                mBlockFrquentPointSize != s->block_frequent_point_size ||
+                mBlockNum != s->block_num ||
+                mFrequentRange != s->frequent_range
             ) {
-                setUpFrequents(s->blockFrequentPointSize, s->blockNum, s->frequentRange);
+                set_up_frequents(s->block_frequent_point_size, s->block_num, s->frequent_range);
                 mOffset = 0;
             }
             for(const QVector<double>& data : d->mData) {
@@ -68,28 +68,28 @@ namespace YSG {
                     mFristLoop = false;
                 }
             }
-            clearRenderInput();
+            clear_render_input();
         }
 
         void draw(QPainter* painter) override {
-            SweepFrequentRenderState *s = renderState();
+            SweepFrequentRenderState *s = render_state();
             int n = mFrequents.size();
             QVector<QPointF> data(n);
             {
-                Cacl prepareData("轴映射数据耗时:%1 SRTT:%2 RTTVAR:%3", q()->mPlot->d->mShower);
+                Cacl prepare_data("轴映射数据耗时:%1 SRTT:%2 RTTVAR:%3", q()->mPlot->d->mShower);
                 for(int i = 0; i < n; ++i) {
                     const QPointF& p = mFrequents[i];
-                    data[i].rx() = s->frequentAxis->coordToPixel(p.x(), SRC::Render);
-                    data[i].ry() = s->powerAxis->coordToPixel(p.y(), SRC::Render);
+                    data[i].rx() = s->frequent_axis->coord_to_pixel(p.x(), SRC::Render);
+                    data[i].ry() = s->power_axis->coord_to_pixel(p.y(), SRC::Render);
                 }
             }
 
             painter->setPen(s->pen);
             painter->drawPolyline(data.data(), !mFristLoop ? data.size() : mOffset * mBlockFrquentPointSize);
 
-            painter->setPen(s->curFrequentPen);
+            painter->setPen(s->cur_frequent_pen);
             double f = mOffset * mFrequentRange.length()/(mBlockNum-1.0);
-            double ff = s->frequentAxis->coordToPixel(f, SRC::Render);
+            double ff = s->frequent_axis->coord_to_pixel(f, SRC::Render);
             painter->drawLine(QPointF(ff, 0), QPointF(ff, q()->mPlot->height()));
         }
     };
diff --git a/YSGraphic_Core/plottable/WaterFall.cpp b/YSGraphic_Core/plottable/WaterFall.cpp
index 166d0f1..7e30881 100644
--- a/YSGraphic_Core/plottable/WaterFall.cpp
+++ b/YSGraphic_Core/plottable/WaterFall.cpp
@@ -10,68 +10,68 @@ namespace YSG {
     WaterFallPrivate* WaterFall::d() {
         return WaterFall_Binding::d(this);
     }
-    RenderData* WaterFall::createRenderData() {
+    RenderData* WaterFall::create_render_data() {
         return WaterFall_Binding::create_render_data();
     }
-    RenderState* WaterFall::createRenderState() {
+    RenderState* WaterFall::create_render_state() {
         return WaterFall_Binding::create_render_state();
     }
-    InputData* WaterFall::createInputData() {
+    InputData* WaterFall::create_input_data() {
         return WaterFall_Binding::create_input_data();
     }
-    FrequentAxis* WaterFall::frequentAxis(SRC src) {
-        return d()->state_value(&WaterFallRenderState::frequentAxis, src);
+    FrequentAxis* WaterFall::frequent_axis(SRC src) {
+        return d()->state_value(&WaterFallRenderState::frequent_axis, src);
     }
-    void WaterFall::set_frequentAxis(FrequentAxis* value) {
-        d()->set_state_value(&WaterFallRenderState::frequentAxis, value);
+    void WaterFall::set_frequent_axis(FrequentAxis* value) {
+        d()->set_state_value(&WaterFallRenderState::frequent_axis, value);
     }
-    TimeAxis* WaterFall::timeAxis(SRC src) {
-        return d()->state_value(&WaterFallRenderState::timeAxis, src);
+    TimeAxis* WaterFall::time_axis(SRC src) {
+        return d()->state_value(&WaterFallRenderState::time_axis, src);
     }
-    void WaterFall::set_timeAxis(TimeAxis* value) {
-        d()->set_state_value(&WaterFallRenderState::timeAxis, value);
+    void WaterFall::set_time_axis(TimeAxis* value) {
+        d()->set_state_value(&WaterFallRenderState::time_axis, value);
     }
-    Range WaterFall::frequentRange(SRC src) {
-        return d()->state_value(&WaterFallRenderState::frequentRange, src);
+    Range WaterFall::frequent_range(SRC src) {
+        return d()->state_value(&WaterFallRenderState::frequent_range, src);
     }
-    void WaterFall::set_frequentRange(Range value) {
-        d()->set_state_value(&WaterFallRenderState::frequentRange, std::move(value));
+    void WaterFall::set_frequent_range(Range value) {
+        d()->set_state_value(&WaterFallRenderState::frequent_range, std::move(value));
     }
-    Range WaterFall::powerRange(SRC src) {
-        return d()->state_value(&WaterFallRenderState::powerRange, src);
+    Range WaterFall::power_range(SRC src) {
+        return d()->state_value(&WaterFallRenderState::power_range, src);
     }
-    void WaterFall::set_powerRange(Range value) {
-        d()->set_state_value(&WaterFallRenderState::powerRange, std::move(value));
+    void WaterFall::set_power_range(Range value) {
+        d()->set_state_value(&WaterFallRenderState::power_range, std::move(value));
     }
-    int WaterFall::frequentPointSize(SRC src) {
-        return d()->state_value(&WaterFallRenderState::frequentPointSize, src);
+    int WaterFall::frequent_point_size(SRC src) {
+        return d()->state_value(&WaterFallRenderState::frequent_point_size, src);
     }
-    void WaterFall::set_frequentPointSize(int value) {
-        d()->set_state_value(&WaterFallRenderState::frequentPointSize, value);
+    void WaterFall::set_frequent_point_size(int value) {
+        d()->set_state_value(&WaterFallRenderState::frequent_point_size, value);
     }
-    void WaterFall::giveData(int tick, const QVector<double>& data) {
+    void WaterFall::give_data(int tick, const QVector<double>& data) {
         if(!ok()) return;
         Render_Input_Lease<WaterFallPrivate, WaterFallInputData> input(d());
         input->mDataList.push_back({tick, data});
     }
 
-    WaterFall::Builder::Builder(FrequentAxis* frequentAxis, TimeAxis* timeAxis) {
-        ASSERT(frequentAxis->mPlot != nullptr, "Afterglow build error! frequentAxis->mPlot == nullptr");
-        ASSERT(frequentAxis->mPlot == timeAxis->mPlot, "Afterglow build error! frequentAxis->mPlot != timeAxis->mPlot");
-        plot = frequentAxis->mPlot;
-        this->frequentAxis = frequentAxis;
-        this->timeAxis = timeAxis;
+    WaterFall::Builder::Builder(FrequentAxis* frequent_axis, TimeAxis* time_axis) {
+        ASSERT(frequent_axis->mPlot != nullptr, "Afterglow build error! frequent_axis->mPlot == nullptr");
+        ASSERT(frequent_axis->mPlot == time_axis->mPlot, "Afterglow build error! frequent_axis->mPlot != time_axis->mPlot");
+        plot = frequent_axis->mPlot;
+        this->frequent_axis = frequent_axis;
+        this->time_axis = time_axis;
     }
     WaterFall* WaterFall::Builder::build() {
         auto ret = new WaterFall();
         ret->init(plot, layerName);
         WaterFallPrivate* pd = ret->d();
         WaterFallRenderState* sc = reinterpret_cast<WaterFallRenderState*>(pd->state(State_Edit));
-        PROP_R(FrequentAxis*, frequentAxis)
-        PROP_R(TimeAxis*, timeAxis)
-        PROP_R(Range, frequentRange)
-        PROP_R(Range, powerRange)
-        PROP_R(int, frequentPointSize)
+        PROP_R(FrequentAxis*, frequent_axis)
+        PROP_R(TimeAxis*, time_axis)
+        PROP_R(Range, frequent_range)
+        PROP_R(Range, power_range)
+        PROP_R(int, frequent_point_size)
         return ret;
     }
 
diff --git a/YSGraphic_Core/plottable/WaterFall.h b/YSGraphic_Core/plottable/WaterFall.h
index 688bfd5..e1d4f80 100644
--- a/YSGraphic_Core/plottable/WaterFall.h
+++ b/YSGraphic_Core/plottable/WaterFall.h
@@ -5,44 +5,44 @@ namespace YSG {
     struct WaterFallPrivate;
     class FrequentAxis;
     class TimeAxis;
-    // 如果timeAxis是竖轴，并且timePointSize 和竖着的像素点数没倍数关系，那么随机数整体看着会闪烁
-    // 如果和竖着的像素有倍数关系，但是timePointSize 是奇数，那么看着中间会闪烁
+    // 如果time_axis是竖轴，并且time_point_size 和竖着的像素点数没倍数关系，那么随机数整体看着会闪烁
+    // 如果和竖着的像素有倍数关系，但是time_point_size 是奇数，那么看着中间会闪烁
     class LIB_DECL WaterFall : public RenderAble, public HoverInfoRenderAble<WaterFall>{
     public:
         WaterFallPrivate* d();
-        RenderData* createRenderData() override;
-        RenderState* createRenderState() override;
-        InputData* createInputData() override;
+        RenderData* create_render_data() override;
+        RenderState* create_render_state() override;
+        InputData* create_input_data() override;
     protected:
         WaterFall();
         friend struct WaterFallPrivate;
         friend struct WaterFallRenderState;
         friend struct WaterFallInputData;
     public:
-        void giveData(int tick, const QVector<double>& data);
-        PROP(FrequentAxis*, frequentAxis)
-        PROP(TimeAxis*, timeAxis)
-        PROP(Range, frequentRange)
-        PROP(Range, powerRange)
-        PROP(int, frequentPointSize)
+        void give_data(int tick, const QVector<double>& data);
+        PROP(FrequentAxis*, frequent_axis)
+        PROP(TimeAxis*, time_axis)
+        PROP(Range, frequent_range)
+        PROP(Range, power_range)
+        PROP(int, frequent_point_size)
         struct Builder;
     };
     struct WaterFall_Prop {
-        FrequentAxis *frequentAxis{};
-        TimeAxis *timeAxis{};
-        Range frequentRange{0, 10};
-        Range powerRange{0, 10};
-        int frequentPointSize{};
+        FrequentAxis *frequent_axis{};
+        TimeAxis *time_axis{};
+        Range frequent_range{0, 10};
+        Range power_range{0, 10};
+        int frequent_point_size{};
         int tickSpace = 50;
     };
     struct LIB_DECL WaterFall::Builder : WaterFall_Prop {
-        PROP_B(FrequentAxis*, frequentAxis)
-        PROP_B(TimeAxis*, timeAxis)
-        PROP_B(Range, frequentRange)
-        PROP_B(Range, powerRange)
-        PROP_B(int, frequentPointSize)
+        PROP_B(FrequentAxis*, frequent_axis)
+        PROP_B(TimeAxis*, time_axis)
+        PROP_B(Range, frequent_range)
+        PROP_B(Range, power_range)
+        PROP_B(int, frequent_point_size)
         SETTER(QString, layerName, "plottable")
-        Builder(FrequentAxis* frequentAxis, TimeAxis* timeAxis);
+        Builder(FrequentAxis* frequent_axis, TimeAxis* time_axis);
         WaterFall* build();
     protected:
         Plot *plot{};
diff --git a/YSGraphic_Core/plottable/WaterFall_p.h b/YSGraphic_Core/plottable/WaterFall_p.h
index f62717c..c8f56e2 100644
--- a/YSGraphic_Core/plottable/WaterFall_p.h
+++ b/YSGraphic_Core/plottable/WaterFall_p.h
@@ -51,7 +51,7 @@ namespace YSG {
             rowBuffer.resize(colCount);
             buffer.init(recordByteSize * rowCount);
         }
-        void pushData(const double* data, int tick) {
+        void push_data(const double* data, int tick) {
             if(dataCount == rowCount) {
                 buffer.skip(recordByteSize);
                 --dataCount;
@@ -65,7 +65,7 @@ namespace YSG {
             buffer.peek_best_effort(snapshotBuffer.data(), recordByteSize * dataCount);
             return dataCount;
         }
-        const double* frequentData(int row) {
+        const double* frequent_data(int row) {
             std::memcpy(rowBuffer.data(), snapshotBuffer.data() + row * recordByteSize, rowByteSize);
             return rowBuffer.data();
         }
@@ -79,67 +79,67 @@ namespace YSG {
         friend class WaterFall;
         WaterFallRingBuffer ringBuffer;
         QImage image;
-        bool selectTest(const QPointF& pos) override {return true;}
-        void setHoverState(const QPoint& pos, bool active) override {
+        bool select_test(const QPointF& pos) override {return true;}
+        void set_hover_state(const QPoint& pos, bool active) override {
             Render_Edit_Lease<WaterFallPrivate, WaterFallRenderState> edit(this);
             edit->hoverInfoPos = pos;
             edit->hoverInfoActive = active;
         }
 
-        void prepareData() override {
-            syncStatePipeline();
-            WaterFallInputData* data = renderInputData();
-            const WaterFallRenderState* s = renderState();
-            int colCount = s->frequentPointSize, rowCount = s->timeAxis->timePointSize();
+        void prepare_data() override {
+            sync_state_pipeline();
+            WaterFallInputData* data = render_input_data();
+            const WaterFallRenderState* s = render_state();
+            int colCount = s->frequent_point_size, rowCount = s->time_axis->time_point_size();
             if(!ringBuffer.match(colCount, rowCount)) {
                 ringBuffer.resize(colCount, rowCount);
             }
             for(WaterFallData& wd : data->mDataList) {
-                QVector<double>& frequentData = wd.mFrequent;
-                if(frequentData.size() != colCount) {
+                QVector<double>& frequent_data = wd.mFrequent;
+                if(frequent_data.size() != colCount) {
                     qDebug() << "WaterFall 舍弃数据 colCount == " << colCount <<
-                        "   dataSize == " << frequentData.size() <<
-                            "s FrequentRectCount==" << s->frequentPointSize <<
-                            "sc FrequentRectCount==" << editState()->frequentPointSize;
+                        "   dataSize == " << frequent_data.size() <<
+                            "s FrequentRectCount==" << s->frequent_point_size <<
+                            "sc FrequentRectCount==" << edit_state()->frequent_point_size;
                     break;
                 }
-                ringBuffer.pushData(frequentData.data(), wd.mTick);
+                ringBuffer.push_data(frequent_data.data(), wd.mTick);
             }
-            clearRenderInput();
+            clear_render_input();
         }
         void draw(QPainter* painter) override {
-            WaterFallRenderState* s = renderState();
+            WaterFallRenderState* s = render_state();
             PerformanceShower *shower = q()->mPlot->d->mShower;
             if(shower) {
-                shower->setPerformanceLine("FrequentRectCount", PerformanceLine(QString("FrequentRectCount:%1   timePointSize: %2").arg(s->frequentPointSize).arg(s->timeAxis->timePointSize())));
+                shower->set_performance_line("FrequentRectCount", PerformanceLine(QString("FrequentRectCount:%1   time_point_size: %2").arg(s->frequent_point_size).arg(s->time_axis->time_point_size())));
             }
-            AbsAxis *hAxis =  s->frequentAxis;
-            TimeAxis *vAxis = s->timeAxis;
-            Range hRange =  s->frequentRange, vRange =  s->timeAxis->coordRange();
+            AbsAxis *hAxis =  s->frequent_axis;
+            TimeAxis *vAxis = s->time_axis;
+            Range hRange =  s->frequent_range, vRange =  s->time_axis->coord_range();
 
-            TimeTicker& maker = s->timeAxis->d()->mTimeTicker;
+            TimeTicker& maker = s->time_axis->d()->mTimeTicker;
             if(!maker.mStartCoordToEndCoord){
                 std::swap(vRange.lower, vRange.upper);
             }
-            int colCount = s->frequentPointSize, rowCount = s->timeAxis->timePointSize();
+            int colCount = s->frequent_point_size, rowCount = s->time_axis->time_point_size();
             if(image.width() != colCount || image.height() != rowCount) {
                 image = QImage(colCount, rowCount, QImage::Format_ARGB32_Premultiplied);
-                image.fill(q()->mPlot->backgroundColor());
+                image.fill(q()->mPlot->background_color());
                 PerformanceShower *shower = q()->mPlot->d->mShower;
                 if(shower) {
-                    shower->setPerformanceLine("colCount, rowCount", PerformanceLine(QString("colCount:%1, rowCount:%2").arg(colCount).arg(rowCount)));
+                    shower->set_performance_line("colCount, rowCount", PerformanceLine(QString("colCount:%1, rowCount:%2").arg(colCount).arg(rowCount)));
                 }
             }
-            double valueStartCoord = s->powerRange.lower;
-            double rate = 256.0 / s->powerRange.size();
+            double valueStartCoord = s->power_range.lower;
+            double rate = 256.0 / s->power_range.size();
             int bufferDataCount = ringBuffer.snapshot();
             QVector<QRgb>& mColorMap = Global::instance()->mColorMap;
             {
                 Cacl c("waterfull setTime:%1 SRTT:%2 RTTVAR:%3", q()->mPlot->d->mShower);
-                int startTick = (int)s->timeAxis->startCoord();
+                int startTick = (int)s->time_axis->start_coord();
                 for(int row = 0; row < bufferDataCount; ++row) {
                     int bufferRow = bufferDataCount - row - 1;
-                    auto list = ringBuffer.frequentData(bufferRow);
+                    auto list = ringBuffer.frequent_data(bufferRow);
                     int tick = ringBuffer.tick(bufferRow);
                     int tickOffset = tick - startTick;
                     if(tickOffset < 0 || tickOffset >= rowCount) continue;
@@ -147,17 +147,17 @@ namespace YSG {
                     for (int col = 0; col < colCount; ++col) {
                         int colorOffset = int((list[col] - valueStartCoord) * rate);
                         if (colorOffset < 0 || colorOffset > 255) {
-                            qDebug() << "colorOffset:" << colorOffset << " value: " << list[col] << s->frequentRange;
+                            qDebug() << "colorOffset:" << colorOffset << " value: " << list[col] << s->frequent_range;
                         }
                         scanLine[col] = mColorMap.at(clamp(colorOffset, 0, 255));
                     }
                 }
             }
-            double x = hAxis->coordToPixel(hRange.lower, SRC::Render);
-            double y = vAxis->coordToPixel(vRange.lower, SRC::Render);
-            double w = hAxis->coordToPixel(hRange.upper, SRC::Render) - x;
-            double h = vAxis->coordToPixel(vRange.upper, SRC::Render) - y;
-            Range &&hAxisRange = hAxis->coordRange(), &&vAxisRange = vAxis->coordRange();
+            double x = hAxis->coord_to_pixel(hRange.lower, SRC::Render);
+            double y = vAxis->coord_to_pixel(vRange.lower, SRC::Render);
+            double w = hAxis->coord_to_pixel(hRange.upper, SRC::Render) - x;
+            double h = vAxis->coord_to_pixel(vRange.upper, SRC::Render) - y;
+            Range &&hAxisRange = hAxis->coord_range(), &&vAxisRange = vAxis->coord_range();
             double hr = ((hAxisRange.lower < hAxisRange.upper) ^ (hRange.lower < hRange.upper)) ? -1 : 1;
             double vr = ((vAxisRange.lower < vAxisRange.upper) ^ (vRange.lower < vRange.upper)) ? -1 : 1;
 
@@ -166,8 +166,8 @@ namespace YSG {
             painter->drawImage(QRectF(hr * x, vr * y, hr * w, vr * h), image);
             painter->restore();
 
-            if(q()->hoverOK(q())) {
-                q()->drawHover(painter, s->frequentAxis, s->timeAxis);
+            if(q()->hover_ok(q())) {
+                q()->draw_hover(painter, s->frequent_axis, s->time_axis);
             }
         }
     };