Refactored

src/epdgui/epdgui.cpp

@@ -3,8 +3,7 @@
 #include <list>
 #include "epdgui.h"
 
-typedef struct
-{
+typedef struct {
     Frame_Base* frame;
     epdgui_args_vector_t args;
 }frame_struct_t;
@@ -18,53 +17,42 @@ uint8_t frame_switch_count = 0;
 bool _is_auto_update = true;
 uint16_t _last_pos_x = 0xFFFF, _last_pos_y = 0xFFFF;
 
-void EPDGUI_AddObject(EPDGUI_Base* object)
-{
+void EPDGUI_AddObject(EPDGUI_Base* object) {
     object->SetID(obj_id);
     obj_id++;
     epdgui_object_list.push_back(object);
 }
 
-void EPDGUI_Draw(m5epd_update_mode_t mode)
-{
-    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++)
-    {
+void EPDGUI_Draw(m5epd_update_mode_t mode) {
+    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++) {
         (*p)->Draw(mode);
     }
 }
 
-void EPDGUI_Process(void)
-{
-    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++)
-    {
+void EPDGUI_Process(void) {
+    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++) {
         (*p)->UpdateState(-1, -1);
     }
 }
 
-void EPDGUI_Process(int16_t x, int16_t y)
-{
-    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++)
-    {
+void EPDGUI_Process(int16_t x, int16_t y) {
+    for(std::list<EPDGUI_Base*>::iterator p = epdgui_object_list.begin(); p != epdgui_object_list.end(); p++) {
         // log_d("%d, %d -> %d, %d, %d, %d", x, y, (*p)->getX(), (*p)->getY(), (*p)->getRX(), (*p)->getBY());
         (*p)->UpdateState(x, y);
     }
 }
 
-void EPDGUI_Clear(void)
-{
+void EPDGUI_Clear(void) {
     epdgui_object_list.clear();
 }
 
-void EPDGUI_Run(Frame_Base* frame)
-{
+void EPDGUI_Run(Frame_Base* frame) {
     uint32_t last_active_time = 0;
 
-    if(frame->isRun() == 0)
-    {
+    if(frame->isRun() == 0) {
         frame->exit();
         log_d("Exit %s", frame->GetFrameName().c_str());
-        if(wait_for_delete != NULL)
-        {
+        if(wait_for_delete != NULL) {
             delete wait_for_delete;
             wait_for_delete = NULL;
         }
@@ -72,26 +60,20 @@ void EPDGUI_Run(Frame_Base* frame)
     }
 
     EPDGUI_Draw(UPDATE_MODE_NONE);
-    if((frame->GetFrameID() == 1) || (frame_switch_count > 3))
-    {
+    if((frame->GetFrameID() == 1) || (frame_switch_count > 3)) {
         frame_switch_count = 0;
         M5.EPD.UpdateFull(UPDATE_MODE_GC16);
-    }
-    else
-    {
+     } else {
         M5.EPD.UpdateFull(UPDATE_MODE_GL16);
         frame_switch_count++;
     }
 
-    while (1)
-    {
-        if((frame->isRun() == 0) || (frame->run() == 0))
-        {
+    while (1) {
+        if((frame->isRun() == 0) || (frame->run() == 0)) {
             frame->exit();
             // M5.EPD.Clear();
             log_d("Exit %s", frame->GetFrameName().c_str());
-            if(wait_for_delete != NULL)
-            {
+            if(wait_for_delete != NULL) {
                 log_d("delete %s", wait_for_delete->GetFrameName().c_str());
                 delete wait_for_delete;
                 wait_for_delete = NULL;
@@ -99,21 +81,16 @@ void EPDGUI_Run(Frame_Base* frame)
             return;
         }
 
-        if (M5.TP.avaliable())
-        {
+        if (M5.TP.avaliable()) {
             M5.TP.update();
             bool is_finger_up = M5.TP.isFingerUp();
-            if(is_finger_up || (_last_pos_x != M5.TP.readFingerX(0)) || (_last_pos_y != M5.TP.readFingerY(0)))
-            {
+            if(is_finger_up || (_last_pos_x != M5.TP.readFingerX(0)) || (_last_pos_y != M5.TP.readFingerY(0))) {
                 _last_pos_x = M5.TP.readFingerX(0);
                 _last_pos_y = M5.TP.readFingerY(0);
-                if(is_finger_up)
-                {
+                if(is_finger_up) {
                     EPDGUI_Process();
                     last_active_time = millis();
-                }
-                else
-                {
+                 } else {
                     EPDGUI_Process(M5.TP.readFingerX(0), M5.TP.readFingerY(0));
                     last_active_time = 0;
                 }
@@ -123,13 +100,10 @@ void EPDGUI_Run(Frame_Base* frame)
             M5.TP.flush();
         }
 
-        if((last_active_time != 0) && (millis() - last_active_time > 2000))
-        {
-            if(M5.EPD.UpdateCount() > 4)
-            {
+        if((last_active_time != 0) && (millis() - last_active_time > 2000)) {
+            if(M5.EPD.UpdateCount() > 4) {
                 M5.EPD.ResetUpdateCount();
-                if(_is_auto_update)
-                {
+                if(_is_auto_update) {
                     M5.EPD.UpdateFull(UPDATE_MODE_GL16);
                 }
             }
@@ -138,10 +112,8 @@ void EPDGUI_Run(Frame_Base* frame)
     }
 }
 
-void EPDGUI_MainLoop(void)
-{
-    if((!frame_stack.empty()) && (frame_stack.top() != NULL))
-    {
+void EPDGUI_MainLoop(void) {
+    if((!frame_stack.empty()) && (frame_stack.top() != NULL)) {
         Frame_Base *frame = frame_stack.top();
         log_d("Run %s", frame->GetFrameName().c_str());
         EPDGUI_Clear();
@@ -151,63 +123,49 @@ void EPDGUI_MainLoop(void)
     }
 }
 
-void EPDGUI_AddFrame(String name, Frame_Base* frame)
-{
+void EPDGUI_AddFrame(String name, Frame_Base* frame) {
     frame_struct_t f;
     f.frame = frame;
     frame_map.insert(std::pair<String, frame_struct_t>(name, f));
 }
 
-void EPDGUI_AddFrameArg(String name, int n, void* arg)
-{
-    if(frame_map.count(name) == 0)
-    {
+void EPDGUI_AddFrameArg(String name, int n, void* arg) {
+    if(frame_map.count(name) == 0) {
         return;
     }
-    if(frame_map[name].args.size() > n)
-    {
+    if(frame_map[name].args.size() > n) {
         frame_map[name].args[n] = arg;
-    }
-    else
-    {
+     } else {
         frame_map[name].args.push_back(arg);
     }
     log_d("%d", frame_map[name].args.size());
 }
 
-Frame_Base* EPDGUI_GetFrame(String name)
-{
-    if(frame_map.count(name) > 0)
-    {
+Frame_Base* EPDGUI_GetFrame(String name) {
+    if(frame_map.count(name) > 0) {
         return frame_map[name].frame;
     }
     return NULL;
 }
 
-void EPDGUI_PushFrame(Frame_Base* frame)
-{
+void EPDGUI_PushFrame(Frame_Base* frame) {
     frame_stack.push(frame);
 }
 
-void EPDGUI_PopFrame(bool isDelete)
-{
-    if(isDelete)
-    {
+void EPDGUI_PopFrame(bool isDelete) {
+    if(isDelete) {
         wait_for_delete = frame_stack.top();
     }
     frame_stack.pop();
 }
 
-void EPDGUI_OverwriteFrame(Frame_Base* frame)
-{
-    while(!frame_stack.empty())
-    {
+void EPDGUI_OverwriteFrame(Frame_Base* frame) {
+    while(!frame_stack.empty()) {
         frame_stack.pop();
     }
     frame_stack.push(frame);
 }
 
-void EPDGUI_SetAutoUpdate(bool isAuto)
-{
+void EPDGUI_SetAutoUpdate(bool isAuto) {
     _is_auto_update = isAuto;
 }

src/epdgui/epdgui_base.cpp

@@ -1,7 +1,6 @@
 #include "epdgui_base.h"
 
-EPDGUI_Base::EPDGUI_Base(int16_t x, int16_t y, int16_t w, int16_t h)
-{
+EPDGUI_Base::EPDGUI_Base(int16_t x, int16_t y, int16_t w, int16_t h) {
     x = (x + 3) & 0xFFFC;
     w = (w + 3) & 0xFFFC;
     this->_x = x;
@@ -12,24 +11,19 @@ EPDGUI_Base::EPDGUI_Base(int16_t x, int16_t y, int16_t w, int16_t h)
     _by = _y + _h;
 }
 
-EPDGUI_Base::EPDGUI_Base()
-{
+EPDGUI_Base::EPDGUI_Base() {
 }
 
-bool EPDGUI_Base::isSelected(void)
-{
+bool EPDGUI_Base::isSelected(void) {
     return _issel;
 }
 
-bool EPDGUI_Base::isInBox(int16_t x, int16_t y)
-{
-    if (x == -1 || y == -1)
-    {
+bool EPDGUI_Base::isInBox(int16_t x, int16_t y) {
+    if (x == -1 || y == -1) {
         return false;
     }
 
-    if ((x > _x) && (x < _rx) && (y > _y) && (y < _by))
-    {
+    if ((x > _x) && (x < _rx) && (y > _y) && (y < _by)) {
         _issel = true;
         return 1;
     }
@@ -37,18 +31,15 @@ bool EPDGUI_Base::isInBox(int16_t x, int16_t y)
     return 0;
 }
 
-void EPDGUI_Base::SetHide(bool ishide)
-{
+void EPDGUI_Base::SetHide(bool ishide) {
     this->_ishide = ishide;
 }
 
-void EPDGUI_Base::SetEnable(bool isenable)
-{
+void EPDGUI_Base::SetEnable(bool isenable) {
     this->_isenable = isenable;
 }
 
-void EPDGUI_Base::SetGeometry(int16_t x, int16_t y, int16_t w, int16_t h)
-{
+void EPDGUI_Base::SetGeometry(int16_t x, int16_t y, int16_t w, int16_t h) {
     x = (x + 3) & 0xFFFC;
     w = (w + 3) & 0xFFFC;
     this->_x = x;
@@ -57,14 +48,12 @@ void EPDGUI_Base::SetGeometry(int16_t x, int16_t y, int16_t w, int16_t h)
     this->_h = h;
 }
 
-void EPDGUI_Base::SetPos(int16_t x, int16_t y)
-{
+void EPDGUI_Base::SetPos(int16_t x, int16_t y) {
     x = (x + 3) & 0xFFFC;
     this->_x = x;
     this->_y = y;
 }
 
-void EPDGUI_Base::UpdateGram(m5epd_update_mode_t mode)
-{
+void EPDGUI_Base::UpdateGram(m5epd_update_mode_t mode) {
     M5.EPD.UpdateArea(_x, _y, _w, _h, mode);
 }

src/epdgui/epdgui_base.h

@@ -8,8 +8,7 @@
 
 typedef std::vector<void*> epdgui_args_vector_t;
 
-class EPDGUI_Base
-{
+class EPDGUI_Base {
 public:
     EPDGUI_Base(int16_t x, int16_t y, int16_t w, int16_t h);
     EPDGUI_Base();

src/epdgui/epdgui_button.cpp

@@ -1,8 +1,7 @@
 #include "epdgui_button.h"
 
 EPDGUI_Button::EPDGUI_Button(int16_t x, int16_t y, int16_t w, int16_t h): 
-EPDGUI_Base(x, y, w, h)
-{
+EPDGUI_Base(x, y, w, h) {
     this->_CanvasNormal = new M5EPD_Canvas(&M5.EPD);
     this->_CanvasPressed = new M5EPD_Canvas(&M5.EPD);
     this->_CanvasNormal->createCanvas(_w, _h);
@@ -10,10 +9,8 @@ EPDGUI_Base(x, y, w, h)
 }
 
 EPDGUI_Button::EPDGUI_Button(String label, int16_t x, int16_t y, int16_t w, int16_t h, uint32_t style): 
-EPDGUI_Base(x, y, w, h)
-{
-    if(style & STYLE_INVISABLE)
-    {
+EPDGUI_Base(x, y, w, h) {
+    if(style & STYLE_INVISABLE) {
         _is_invisable = true;
         return;
     }
@@ -35,27 +32,21 @@ EPDGUI_Base(x, y, w, h)
     this->_CanvasPressed->fillCanvas(15);
     this->_CanvasPressed->setTextSize(26);
     this->_CanvasPressed->setTextColor(0);
-    if(style & STYLE_SOLIDBORDER)
-    {
+    if(style & STYLE_SOLIDBORDER) {
         this->_CanvasNormal->drawRect(0, 0, _w, _h, 15);
     }
     
-    if(style & STYLE_ALIGN_LEFT)
-    {
+    if(style & STYLE_ALIGN_LEFT) {
         this->_CanvasNormal->setTextDatum(CL_DATUM);
         this->_CanvasPressed->setTextDatum(CL_DATUM);
         this->_CanvasNormal->drawString(_label,  5, _h / 2 + 3);
         this->_CanvasPressed->drawString(_label, 5, _h / 2 + 3);
-    }
-    else if(style & STYLE_ALIGN_RIGHT)
-    {
+     } else if(style & STYLE_ALIGN_RIGHT) {
         this->_CanvasNormal->setTextDatum(CR_DATUM);
         this->_CanvasPressed->setTextDatum(CR_DATUM);
         this->_CanvasNormal->drawString(_label,  _w - 5, _h / 2 + 3);
         this->_CanvasPressed->drawString(_label, _w - 5, _h / 2 + 3);
-    }
-    else if(style & STYLE_ALIGN_CENTER)
-    {
+     } else if(style & STYLE_ALIGN_CENTER) {
         this->_CanvasNormal->setTextDatum(CC_DATUM);
         this->_CanvasPressed->setTextDatum(CC_DATUM);
         this->_CanvasNormal->drawString(_label,  _w / 2, _h / 2 + 3);
@@ -63,117 +54,88 @@ EPDGUI_Base(x, y, w, h)
     }
 }
 
-EPDGUI_Button::~EPDGUI_Button()
-{
+EPDGUI_Button::~EPDGUI_Button() {
     delete this->_CanvasNormal;
     delete this->_CanvasPressed;
 }
 
-M5EPD_Canvas* EPDGUI_Button::CanvasNormal()
-{
+M5EPD_Canvas* EPDGUI_Button::CanvasNormal() {
     return this->_CanvasNormal;
 }
 
-M5EPD_Canvas* EPDGUI_Button::CanvasPressed()
-{
+M5EPD_Canvas* EPDGUI_Button::CanvasPressed() {
     return this->_CanvasPressed;
 }
 
-void EPDGUI_Button::Draw(m5epd_update_mode_t mode)
-{
-    if(_ishide || _is_invisable)
-    {
+void EPDGUI_Button::Draw(m5epd_update_mode_t mode) {
+    if(_ishide || _is_invisable) {
         return;
     }
 
-    if(_state == EVENT_NONE || _state == EVENT_RELEASED)
-    {
+    if(_state == EVENT_NONE || _state == EVENT_RELEASED) {
         this->_CanvasNormal->pushCanvas(_x, _y, mode);
-    }
-    else if(_state == EVENT_PRESSED)
-    {
+     } else if(_state == EVENT_PRESSED) {
         this->_CanvasPressed->pushCanvas(_x, _y, mode);
     }
 }
 
-void EPDGUI_Button::Draw(M5EPD_Canvas* canvas)
-{
-    if(_ishide)
-    {
+void EPDGUI_Button::Draw(M5EPD_Canvas* canvas) {
+    if(_ishide) {
         return;
     }
 
-    if(_state == EVENT_NONE || _state == EVENT_RELEASED)
-    {
+    if(_state == EVENT_NONE || _state == EVENT_RELEASED) {
         _CanvasNormal->pushToCanvas(_x, _y, canvas);
-    }
-    else if(_state == EVENT_PRESSED)
-    {
+     } else if(_state == EVENT_PRESSED) {
         _CanvasPressed->pushToCanvas(_x, _y, canvas);
     }
 }
 
-void EPDGUI_Button::Bind(int16_t event, void (* func_cb)(epdgui_args_vector_t&))
-{
-    if(event == EVENT_PRESSED)
-    {
+void EPDGUI_Button::Bind(int16_t event, void (* func_cb)(epdgui_args_vector_t&)) {
+    if(event == EVENT_PRESSED) {
         _pressed_cb = func_cb;
-    }
-    else if(event == EVENT_RELEASED)
-    {
+     } else if(event == EVENT_RELEASED) {
         _released_cb = func_cb;
     }
 }
 
-void EPDGUI_Button::UpdateState(int16_t x, int16_t y)
-{
-    if(!_isenable || _ishide)
-    {
+void EPDGUI_Button::UpdateState(int16_t x, int16_t y) {
+    if(!_isenable || _ishide) {
         return;
     }
 
     bool is_in_area = isInBox(x, y);
 
-    if(is_in_area)
-    {
-        if(_state == EVENT_NONE)
-        {
+    if(is_in_area) {
+        if(_state == EVENT_NONE) {
             _state = EVENT_PRESSED;
             // Serial.printf("%s Pressed ", _label.c_str());
             Draw();
-            if(_pressed_cb != NULL)
-            {
+            if(_pressed_cb != NULL) {
                 _pressed_cb(_pressed_cb_args);
             }
         }
-    }
-    else
-    {
-        if(_state == EVENT_PRESSED)
-        {
+     } else {
+        if(_state == EVENT_PRESSED) {
             _state = EVENT_NONE;
             Draw();
-            if(_released_cb != NULL)
-            {
+            if(_released_cb != NULL) {
                 _released_cb(_released_cb_args);
             }
         }
     }
 }
 
-void EPDGUI_Button::setBMPButton(String label_l, String label_r, const uint8_t *bmp32x32)
-{
+void EPDGUI_Button::setBMPButton(String label_l, String label_r, const uint8_t *bmp32x32) {
     _CanvasNormal->fillCanvas(0);
     _CanvasNormal->drawRect(0, 0, _w, _h, 15);
     _CanvasNormal->setTextSize(26);
     _CanvasNormal->setTextColor(15);
-    if(label_l.length())
-    {
+    if(label_l.length()) {
         _CanvasNormal->setTextDatum(CL_DATUM);
         _CanvasNormal->drawString(label_l, 47 + 8, (_h >> 1) + 5);
     }
-    if(label_r.length())
-    {
+    if(label_r.length()) {
         _CanvasNormal->setTextDatum(CR_DATUM);
         _CanvasNormal->drawString(label_r, _w - 15, (_h >> 1) + 5);
     }
@@ -182,8 +144,7 @@ void EPDGUI_Button::setBMPButton(String label_l, String label_r, const uint8_t *
     _CanvasPressed->ReverseColor();
 }
 
-void EPDGUI_Button::setLabel(String label)
-{
+void EPDGUI_Button::setLabel(String label) {
     _label = label;
     this->_CanvasNormal->fillCanvas(0);
     this->_CanvasNormal->drawRect(0, 0, _w, _h, 15);
@@ -199,27 +160,17 @@ void EPDGUI_Button::setLabel(String label)
     this->_CanvasPressed->drawString(_label, _w / 2, _h / 2 + 3);
 }
 
-void EPDGUI_Button::AddArgs(int16_t event, uint16_t n, void* arg)
-{
-    if(event == EVENT_PRESSED)
-    {
-        if(_pressed_cb_args.size() > n)
-        {
+void EPDGUI_Button::AddArgs(int16_t event, uint16_t n, void* arg) {
+    if(event == EVENT_PRESSED) {
+        if(_pressed_cb_args.size() > n) {
             _pressed_cb_args[n] = arg;
-        }
-        else
-        {
+         } else {
             _pressed_cb_args.push_back(arg);
         }
-    }
-    else if(event == EVENT_RELEASED)
-    {
-        if(_released_cb_args.size() > n)
-        {
+     } else if(event == EVENT_RELEASED) {
+        if(_released_cb_args.size() > n) {
             _released_cb_args[n] = arg;
-        }
-        else
-        {
+         } else {
             _released_cb_args.push_back(arg);
         }
     }

src/epdgui/epdgui_button.h

@@ -3,8 +3,7 @@
 
 #include "epdgui_base.h"
 
-class EPDGUI_Button: public EPDGUI_Base
-{
+class EPDGUI_Button: public EPDGUI_Base {
 public:
     static const int16_t EVENT_NONE = 0;
     static const int16_t EVENT_PRESSED = 1;

src/epdgui/epdgui_keyboard.cpp

@@ -30,8 +30,7 @@ static const char* kKeyAlphaMapSymbol[26] = {
 //     "ばバびビぶブべべぼボびゃビャびゅビュびょビョ"
 // };
 
-enum
-{
+enum {
     kKeySpace = 26,
     kKeyBackspace,
     kKeyWrap,
@@ -40,27 +39,23 @@ enum
     kKeyNumber
 };
 
-enum
-{
+enum {
     kSWCase = 0,
     kSWSwitch,
     kSWNumber
 };
 
-enum
-{
+enum {
     kLayoutLowerAlpha = 0,
     kLayoutUpperAlpha,
     kLayoutNumber,
     kLayoutSymbol
 };
 
-EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
-{
+EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base() {
     uint8_t language = GetLanguage();
     
-    if(dir) // Horizontal
-    {
+    if(dir) { // Horizontal 
         const uint16_t kKeyWidth = 72;
         const uint16_t kKeyHeight = 44;
         const uint16_t kKeyInterval = 8;
@@ -70,16 +65,13 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
         const uint16_t k4thLineY = 464;
         const uint16_t kBaseX = 84;
 
-        for(int i = 0; i < 10; i++)
-        {
+        for(int i = 0; i < 10; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + (kKeyInterval + kKeyWidth) * i, kFirstLineY, kKeyWidth, kKeyHeight);
         }
-        for(int i = 10; i < 19; i++)
-        {
+        for(int i = 10; i < 19; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + 40 + (kKeyInterval + kKeyWidth) * (i - 10), kSecondLineY, kKeyWidth, kKeyHeight);
         }
-        for(int i = 19; i < 26; i++)
-        {
+        for(int i = 19; i < 26; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + 118 + (kKeyInterval + kKeyWidth) * (i - 19), kThirdLineY, kKeyWidth, kKeyHeight);
         }
 
@@ -89,24 +81,19 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
         _btn[kKeyBackspace]->CanvasPressed()->pushImage(_btn[kKeyBackspace]->getW() / 2 - 16, _btn[kKeyBackspace]->getH() / 2 - 16, 32, 32, ImageResource_backspace_32x32);
         _btn[kKeyBackspace]->CanvasPressed()->ReverseColor();
 
-        if(language == LANGUAGE_JA)
-        {
+        if(language == LANGUAGE_JA) {
             _btn[kKeySpace] = new EPDGUI_Button("空白", kBaseX + 162, k4thLineY, 468, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("改行", kBaseX + 792 - 152, k4thLineY, 152, kKeyHeight);
             else if(style & STYLE_INPUTMODE_NEEDCONFIRM)
                 _btn[kKeyWrap] = new EPDGUI_Button("確認", kBaseX + 792 - 152, k4thLineY, 152, kKeyHeight);
-        }
-        else if(language == LANGUAGE_ZH)
-        {
+         } else if(language == LANGUAGE_ZH) {
             _btn[kKeySpace] = new EPDGUI_Button("空格", kBaseX + 162, k4thLineY, 468, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("换行", kBaseX + 792 - 152, k4thLineY, 152, kKeyHeight);
             else if(style & STYLE_INPUTMODE_NEEDCONFIRM)
                 _btn[kKeyWrap] = new EPDGUI_Button("确认", kBaseX + 792 - 152, k4thLineY, 152, kKeyHeight);
-        }
-        else
-        {
+         } else {
             _btn[kKeySpace] = new EPDGUI_Button("Space", kBaseX + 162, k4thLineY, 468, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("Wrap", kBaseX + 792 - 152, k4thLineY, 152, kKeyHeight);
@@ -118,9 +105,7 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
         _sw[kSWCase] = new EPDGUI_Switch(2, kBaseX, kThirdLineY, 96, kKeyHeight);
         _sw[kSWSwitch] = new EPDGUI_Switch(2, kBaseX, k4thLineY, 68, kKeyHeight);
         _sw[kSWNumber] = new EPDGUI_Switch(2, kBaseX + 162 - kKeyInterval - 68, k4thLineY, 68, kKeyHeight);
-    }
-    else
-    {
+     } else {
         const uint16_t kBaseX = 16;
         const uint16_t kBaseY = 700;
         const uint16_t kKeyWidth = 44;
@@ -131,16 +116,13 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
         const uint16_t kThirdLineY = kSecondLineY + 64;
         const uint16_t k4thLineY = kThirdLineY + 64;
 
-        for(int i = 0; i < 10; i++)
-        {
+        for(int i = 0; i < 10; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + (kKeyInterval + kKeyWidth) * i, kFirstLineY, kKeyWidth, kKeyHeight);
         }
-        for(int i = 10; i < 19; i++)
-        {
+        for(int i = 10; i < 19; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + 28 + (kKeyInterval + kKeyWidth) * (i - 10), kSecondLineY, kKeyWidth, kKeyHeight);
         }
-        for(int i = 19; i < 26; i++)
-        {
+        for(int i = 19; i < 26; i++) {
             _btn[i] = new EPDGUI_Button(kKeyAlphaMapLowerCase[i], kBaseX + 80 + (kKeyInterval + kKeyWidth) * (i - 19), kThirdLineY, kKeyWidth, kKeyHeight);
         }
 
@@ -150,24 +132,19 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
         _btn[kKeyBackspace]->CanvasPressed()->pushImage(_btn[kKeyBackspace]->getW() / 2 - 16, _btn[kKeyBackspace]->getH() / 2 - 16, 32, 32, ImageResource_backspace_32x32);
         _btn[kKeyBackspace]->CanvasPressed()->ReverseColor();
 
-        if(language == LANGUAGE_JA)
-        {
+        if(language == LANGUAGE_JA) {
             _btn[kKeySpace] = new EPDGUI_Button("空白", kBaseX + 132, k4thLineY, 244, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("改行", kBaseX + 512 - 128, k4thLineY, 128, kKeyHeight);
             else if(style & STYLE_INPUTMODE_NEEDCONFIRM)
                 _btn[kKeyWrap] = new EPDGUI_Button("確認", kBaseX + 512 - 128, k4thLineY, 128, kKeyHeight);
-        }
-        else if(language == LANGUAGE_ZH)
-        {
+         } else if(language == LANGUAGE_ZH) {
             _btn[kKeySpace] = new EPDGUI_Button("空格", kBaseX + 132, k4thLineY, 244, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("换行", kBaseX + 512 - 128, k4thLineY, 128, kKeyHeight);
             else if(style & STYLE_INPUTMODE_NEEDCONFIRM)
                 _btn[kKeyWrap] = new EPDGUI_Button("确认", kBaseX + 512 - 128, k4thLineY, 128, kKeyHeight);
-        }
-        else
-        {
+         } else {
             _btn[kKeySpace] = new EPDGUI_Button("Space", kBaseX + 132, k4thLineY, 244, kKeyHeight);
             if(style & STYLE_INPUTMODE_NORMALTEXT)
                 _btn[kKeyWrap] = new EPDGUI_Button("Wrap", kBaseX + 512 - 128, k4thLineY, 128, kKeyHeight);
@@ -189,8 +166,7 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
     _sw[kSWNumber]->SetLabel(0, "123");
     _sw[kSWNumber]->SetLabel(1, "Abc");
 
-    for(int i = 0; i < 29; i++)
-    {
+    for(int i = 0; i < 29; i++) {
         _key[i] = _btn[i];
     }
     _key[kKeyCase] = _sw[kSWCase];
@@ -202,93 +178,69 @@ EPDGUI_Keyboard::EPDGUI_Keyboard(int16_t dir, uint32_t style): EPDGUI_Base()
     _layout = kLayoutLowerAlpha;
 }
 
-EPDGUI_Keyboard::~EPDGUI_Keyboard()
-{
-    for(int i = 0; i < 29; i++)
-    {
+EPDGUI_Keyboard::~EPDGUI_Keyboard() {
+    for(int i = 0; i < 29; i++) {
         delete _btn[i];
     }
-    for(int i = 0; i < 3; i++)
-    {
+    for(int i = 0; i < 3; i++) {
         delete _sw[i];
     }
 }
 
-void EPDGUI_Keyboard::Draw(m5epd_update_mode_t mode)
-{
-    if(_ishide)
-    {
+void EPDGUI_Keyboard::Draw(m5epd_update_mode_t mode) {
+    if(_ishide) {
         return;
     }
 
-    for(int i = 0; i < 32; i++)
-    {
+    for(int i = 0; i < 32; i++) {
         _key[i]->Draw(mode);
     }
 }
 
-void EPDGUI_Keyboard::Draw(M5EPD_Canvas* canvas)
-{
-    if(_ishide)
-    {
+void EPDGUI_Keyboard::Draw(M5EPD_Canvas* canvas) {
+    if(_ishide) {
         return;
     }
 
-    for(int i = 0; i < 32; i++)
-    {
+    for(int i = 0; i < 32; i++) {
         _key[i]->Draw(canvas);
     }
 }
 
-void EPDGUI_Keyboard::Bind(int16_t state, void (* func_cb)(epdgui_args_vector_t&))
-{
+void EPDGUI_Keyboard::Bind(int16_t state, void (* func_cb)(epdgui_args_vector_t&)) {
     
 }
 
-void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y)
-{
-    if(!_isenable)
-    {
+void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y) {
+    if(!_isenable) {
         return;
     }
     // log_d("UpdateState %d, %d", x, y);
-    for(int i = 0; i < 32; i++)
-    {
+    for(int i = 0; i < 32; i++) {
         bool keypressed = _key[i]->isInBox(x, y);
         _key[i]->UpdateState(x, y);
-        if(keypressed)
-        {
-            if(i < 26)
-            {
-                switch(_layout)
-                {
+        if(keypressed) {
+            if(i < 26) {
+                switch(_layout) {
                     case kLayoutLowerAlpha: _data += kKeyAlphaMapLowerCase[i]; break;
                     case kLayoutUpperAlpha: _data += kKeyAlphaMapUpperCase[i]; break;
                     case kLayoutNumber: _data += kKeyAlphaMapNumber[i]; break;
                     case kLayoutSymbol: _data += kKeyAlphaMapSymbol[i]; break;
                 }
             }
-            switch(i)
-            {
+            switch(i) {
                 case kKeyBackspace: _data += "\u0008"; break;
                 case kKeySpace: _data += " "; break;
                 case kKeyWrap: _data += "\n"; break;
-                case kKeyCase:
-                {
-                    if(_layout == kLayoutNumber || _layout == kLayoutSymbol)
-                    {
-                        if(_sw[kSWCase]->getState() == 1)
-                        {
-                            for(int j = 0; j < 26; j++)
-                            {
+                case kKeyCase: {
+                    if(_layout == kLayoutNumber || _layout == kLayoutSymbol) {
+                        if(_sw[kSWCase]->getState() == 1) {
+                            for(int j = 0; j < 26; j++) {
                                 _btn[j]->setLabel(kKeyAlphaMapNumber[j]);
                                 _layout = kLayoutNumber;
                             }
-                        }
-                        else
-                        {
-                            for(int j = 0; j < 26; j++)
-                            {
+                         } else {
+                            for(int j = 0; j < 26; j++) {
                                 _btn[j]->setLabel(kKeyAlphaMapSymbol[j]);
                                 _layout = kLayoutSymbol;
                             }
@@ -296,21 +248,14 @@ void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y)
                         _sw[kSWCase]->UpdateState(-1, -1);
                         Draw(UPDATE_MODE_NONE);
                         M5.EPD.UpdateFull(UPDATE_MODE_GL16);
-                    }
-                    else
-                    {
-                        if(_sw[kSWCase]->getState() == 1)
-                        {
-                            for(int j = 0; j < 26; j++)
-                            {
+                     } else {
+                        if(_sw[kSWCase]->getState() == 1) {
+                            for(int j = 0; j < 26; j++) {
                                 _btn[j]->setLabel(kKeyAlphaMapLowerCase[j]);
                                 _layout = kLayoutLowerAlpha;
                             }
-                        }
-                        else
-                        {
-                            for(int j = 0; j < 26; j++)
-                            {
+                         } else {
+                            for(int j = 0; j < 26; j++) {
                                 _btn[j]->setLabel(kKeyAlphaMapUpperCase[j]);
                                 _layout = kLayoutUpperAlpha;
                             }
@@ -321,10 +266,8 @@ void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y)
                     }
                     break;
                 }
-                case kKeyNumber:
-                {
-                    if(_sw[kSWNumber]->getState() == 1)
-                    {
+                case kKeyNumber: {
+                    if(_sw[kSWNumber]->getState() == 1) {
                         _sw[kSWCase]->setState(0);
                         _sw[kSWCase]->Canvas(0)->fillCanvas(0);
                         _sw[kSWCase]->Canvas(1)->fillCanvas(0);
@@ -334,20 +277,16 @@ void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y)
                         _sw[kSWCase]->Canvas(1)->pushImage(_sw[kSWCase]->getW() / 2 - 16, _sw[kSWCase]->getH() / 2 - 16, 32, 32, ImageResource_upper_32x32);
                         _sw[kSWCase]->Canvas(1)->ReverseColor();
 
-                        for(int j = 0; j < 26; j++)
-                        {
+                        for(int j = 0; j < 26; j++) {
                             _btn[j]->setLabel(kKeyAlphaMapLowerCase[j]);
                             _layout = kLayoutLowerAlpha;
                         }
-                    }
-                    else
-                    {
+                     } else {
                         _sw[kSWCase]->setState(0);
                         _sw[kSWCase]->SetLabel(0, "#+-");
                         _sw[kSWCase]->SetLabel(1, "123");
 
-                        for(int j = 0; j < 26; j++)
-                        {
+                        for(int j = 0; j < 26; j++) {
                             _btn[j]->setLabel(kKeyAlphaMapNumber[j]);
                             _layout = kLayoutNumber;
                         }
@@ -362,8 +301,7 @@ void EPDGUI_Keyboard::UpdateState(int16_t x, int16_t y)
     }
 }
 
-String EPDGUI_Keyboard::getData(void)
-{
+String EPDGUI_Keyboard::getData(void) {
     String data = _data;
     _data = "";
     return data;   

src/epdgui/epdgui_keyboard.h

@@ -4,8 +4,7 @@
 #include "epdgui_button.h"
 #include "epdgui_switch.h"
 
-class EPDGUI_Keyboard: public EPDGUI_Base
-{
+class EPDGUI_Keyboard: public EPDGUI_Base {
 public:
     static const uint32_t STYLE_INPUTMODE_NORMALTEXT = 0x00000001;
     static const uint32_t STYLE_INPUTMODE_NEEDCONFIRM = 0x00000002;

src/epdgui/epdgui_mutexswitch.cpp

@@ -1,57 +1,44 @@
 #include "epdgui_mutexswitch.h"
 
-EPDGUI_MutexSwitch::EPDGUI_MutexSwitch()
-{
+EPDGUI_MutexSwitch::EPDGUI_MutexSwitch() {
 
 }
 
-void EPDGUI_MutexSwitch::Draw(m5epd_update_mode_t mode)
-{
-    if(_ishide)
-    {
+void EPDGUI_MutexSwitch::Draw(m5epd_update_mode_t mode) {
+    if(_ishide) {
         return;
     }
-    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++)
-    {
+    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++) {
         (*p)->Draw(mode);
     }
 }
 
-void EPDGUI_MutexSwitch::Draw(M5EPD_Canvas* canvas)
-{
-    if(_ishide)
-    {
+void EPDGUI_MutexSwitch::Draw(M5EPD_Canvas* canvas) {
+    if(_ishide) {
         return;
     }
-    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++)
-    {
+    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++) {
         (*p)->Draw(canvas);
     }
 }
 
-void EPDGUI_MutexSwitch::Bind(int16_t event, void (* func_cb)(epdgui_args_vector_t&))
-{
+void EPDGUI_MutexSwitch::Bind(int16_t event, void (* func_cb)(epdgui_args_vector_t&)) {
 
 }
 
-void EPDGUI_MutexSwitch::UpdateState(int16_t x, int16_t y)
-{
-    if(!_isenable)
-    {
+void EPDGUI_MutexSwitch::UpdateState(int16_t x, int16_t y) {
+    if(!_isenable) {
         return;
     }
 
     std::list<EPDGUI_Switch*>::iterator pressed_sw = _object_list.end();
-    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++)
-    {
-        if(_last_pressed == p)
-        {
+    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++) {
+        if(_last_pressed == p) {
             (*p)->UpdateState(-1, -1);
             continue;
         }
 
-        if((*p)->isInBox(x, y))
-        {
+        if((*p)->isInBox(x, y)) {
             _last_pressed = p;
             pressed_sw = p;
         }
@@ -59,49 +46,38 @@ void EPDGUI_MutexSwitch::UpdateState(int16_t x, int16_t y)
         (*p)->UpdateState(x, y);
     }
 
-    if(!_is_exclusive)
-    {
+    if(!_is_exclusive) {
         return;
     }
 
-    if(pressed_sw == _object_list.end())
-    {
+    if(pressed_sw == _object_list.end()) {
         return;
     }
 
-    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++)
-    {
-        if(pressed_sw == p)
-        {
+    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++) {
+        if(pressed_sw == p) {
             continue;
         }
 
-        if((*p)->getState() != 0)
-        {   
+        if((*p)->getState() != 0) {   
             (*p)->setState(0);
             (*p)->Draw(UPDATE_MODE_GL16);
         }
     }
 }
 
-void EPDGUI_MutexSwitch::SetDefault(uint16_t idx)
-{
-    if(idx < _object_list.size())
-    {
+void EPDGUI_MutexSwitch::SetDefault(uint16_t idx) {
+    if(idx < _object_list.size()) {
         _default_idx = idx;
     }
     
     int i = 0;
-    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++)
-    {
-        if(i == _default_idx)
-        {
+    for(std::list<EPDGUI_Switch*>::iterator p = _object_list.begin(); p != _object_list.end(); p++) {
+        if(i == _default_idx) {
             _last_pressed = p;
             (*p)->setState(1);
             // (*p)->Draw(UPDATE_MODE_GL16);
-        }
-        else
-        {
+         } else {
             (*p)->setState(0);
             // (*p)->Draw(UPDATE_MODE_GL16);
         }

src/epdgui/epdgui_mutexswitch.h

@@ -4,8 +4,7 @@
 #include "epdgui_switch.h"
 #include <list>
 
-class EPDGUI_MutexSwitch : public EPDGUI_Base
-{
+class EPDGUI_MutexSwitch : public EPDGUI_Base {
 public:
     EPDGUI_MutexSwitch();
     

src/epdgui/epdgui_switch.cpp

@@ -1,16 +1,13 @@
 #include "epdgui_switch.h"
 
 EPDGUI_Switch::EPDGUI_Switch(int16_t state_num, int16_t x, int16_t y, int16_t w, int16_t h): 
-EPDGUI_Base(x, y, w, h)
-{
-    if(state_num > EPDGUI_SWITCH_MAX_STATE)
-    {
+EPDGUI_Base(x, y, w, h) {
+    if(state_num > EPDGUI_SWITCH_MAX_STATE) {
         state_num = EPDGUI_SWITCH_MAX_STATE;
     }
     this->_state_num = state_num;
 
-    for(int i = 0; i < _state_num; i++)
-    {
+    for(int i = 0; i < _state_num; i++) {
         this->_canvas[i] = new M5EPD_Canvas(&M5.EPD);
         this->_canvas[i]->createCanvas(_w, _h);
         // this->_canvas[i]->fillCanvas(i & 0x01 ? 0 : 15);
@@ -23,27 +20,21 @@ EPDGUI_Base(x, y, w, h)
     _canvas_pressed->fillCanvas(15);
 }
 
-EPDGUI_Switch::~EPDGUI_Switch()
-{
-    for(int i = 0; i < _state_num; i++)
-    {
+EPDGUI_Switch::~EPDGUI_Switch() {
+    for(int i = 0; i < _state_num; i++) {
         delete this->_canvas[i];
     }
 }
 
-M5EPD_Canvas* EPDGUI_Switch::Canvas(int16_t state)
-{
-    if(state == -1)
-    {
+M5EPD_Canvas* EPDGUI_Switch::Canvas(int16_t state) {
+    if(state == -1) {
         return _canvas_pressed;
     }
     return _canvas[state];
 }
 
-void EPDGUI_Switch::SetLabel(int16_t state, String label)
-{
-    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0)
-    {
+void EPDGUI_Switch::SetLabel(int16_t state, String label) {
+    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0) {
         return;
     }
 
@@ -57,15 +48,12 @@ void EPDGUI_Switch::SetLabel(int16_t state, String label)
     this->_label_array[state] = label;
 }
 
-void EPDGUI_Switch::Draw(m5epd_update_mode_t mode)
-{
-    if(_ishide)
-    {
+void EPDGUI_Switch::Draw(m5epd_update_mode_t mode) {
+    if(_ishide) {
         return;
     }
 
-    if(_event == EVENT_PRESSED)
-    {
+    if(_event == EVENT_PRESSED) {
         _canvas_pressed->pushCanvas(_x, _y, mode);
         return;
     }
@@ -73,15 +61,12 @@ void EPDGUI_Switch::Draw(m5epd_update_mode_t mode)
     this->_canvas[_state]->pushCanvas(_x, _y, mode);
 }
 
-void EPDGUI_Switch::Draw(M5EPD_Canvas* canvas)
-{
-    if(_ishide)
-    {
+void EPDGUI_Switch::Draw(M5EPD_Canvas* canvas) {
+    if(_ishide) {
         return;
     }
 
-    if(_event == EVENT_PRESSED)
-    {
+    if(_event == EVENT_PRESSED) {
         _canvas_pressed->pushToCanvas(_x, _y, canvas);
         return;
     }
@@ -89,81 +74,62 @@ void EPDGUI_Switch::Draw(M5EPD_Canvas* canvas)
     this->_canvas[_state]->pushToCanvas(_x, _y, canvas);
 }
 
-void EPDGUI_Switch::Bind(int16_t state, void (* func_cb)(epdgui_args_vector_t&))
-{
-    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0)
-    {
+void EPDGUI_Switch::Bind(int16_t state, void (* func_cb)(epdgui_args_vector_t&)) {
+    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0) {
         return;
     }
     
     this->_func_cb_array[state] = func_cb;
 }
 
-void EPDGUI_Switch::UpdateState(int16_t x, int16_t y)
-{
-    if(!_isenable || _ishide)
-    {
+void EPDGUI_Switch::UpdateState(int16_t x, int16_t y) {
+    if(!_isenable || _ishide) {
         return;
     }
 
     bool is_in_area = isInBox(x, y);
 
-    if(is_in_area)
-    {
-        if(_event == EVENT_NONE)
-        {
+    if(is_in_area) {
+        if(_event == EVENT_NONE) {
             _event = EVENT_PRESSED;
             Draw();
         }
-    }
-    else
-    {
-        if(_event == EVENT_PRESSED)
-        {
+     } else {
+        if(_event == EVENT_PRESSED) {
             _event = EVENT_NONE;
             _state++;
-            if(_state == _state_num)
-            {
+            if(_state == _state_num) {
                 _state = 0;
             }
 
             Draw();
-            if(this->_func_cb_array[_state] != NULL)
-            {
+            if(this->_func_cb_array[_state] != NULL) {
                 this->_func_cb_array[_state](this->_func_cb_param_array[_state]);
             }
         }
     }
 }
 
-void EPDGUI_Switch::setState(int16_t state)
-{
-    if(state >= _state_num || state < 0)
-    {
+void EPDGUI_Switch::setState(int16_t state) {
+    if(state >= _state_num || state < 0) {
         return;
     }
     _state = state;
     Draw(UPDATE_MODE_NONE);
 }
 
-int16_t EPDGUI_Switch::getState(void)
-{
+int16_t EPDGUI_Switch::getState(void) {
     return _state;
 }
 
-void EPDGUI_Switch::AddArgs(int16_t state, uint16_t n, void* arg)
-{
-    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0)
-    {
+void EPDGUI_Switch::AddArgs(int16_t state, uint16_t n, void* arg) {
+    if(state > EPDGUI_SWITCH_MAX_STATE || state < 0) {
         return;
     }
     
-    if(this->_func_cb_param_array[state].size() > n)
-    {
+    if(this->_func_cb_param_array[state].size() > n) {
         this->_func_cb_param_array[state][n] = arg;
-    }
-    else
-    {
+     } else {
         this->_func_cb_param_array[state].push_back(arg);
     }
 }

src/epdgui/epdgui_switch.h

@@ -5,8 +5,7 @@
 
 #define EPDGUI_SWITCH_MAX_STATE 5
 
-class EPDGUI_Switch: public EPDGUI_Base
-{
+class EPDGUI_Switch: public EPDGUI_Base {
 public:
     static const int16_t EVENT_NONE = 0;
     static const int16_t EVENT_PRESSED = 1;

src/epdgui/epdgui_textbox.cpp

@@ -2,8 +2,7 @@
 
 uint32_t EPDGUI_Textbox::_textbox_touching_id = 0;
 
-EPDGUI_Textbox::EPDGUI_Textbox(int16_t x, int16_t y, int16_t w, int16_t h) : EPDGUI_Base(x, y, w, h)
-{
+EPDGUI_Textbox::EPDGUI_Textbox(int16_t x, int16_t y, int16_t w, int16_t h) : EPDGUI_Base(x, y, w, h) {
     _canvas = new M5EPD_Canvas(&M5.EPD);
 
     _size = 26;
@@ -13,8 +12,7 @@ EPDGUI_Textbox::EPDGUI_Textbox(int16_t x, int16_t y, int16_t w, int16_t h) : EPD
 
     _canvas->fillCanvas(15);
     _canvas->drawRect(0, 0, _w, _h, 15);
-    if (!_canvas->isRenderExist(_size))
-    {
+    if (!_canvas->isRenderExist(_size)) {
         _canvas->createRender(_size, 60);
         _thiscreat = true;
     }
@@ -23,8 +21,7 @@ EPDGUI_Textbox::EPDGUI_Textbox(int16_t x, int16_t y, int16_t w, int16_t h) : EPD
     _canvas->setTextDatum(TL_DATUM);
     _canvas->setTextColor(15);
 
-    for (int i = 0; i < 26; i++)
-    {
+    for (int i = 0; i < 26; i++) {
         _canvas->preRender('a' + i);
         _canvas->preRender('A' + i);
     }
@@ -37,63 +34,50 @@ EPDGUI_Textbox::EPDGUI_Textbox(int16_t x, int16_t y, int16_t w, int16_t h) : EPD
     _state = EVENT_NONE;
 }
 
-EPDGUI_Textbox::~EPDGUI_Textbox()
-{
+EPDGUI_Textbox::~EPDGUI_Textbox() {
     delete _canvas;
 }
 
-void EPDGUI_Textbox::SetTextMargin(int16_t left, int16_t top, int16_t right, int16_t bottom)
-{
+void EPDGUI_Textbox::SetTextMargin(int16_t left, int16_t top, int16_t right, int16_t bottom) {
     _margin_left = left;
     _margin_top = top;
     _margin_right = right + left;
     _margin_bottom = bottom + top;
 }
 
-void EPDGUI_Textbox::SetTextSize(uint16_t size)
-{
-    if (_thiscreat)
-    {
+void EPDGUI_Textbox::SetTextSize(uint16_t size) {
+    if (_thiscreat) {
         _canvas->destoryRender(_size);
     }
     _size = size;
-    if (!_canvas->isRenderExist(_size))
-    {
+    if (!_canvas->isRenderExist(_size)) {
         _canvas->createRender(_size, 60);
         _thiscreat = true;
-    }
-    else
-    {
+     } else {
         _thiscreat = false;
     }
     
     _canvas->setTextSize(_size);
-    for (int i = 0; i < 26; i++)
-    {
+    for (int i = 0; i < 26; i++) {
         _canvas->preRender('a' + i);
         _canvas->preRender('A' + i);
     }
     Draw(UPDATE_MODE_GC16);
 }
 
-void EPDGUI_Textbox::Draw(m5epd_update_mode_t mode)
-{
-    if (_ishide)
-    {
+void EPDGUI_Textbox::Draw(m5epd_update_mode_t mode) {
+    if (_ishide) {
         return;
     }
 
-    if (_state == EVENT_NONE)
-    {
+    if (_state == EVENT_NONE) {
         _canvas->setTextSize(_size);
         _canvas->fillCanvas(0);
         _canvas->drawRect(0, 0, _w, _h, 15);
         _canvas->setTextArea(_margin_left, _margin_top, _w - _margin_right, _h - _margin_bottom);
         _canvas->print(_data);
         _canvas->pushCanvas(_x, _y, mode);
-    }
-    else
-    {
+     } else {
         _canvas->setTextSize(_size);
         _canvas->fillCanvas(0);
         _canvas->drawRect(0, 0, _w, _h, 15);
@@ -105,24 +89,19 @@ void EPDGUI_Textbox::Draw(m5epd_update_mode_t mode)
     }
 }
 
-void EPDGUI_Textbox::Draw(M5EPD_Canvas* canvas)
-{
-    if (_ishide)
-    {
+void EPDGUI_Textbox::Draw(M5EPD_Canvas* canvas) {
+    if (_ishide) {
         return;
     }
 
-    if (_state == EVENT_NONE)
-    {
+    if (_state == EVENT_NONE) {
         _canvas->setTextSize(_size);
         _canvas->fillCanvas(0);
         _canvas->drawRect(0, 0, _w, _h, 15);
         _canvas->setTextArea(_margin_left, _margin_top, _w - _margin_right, _h - _margin_bottom);
         _canvas->print(_data);
         _canvas->pushToCanvas(_x, _y, canvas);
-    }
-    else
-    {
+     } else {
         _canvas->setTextSize(_size);
         _canvas->fillCanvas(0);
         _canvas->drawRect(0, 0, _w, _h, 15);
@@ -134,25 +113,20 @@ void EPDGUI_Textbox::Draw(M5EPD_Canvas* canvas)
     }
 }
 
-void EPDGUI_Textbox::Bind(int16_t event, void (*func_cb)(epdgui_args_vector_t &))
-{
+void EPDGUI_Textbox::Bind(int16_t event, void (*func_cb)(epdgui_args_vector_t &)) {
 }
 
-void EPDGUI_Textbox::UpdateState(int16_t x, int16_t y)
-{
-    if (!_isenable)
-    {
+void EPDGUI_Textbox::UpdateState(int16_t x, int16_t y) {
+    if (!_isenable) {
         return;
     }
 
     int16_t state = _state;
-    if ((_state == EVENT_PRESSED) && (_textbox_touching_id != _id))
-    {
+    if ((_state == EVENT_PRESSED) && (_textbox_touching_id != _id)) {
         state = EVENT_NONE;
     }
 
-    if (isInBox(x, y))
-    {
+    if (isInBox(x, y)) {
         _textbox_touching_id = _id;
         state = EVENT_PRESSED;
     }
@@ -160,54 +134,43 @@ void EPDGUI_Textbox::UpdateState(int16_t x, int16_t y)
     SetState(state);
 }
 
-void EPDGUI_Textbox::SetState(int16_t state)
-{
-    if (state != _state)
-    {
-        if(state == EVENT_PRESSED)
-        {
+void EPDGUI_Textbox::SetState(int16_t state) {
+    if (state != _state) {
+        if(state == EVENT_PRESSED) {
             _textbox_touching_id = _id;
         }
         _state = state;
     }
 }
 
-void EPDGUI_Textbox::SetText(String text)
-{
-    if (text != _data)
-    {
+void EPDGUI_Textbox::SetText(String text) {
+    if (text != _data) {
         _data = text;
         Draw(UPDATE_MODE_A2);
     }
 }
 
-void EPDGUI_Textbox::Remove(int16_t idx)
-{
+void EPDGUI_Textbox::Remove(int16_t idx) {
     uint16_t n = 0, last_n = 0;
     uint8_t* buf = (uint8_t *)_data.c_str();
     uint16_t len = strlen((char*)buf);
     uint16_t cnt = 0;
-    while (n < len)
-    {
+    while (n < len) {
         last_n = n;
         _canvas->decodeUTF8(buf, &n, len - n);
-        if(cnt == idx)
-        {
+        if(cnt == idx) {
             _data.remove(last_n, n - last_n);
             return;
         }
         cnt++;
     }
-    if(idx == -1)
-    {
+    if(idx == -1) {
         _data.remove(last_n, n - last_n);
     }
 }
 
-void EPDGUI_Textbox::AddText(String text)
-{
-    if(text.length() == 0)
-    {
+void EPDGUI_Textbox::AddText(String text) {
+    if(text.length() == 0) {
         return;
     }
     
@@ -215,16 +178,12 @@ void EPDGUI_Textbox::AddText(String text)
     uint16_t len = strlen((char*)buf);
     uint16_t n = 0, last_n = 0;
 
-    while (n < len)
-    {
+    while (n < len) {
         last_n = n;
         uint16_t uniCode = _canvas->decodeUTF8(buf, &n, len - n);
-        if(uniCode == 0x0008)
-        {
+        if(uniCode == 0x0008) {
             Remove(-1);
-        }
-        else
-        {
+         } else {
             _data += text.substring(last_n, n);
         }
     }

src/epdgui/epdgui_textbox.h

@@ -3,8 +3,7 @@
 
 #include "epdgui_base.h"
 
-class EPDGUI_Textbox : public EPDGUI_Base
-{
+class EPDGUI_Textbox : public EPDGUI_Base {
 public:
     static const int16_t EVENT_NONE = 0;
     static const int16_t EVENT_PRESSED = 1;

src/frame/frame_base.cpp

@@ -1,10 +1,8 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-Frame_Base::Frame_Base(bool _has_title)
-{
-    if(_has_title)
-    {
+Frame_Base::Frame_Base(bool _has_title) {
+    if(_has_title) {
         _canvas_title = new M5EPD_Canvas(&M5.EPD);
         _canvas_title->createCanvas(540, 64);
         _canvas_title->drawFastHLine(0, 64, 540, 15);
@@ -17,16 +15,14 @@ Frame_Base::Frame_Base(bool _has_title)
     _frame_name = "Frame_Base";
 }
 
-Frame_Base::~Frame_Base() 
-{
+Frame_Base::~Frame_Base()  {
     if(_key_exit != NULL)
         delete _key_exit;
     if(_canvas_title != NULL)
         delete _canvas_title;
 }
 
-void Frame_Base::exitbtn(String title, uint16_t width)
-{
+void Frame_Base::exitbtn(String title, uint16_t width) {
     _key_exit = new EPDGUI_Button(8, 12, width, 48);
     _key_exit->CanvasNormal()->fillCanvas(0);
     _key_exit->CanvasNormal()->setTextSize(26);
@@ -38,17 +34,14 @@ void Frame_Base::exitbtn(String title, uint16_t width)
     _key_exit->CanvasPressed()->ReverseColor();
 }
 
-int Frame_Base::run(void)
-{
+int Frame_Base::run(void) {
     return _is_run;
 }
 
-void Frame_Base::exit(void)
-{
+void Frame_Base::exit(void) {
 }
 
-void Frame_Base::exit_cb(epdgui_args_vector_t &args)
-{
+void Frame_Base::exit_cb(epdgui_args_vector_t &args) {
     EPDGUI_PopFrame();
     *((int*)(args[0])) = 0;
 }

src/frame/frame_base.h

@@ -6,8 +6,7 @@
 #include "../global_setting.h"
 #include "../resources/ImageResource.h"
 
-class Frame_Base
-{
+class Frame_Base {
 public:
     Frame_Base(bool _has_title = true);
     void exitbtn(String title, uint16_t width = 150);

src/frame/frame_compare.cpp

@@ -1,51 +1,40 @@
 #include "frame_compare.h"
 
-void UpdateCompareCanvasDraw(uint8_t mode, M5EPD_Canvas *update_canvas)
-{
+void UpdateCompareCanvasDraw(uint8_t mode, M5EPD_Canvas *update_canvas) {
     update_canvas->fillCanvas(0);
-    for(int i = 0; i < 16; i++)
-    {
+    for(int i = 0; i < 16; i++) {
         update_canvas->fillRect(i * 27, 0, 27, 50, i);
     }
-    switch(mode)
-    {
-        case UPDATE_MODE_INIT :
-        {
+    switch(mode) {
+        case UPDATE_MODE_INIT : {
             update_canvas->drawString("Display initialization", 8, 60);
             break;
         }
-        case UPDATE_MODE_DU   :
-        {
+        case UPDATE_MODE_DU   : {
             update_canvas->drawString("Monochrome menu, text input ", 8, 60);
             break;
         }
-        case UPDATE_MODE_GC16 :
-        {
+        case UPDATE_MODE_GC16 : {
             update_canvas->drawString("High quality images", 8, 60);
             break;
         }
-        case UPDATE_MODE_GL16 :
-        {
+        case UPDATE_MODE_GL16 : {
             update_canvas->drawString("Text with white background", 8, 60);
             break;
         }
-        case UPDATE_MODE_GLR16:
-        {
+        case UPDATE_MODE_GLR16: {
             update_canvas->drawString("Text with white background", 8, 60);
             break;
         }
-        case UPDATE_MODE_GLD16:
-        {
+        case UPDATE_MODE_GLD16: {
             update_canvas->drawString("Graphics with white background", 8, 60);
             break;
         }
-        case UPDATE_MODE_DU4  :
-        {
+        case UPDATE_MODE_DU4  : {
             update_canvas->drawString("Fast page flipping", 8, 60);
             break;
         }
-        case UPDATE_MODE_A2   :
-        {
+        case UPDATE_MODE_A2   : {
             update_canvas->drawString("Anti-aliased text in menus", 8, 60);
             break;
         }
@@ -53,8 +42,7 @@ void UpdateCompareCanvasDraw(uint8_t mode, M5EPD_Canvas *update_canvas)
     update_canvas->drawRect(0, 0, 432, 100, 15);
 }
 
-void key_update_mode_cb(epdgui_args_vector_t &args)
-{
+void key_update_mode_cb(epdgui_args_vector_t &args) {
     EPDGUI_Button *btn = (EPDGUI_Button*)(args[0]);
     M5EPD_Canvas *canvas = (M5EPD_Canvas*)(args[1]);
     M5EPD_Canvas *canvas_time = (M5EPD_Canvas*)(args[2]);
@@ -70,14 +58,12 @@ void key_update_mode_cb(epdgui_args_vector_t &args)
     canvas_time->pushCanvas(330, 925, UPDATE_MODE_GL16);
 }
 
-void key_update_reset_cb(epdgui_args_vector_t &args)
-{
+void key_update_reset_cb(epdgui_args_vector_t &args) {
     M5.EPD.FillPartGram4bpp(104, 168, 432, 748, 0xFFFF);
     M5.EPD.UpdateArea(104, 168, 432, 748, UPDATE_MODE_INIT);
 }
 
-Frame_Compare::Frame_Compare(void)
-{
+Frame_Compare::Frame_Compare(void) {
     _frame_name = "Frame_Compare";
     
     _canvas_time = new M5EPD_Canvas(&M5.EPD);
@@ -89,20 +75,15 @@ Frame_Compare::Frame_Compare(void)
     _canvas_time->setTextDatum(CR_DATUM);
 
     uint8_t language = GetLanguage();
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("比較", 270, 34);
         _key_updatemode[UPDATE_MODE_INIT] = new EPDGUI_Button("リセット", 4, 88, 532, 60);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("比较", 270, 34);
         _key_updatemode[UPDATE_MODE_INIT] = new EPDGUI_Button("全部重置", 4, 88, 532, 60);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("Compare", 270, 34);
         _key_updatemode[UPDATE_MODE_INIT] = new EPDGUI_Button("Reset all", 4, 88, 532, 60);
@@ -110,8 +91,7 @@ Frame_Compare::Frame_Compare(void)
 
     _key_updatemode[UPDATE_MODE_INIT]->Bind(EPDGUI_Button::EVENT_RELEASED, key_update_reset_cb);
 
-    for(int i = 1; i < 8; i++)
-    {
+    for(int i = 1; i < 8; i++) {
         _key_updatemode[i] = new EPDGUI_Button(0, 168 + (i-1) * 108, 100, 100);
         char buf[10];
         sprintf(buf, "%d", i);
@@ -134,24 +114,18 @@ Frame_Compare::Frame_Compare(void)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Compare::~Frame_Compare(void)
-{
-    for(int i = 0; i < 8; i++)
-    {
+Frame_Compare::~Frame_Compare(void) {
+    for(int i = 0; i < 8; i++) {
         delete _key_updatemode[i];
     }
     delete _canvas;
 }
 
-int Frame_Compare::run()
-{
-    switch(_update_flag)
-    {
-        case 1:
-        {
+int Frame_Compare::run() {
+    switch(_update_flag) {
+        case 1: {
             _update_flag = 0;
-            for(int i = 1; i < 8; i++)
-            {
+            for(int i = 1; i < 8; i++) {
                 UpdateCompareCanvasDraw(i, _canvas);
                 _canvas->pushCanvas(104, 168 + (i-1) * 108, (m5epd_update_mode_t)i);
             }
@@ -161,15 +135,13 @@ int Frame_Compare::run()
     return 1;
 }
 
-int Frame_Compare::init(epdgui_args_vector_t &args)
-{
+int Frame_Compare::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     _update_flag = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
     EPDGUI_AddObject(_key_exit);
-    for(int i = 0; i < 8; i++)
-    {
+    for(int i = 0; i < 8; i++) {
         EPDGUI_AddObject(_key_updatemode[i]);
     }
     EPDGUI_SetAutoUpdate(false);

src/frame/frame_compare.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Compare : public Frame_Base
-{
+class Frame_Compare : public Frame_Base {
 public:
     Frame_Compare();
     ~Frame_Compare();

src/frame/frame_factorytest.cpp

@@ -6,14 +6,12 @@
 
 const uint8_t kPins[6] = {32, 25, 33, 26, 19, 18};
 
-void frame_factorytest_exit_cb(epdgui_args_vector_t &args)
-{
+void frame_factorytest_exit_cb(epdgui_args_vector_t &args) {
     EPDGUI_PopFrame();
     *((int *)(args[0])) = 0;
 }
 
-Frame_FactoryTest::Frame_FactoryTest(void)
-{
+Frame_FactoryTest::Frame_FactoryTest(void) {
     //TODO: Voltage WiFi Psram touch pos
     _frame_name = "Frame_FactoryTest";
 
@@ -42,18 +40,13 @@ Frame_FactoryTest::Frame_FactoryTest(void)
     _canvas_pass->setTextDatum(CR_DATUM);
 
     _language = GetLanguage();
-    if (_language == LANGUAGE_JA)
-    {
+    if (_language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("工場テスト", 270, 34);
-    }
-    else if (_language == LANGUAGE_ZH)
-    {
+     } else if (_language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("出厂测试", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("Factory Test", 270, 34);
     }
@@ -61,8 +54,7 @@ Frame_FactoryTest::Frame_FactoryTest(void)
     _key_exit->AddArgs(EPDGUI_Button::EVENT_RELEASED, 0, (void *)(&_is_run));
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 
-    for (int i = 0; i < 6; i++)
-    {
+    for (int i = 0; i < 6; i++) {
         pinMode(kPins[i], OUTPUT);
         digitalWrite(kPins[i], HIGH);
     }
@@ -74,8 +66,7 @@ Frame_FactoryTest::Frame_FactoryTest(void)
     M5.RTC.getTime(&time_struct);
     M5.RTC.getDate(&date_struct);
 
-    if ((isTimeSynced() == 0) || (date_struct.year < 2010))
-    {
+    if ((isTimeSynced() == 0) || (date_struct.year < 2010)) {
         rtc_time_t time_struct;
         time_struct.hour = 23;
         time_struct.min = 33;
@@ -97,8 +88,7 @@ Frame_FactoryTest::Frame_FactoryTest(void)
     _pass_flag |= GetInitStatus(0) ? 0x0080 : 0;
 }
 
-Frame_FactoryTest::~Frame_FactoryTest(void)
-{
+Frame_FactoryTest::~Frame_FactoryTest(void) {
     delete _canvas_base;
     delete _canvas_data;
     delete _canvas_pos;
@@ -106,27 +96,21 @@ Frame_FactoryTest::~Frame_FactoryTest(void)
     delete _canvas_pass;
 }
 
-void Frame_FactoryTest::drawItem(uint16_t flag, const char* str, int y)
-{
+void Frame_FactoryTest::drawItem(uint16_t flag, const char* str, int y) {
     String prefix_pass("[PASS] ");
     String prefix_none("");
-    if(_pass_flag & flag)
-    {
+    if(_pass_flag & flag) {
         _canvas_base->drawString(prefix_pass + str, POS_LX, y);
-    }
-    else
-    {
+     } else {
         _canvas_base->drawString(str, POS_LX, y);
         _canvas_base->ReversePartColor(0, y - 30, 300, 60);
     }
 }
 
-void Frame_FactoryTest::drawItem(m5epd_update_mode_t mode)
-{
+void Frame_FactoryTest::drawItem(m5epd_update_mode_t mode) {
     
     _canvas_base->fillCanvas(0);
-    if (_language == LANGUAGE_JA)
-    {
+    if (_language == LANGUAGE_JA) {
         drawItem(0x0001, "1.期日", 30);
         drawItem(0x0002, "2.時間", 90);
         drawItem(0x0004, "3.温度", 150);
@@ -137,9 +121,7 @@ void Frame_FactoryTest::drawItem(m5epd_update_mode_t mode)
         drawItem(0x0080, "8.SDカード", 450);
         drawItem(0x0100, "9.ボタン", 510);
         drawItem(0x0200, "10.タッチパッド", 570);
-    }
-    else if (_language == LANGUAGE_ZH)
-    {
+     } else if (_language == LANGUAGE_ZH) {
         drawItem(0x0001, "1.日期", 30);
         drawItem(0x0002, "2.时间", 90);
         drawItem(0x0004, "3.温度", 150);
@@ -150,9 +132,7 @@ void Frame_FactoryTest::drawItem(m5epd_update_mode_t mode)
         drawItem(0x0080, "8.SD卡", 450);
         drawItem(0x0100, "9.按键", 510);
         drawItem(0x0200, "10.触屏", 570);
-    }
-    else
-    {
+     } else {
         drawItem(0x0001, "1.day", 30);
         drawItem(0x0002, "2.Time", 90);
         drawItem(0x0004, "3.Temperature", 150);
@@ -167,31 +147,25 @@ void Frame_FactoryTest::drawItem(m5epd_update_mode_t mode)
     _canvas_base->pushCanvas(0, 100, mode);
 }
 
-void Frame_FactoryTest::drawGrove(m5epd_update_mode_t mode)
-{
+void Frame_FactoryTest::drawGrove(m5epd_update_mode_t mode) {
     M5.EPD.WritePartGram4bpp(428, 916, 100, 40, (_pass_flag & 0x0400) ? ImageResource_factory_pass_h_100x40 : ImageResource_factory_port_a_100x40);
     M5.EPD.WritePartGram4bpp(4, 848, 40, 100, (_pass_flag & 0x0800) ? ImageResource_factory_pass_v_40x100 : ImageResource_factory_port_b_40x100);
     M5.EPD.WritePartGram4bpp(4, 720, 40, 100, (_pass_flag & 0x1000) ? ImageResource_factory_pass_v_40x100 : ImageResource_factory_port_c_40x100);
     M5.EPD.UpdateArea(0, 720, 540, 240, mode);
 }
 
-bool Frame_FactoryTest::checkGrove(int sda, int scl)
-{
+bool Frame_FactoryTest::checkGrove(int sda, int scl) {
     Wire1.begin(sda, scl, 10000);
     bool groveCheck = true;
 
     Wire1.beginTransmission(0x76);
     Wire1.write(0xD0);
-    if (Wire1.endTransmission() != 0)
-    {
+    if (Wire1.endTransmission() != 0) {
         groveCheck = false;
-    }
-    else
-    {
+     } else {
         Wire1.requestFrom(0x76, 1);
         uint8_t chipID = Wire1.read();
-        if (chipID != 0x58)
-        {
+        if (chipID != 0x58) {
             groveCheck = false;
         }
     }
@@ -199,8 +173,7 @@ bool Frame_FactoryTest::checkGrove(int sda, int scl)
     return groveCheck;
 }
 
-void Frame_FactoryTest::drawPassCount(m5epd_update_mode_t mode)
-{
+void Frame_FactoryTest::drawPassCount(m5epd_update_mode_t mode) {
     uint16_t x = _pass_flag, n = 0;
     for (; x; x >>= 1)
         n += x & 1;
@@ -211,18 +184,15 @@ void Frame_FactoryTest::drawPassCount(m5epd_update_mode_t mode)
     _canvas_pass->pushCanvas(375, 28, mode);
 }
 
-void Frame_FactoryTest::scan(String *ssid, int32_t *rssi)
-{
+void Frame_FactoryTest::scan(String *ssid, int32_t *rssi) {
     WiFi.mode(WIFI_STA);
     WiFi.disconnect();
     WiFi.scanNetworks(true);
 
     int wifi_num;
-    while (1)
-    {
+    while (1) {
         wifi_num = WiFi.scanComplete();
-        if (wifi_num >= 0)
-        {
+        if (wifi_num >= 0) {
             break;
         }
     }
@@ -232,13 +202,11 @@ void Frame_FactoryTest::scan(String *ssid, int32_t *rssi)
     WiFi.scanDelete();
 }
 
-int Frame_FactoryTest::run()
-{
+int Frame_FactoryTest::run() {
     uint16_t pass_flag = _pass_flag;
     char buf[100];
     // POS
-    if ((M5.TP.readFingerX(0) != _last_x) || (M5.TP.readFingerY(0) != _last_y))
-    {
+    if ((M5.TP.readFingerX(0) != _last_x) || (M5.TP.readFingerY(0) != _last_y)) {
         pass_flag |= 0x0200;
         _last_x = M5.TP.readFingerX(0);
         _last_y = M5.TP.readFingerY(0);
@@ -252,59 +220,49 @@ int Frame_FactoryTest::run()
     M5.update();
     int ptr = 0;
     bool ispressed = false;
-    if (_btn == 0x07)
-    {
+    if (_btn == 0x07) {
         _btn |= 0x08;
         pass_flag |= 0x0100;
     }
-    if (M5.BtnL.isPressed())
-    {
+    if (M5.BtnL.isPressed()) {
         _btn |= 0x01;
         buf[ptr++] = 'L';
         ispressed = true;
     }
-    if (M5.BtnP.isPressed())
-    {
+    if (M5.BtnP.isPressed()) {
         _btn |= 0x02;
         buf[ptr++] = 'P';
         ispressed = true;
     }
-    if (M5.BtnR.isPressed())
-    {
+    if (M5.BtnR.isPressed()) {
         _btn |= 0x04;
         buf[ptr++] = 'R';
         ispressed = true;
     }
     buf[ptr] = '\0';
-    if(ptr == 0)
-    {
+    if(ptr == 0) {
         strcpy(buf, "Waiting...");
     }
-    if (ispressed)
-    {
+    if (ispressed) {
         _canvas_btn->fillCanvas(0);
         _canvas_btn->drawString(buf, POS_RX, 30);
         _canvas_btn->pushCanvas(300, 580, UPDATE_MODE_A2);
     }
 
-    if (millis() - _time > 1000)
-    {
+    if (millis() - _time > 1000) {
         _time = millis();
         rtc_time_t time_struct;
         rtc_date_t date_struct;
         M5.RTC.getTime(&time_struct);
         M5.RTC.getDate(&date_struct);
 
-        if ((date_struct.year > 2010) && (time_struct.hour <= 24) && (time_struct.min <= 60) && (time_struct.sec <= 60))
-        {
+        if ((date_struct.year > 2010) && (time_struct.hour <= 24) && (time_struct.min <= 60) && (time_struct.sec <= 60)) {
             pass_flag |= 0x01;
         }
-        if (_prev_sec == 255)
-        {
+        if (_prev_sec == 255) {
             _prev_sec = time_struct.sec;
         }
-        if (time_struct.sec != _prev_sec)
-        {
+        if (time_struct.sec != _prev_sec) {
             pass_flag |= 0x02;
         }
 
@@ -319,31 +277,24 @@ int Frame_FactoryTest::run()
 
         // SHT30
         M5.SHT30.UpdateData();
-        if(M5.SHT30.GetError() == 0)
-        {
+        if(M5.SHT30.GetError() == 0) {
             float ctemp = M5.SHT30.GetTemperature();
             float chumi = M5.SHT30.GetRelHumidity();
 
-            if (!(pass_flag & 0x04))
-            {
-                if (_prev_temp > 100)
-                {
+            if (!(pass_flag & 0x04)) {
+                if (_prev_temp > 100) {
                     _prev_temp = ctemp;
                 }
-                if ((ctemp < 40) && (ctemp > 0) && (_prev_temp != ctemp))
-                {
+                if ((ctemp < 40) && (ctemp > 0) && (_prev_temp != ctemp)) {
                     pass_flag |= 0x04;
                 }
             }
 
-            if (!(pass_flag & 0x08))
-            {
-                if (_prev_hum > 100)
-                {
+            if (!(pass_flag & 0x08)) {
+                if (_prev_hum > 100) {
                     _prev_hum = chumi;
                 }
-                if ((chumi >= 0) && (chumi <= 100) && (_prev_hum != chumi))
-                {
+                if ((chumi >= 0) && (chumi <= 100) && (_prev_hum != chumi)) {
                     pass_flag |= 0x08;
                 }
             }
@@ -352,21 +303,17 @@ int Frame_FactoryTest::run()
             _canvas_data->drawString(buf, POS_RX, 150);
             sprintf(buf, "%d %%", (int)chumi);
             _canvas_data->drawString(buf, POS_RX, 210);
-        }
-        else
-        {
+         } else {
             _canvas_data->drawString("[FAILED]", POS_RX, 150);
             _canvas_data->drawString("[FAILED]", POS_RX, 210);
         }
 
         // Battery
         uint32_t vol = M5.getBatteryVoltage();
-        if (_prev_vol == 0)
-        {
+        if (_prev_vol == 0) {
             _prev_vol = vol;
         }
-        if (_prev_vol != vol)
-        {
+        if (_prev_vol != vol) {
             pass_flag |= 0x10;
         }
         float vol_f = vol / 1000.0f;
@@ -374,60 +321,46 @@ int Frame_FactoryTest::run()
         _canvas_data->drawString(buf, POS_RX, 270);
 
         // WiFi
-        if (_isfirst)
-        {
+        if (_isfirst) {
             String ssid;
             int32_t rssi;
             scan(&ssid, &rssi);
             sprintf(buf, "%s (%d db)", ssid.c_str(), rssi);
             _wifistr = String(buf);
-            if (rssi > -55)
-            {
+            if (rssi > -55) {
                 pass_flag |= 0x20;
             }
         }
         _canvas_data->drawString(_wifistr, POS_RX, 330);
 
         // PSRAM
-        if (_isfirst)
-        {
+        if (_isfirst) {
             uint8_t *test_p = (uint8_t *)ps_malloc(16);
-            if (test_p != NULL)
-            {
+            if (test_p != NULL) {
                 free(test_p);
                 _psram_success = true;
                 sprintf(buf, "Free %.2f KiB", ESP.getFreePsram() / 1024.0f);
                 _canvas_data->drawString(buf, POS_RX, 390);
                 pass_flag |= 0x40;
-            }
-            else
-            {
+             } else {
                 _psram_success = false;
                 sprintf(buf, "[FAILED]");
                 _canvas_data->drawString(buf, POS_RX, 390);
             }
-        }
-        else
-        {
-            if (_psram_success)
-            {
+         } else {
+            if (_psram_success) {
                 sprintf(buf, "Free %.2f KiB", ESP.getFreePsram() / 1024.0f);
                 _canvas_data->drawString(buf, POS_RX, 390);
-            }
-            else
-            {
+             } else {
                 _canvas_data->drawString("[FAILED]", POS_RX, 390);
             }
         }
 
         // SD
-        if (GetInitStatus(0))
-        {
+        if (GetInitStatus(0)) {
             sprintf(buf, "%.2f MiB", SD.cardSize() / 1024.0f / 1024.0f);
             _canvas_data->drawString(buf, POS_RX, 450);
-        }
-        else
-        {
+         } else {
             _canvas_data->drawString("[FAILED]", POS_RX, 450);
         }
 
@@ -437,51 +370,41 @@ int Frame_FactoryTest::run()
 
     //  grove
     uint16_t temp = pass_flag;
-    if (!(pass_flag & 0x0400))
-    {
+    if (!(pass_flag & 0x0400)) {
         pass_flag |= checkGrove(M5EPD_PORTA_Y_PIN, M5EPD_PORTA_W_PIN) ? 0x0400 : 0x0000;
     }
-    if (!(pass_flag & 0x0800))
-    {
+    if (!(pass_flag & 0x0800)) {
         pass_flag |= checkGrove(M5EPD_PORTB_Y_PIN, M5EPD_PORTB_W_PIN) ? 0x0800 : 0x0000;
     }
-    if (!(pass_flag & 0x1000))
-    {
+    if (!(pass_flag & 0x1000)) {
         pass_flag |= checkGrove(M5EPD_PORTC_Y_PIN, M5EPD_PORTC_W_PIN) ? 0x1000 : 0x0000;
     }
     
     bool update_flag = false;
-    if(temp != pass_flag)
-    {
-        if(pass_flag != _pass_flag)
-        {
+    if(temp != pass_flag) {
+        if(pass_flag != _pass_flag) {
             update_flag = true;
         }
         _pass_flag = pass_flag;
         drawGrove(UPDATE_MODE_GL16);
         update_flag = true;
-    }
-    else if (update_flag || (pass_flag != _pass_flag))
-    {
+     } else if (update_flag || (pass_flag != _pass_flag)) {
         _pass_flag = pass_flag;
         drawItem(UPDATE_MODE_GL16);
         update_flag = true;
     }
-    if(update_flag)
-    {
+    if(update_flag) {
         drawPassCount(UPDATE_MODE_GL16);
     }
 
-    if (_isfirst)
-    {
+    if (_isfirst) {
         _isfirst = false;
     }
 
     return 1;
 }
 
-int Frame_FactoryTest::init(epdgui_args_vector_t &args)
-{
+int Frame_FactoryTest::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_factorytest.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_FactoryTest : public Frame_Base
-{
+class Frame_FactoryTest : public Frame_Base {
 public:
     Frame_FactoryTest();
     ~Frame_FactoryTest();

src/frame/frame_fileindex.cpp

@@ -5,67 +5,53 @@
 
 #define MAX_BTN_NUM     14
 
-void key_fileindex_floder_cb(epdgui_args_vector_t &args)
-{
+void key_fileindex_floder_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = new Frame_FileIndex(((EPDGUI_Button*)(args[0]))->GetCustomString());
     EPDGUI_PushFrame(frame);
     *((int*)(args[1])) = 0;
     log_d("%s", ((EPDGUI_Button*)(args[0]))->GetCustomString().c_str());
 }
 
-void key_fileindex_image_cb(epdgui_args_vector_t &args)
-{
+void key_fileindex_image_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = new Frame_PictureViewer(((EPDGUI_Button*)(args[0]))->GetCustomString());
     EPDGUI_PushFrame(frame);
     *((int*)(args[1])) = 0;
     log_d("%s", ((EPDGUI_Button*)(args[0]))->GetCustomString().c_str());
 }
 
-void key_fileindex_text_cb(epdgui_args_vector_t &args)
-{
+void key_fileindex_text_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = new Frame_txtReader(((EPDGUI_Button*)(args[0]))->GetCustomString());
     EPDGUI_PushFrame(frame);
     *((int*)(args[1])) = 0;
     log_d("%s", ((EPDGUI_Button*)(args[0]))->GetCustomString().c_str());
 }
 
-void key_fileindex_exit_cb(epdgui_args_vector_t &args)
-{
+void key_fileindex_exit_cb(epdgui_args_vector_t &args) {
     EPDGUI_PopFrame(true);
     *((int*)(args[0])) = 0;
 }
 
-Frame_FileIndex::Frame_FileIndex(String path)
-{
+Frame_FileIndex::Frame_FileIndex(String path) {
     _frame_name = "Frame_FileIndex";
     _path = path;
 
     uint8_t language = GetLanguage();
     _canvas_title->setTextDatum(CR_DATUM);
-    if (path == "/")
-    {
-        if (language == LANGUAGE_JA)
-        {
+    if (path == "/") {
+        if (language == LANGUAGE_JA) {
             exitbtn("ホーム");
-        }
-        else if (language == LANGUAGE_ZH)
-        {
+         } else if (language == LANGUAGE_ZH) {
             exitbtn("主页");
-        }
-        else
-        {
+         } else {
             exitbtn("Home");
         }
         _canvas_title->drawString("SD/", 540 - 15, 34);
-    }
-    else
-    {
+     } else {
         String parent_directory = path.substring(0, path.lastIndexOf("/"));
 
         exitbtn("/..");
         String subpath = path;
-        if(path.length() > 20)
-        {
+        if(path.length() > 20) {
             subpath = path.substring(0, 20) + "...";
         }
         _canvas_title->drawString("SD" + subpath, 540 - 15, 34);
@@ -75,16 +61,13 @@ Frame_FileIndex::Frame_FileIndex(String path)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &key_fileindex_exit_cb);
 }
 
-void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
-{
+void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname) {
     File root = fs.open(dirname);
-    if (!root)
-    {
+    if (!root) {
         log_d("Failed to open directory");
         return;
     }
-    if (!root.isDirectory())
-    {
+    if (!root.isDirectory()) {
         log_d("Not a directory");
         return;
     }
@@ -93,23 +76,17 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
     std::vector<File> files;
 
     File file = root.openNextFile();
-    while (file)
-    {
-        if (file.isDirectory())
-        {
+    while (file) {
+        if (file.isDirectory()) {
             floders.push_back(file);
-        }
-        else
-        {
+         } else {
             files.push_back(file);
         }
         file = root.openNextFile();
     }
 
-    for(int n = 0; n < floders.size(); n++)
-    {
-        if(_key_files.size() > MAX_BTN_NUM)
-        {
+    for(int n = 0; n < floders.size(); n++) {
+        if(_key_files.size() > MAX_BTN_NUM) {
             break;
         }
         File file = floders[n];
@@ -118,8 +95,7 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
 
         String filename(file.name());
         filename = filename.substring(filename.lastIndexOf("/"));
-        if(filename.length() > 19)
-        {
+        if(filename.length() > 19) {
             filename = filename.substring(0, 19) + "...";
         }
         btn->CanvasNormal()->fillCanvas(0);
@@ -140,10 +116,8 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
         btn->Bind(EPDGUI_Button::EVENT_RELEASED, key_fileindex_floder_cb);
     }
 
-    for(int n = 0; n < files.size(); n++)
-    {
-        if(_key_files.size() > MAX_BTN_NUM)
-        {
+    for(int n = 0; n < files.size(); n++) {
+        if(_key_files.size() > MAX_BTN_NUM) {
             break;
         }
         File file = files[n];
@@ -152,8 +126,7 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
 
         String filename(file.name());
         filename = filename.substring(filename.lastIndexOf("/"));
-        if(filename.length() > 19)
-        {
+        if(filename.length() > 19) {
             filename = filename.substring(0, 19) + "...";
         }
         btn->CanvasNormal()->fillCanvas(0);
@@ -166,27 +139,22 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
         btn->CanvasNormal()->setTextDatum(CR_DATUM);
 
         String suffix = filename.substring(filename.lastIndexOf("."));
-        if(suffix.indexOf("txt") >= 0)
-        {
+        if(suffix.indexOf("txt") >= 0) {
             btn->CanvasNormal()->pushImage(15, 14, 32, 32, ImageResource_item_icon_file_text_32x32);
             btn->AddArgs(EPDGUI_Button::EVENT_RELEASED, 0, btn);
             btn->AddArgs(EPDGUI_Button::EVENT_RELEASED, 1, (void*)(&_is_run));
             btn->Bind(EPDGUI_Button::EVENT_RELEASED, key_fileindex_text_cb);
-        }
-        else if((suffix.indexOf("bmp") >= 0) 
+         } else if((suffix.indexOf("bmp") >= 0) 
         || (suffix.indexOf("BMP") >= 0) 
         || (suffix.indexOf("png") >= 0)
         || (suffix.indexOf("PNG") >= 0)
         || (suffix.indexOf("jpg") >= 0)
-        || (suffix.indexOf("JPG") >= 0))
-        {
+        || (suffix.indexOf("JPG") >= 0)) {
             btn->CanvasNormal()->pushImage(15, 14, 32, 32, ImageResource_item_icon_file_image_32x32);
             btn->AddArgs(EPDGUI_Button::EVENT_RELEASED, 0, btn);
             btn->AddArgs(EPDGUI_Button::EVENT_RELEASED, 1, (void*)(&_is_run));
             btn->Bind(EPDGUI_Button::EVENT_RELEASED, key_fileindex_image_cb);
-        }
-        else
-        {
+         } else {
             btn->CanvasNormal()->pushImage(15, 14, 32, 32, ImageResource_item_icon_file_unknow_32x32);
             btn->SetEnable(false);
         }
@@ -199,20 +167,16 @@ void Frame_FileIndex::listDir(fs::FS &fs, const char *dirname)
     }
 }
 
-Frame_FileIndex::~Frame_FileIndex(void)
-{
-    for(int i = 0; i < _key_files.size(); i++)
-    {
+Frame_FileIndex::~Frame_FileIndex(void) {
+    for(int i = 0; i < _key_files.size(); i++) {
         delete _key_files[i];
     }
 }
 
-int Frame_FileIndex::init(epdgui_args_vector_t &args)
-{
+int Frame_FileIndex::init(epdgui_args_vector_t &args) {
     _is_run = 1;
 
-    if(_key_files.size() == 0)
-    {
+    if(_key_files.size() == 0) {
         listDir(SD, _path.c_str());
     }
     
@@ -220,8 +184,7 @@ int Frame_FileIndex::init(epdgui_args_vector_t &args)
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
     EPDGUI_AddObject(_key_exit);
 
-    for(int i = 0; i < _key_files.size(); i++)
-    {
+    for(int i = 0; i < _key_files.size(); i++) {
         EPDGUI_AddObject(_key_files[i]);
     }
 

src/frame/frame_fileindex.h

@@ -5,8 +5,7 @@
 #include "../epdgui/epdgui.h"
 #include <SD.h>
 
-class Frame_FileIndex : public Frame_Base
-{
+class Frame_FileIndex : public Frame_Base {
 public:
     Frame_FileIndex(String path);
     ~Frame_FileIndex();

src/frame/frame_home.cpp

@@ -1,7 +1,6 @@
 #include "frame_home.h"
 
-void Frame_Home::InitSwitch(EPDGUI_Switch* sw, String title, String subtitle, const uint8_t *img1, const uint8_t *img2)
-{
+void Frame_Home::InitSwitch(EPDGUI_Switch* sw, String title, String subtitle, const uint8_t *img1, const uint8_t *img2) {
     memcpy(sw->Canvas(0)->frameBuffer(), ImageResource_home_button_background_228x228, 228 * 228 / 2);
     sw->Canvas(0)->setTextSize(36);
     sw->Canvas(0)->setTextDatum(TC_DATUM);
@@ -13,23 +12,18 @@ void Frame_Home::InitSwitch(EPDGUI_Switch* sw, String title, String subtitle, co
     sw->Canvas(1)->pushImage(68, 20, 92, 92, img2);
 }
 
-void key_home_air_adjust_cb(epdgui_args_vector_t &args)
-{
+void key_home_air_adjust_cb(epdgui_args_vector_t &args) {
     int operation = ((EPDGUI_Button*)(args[0]))->GetCustomString().toInt();
     EPDGUI_Switch *sw = ((EPDGUI_Switch*)(args[1]));
-    if(sw->getState() == 0)
-    {
+    if(sw->getState() == 0) {
         return;
     }
     int temp = sw->GetCustomString().toInt();
     char buf[10];
-    if(operation == 1)
-    {
+    if(operation == 1) {
         temp++;
         
-    }
-    else
-    {
+     } else {
         temp--;
     }
     sprintf(buf, "%d", temp);
@@ -42,24 +36,21 @@ void key_home_air_adjust_cb(epdgui_args_vector_t &args)
     sw->Canvas(1)->pushCanvas(sw->getX(), sw->getY(), UPDATE_MODE_A2);
 }
 
-void key_home_air_state0_cb(epdgui_args_vector_t &args)
-{
+void key_home_air_state0_cb(epdgui_args_vector_t &args) {
     EPDGUI_Button *b1 = ((EPDGUI_Button*)(args[0]));
     EPDGUI_Button *b2 = ((EPDGUI_Button*)(args[1]));
     b1->SetEnable(false);
     b2->SetEnable(false);
 }
 
-void key_home_air_state1_cb(epdgui_args_vector_t &args)
-{
+void key_home_air_state1_cb(epdgui_args_vector_t &args) {
     EPDGUI_Button *b1 = ((EPDGUI_Button*)(args[0]));
     EPDGUI_Button *b2 = ((EPDGUI_Button*)(args[1]));
     b1->SetEnable(true);
     b2->SetEnable(true);
 }
 
-Frame_Home::Frame_Home(void)
-{
+Frame_Home::Frame_Home(void) {
     _frame_name = "Frame_Home";
 
     _sw_light1       = new EPDGUI_Switch(2, 20, 44 + 72, 228, 228);
@@ -94,22 +85,17 @@ Frame_Home::Frame_Home(void)
     canvas_temp.createRender(36);
     uint8_t language = GetLanguage();
 
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         InitSwitch(_sw_light1, "ランプ", "客間", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_light2, "ランプ", "寝室", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_socket1, "炊飯器", "厨房", ImageResource_home_icon_socket_off_92x92, ImageResource_home_icon_socket_on_92x92);
         InitSwitch(_sw_socket2, "パソコン", "寝室", ImageResource_home_icon_socket_off_92x92, ImageResource_home_icon_socket_on_92x92);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         InitSwitch(_sw_light1, "吸顶灯", "客厅", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_light2, "台灯", "卧室", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_socket1, "电饭煲", "厨房", ImageResource_home_icon_socket_off_92x92, ImageResource_home_icon_socket_on_92x92);
         InitSwitch(_sw_socket2, "电脑", "卧室", ImageResource_home_icon_socket_off_92x92, ImageResource_home_icon_socket_on_92x92);
-    }
-    else
-    {
+     } else {
         InitSwitch(_sw_light1, "Ceiling Light", "Living Room", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_light2, "Table Lamp", "Bedroom", ImageResource_home_icon_light_off_92x92, ImageResource_home_icon_light_on_92x92);
         InitSwitch(_sw_socket1, "Rice Cooker", "Kitchen", ImageResource_home_icon_socket_off_92x92, ImageResource_home_icon_socket_on_92x92);
@@ -121,16 +107,11 @@ Frame_Home::Frame_Home(void)
     memcpy(_sw_air_1->Canvas(0)->frameBuffer(), ImageResource_home_air_background_228x184, 228 * 184 / 2);
     _sw_air_1->Canvas(0)->setTextDatum(TC_DATUM);
     _sw_air_1->Canvas(0)->setTextSize(26);
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         _sw_air_1->Canvas(0)->drawString("寝室", 114, 152);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         _sw_air_1->Canvas(0)->drawString("卧室", 114, 152);
-    }
-    else
-    {
+     } else {
         _sw_air_1->Canvas(0)->drawString("Bedroom", 114, 152);
     }
     memcpy(_sw_air_1->Canvas(1)->frameBuffer(), _sw_air_1->Canvas(0)->frameBuffer(), 228 * 184 / 2);
@@ -144,16 +125,11 @@ Frame_Home::Frame_Home(void)
     memcpy(_sw_air_2->Canvas(0)->frameBuffer(), ImageResource_home_air_background_228x184, 228 * 184 / 2);
     _sw_air_2->Canvas(0)->setTextDatum(TC_DATUM);
     _sw_air_2->Canvas(0)->setTextSize(26);
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         _sw_air_2->Canvas(0)->drawString("客間", 114, 152);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         _sw_air_2->Canvas(0)->drawString("客厅", 114, 152);
-    }
-    else
-    {
+     } else {
         _sw_air_2->Canvas(0)->drawString("Living Room", 114, 152);
     }
     memcpy(_sw_air_2->Canvas(1)->frameBuffer(), _sw_air_2->Canvas(0)->frameBuffer(), 228 * 184 / 2);
@@ -205,18 +181,13 @@ Frame_Home::Frame_Home(void)
     _sw_air_2->AddArgs(1, 2, _sw_air_2);
     _sw_air_2->Bind(1, key_home_air_state1_cb);
 
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("コントロールパネル", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("控制面板", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("Control Panel", 270, 34);
     }
@@ -225,8 +196,7 @@ Frame_Home::Frame_Home(void)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Home::~Frame_Home(void)
-{
+Frame_Home::~Frame_Home(void) {
     delete _sw_light1;
     delete _sw_light2;
     delete _sw_socket1;
@@ -239,8 +209,7 @@ Frame_Home::~Frame_Home(void)
     delete _key_air_2_minus;
 }
 
-int Frame_Home::init(epdgui_args_vector_t &args)
-{
+int Frame_Home::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_home.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Home : public Frame_Base
-{
+class Frame_Home : public Frame_Base {
 public:
     Frame_Home();
     ~Frame_Home();

src/frame/frame_keyboard.cpp

@@ -2,16 +2,13 @@
 
 uint16_t textsize = 26;
 
-void key_textclear_cb(epdgui_args_vector_t &args)
-{
+void key_textclear_cb(epdgui_args_vector_t &args) {
     ((EPDGUI_Textbox*)(args[0]))->SetText("");
 }
 
-void key_textsize_plus_cb(epdgui_args_vector_t &args)
-{
+void key_textsize_plus_cb(epdgui_args_vector_t &args) {
     textsize += 4;
-    if(textsize > 96)
-    {
+    if(textsize > 96) {
         textsize = 96;
     }
     char buf[10];
@@ -21,11 +18,9 @@ void key_textsize_plus_cb(epdgui_args_vector_t &args)
     ((EPDGUI_Textbox*)(args[0]))->SetTextSize(textsize);
 }
 
-void key_textsize_minus_cb(epdgui_args_vector_t &args)
-{
+void key_textsize_minus_cb(epdgui_args_vector_t &args) {
     textsize -= 4;
-    if(textsize < 12)
-    {
+    if(textsize < 12) {
         textsize = 12;
     }
     char buf[10];
@@ -35,8 +30,7 @@ void key_textsize_minus_cb(epdgui_args_vector_t &args)
     ((EPDGUI_Textbox*)(args[0]))->SetTextSize(textsize);
 }
 
-void key_textsize_reset_cb(epdgui_args_vector_t &args)
-{
+void key_textsize_reset_cb(epdgui_args_vector_t &args) {
     textsize = 26;
     char buf[10];
     sprintf(buf, "%d", textsize);
@@ -45,12 +39,10 @@ void key_textsize_reset_cb(epdgui_args_vector_t &args)
     ((EPDGUI_Textbox*)(args[0]))->SetTextSize(textsize);
 }
 
-Frame_Keyboard::Frame_Keyboard(bool isHorizontal) : Frame_Base()
-{
+Frame_Keyboard::Frame_Keyboard(bool isHorizontal) : Frame_Base() {
     _frame_name = "Frame_Keyboard";
     uint8_t language = GetLanguage();
-    if(isHorizontal)
-    {
+    if(isHorizontal) {
         inputbox = new EPDGUI_Textbox(84, 25, 712, 250);
         if(language == LANGUAGE_JA)
             key_textclear = new EPDGUI_Button("削除", 804, 25, 72, 120);
@@ -62,9 +54,7 @@ Frame_Keyboard::Frame_Keyboard(bool isHorizontal) : Frame_Base()
         key_textsize_plus = new EPDGUI_Button("+", 804, 157, 72, 40);
         key_textsize_reset = new EPDGUI_Button("26", 804, 196, 72, 40);
         key_textsize_minus = new EPDGUI_Button("-", 804, 235, 72, 40);
-    }
-    else
-    {
+     } else {
         const uint16_t kKeyBaseY = 628;
         inputbox = new EPDGUI_Textbox(4, 100, 532, 512);
         if(language == LANGUAGE_JA)
@@ -95,18 +85,13 @@ Frame_Keyboard::Frame_Keyboard(bool isHorizontal) : Frame_Base()
     key_textsize_minus->AddArgs(EPDGUI_Button::EVENT_RELEASED, 1, (void*)key_textsize_reset);
     key_textsize_minus->Bind(EPDGUI_Button::EVENT_RELEASED, key_textsize_minus_cb);
 
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("鍵盤", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("键盘", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("Keyboard", 270, 34);
     }
@@ -115,8 +100,7 @@ Frame_Keyboard::Frame_Keyboard(bool isHorizontal) : Frame_Base()
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Keyboard::~Frame_Keyboard()
-{
+Frame_Keyboard::~Frame_Keyboard() {
     delete inputbox;
     delete keyboard;
     delete key_textclear;
@@ -125,8 +109,7 @@ Frame_Keyboard::~Frame_Keyboard()
     delete key_textsize_minus;
 }
 
-int Frame_Keyboard::init(epdgui_args_vector_t &args)
-{
+int Frame_Keyboard::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
@@ -140,8 +123,7 @@ int Frame_Keyboard::init(epdgui_args_vector_t &args)
     return 6;
 }
 
-int Frame_Keyboard::run(void)
-{
+int Frame_Keyboard::run(void) {
     inputbox->AddText(keyboard->getData());
     return 1;
 }

src/frame/frame_keyboard.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Keyboard : public Frame_Base
-{
+class Frame_Keyboard : public Frame_Base {
 public:
     Frame_Keyboard(bool isHorizontal = false);
     ~Frame_Keyboard();

src/frame/frame_lifegame.cpp

@@ -22,139 +22,98 @@ M5EPD_Canvas lifegame_cells_1(&M5.EPD);
 M5EPD_Canvas lifegame_canvas_0(&M5.EPD);
 M5EPD_Canvas lifegame_canvas_1(&M5.EPD);
 
-void LifeGame_RandomCell()
-{
+void LifeGame_RandomCell() {
     lifegame_cells_flag = 0;
     uint8_t randbuf[CELL_X];
-    for (int y = 0; y < CELL_Y; y++)
-    {
+    for (int y = 0; y < CELL_Y; y++) {
         esp_fill_random(randbuf, CELL_X);
-        for (int x = 0; x < CELL_X; x++)
-        {
+        for (int x = 0; x < CELL_X; x++) {
             lifegame_cells_0.drawPixel(x, y, randbuf[x] & 0x01 ? 15 : 0);
         }
     }
     lifegame_cells_1.fillCanvas(0);
 }
 
-uint8_t LifeGame_Count3x3_0(uint8_t x, uint8_t y)
-{
+uint8_t LifeGame_Count3x3_0(uint8_t x, uint8_t y) {
     uint8_t count = 0;
-    for(int j = y - 1; j < y + 2; j++)
-    {
-        for(int i = x - 1; i < x + 2; i++)
-        {
-            if(lifegame_cells_0.readPixel(i, j))
-            {
+    for(int j = y - 1; j < y + 2; j++) {
+        for(int i = x - 1; i < x + 2; i++) {
+            if(lifegame_cells_0.readPixel(i, j)) {
                 count++;
             }
         }
     }
-    if(lifegame_cells_0.readPixel(x, y))
-    {
+    if(lifegame_cells_0.readPixel(x, y)) {
         count--;
     }
     return count;
 }
 
-uint8_t LifeGame_Count3x3_1(uint8_t x, uint8_t y)
-{
+uint8_t LifeGame_Count3x3_1(uint8_t x, uint8_t y) {
     uint8_t count = 0;
-    for(int j = y - 1; j < y + 2; j++)
-    {
-        for(int i = x - 1; i < x + 2; i++)
-        {
-            if(lifegame_cells_1.readPixel(i, j))
-            {
+    for(int j = y - 1; j < y + 2; j++) {
+        for(int i = x - 1; i < x + 2; i++) {
+            if(lifegame_cells_1.readPixel(i, j)) {
                 count++;
             }
         }
     }
-    if(lifegame_cells_1.readPixel(x, y))
-    {
+    if(lifegame_cells_1.readPixel(x, y)) {
         count--;
     }
     return count;
 }
 
-void LifeGame_CellProcess_0(uint8_t x, uint8_t y)
-{
+void LifeGame_CellProcess_0(uint8_t x, uint8_t y) {
     uint8_t count = LifeGame_Count3x3_0(x, y);
-    if(lifegame_cells_0.readPixel(x, y))
-    {
+    if(lifegame_cells_0.readPixel(x, y)) {
         //dead
-        if(count < 2 || count > 3)
-        {
+        if(count < 2 || count > 3) {
             lifegame_cells_1.drawPixel(x, y, 0);
-        }
-        else
-        {
+         } else {
             lifegame_cells_1.drawPixel(x, y, 15);
         }
-    }
-    else
-    {
+     } else {
         //new life
-        if(count == 3)
-        {
+        if(count == 3) {
             lifegame_cells_1.drawPixel(x, y, 15);
-        }
-        else
-        {
+         } else {
             lifegame_cells_1.drawPixel(x, y, 0);
         }
     }
 }
 
-void LifeGame_CellProcess_1(uint8_t x, uint8_t y)
-{
+void LifeGame_CellProcess_1(uint8_t x, uint8_t y) {
     uint8_t count = LifeGame_Count3x3_1(x, y);
-    if(lifegame_cells_1.readPixel(x, y))
-    {
+    if(lifegame_cells_1.readPixel(x, y)) {
         //dead
-        if(count < 2 || count > 3)
-        {
+        if(count < 2 || count > 3) {
             lifegame_cells_0.drawPixel(x, y, 0);
-        }
-        else
-        {
+         } else {
             lifegame_cells_0.drawPixel(x, y, 15);
         }
-    }
-    else
-    {
+     } else {
         //new life
-        if(count == 3)
-        {
+        if(count == 3) {
             lifegame_cells_0.drawPixel(x, y, 15);
-        }
-        else
-        {
+         } else {
             lifegame_cells_0.drawPixel(x, y, 0);
         }
     }
 }
 
-void LifeGame_RoundProcess()
-{
-    if(lifegame_cells_flag == 0)
-    {
-        for (int y = 1; y < CELL_Y - 1; y++)
-        {
-            for (int x = 1; x < CELL_X - 1; x++)
-            {
+void LifeGame_RoundProcess() {
+    if(lifegame_cells_flag == 0) {
+        for (int y = 1; y < CELL_Y - 1; y++) {
+            for (int x = 1; x < CELL_X - 1; x++) {
                 LifeGame_CellProcess_0(x, y);
                 lifegame_canvas_0.fillRect((x - 1) * CELL_W, (y - 1) * CELL_H, CELL_W, CELL_H, lifegame_cells_1.readPixel(x, y));
             }
         }
         lifegame_cells_flag = 1;
-    }
-    else
-    {
-        for (int y = 1; y < CELL_Y - 1; y++)
-        {
-            for (int x = 1; x < CELL_X - 1; x++)
-            {
+     } else {
+        for (int y = 1; y < CELL_Y - 1; y++) {
+            for (int x = 1; x < CELL_X - 1; x++) {
                 LifeGame_CellProcess_1(x, y);
                 lifegame_canvas_1.fillRect((x - 1) * CELL_W, (y - 1) * CELL_H, CELL_W, CELL_H, lifegame_cells_0.readPixel(x, y));
             }
@@ -163,57 +122,44 @@ void LifeGame_RoundProcess()
     }
 }
 
-void LifeGame_NextGen(void *pvParameters)
-{
+void LifeGame_NextGen(void *pvParameters) {
     LifeGame_RoundProcess();
     vTaskDelete(NULL);
 }
 
-int Frame_Lifegame::run()
-{
+int Frame_Lifegame::run() {
     M5.update();
-    if(M5.BtnP.wasReleased())
-    {
+    if(M5.BtnP.wasReleased()) {
         LifeGame_RandomCell();
     }
     xTaskCreatePinnedToCore(LifeGame_NextGen, "LifeGame_NextGen", 4096, NULL, 1, NULL, 0);
-    if(lifegame_cells_flag == 0)
-    {
+    if(lifegame_cells_flag == 0) {
         lifegame_canvas_1.pushCanvas(0, 72, UPDATE_MODE_DU4);
-    }
-    else
-    {
+     } else {
         lifegame_canvas_0.pushCanvas(0, 72, UPDATE_MODE_DU4);
     }
     log_d("");
     return 1;
 }
 
-void Frame_Lifegame::exit()
-{
+void Frame_Lifegame::exit() {
     lifegame_cells_0.deleteCanvas();
     lifegame_cells_1.deleteCanvas();
     lifegame_canvas_0.deleteCanvas();
     lifegame_canvas_1.deleteCanvas();
 }
 
-Frame_Lifegame::Frame_Lifegame(void)
-{
+Frame_Lifegame::Frame_Lifegame(void) {
     _frame_name = "Frame_Lifegame";
  
     uint8_t language = GetLanguage();
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("ライフゲーム", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("生命游戏", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("Life Game", 270, 34);
     }
@@ -222,12 +168,10 @@ Frame_Lifegame::Frame_Lifegame(void)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Lifegame::~Frame_Lifegame(void)
-{
+Frame_Lifegame::~Frame_Lifegame(void) {
 }
 
-int Frame_Lifegame::init(epdgui_args_vector_t &args)
-{
+int Frame_Lifegame::init(epdgui_args_vector_t &args) {
     _is_run = 1;
 
     lifegame_cells_0.createCanvas(CELL_X, CELL_Y);

src/frame/frame_lifegame.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Lifegame : public Frame_Base
-{
+class Frame_Lifegame : public Frame_Base {
 public:
     Frame_Lifegame();
     ~Frame_Lifegame();

src/frame/frame_main.cpp

@@ -8,8 +8,7 @@
 #include "frame_compare.h"
 #include "frame_home.h"
 
-enum
-{
+enum {
     kKeyFactoryTest = 0,
     kKeySetting,
     kKeyKeyboard,
@@ -23,11 +22,9 @@ enum
 #define KEY_W 92
 #define KEY_H 92
 
-void key_setting_cb(epdgui_args_vector_t &args)
-{
+void key_setting_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Setting");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Setting();
         EPDGUI_AddFrame("Frame_Setting", frame);
     }
@@ -35,11 +32,9 @@ void key_setting_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_keyboard_cb(epdgui_args_vector_t &args)
-{
+void key_keyboard_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Keyboard");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Keyboard(0);
         EPDGUI_AddFrame("Frame_Keyboard", frame);
     }
@@ -47,11 +42,9 @@ void key_keyboard_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_factorytest_cb(epdgui_args_vector_t &args)
-{
+void key_factorytest_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_FactoryTest");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_FactoryTest();
         EPDGUI_AddFrame("Frame_FactoryTest", frame);
     }
@@ -59,11 +52,9 @@ void key_factorytest_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_wifiscan_cb(epdgui_args_vector_t &args)
-{
+void key_wifiscan_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_WifiScan");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_WifiScan();
         EPDGUI_AddFrame("Frame_WifiScan", frame);
     }
@@ -71,11 +62,9 @@ void key_wifiscan_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_lifegame_cb(epdgui_args_vector_t &args)
-{
+void key_lifegame_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Lifegame");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Lifegame();
         EPDGUI_AddFrame("Frame_Lifegame", frame);
     }
@@ -83,18 +72,15 @@ void key_lifegame_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_sdfile_cb(epdgui_args_vector_t &args)
-{
+void key_sdfile_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = new Frame_FileIndex("/");
     EPDGUI_PushFrame(frame);
     *((int*)(args[0])) = 0;
 }
 
-void key_compare_cb(epdgui_args_vector_t &args)
-{
+void key_compare_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Compare");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Compare();
         EPDGUI_AddFrame("Frame_Compare", frame);
     }
@@ -102,11 +88,9 @@ void key_compare_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_home_cb(epdgui_args_vector_t &args)
-{
+void key_home_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Home");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Home();
         EPDGUI_AddFrame("Frame_Home", frame);
     }
@@ -115,8 +99,7 @@ void key_home_cb(epdgui_args_vector_t &args)
 }
 
 
-Frame_Main::Frame_Main(void): Frame_Base(false)
-{
+Frame_Main::Frame_Main(void): Frame_Base(false) {
     _frame_name = "Frame_Main";
     _frame_id = 1;
 
@@ -128,13 +111,11 @@ Frame_Main::Frame_Main(void): Frame_Base(false)
     _names->createCanvas(540, 32);
     _names->setTextDatum(CC_DATUM);
     
-    for(int i = 0; i < 4; i++)
-    {
+    for(int i = 0; i < 4; i++) {
         _key[i] = new EPDGUI_Button("测试", 20 + i * 136, 90, KEY_W, KEY_H);
     }
 
-    for(int i = 0; i < 4; i++)
-    {
+    for(int i = 0; i < 4; i++) {
         _key[i + 4] = new EPDGUI_Button("测试", 20 + i * 136, 240, KEY_W, KEY_H);
     }
 
@@ -191,38 +172,29 @@ Frame_Main::Frame_Main(void): Frame_Base(false)
 }
 
 
-Frame_Main::~Frame_Main(void)
-{
-    for(int i = 0; i < 8; i++)
-    {
+Frame_Main::~Frame_Main(void) {
+    for(int i = 0; i < 8; i++) {
         delete _key[i];
     }
 }
 
-void Frame_Main::AppName(m5epd_update_mode_t mode)
-{
-    if(!_names->isRenderExist(20))
-    {
+void Frame_Main::AppName(m5epd_update_mode_t mode) {
+    if(!_names->isRenderExist(20)) {
         _names->createRender(20, 26);
     }
     _names->setTextSize(20);
     _names->fillCanvas(0);
     uint8_t language = GetLanguage();
     _names->drawString("WLAN", 20 + 46 + 3 * 136, 16);
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         _names->drawString("工場テスト", 20 + 46, 16);
         _names->drawString("設定", 20 + 46 + 136, 16);
         _names->drawString("鍵盤", 20 + 46 + 2 * 136, 16);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         _names->drawString("出厂测试", 20 + 46, 16);
         _names->drawString("设定", 20 + 46 + 136, 16);
         _names->drawString("键盘", 20 + 46 + 2 * 136, 16);
-    }
-    else
-    {
+     } else {
         _names->drawString("Test", 20 + 46, 16);
         _names->drawString("Setting", 20 + 46 + 136, 16);
         _names->drawString("Keyboard", 20 + 46 + 2 * 136, 16);
@@ -230,22 +202,17 @@ void Frame_Main::AppName(m5epd_update_mode_t mode)
     _names->pushCanvas(0, 186, mode);
     
     _names->fillCanvas(0);
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         _names->drawString("メモリー", 20 + 46, 16);
         _names->drawString("刷新比較", 20 + 46 + 136, 16);
         _names->drawString("家", 20 + 46 + 2 * 136, 16);
         _names->drawString("ライフゲーム", 20 + 46 + 3 * 136, 16);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         _names->drawString("存储", 20 + 46, 16);
         _names->drawString("刷新比较", 20 + 46 + 136, 16);
         _names->drawString("家", 20 + 46 + 2 * 136, 16);
         _names->drawString("生命游戏", 20 + 46 + 3 * 136, 16);
-    }
-    else
-    {
+     } else {
         _names->drawString("Storage", 20 + 46, 16);
         _names->drawString("Compare", 20 + 46 + 136, 16);
         _names->drawString("Home", 20 + 46 + 2 * 136, 16);
@@ -254,10 +221,8 @@ void Frame_Main::AppName(m5epd_update_mode_t mode)
     _names->pushCanvas(0, 337, mode);
 }
 
-void Frame_Main::StatusBar(m5epd_update_mode_t mode)
-{
-    if((millis() - _time) < _next_update_time)
-    {
+void Frame_Main::StatusBar(m5epd_update_mode_t mode) {
+    if((millis() - _time) < _next_update_time) {
         return;
     }
     char buf[20];
@@ -271,21 +236,16 @@ void Frame_Main::StatusBar(m5epd_update_mode_t mode)
     _bar->pushImage(498, 8, 32, 32, ImageResource_status_bar_battery_32x32);
     uint32_t vol = M5.getBatteryVoltage();
 
-    if(vol < 3300)
-    {
+    if(vol < 3300) {
         vol = 3300;
-    }
-    else if(vol > 4350)
-    {
+     } else if(vol > 4350) {
         vol = 4350;
     }
     float battery = (float)(vol - 3300) / (float)(4350 - 3300);
-    if(battery <= 0.01)
-    {
+    if(battery <= 0.01) {
         battery = 0.01;
     }
-    if(battery > 1)
-    {
+    if(battery > 1) {
         battery = 1;
     }
     uint8_t px = battery * 25;
@@ -309,12 +269,10 @@ void Frame_Main::StatusBar(m5epd_update_mode_t mode)
 }
 
 
-int Frame_Main::init(epdgui_args_vector_t &args)
-{
+int Frame_Main::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
-    for(int i = 0; i < 8; i++)
-    {
+    for(int i = 0; i < 8; i++) {
         EPDGUI_AddObject(_key[i]);
     }
     _time = 0;
@@ -324,8 +282,7 @@ int Frame_Main::init(epdgui_args_vector_t &args)
     return 9;
 }
 
-int Frame_Main::run()
-{
+int Frame_Main::run() {
     StatusBar(UPDATE_MODE_GL16);
     return 1;
 }

src/frame/frame_main.h

@@ -3,8 +3,7 @@
 
 #include "frame_base.h"
 
-class Frame_Main : public Frame_Base
-{
+class Frame_Main : public Frame_Base {
 public:
     Frame_Main();
     ~Frame_Main();

src/frame/frame_pictureviewer.cpp

@@ -1,14 +1,12 @@
 #include "frame_pictureviewer.h"
 #include "SD.h"
 
-void key_pictureviewer_exit_cb(epdgui_args_vector_t &args)
-{
+void key_pictureviewer_exit_cb(epdgui_args_vector_t &args) {
     EPDGUI_PopFrame(true);
     *((int*)(args[0])) = 0;
 }
 
-Frame_PictureViewer::Frame_PictureViewer(String path)
-{
+Frame_PictureViewer::Frame_PictureViewer(String path) {
     _frame_name = "Frame_PictureViewer";
     _pic_path = path;
 
@@ -19,16 +17,11 @@ Frame_PictureViewer::Frame_PictureViewer(String path)
     _canvas_picture->setTextDatum(CC_DATUM);
  
     uint8_t language = GetLanguage();
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("戻る");
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("返回");
-    }
-    else
-    {
+     } else {
         exitbtn("Back");
     }
 
@@ -40,46 +33,34 @@ Frame_PictureViewer::Frame_PictureViewer(String path)
     _is_first = true;
 }
 
-Frame_PictureViewer::~Frame_PictureViewer(void)
-{
+Frame_PictureViewer::~Frame_PictureViewer(void) {
     delete _canvas_picture;
 }
 
-void Frame_PictureViewer::err(String info)
-{
+void Frame_PictureViewer::err(String info) {
     _canvas_picture->fillCanvas(0);
     _canvas_picture->fillRect(254 - 150, 500 - 50, 300, 100, 15);
     _canvas_picture->drawString(info, 150, 55);
 }
 
-int Frame_PictureViewer::run()
-{
-    if(_is_first)
-    {
+int Frame_PictureViewer::run() {
+    if(_is_first) {
         _is_first = false;
         LoadingAnime_32x32_Start(254, 500);
         String suffix = _pic_path.substring(_pic_path.lastIndexOf("."));
-        if((suffix.indexOf("bmp") >= 0) || (suffix.indexOf("BMP") >= 0))
-        {
+        if((suffix.indexOf("bmp") >= 0) || (suffix.indexOf("BMP") >= 0)) {
             bool ret = _canvas_picture->drawBmpFile(SD, _pic_path.c_str(), 0, 0);
-            if(ret == 0)
-            {
+            if(ret == 0) {
                 err("Error opening " + _pic_path.substring(_pic_path.lastIndexOf("/")));
             }
-        }
-        else if ((suffix.indexOf("png") >= 0) || (suffix.indexOf("PNG") >= 0))
-        {
+         } else if ((suffix.indexOf("png") >= 0) || (suffix.indexOf("PNG") >= 0)) {
             bool ret = _canvas_picture->drawPngFile(SD, _pic_path.c_str());
-            if(ret == 0)
-            {
+            if(ret == 0) {
                 err("Error opening " + _pic_path.substring(_pic_path.lastIndexOf("/")));
             }
-        }
-        else if ((suffix.indexOf("jpg") >= 0) || (suffix.indexOf("JPG") >= 0))
-        {
+         } else if ((suffix.indexOf("jpg") >= 0) || (suffix.indexOf("JPG") >= 0)) {
             bool ret = _canvas_picture->drawJpgFile(SD, _pic_path.c_str());
-            if(ret == 0)
-            {
+            if(ret == 0) {
                 err("Error opening " + _pic_path.substring(_pic_path.lastIndexOf("/")));
             }
         }
@@ -89,8 +70,7 @@ int Frame_PictureViewer::run()
     return 1;
 }
 
-int Frame_PictureViewer::init(epdgui_args_vector_t &args)
-{
+int Frame_PictureViewer::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_pictureviewer.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_PictureViewer : public Frame_Base
-{
+class Frame_PictureViewer : public Frame_Base {
 public:
     Frame_PictureViewer(String path);
     ~Frame_PictureViewer();

src/frame/frame_setting.cpp

@@ -7,8 +7,7 @@
 #define KEY_H 92
 const uint16_t kTimeZoneY = 520;
 
-void key_shutdown_cb(epdgui_args_vector_t &args)
-{
+void key_shutdown_cb(epdgui_args_vector_t &args) {
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     M5.EPD.UpdateFull(UPDATE_MODE_GC16);
     M5.EPD.UpdateFull(UPDATE_MODE_GC16);
@@ -21,19 +20,16 @@ void key_shutdown_cb(epdgui_args_vector_t &args)
     while(1);
 }
 
-void key_restart_cb(epdgui_args_vector_t &args)
-{
+void key_restart_cb(epdgui_args_vector_t &args) {
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     M5.EPD.UpdateFull(UPDATE_MODE_GC16);
     SaveSetting();
     esp_restart();
 }
 
-void key_language_cb(epdgui_args_vector_t &args)
-{
+void key_language_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Setting_Language");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Setting_Language();
         EPDGUI_AddFrame("Frame_Setting_Language", frame);
     }
@@ -41,11 +37,9 @@ void key_language_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_wallpaper_cb(epdgui_args_vector_t &args)
-{
+void key_wallpaper_cb(epdgui_args_vector_t &args) {
     Frame_Base *frame = EPDGUI_GetFrame("Frame_Setting_Wallpaper");
-    if(frame == NULL)
-    {
+    if(frame == NULL) {
         frame = new Frame_Setting_Wallpaper();
         EPDGUI_AddFrame("Frame_Setting_Wallpaper", frame);
     }
@@ -53,8 +47,7 @@ void key_wallpaper_cb(epdgui_args_vector_t &args)
     *((int*)(args[0])) = 0;
 }
 
-void key_synctime_cb(epdgui_args_vector_t &args)
-{
+void key_synctime_cb(epdgui_args_vector_t &args) {
     SaveSetting();
     M5EPD_Canvas info(&M5.EPD);
     M5EPD_Canvas *title = (M5EPD_Canvas*)(args[0]);
@@ -65,18 +58,12 @@ void key_synctime_cb(epdgui_args_vector_t &args)
     info.setTextColor(0);
     info.setTextDatum(CC_DATUM);
     uint8_t language = GetLanguage();
-    if(WiFi.status() != WL_CONNECTED)
-    {
-        if(language == LANGUAGE_JA)
-        {
+    if(WiFi.status() != WL_CONNECTED) {
+        if(language == LANGUAGE_JA) {
             info.drawString("WLANが接続いません", 150, 55);
-        }
-        else if(language == LANGUAGE_ZH)
-        {
+         } else if(language == LANGUAGE_ZH) {
             info.drawString("WLAN未连接", 150, 55);
-        }
-        else
-        {
+         } else {
             info.drawString("WLAN not connected", 150, 55);
         }
         info.pushCanvas(120, 430, UPDATE_MODE_GL16);
@@ -92,34 +79,21 @@ void key_synctime_cb(epdgui_args_vector_t &args)
     bool ret = SyncNTPTime();
     LoadingAnime_32x32_Stop();
 
-    if(ret == 0)
-    {
-        if(language == LANGUAGE_JA)
-        {
+    if(ret == 0) {
+        if(language == LANGUAGE_JA) {
             info.drawString("シンクロが失敗しました", 150, 55);
-        }
-        else if(language == LANGUAGE_ZH)
-        {
+         } else if(language == LANGUAGE_ZH) {
             info.drawString("同步失败", 150, 55);
-        }
-        else
-        {
+         } else {
             info.drawString("Time sync failed", 150, 55);
         }
         info.pushCanvas(120, 430, UPDATE_MODE_GL16);
-    }
-    else
-    {
-        if(language == LANGUAGE_JA)
-        {
+     } else {
+        if(language == LANGUAGE_JA) {
             info.drawString("成功", 150, 55);
-        }
-        else if(language == LANGUAGE_ZH)
-        {
+         } else if(language == LANGUAGE_ZH) {
             info.drawString("成功", 150, 55);
-        }
-        else
-        {
+         } else {
             info.drawString("Success", 150, 55);
         }
         info.pushCanvas(120, 430, UPDATE_MODE_GL16);
@@ -132,17 +106,14 @@ void key_synctime_cb(epdgui_args_vector_t &args)
     M5.EPD.UpdateFull(UPDATE_MODE_GL16);
 }
 
-void key_timezone_plus_cb(epdgui_args_vector_t &args)
-{
+void key_timezone_plus_cb(epdgui_args_vector_t &args) {
     int *tz = (int*)(args[0]);
     (*tz)++;
-    if((*tz) > 12)
-    {
+    if((*tz) > 12) {
         (*tz) = 12;
     }
     String str = String(*tz);
-    if((*tz) > 0)
-    {
+    if((*tz) > 0) {
         str = "+" + str;
     }
     ((EPDGUI_Button*)(args[1]))->setLabel(str);
@@ -150,17 +121,14 @@ void key_timezone_plus_cb(epdgui_args_vector_t &args)
     SetTimeZone(*tz);
 }
 
-void key_timezone_minus_cb(epdgui_args_vector_t &args)
-{
+void key_timezone_minus_cb(epdgui_args_vector_t &args) {
     int *tz = (int*)(args[0]);
     (*tz)--;
-    if((*tz) < -11)
-    {
+    if((*tz) < -11) {
         (*tz) = -11;
     }
     String str = String(*tz);
-    if((*tz) > 0)
-    {
+    if((*tz) > 0) {
         str = "+" + str;
     }
     ((EPDGUI_Button*)(args[1]))->setLabel(str);
@@ -168,8 +136,7 @@ void key_timezone_minus_cb(epdgui_args_vector_t &args)
     SetTimeZone(*tz);
 }
 
-void key_timezone_reset_cb(epdgui_args_vector_t &args)
-{
+void key_timezone_reset_cb(epdgui_args_vector_t &args) {
     int *tz = (int*)(args[0]);
     (*tz) = 0;
     ((EPDGUI_Button*)(args[1]))->setLabel(String(*tz));
@@ -177,8 +144,7 @@ void key_timezone_reset_cb(epdgui_args_vector_t &args)
     SetTimeZone(*tz);
 }
 
-Frame_Setting::Frame_Setting(void)
-{
+Frame_Setting::Frame_Setting(void) {
     _frame_name = "Frame_Setting";
 
     _timezone_canvas = new M5EPD_Canvas(&M5.EPD);
@@ -197,8 +163,7 @@ Frame_Setting::Frame_Setting(void)
 
     key_timezone_plus = new EPDGUI_Button("+", 448, kTimeZoneY, 88, 52);
     String str = String(GetTimeZone());
-    if(GetTimeZone() > 0)
-    {
+    if(GetTimeZone() > 0) {
         str = "+" + str;
     }
     key_timezone_reset = new EPDGUI_Button(str, 360, kTimeZoneY, 88, 52);
@@ -216,8 +181,7 @@ Frame_Setting::Frame_Setting(void)
     key_timezone_minus->AddArgs(EPDGUI_Button::EVENT_RELEASED, 1, key_timezone_reset);
     key_timezone_minus->Bind(EPDGUI_Button::EVENT_RELEASED, key_timezone_minus_cb);
 
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         _key_wallpaper->setBMPButton("  壁紙", "\u25B6", ImageResource_item_icon_wallpaper_32x32);
         _key_language->setBMPButton("  言語", "\u25B6", ImageResource_item_icon_language_32x32);
         _key_syncntp->setBMPButton("  時間シンクロ", "", ImageResource_item_icon_ntptime_32x32);
@@ -226,9 +190,7 @@ Frame_Setting::Frame_Setting(void)
         _timezone_canvas->drawString("時間帯 (UTC)", 15, 35);
         exitbtn("ホーム");
         _canvas_title->drawString("設定", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         _key_wallpaper->setBMPButton("  壁纸", "\u25B6", ImageResource_item_icon_wallpaper_32x32);
         _key_language->setBMPButton("  语言", "\u25B6", ImageResource_item_icon_language_32x32);
         _key_syncntp->setBMPButton("  同步时间", "", ImageResource_item_icon_ntptime_32x32);
@@ -237,9 +199,7 @@ Frame_Setting::Frame_Setting(void)
         _timezone_canvas->drawString("时区 (UTC)", 15, 35);
         exitbtn("主页");
         _canvas_title->drawString("设置", 270, 34);
-    }
-    else
-    {
+     } else {
         _key_wallpaper->setBMPButton("  Wallpaper", "\u25B6", ImageResource_item_icon_wallpaper_32x32);
         _key_language->setBMPButton("  Language", "\u25B6", ImageResource_item_icon_language_32x32);
         _key_syncntp->setBMPButton("  Sync Time", "", ImageResource_item_icon_ntptime_32x32);
@@ -268,8 +228,7 @@ Frame_Setting::Frame_Setting(void)
     _timezone = GetTimeZone();
 }
 
-Frame_Setting::~Frame_Setting(void)
-{
+Frame_Setting::~Frame_Setting(void) {
     delete _key_wallpaper;
     delete _key_language;
     delete _key_shutdown;
@@ -277,8 +236,7 @@ Frame_Setting::~Frame_Setting(void)
     delete _key_syncntp;
 }
 
-int Frame_Setting::init(epdgui_args_vector_t &args)
-{
+int Frame_Setting::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_setting.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Setting : public Frame_Base
-{
+class Frame_Setting : public Frame_Base {
 public:
     Frame_Setting();
     ~Frame_Setting();

src/frame/frame_setting_language.cpp

@@ -1,31 +1,26 @@
 #include "frame_setting_language.h"
 
 
-void sw_en_cb(epdgui_args_vector_t &args)
-{
+void sw_en_cb(epdgui_args_vector_t &args) {
     SetLanguage(LANGUAGE_EN);
 }
 
-void sw_zh_cb(epdgui_args_vector_t &args)
-{
+void sw_zh_cb(epdgui_args_vector_t &args) {
     SetLanguage(LANGUAGE_ZH);
 }
 
-void sw_ja_cb(epdgui_args_vector_t &args)
-{
+void sw_ja_cb(epdgui_args_vector_t &args) {
     SetLanguage(LANGUAGE_JA);
 }
 
-Frame_Setting_Language::Frame_Setting_Language(void)
-{
+Frame_Setting_Language::Frame_Setting_Language(void) {
     _frame_name = "Frame_Setting_Language";
 
     _sw_en = new EPDGUI_Switch(2, 4, 100, 532, 61);
     _sw_zh = new EPDGUI_Switch(2, 4, 160, 532, 61);
     _sw_ja = new EPDGUI_Switch(2, 4, 220, 532, 61);
 
-    if(isTTFLoaded())
-    {
+    if(isTTFLoaded()) {
         _sw_en->SetLabel(0, "English");
         _sw_en->SetLabel(1, "English");
         _sw_en->Canvas(1)->ReverseColor();
@@ -38,9 +33,7 @@ Frame_Setting_Language::Frame_Setting_Language(void)
         _sw_ja->SetLabel(1, "日本語");
         _sw_ja->Canvas(1)->ReverseColor();
         _sw_ja->Bind(1, &sw_ja_cb);
-    }
-    else
-    {
+     } else {
         _sw_en->SetLabel(0, "English");
         _sw_en->SetLabel(1, "English");
         _sw_en->Canvas(1)->ReverseColor();
@@ -61,20 +54,15 @@ Frame_Setting_Language::Frame_Setting_Language(void)
     _sw_mutex_group->Add(_sw_ja);
  
     uint8_t language = GetLanguage();
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("設定");
         _canvas_title->drawString("言語", 270, 34);
         _sw_ja->setState(1);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("设置");
         _canvas_title->drawString("语言", 270, 34);
         _sw_zh->setState(1);
-    }
-    else
-    {
+     } else {
         exitbtn("Setting");
         _canvas_title->drawString("Language", 270, 34);
         _sw_en->setState(1);
@@ -84,16 +72,14 @@ Frame_Setting_Language::Frame_Setting_Language(void)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Setting_Language::~Frame_Setting_Language(void)
-{
+Frame_Setting_Language::~Frame_Setting_Language(void) {
     delete _sw_en;
     delete _sw_zh;
     delete _sw_ja;
     delete _sw_mutex_group;
 }
 
-int Frame_Setting_Language::init(epdgui_args_vector_t &args)
-{
+int Frame_Setting_Language::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_setting_language.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Setting_Language : public Frame_Base
-{
+class Frame_Setting_Language : public Frame_Base {
 public:
     Frame_Setting_Language();
     ~Frame_Setting_Language();

src/frame/frame_setting_wallpaper.cpp

@@ -1,18 +1,15 @@
 #include "frame_setting_wallpaper.h"
 
-void sw_wallpapers_cb(epdgui_args_vector_t &args)
-{
+void sw_wallpapers_cb(epdgui_args_vector_t &args) {
     SetWallpaper(*((uint32_t*)(args[0])));
 }
 
-Frame_Setting_Wallpaper::Frame_Setting_Wallpaper(void)
-{
+Frame_Setting_Wallpaper::Frame_Setting_Wallpaper(void) {
     _frame_name = "Frame_Setting_Wallpaper";
 
     _sw_mutex_group = new EPDGUI_MutexSwitch();
 
-    for(int i = 0; i < WALLPAPER_NUM; i++)
-    {
+    for(int i = 0; i < WALLPAPER_NUM; i++) {
         _sw_wallpapers[i] = new EPDGUI_Switch(2, 4, 100 + i * 60, 532, 61);
         _sw_mutex_group->Add(_sw_wallpapers[i]);
         _sw_wallpapers[i]->SetLabel(0, GetWallpaperName(i));
@@ -25,18 +22,13 @@ Frame_Setting_Wallpaper::Frame_Setting_Wallpaper(void)
     _sw_wallpapers[GetWallpaperID()]->setState(1);
 
     uint8_t language = GetLanguage();
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("設定");
         _canvas_title->drawString("壁紙", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("设置");
         _canvas_title->drawString("壁纸", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Setting");
         _canvas_title->drawString("Wallpaper", 270, 34);
     }
@@ -45,17 +37,14 @@ Frame_Setting_Wallpaper::Frame_Setting_Wallpaper(void)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_Setting_Wallpaper::~Frame_Setting_Wallpaper(void)
-{
-    for(int i = 0; i < WALLPAPER_NUM; i++)
-    {
+Frame_Setting_Wallpaper::~Frame_Setting_Wallpaper(void) {
+    for(int i = 0; i < WALLPAPER_NUM; i++) {
         delete _sw_wallpapers[i];
     }
     delete _sw_mutex_group;
 }
 
-int Frame_Setting_Wallpaper::init(epdgui_args_vector_t &args)
-{
+int Frame_Setting_Wallpaper::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);

src/frame/frame_setting_wallpaper.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_Setting_Wallpaper : public Frame_Base
-{
+class Frame_Setting_Wallpaper : public Frame_Base {
 public:
     Frame_Setting_Wallpaper();
     ~Frame_Setting_Wallpaper();

src/frame/frame_txtreader.cpp

@@ -1,26 +1,22 @@
 #include "frame_txtreader.h"
 
-void key_txtreader_exit_cb(epdgui_args_vector_t &args)
-{
+void key_txtreader_exit_cb(epdgui_args_vector_t &args) {
     EPDGUI_PopFrame(true);
     *((int*)(args[0])) = 0;
 }
 
 int8_t _key_operation = 0;
-void key_nextpage_released_cb(epdgui_args_vector_t &args)
-{
+void key_nextpage_released_cb(epdgui_args_vector_t &args) {
     _key_operation = 1;
     // *((int8_t*)(args[0])) = 1;
 }
 
-void key_prevpage_released_cb(epdgui_args_vector_t &args)
-{
+void key_prevpage_released_cb(epdgui_args_vector_t &args) {
     _key_operation = -1;
     // *((int8_t*)(args[0])) = -1;
 }
 
-Frame_txtReader::Frame_txtReader(String path)
-{
+Frame_txtReader::Frame_txtReader(String path) {
     _frame_name = "Frame_txtReader";
     _txt_path = path;
     _text_size = GetTextSize();
@@ -38,16 +34,11 @@ Frame_txtReader::Frame_txtReader(String path)
     _key_prev->Bind(EPDGUI_Button::EVENT_RELEASED, key_prevpage_released_cb);
 
     _language = GetLanguage();
-    if(_language == LANGUAGE_JA)
-    {
+    if(_language == LANGUAGE_JA) {
         exitbtn("戻る");
-    }
-    else if(_language == LANGUAGE_ZH)
-    {
+     } else if(_language == LANGUAGE_ZH) {
         exitbtn("返回");
-    }
-    else
-    {
+     } else {
         exitbtn("Back");
     }
 
@@ -57,10 +48,8 @@ Frame_txtReader::Frame_txtReader(String path)
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &key_txtreader_exit_cb);
 }
 
-Frame_txtReader::~Frame_txtReader(void)
-{
-    if(_text_size != 26)
-    {
+Frame_txtReader::~Frame_txtReader(void) {
+    if(_text_size != 26) {
         _canvas_prev->destoryRender(_text_size);
     }
     delete _canvas_prev;
@@ -72,8 +61,7 @@ Frame_txtReader::~Frame_txtReader(void)
     _txt_file.close();
 }
 
-uint32_t Frame_txtReader::renderText(uint32_t cursor, uint32_t length, M5EPD_Canvas *canvas)
-{
+uint32_t Frame_txtReader::renderText(uint32_t cursor, uint32_t length, M5EPD_Canvas *canvas) {
     canvas->fillCanvas(0);
     canvas->setTextArea(10, 10, 520, 868);
     canvas->setTextSize(_text_size);
@@ -86,92 +74,69 @@ uint32_t Frame_txtReader::renderText(uint32_t cursor, uint32_t length, M5EPD_Can
     return canvas->getExceedOffset();
 }
 
-int Frame_txtReader::run()
-{
-    if(_is_first)
-    {
+int Frame_txtReader::run() {
+    if(_is_first) {
         LoadingAnime_32x32_Start(254, 500);
         _is_first = false;
         uint32_t cursor;
         _page_cursor.insert(std::pair<uint32_t, uint32_t>(0, 0));
         cursor = renderText(0, _render_len, _canvas_current);
-        if(cursor == 0)
-        {
+        if(cursor == 0) {
             _page_end = 0;
             _end_accessed = true;
-        }
-        else
-        {
+         } else {
             _page_end = _page + 1;
             _page_cursor.insert(std::pair<uint32_t, uint32_t>(1, cursor));
             uint32_t offset = renderText(_page_cursor[1], _render_len, _canvas_next);
-            if(offset == 0)
-            {
+            if(offset == 0) {
                 _page_end = 1;
                 _end_accessed = true;
-            }
-            else
-            {
+             } else {
                 _page_cursor.insert(std::pair<uint32_t, uint32_t>(2, cursor + offset));
             }
         }
         LoadingAnime_32x32_Stop();
         _canvas_current->pushCanvas(0, 72, UPDATE_MODE_GC16);
-    }
-    else
-    {
+     } else {
         M5.update();
-        if(M5.BtnR.wasReleased() || (_key_operation == 1))
-        {
+        if(M5.BtnR.wasReleased() || (_key_operation == 1)) {
             _key_operation = 0;
-            if(_page != _page_end)
-            {
+            if(_page != _page_end) {
                 _page++;
                 _canvas_next->pushCanvas(0, 72, UPDATE_MODE_GC16);
                 memcpy(_canvas_prev->frameBuffer(), _canvas_current->frameBuffer(), _canvas_current->getBufferSize());
                 memcpy(_canvas_current->frameBuffer(), _canvas_next->frameBuffer(), _canvas_next->getBufferSize());
 
-                if((_end_accessed == false) || (_page != _page_end))
-                {
+                if((_end_accessed == false) || (_page != _page_end)) {
                     uint32_t offset = renderText(_page_cursor[_page + 1], _render_len, _canvas_next);
 
-                    if(offset != 0)
-                    {
-                        if(_page_cursor.count(_page + 2) == 0)
-                        {
+                    if(offset != 0) {
+                        if(_page_cursor.count(_page + 2) == 0) {
                             _page_cursor.insert(std::pair<uint32_t, uint32_t>(_page + 2, _page_cursor[_page + 1] + offset));
                         }
-                    }
-                    else if(_end_accessed == false)
-                    {
+                     } else if(_end_accessed == false) {
                         _page_end = _page + 1;
                         _end_accessed = true;
                     }
-                    if(!_end_accessed)
-                    {
+                    if(!_end_accessed) {
                         _page_end = _page + 1;
                     }
                 }
             }
-        }
-        else if(M5.BtnL.wasReleased() || (_key_operation == -1))
-        {
+         } else if(M5.BtnL.wasReleased() || (_key_operation == -1)) {
             _key_operation = 0;
-            if(_page > 0)
-            {
+            if(_page > 0) {
                 _page--;
                 _canvas_prev->pushCanvas(0, 72, UPDATE_MODE_GC16);
                 memcpy(_canvas_next->frameBuffer(), _canvas_current->frameBuffer(), _canvas_current->getBufferSize());
                 memcpy(_canvas_current->frameBuffer(), _canvas_prev->frameBuffer(), _canvas_prev->getBufferSize());
-                if(_page != 0)
-                {
+                if(_page != 0) {
                     renderText(_page_cursor[_page - 1], _render_len, _canvas_prev);
                 }
             }
         }
     }
-    if(_last_page != _page)
-    {
+    if(_last_page != _page) {
         _last_page = _page;
         _canvas_page->setTextSize(26);
         _canvas_page->fillCanvas(0);
@@ -183,8 +148,7 @@ int Frame_txtReader::run()
     return 1;
 }
 
-int Frame_txtReader::init(epdgui_args_vector_t &args)
-{
+int Frame_txtReader::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
@@ -193,8 +157,7 @@ int Frame_txtReader::init(epdgui_args_vector_t &args)
     _canvas_next->createCanvas(540, 888);
     _canvas_page->createCanvas(100, 60);
     _canvas_page->setTextDatum(CR_DATUM);
-    if(!_canvas_prev->isRenderExist(_text_size))
-    {
+    if(!_canvas_prev->isRenderExist(_text_size)) {
         _canvas_prev->createRender(_text_size, 128);
     }
     EPDGUI_AddObject(_key_exit);

src/frame/frame_txtreader.h

@@ -5,8 +5,7 @@
 #include "../epdgui/epdgui.h"
 #include "SD.h"
 
-class Frame_txtReader : public Frame_Base
-{
+class Frame_txtReader : public Frame_Base {
 public:
     Frame_txtReader(String path);
     ~Frame_txtReader();

src/frame/frame_wifipassword.cpp

@@ -1,18 +1,15 @@
 #include "frame_wifipassword.h"
 
 
-void key_passwordclear_cb(epdgui_args_vector_t &args)
-{
+void key_passwordclear_cb(epdgui_args_vector_t &args) {
     ((EPDGUI_Textbox*)(args[0]))->SetText("");
 }
 
 
-Frame_WifiPassword::Frame_WifiPassword(bool isHorizontal) : Frame_Base()
-{
+Frame_WifiPassword::Frame_WifiPassword(bool isHorizontal) : Frame_Base() {
     _frame_name = "Frame_WifiPassword";
     uint8_t language = GetLanguage();
-    if(isHorizontal)
-    {
+    if(isHorizontal) {
         inputbox = new EPDGUI_Textbox(84, 25, 712, 250);
         if(language == LANGUAGE_JA)
             key_textclear = new EPDGUI_Button("削除", 804, 25, 72, 120);
@@ -20,9 +17,7 @@ Frame_WifiPassword::Frame_WifiPassword(bool isHorizontal) : Frame_Base()
             key_textclear = new EPDGUI_Button("清除", 804, 25, 72, 120);
         else
             key_textclear = new EPDGUI_Button("CLR", 804, 25, 72, 120);
-    }
-    else
-    {
+     } else {
         const uint16_t kKeyBaseY = 176;
         inputbox = new EPDGUI_Textbox(4, 100, 532, 60);
         if(language == LANGUAGE_JA)
@@ -41,18 +36,13 @@ Frame_WifiPassword::Frame_WifiPassword(bool isHorizontal) : Frame_Base()
     key_textclear->AddArgs(EPDGUI_Button::EVENT_RELEASED, 0, (void*)inputbox);
     key_textclear->Bind(EPDGUI_Button::EVENT_RELEASED, key_passwordclear_cb);
 
-    if(language == LANGUAGE_JA)
-    {
+    if(language == LANGUAGE_JA) {
         exitbtn("WLAN");
         _canvas_title->drawString("パスワード", 270, 34);
-    }
-    else if(language == LANGUAGE_ZH)
-    {
+     } else if(language == LANGUAGE_ZH) {
         exitbtn("无线局域网", 200);
         _canvas_title->drawString("密码", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("WLAN");
         _canvas_title->drawString("Password", 270, 34);
     }
@@ -61,15 +51,13 @@ Frame_WifiPassword::Frame_WifiPassword(bool isHorizontal) : Frame_Base()
     _key_exit->Bind(EPDGUI_Button::EVENT_RELEASED, &Frame_Base::exit_cb);
 }
 
-Frame_WifiPassword::~Frame_WifiPassword()
-{
+Frame_WifiPassword::~Frame_WifiPassword() {
     delete inputbox;
     delete keyboard;
     delete key_textclear;
 }
 
-int Frame_WifiPassword::init(epdgui_args_vector_t &args)
-{
+int Frame_WifiPassword::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     M5.EPD.Clear();
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
@@ -80,11 +68,9 @@ int Frame_WifiPassword::init(epdgui_args_vector_t &args)
     return 6;
 }
 
-int Frame_WifiPassword::run(void)
-{
+int Frame_WifiPassword::run(void) {
     String data = keyboard->getData();
-    if(data.indexOf("\n") >= 0)
-    {
+    if(data.indexOf("\n") >= 0) {
         String *pswd = new String(inputbox->GetText());
         EPDGUI_AddFrameArg("Frame_WifiScan", 0, pswd);        
         inputbox->SetText("");

src/frame/frame_wifipassword.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_WifiPassword : public Frame_Base
-{
+class Frame_WifiPassword : public Frame_Base {
 public:
     Frame_WifiPassword(bool isHorizontal = false);
     ~Frame_WifiPassword();

src/frame/frame_wifiscan.cpp

@@ -14,18 +14,13 @@ const uint8_t *kIMGWifiLevel[4] = {
     ImageResource_item_icon_wifi_3_32x32
 };
 
-void key_wifi_cb(epdgui_args_vector_t &args)
-{
-    if(((EPDGUI_Button*)(args[0]))->GetCustomString() == "_$refresh$_")
-    {
+void key_wifi_cb(epdgui_args_vector_t &args) {
+    if(((EPDGUI_Button*)(args[0]))->GetCustomString() == "_$refresh$_") {
         _update_flag = true;
-    }
-    else
-    {
+     } else {
         _connect_key = (EPDGUI_Button*)(args[0]);
         Frame_Base *frame = EPDGUI_GetFrame("Frame_WifiPassword");
-        if(frame == NULL)
-        {
+        if(frame == NULL) {
             frame = new Frame_WifiPassword(false);
             EPDGUI_AddFrame("Frame_WifiPassword", frame);
         }
@@ -35,12 +30,10 @@ void key_wifi_cb(epdgui_args_vector_t &args)
 }
 
 
-Frame_WifiScan::Frame_WifiScan(void)
-{
+Frame_WifiScan::Frame_WifiScan(void) {
     _frame_name = "Frame_WifiScan";
 
-    for(int i = 0; i < MAX_BTN_NUM; i++)
-    {
+    for(int i = 0; i < MAX_BTN_NUM; i++) {
         _key_wifi[i] = new EPDGUI_Button(4, 100 + i * 60, 532, 61);
         _key_wifi[i]->SetHide(true);
         _key_wifi[i]->CanvasNormal()->setTextSize(26);
@@ -52,18 +45,13 @@ Frame_WifiScan::Frame_WifiScan(void)
     }
  
     _language = GetLanguage();
-    if(_language == LANGUAGE_JA)
-    {
+    if(_language == LANGUAGE_JA) {
         exitbtn("ホーム");
         _canvas_title->drawString("WLAN", 270, 34);
-    }
-    else if(_language == LANGUAGE_ZH)
-    {
+     } else if(_language == LANGUAGE_ZH) {
         exitbtn("主页");
         _canvas_title->drawString("无线局域网", 270, 34);
-    }
-    else
-    {
+     } else {
         exitbtn("Home");
         _canvas_title->drawString("WLAN", 270, 34);
     }
@@ -75,31 +63,22 @@ Frame_WifiScan::Frame_WifiScan(void)
     _connected = 0;
 }
 
-Frame_WifiScan::~Frame_WifiScan(void)
-{
-    for(int i = 0; i < MAX_BTN_NUM; i++)
-    {
+Frame_WifiScan::~Frame_WifiScan(void) {
+    for(int i = 0; i < MAX_BTN_NUM; i++) {
         delete _key_wifi[i];
     }
 }
 
-void Frame_WifiScan::DrawItem(EPDGUI_Button *btn, String ssid, int rssi)
-{
+void Frame_WifiScan::DrawItem(EPDGUI_Button *btn, String ssid, int rssi) {
     int level = 0;
-    if(rssi > -55)
-    {
+    if(rssi > -55) {
         level = 3;
-    }
-    else if(rssi > -88)
-    {
+     } else if(rssi > -88) {
         level = 2;
-    }
-    else
-    {
+     } else {
         level = 1;
     }
-    if(ssid.length() > 22)
-    {
+    if(ssid.length() > 22) {
         ssid = ssid.substring(0, 22) + "...";
     }
     btn->SetHide(false);
@@ -112,29 +91,24 @@ void Frame_WifiScan::DrawItem(EPDGUI_Button *btn, String ssid, int rssi)
     btn->CanvasPressed()->ReverseColor();
 }
 
-int Frame_WifiScan::run()
-{
-    if(_connect)
-    {
+int Frame_WifiScan::run() {
+    if(_connect) {
         _connect = false;
         Connect();
     }
-    if(_update_flag)
-    {
+    if(_update_flag) {
         _update_flag = false;
         scan();
     }
     return 1;
 }
 
-int Frame_WifiScan::scan()
-{
+int Frame_WifiScan::scan() {
     WiFi.mode(WIFI_STA);
     // WiFi.disconnect();
     WiFi.scanNetworks(true);
 
-    if(_scan_count > 0)
-    {
+    if(_scan_count > 0) {
         M5.EPD.WriteFullGram4bpp(GetWallpaper());
         _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
         _key_exit->Draw(UPDATE_MODE_NONE);
@@ -143,39 +117,31 @@ int Frame_WifiScan::scan()
     _scan_count++;
     
     int wifi_num;
-    while(1)
-    {
+    while(1) {
         wifi_num = WiFi.scanComplete();
-        if(wifi_num >= 0)
-        {
+        if(wifi_num >= 0) {
             break;
         }
     }
 
     int connect_wifi_idx = -1;
-    if(_connected)
-    {
-        for(int i = 0; i < wifi_num; i++)
-        {
+    if(_connected) {
+        for(int i = 0; i < wifi_num; i++) {
             String ssid = WiFi.SSID(i);
             
-            if(ssid == _connect_ssid)
-            {
+            if(ssid == _connect_ssid) {
                 connect_wifi_idx = i;
-                if(WiFi.RSSI(i) < -90)
-                {
+                if(WiFi.RSSI(i) < -90) {
                     connect_wifi_idx = -1;
                 }
                 break;
             }
         }
-        if(connect_wifi_idx == -1)
-        {
+        if(connect_wifi_idx == -1) {
             WiFi.disconnect();
             _key_wifi[0]->SetEnable(true);
             _connected = 0;
-            for(int i = 1; i < MAX_BTN_NUM; i++)
-            {
+            for(int i = 1; i < MAX_BTN_NUM; i++) {
                 _key_wifi[i]->SetPos(_key_wifi[i]->getX(), _key_wifi[i]->getY() - 32);
             }
         }
@@ -184,21 +150,17 @@ int Frame_WifiScan::scan()
     wifi_num = wifi_num > MAX_WIFI_NUM ? MAX_WIFI_NUM : wifi_num;
     wifi_num -= _connected;
 
-    for(int i = _connected; i < MAX_BTN_NUM; i++)
-    {
+    for(int i = _connected; i < MAX_BTN_NUM; i++) {
         _key_wifi[i]->SetHide(true);
     }
 
-    if(_connected)
-    {
+    if(_connected) {
         _key_wifi[0]->Draw(UPDATE_MODE_A2);
     }
 
     int idx = 0, cnt = _connected;
-    while(1)
-    {
-        if(idx == connect_wifi_idx)
-        {
+    while(1) {
+        if(idx == connect_wifi_idx) {
             idx++;
             continue;
         }
@@ -208,8 +170,7 @@ int Frame_WifiScan::scan()
         _key_wifi[cnt]->Draw(UPDATE_MODE_A2);
 
         idx++;
-        if(idx == wifi_num)
-        {
+        if(idx == wifi_num) {
             break;
         }
 
@@ -221,16 +182,11 @@ int Frame_WifiScan::scan()
     _key_wifi[wifi_num]->CanvasNormal()->fillCanvas(0);
     _key_wifi[wifi_num]->CanvasNormal()->drawRect(0, 0, 532, 61, 15);
     _key_wifi[wifi_num]->CanvasNormal()->pushImage(15, 14, 32, 32, ImageResource_item_icon_refresh_32x32);
-    if(_language == LANGUAGE_JA)
-    {
+    if(_language == LANGUAGE_JA) {
         _key_wifi[wifi_num]->CanvasNormal()->drawString("刷新", 58, 35);
-    }
-    else if(_language == LANGUAGE_ZH)
-    {
+     } else if(_language == LANGUAGE_ZH) {
         _key_wifi[wifi_num]->CanvasNormal()->drawString("刷新", 58, 35);
-    }
-    else
-    {
+     } else {
         _key_wifi[wifi_num]->CanvasNormal()->drawString("Refresh", 58, 35);
     }
     *(_key_wifi[wifi_num]->CanvasPressed()) = *(_key_wifi[wifi_num]->CanvasNormal());
@@ -245,8 +201,7 @@ int Frame_WifiScan::scan()
     return 0;
 }
 
-void Frame_WifiScan::Connect()
-{
+void Frame_WifiScan::Connect() {
     int anime_cnt = 0;
     int x = 532 - 15 - 32;
     int y = _connect_key->getY() + 14;
@@ -260,34 +215,26 @@ void Frame_WifiScan::Connect()
     WiFi.disconnect();
     WiFi.begin(_connect_ssid.c_str(), _connect_password.c_str());
     uint32_t start_time = millis();
-    while (WiFi.status() != WL_CONNECTED)
-    {
+    while (WiFi.status() != WL_CONNECTED) {
         loading.pushImage(0, 0, 32, 32, GetLoadingIMG_32x32(anime_cnt));
         loading.pushCanvas(x, y, UPDATE_MODE_DU4);
         anime_cnt++;
-        if(anime_cnt == 16)
-        {
+        if(anime_cnt == 16) {
             anime_cnt = 0;
         }
 
-        if (millis() - start_time > 10000)
-        {
+        if (millis() - start_time > 10000) {
             M5EPD_Canvas err(&M5.EPD);
             err.createCanvas(300, 100);
             err.fillCanvas(15);
             err.setTextSize(26);
             err.setTextColor(0);
             err.setTextDatum(CC_DATUM);
-            if(_language == LANGUAGE_JA)
-            {
+            if(_language == LANGUAGE_JA) {
                 err.drawString("パスワードが違います", 150, 55);
-            }
-            else if(_language == LANGUAGE_ZH)
-            {
+             } else if(_language == LANGUAGE_ZH) {
                 err.drawString("密码错误", 150, 55);
-            }
-            else
-            {
+             } else {
                 err.drawString("Wrong password", 150, 55);
             }
             err.pushCanvas(120, 430, UPDATE_MODE_GL16);
@@ -295,8 +242,7 @@ void Frame_WifiScan::Connect()
         }
     }
 
-    for(int i = 1; i < MAX_BTN_NUM; i++)
-    {
+    for(int i = 1; i < MAX_BTN_NUM; i++) {
         _key_wifi[i]->SetPos(_key_wifi[i]->getX(), _key_wifi[i]->getY() + 32);
     }
 
@@ -304,8 +250,7 @@ void Frame_WifiScan::Connect()
     
     _key_wifi[0]->SetEnable(false);
     _key_wifi[0]->SetHide(false);
-    if(_connect_key != _key_wifi[0])
-    {
+    if(_connect_key != _key_wifi[0]) {
          *(_key_wifi[0]->CanvasNormal()) = *(_connect_key->CanvasNormal());
         *(_key_wifi[0]->CanvasPressed()) = *(_connect_key->CanvasNormal());
         _key_wifi[0]->CanvasPressed()->ReverseColor();
@@ -319,12 +264,10 @@ void Frame_WifiScan::Connect()
     scan();
 }
 
-void Frame_WifiScan::SetConnected(String ssid, int rssi)
-{
+void Frame_WifiScan::SetConnected(String ssid, int rssi) {
     _connect_ssid = ssid;
     DrawItem(_key_wifi[0], ssid, rssi);
-    for(int i = 1; i < MAX_BTN_NUM; i++)
-    {
+    for(int i = 1; i < MAX_BTN_NUM; i++) {
         _key_wifi[i]->SetPos(_key_wifi[i]->getX(), _key_wifi[i]->getY() + 32);
     }    
     _key_wifi[0]->SetEnable(false);
@@ -332,35 +275,28 @@ void Frame_WifiScan::SetConnected(String ssid, int rssi)
     _connected = 1;
 }
 
-int Frame_WifiScan::init(epdgui_args_vector_t &args)
-{
+int Frame_WifiScan::init(epdgui_args_vector_t &args) {
     _is_run = 1;
     _connect = false;
     M5.EPD.WriteFullGram4bpp(GetWallpaper());
     _canvas_title->pushCanvas(0, 8, UPDATE_MODE_NONE);
-    if(args.size() > 0)
-    {
+    if(args.size() > 0) {
         String *password = (String*)(args[0]);
         _connect_password = *password;
         delete password;
         args.pop_back();
 
-        for(int i = 0; i < MAX_BTN_NUM; i++)
-        {
+        for(int i = 0; i < MAX_BTN_NUM; i++) {
             EPDGUI_AddObject(_key_wifi[i]);
         }
         _update_flag = false;
         _connect = true;
-    }
-    else
-    {
-        for(int i = 0; i < MAX_BTN_NUM; i++)
-        {
+     } else {
+        for(int i = 0; i < MAX_BTN_NUM; i++) {
             _key_wifi[i]->SetHide(true);
             EPDGUI_AddObject(_key_wifi[i]);
         }
-        if(_connected)
-        {
+        if(_connected) {
             _key_wifi[0]->SetHide(false);
         }
         _update_flag = true;

src/frame/frame_wifiscan.h

@@ -4,8 +4,7 @@
 #include "frame_base.h"
 #include "../epdgui/epdgui.h"
 
-class Frame_WifiScan : public Frame_Base
-{
+class Frame_WifiScan : public Frame_Base {
 public:
     Frame_WifiScan();
     ~Frame_WifiScan();

src/global_setting.cpp

@@ -7,13 +7,12 @@
 SemaphoreHandle_t _xSemaphore_LoadingAnime = NULL;
 static uint8_t _loading_anime_eixt_flag = false;
 esp_err_t __espret__;
-#define NVS_CHECK(x)              \
-    __espret__ = x;           \
-    if (__espret__ != ESP_OK) \
-    {                         \
-        nvs_close(nvs_arg);   \
-        log_e("Check Err");   \
-        return __espret__;    \
+#define NVS_CHECK(x)            \
+    __espret__ = x;             \
+    if (__espret__ != ESP_OK) { \
+        nvs_close(nvs_arg);     \
+        log_e("Check Err");     \
+        return __espret__;      \
     }
 
 const uint8_t *wallpapers[] = {
@@ -67,82 +66,66 @@ uint8_t global_init_status = 0xFF;
 int8_t global_timezone = 8;
 
 
-int8_t GetTimeZone(void)
-{
+int8_t GetTimeZone(void) {
     return global_timezone;
 }
 
-void SetTimeZone(int8_t time_zone)
-{
+void SetTimeZone(int8_t time_zone) {
     global_timezone = time_zone;
 }
 
-void SetInitStatus(uint8_t idx, uint8_t val)
-{
+void SetInitStatus(uint8_t idx, uint8_t val) {
     global_init_status &= ~(1 << idx);
     global_init_status |= (val << idx);
 }
 
-uint8_t GetInitStatus(uint8_t idx)
-{
+uint8_t GetInitStatus(uint8_t idx) {
     return (global_init_status & (1 << idx)) ? true : false;
 }
 
-void SetTTFLoaded(uint8_t val)
-{
+void SetTTFLoaded(uint8_t val) {
     global_ttf_file_loaded = val;
 }
 
-uint8_t isTTFLoaded()
-{
+uint8_t isTTFLoaded() {
     return global_ttf_file_loaded;
 }
 
-uint8_t isTimeSynced(void)
-{
+uint8_t isTimeSynced(void) {
     return global_time_synced;
 }
 
-void SetTimeSynced(uint8_t val)
-{
+void SetTimeSynced(uint8_t val) {
     global_time_synced = val;
     SaveSetting();
 }
 
-void SetLanguage(uint8_t language)
-{
-    if (language >= LANGUAGE_EN && language <= LANGUAGE_ZH)
-    {
+void SetLanguage(uint8_t language) {
+    if (language >= LANGUAGE_EN && language <= LANGUAGE_ZH) {
         global_language = language;
     }
     SaveSetting();
 }
 
-uint8_t GetLanguage(void)
-{
+uint8_t GetLanguage(void) {
     return global_language;
 }
 
-void SetWallpaper(uint16_t wallpaper_id)
-{
+void SetWallpaper(uint16_t wallpaper_id) {
     global_wallpaper = wallpaper_id;
     SaveSetting();
 }
 
-uint16_t GetWallpaperID(void)
-{
+uint16_t GetWallpaperID(void) {
     return global_wallpaper;
 }
 
-const uint8_t *GetWallpaper(void)
-{
+const uint8_t *GetWallpaper(void) {
     return wallpapers[global_wallpaper];
 }
 
-const char *GetWallpaperName(uint16_t wallpaper_id)
-{
-    switch (global_language)
-    {
+const char *GetWallpaperName(uint16_t wallpaper_id) {
+    switch (global_language) {
     case LANGUAGE_ZH:
         return wallpapers_name_zh[wallpaper_id];
     case LANGUAGE_JA:
@@ -152,8 +135,7 @@ const char *GetWallpaperName(uint16_t wallpaper_id)
     }
 }
 
-esp_err_t LoadSetting(void)
-{
+esp_err_t LoadSetting(void) {
     nvs_handle nvs_arg;
     NVS_CHECK(nvs_open("Setting", NVS_READONLY, &nvs_arg));
     NVS_CHECK(nvs_get_u16(nvs_arg, "Wallpaper", &global_wallpaper));
@@ -161,8 +143,7 @@ esp_err_t LoadSetting(void)
     NVS_CHECK(nvs_get_u8(nvs_arg, "Timesync", &global_time_synced));
     nvs_get_i8(nvs_arg, "timezone", &global_timezone);
 
-    if(global_wallpaper >= WALLPAPER_NUM)
-    {
+    if(global_wallpaper >= WALLPAPER_NUM) {
         global_wallpaper = DEFAULT_WALLPAPER;
     }
     
@@ -178,8 +159,7 @@ esp_err_t LoadSetting(void)
     return ESP_OK;
 }
 
-esp_err_t SaveSetting(void)
-{
+esp_err_t SaveSetting(void) {
     nvs_handle nvs_arg;
     NVS_CHECK(nvs_open("Setting", NVS_READWRITE, &nvs_arg));
     NVS_CHECK(nvs_set_u16(nvs_arg, "Wallpaper", global_wallpaper));
@@ -193,36 +173,30 @@ esp_err_t SaveSetting(void)
     return ESP_OK;
 }
 
-void SetWifi(String ssid, String password)
-{
+void SetWifi(String ssid, String password) {
     global_wifi_ssid = ssid;
     global_wifi_password = password;
     SaveSetting();
 }
 
-uint8_t isWiFiConfiged(void)
-{
+uint8_t isWiFiConfiged(void) {
     return global_wifi_configed;
 }
 
-String GetWifiSSID(void)
-{
+String GetWifiSSID(void) {
     return global_wifi_ssid;
 }
 
-String GetWifiPassword(void)
-{
+String GetWifiPassword(void) {
     return global_wifi_password;
 }
 
-bool SyncNTPTime(void)
-{
+bool SyncNTPTime(void) {
     const char *ntpServer = "time.cloudflare.com";
     configTime(global_timezone * 3600, 0, ntpServer);
 
     struct tm timeInfo;
-    if (getLocalTime(&timeInfo))
-    {
+    if (getLocalTime(&timeInfo)) {
         rtc_time_t time_struct;
         time_struct.hour = timeInfo.tm_hour;
         time_struct.min = timeInfo.tm_min;
@@ -241,23 +215,19 @@ bool SyncNTPTime(void)
     return 0;
 }
 
-uint16_t GetTextSize()
-{
+uint16_t GetTextSize() {
     return global_reader_textsize;
 }
 
-void SetTextSize(uint16_t size)
-{
+void SetTextSize(uint16_t size) {
     global_reader_textsize = size;
 }
 
-const uint8_t* GetLoadingIMG_32x32(uint8_t id)
-{
+const uint8_t* GetLoadingIMG_32x32(uint8_t id) {
     return kIMGLoading[id];
 }
 
-void __LoadingAnime_32x32(void *pargs)
-{
+void __LoadingAnime_32x32(void *pargs) {
     uint16_t *args = (uint16_t *)pargs;
     uint16_t x = args[0];
     uint16_t y = args[1];
@@ -268,23 +238,19 @@ void __LoadingAnime_32x32(void *pargs)
     loading.pushCanvas(x, y, UPDATE_MODE_GL16);
     int anime_cnt = 0;
     uint32_t time = 0;
-    while (1)
-    {
-        if(millis() - time > 200)
-        {
+    while (1) {
+        if(millis() - time > 200) {
             time = millis();
             loading.pushImage(0, 0, 32, 32, GetLoadingIMG_32x32(anime_cnt));
             loading.pushCanvas(x, y, UPDATE_MODE_DU4);
             anime_cnt++;
-            if(anime_cnt == 16)
-            {
+            if(anime_cnt == 16) {
                 anime_cnt = 0;
             }
         }
 
         xSemaphoreTake(_xSemaphore_LoadingAnime, portMAX_DELAY);
-        if(_loading_anime_eixt_flag == true)
-        {
+        if(_loading_anime_eixt_flag == true) {
             xSemaphoreGive(_xSemaphore_LoadingAnime);
             break;
         }
@@ -293,10 +259,8 @@ void __LoadingAnime_32x32(void *pargs)
     vTaskDelete(NULL);
 }
 
-void LoadingAnime_32x32_Start(uint16_t x, uint16_t y)
-{
-    if(_xSemaphore_LoadingAnime == NULL)
-    {
+void LoadingAnime_32x32_Start(uint16_t x, uint16_t y) {
+    if(_xSemaphore_LoadingAnime == NULL) {
         _xSemaphore_LoadingAnime = xSemaphoreCreateMutex();
     }
     _loading_anime_eixt_flag = false;
@@ -306,8 +270,7 @@ void LoadingAnime_32x32_Start(uint16_t x, uint16_t y)
     xTaskCreatePinnedToCore(__LoadingAnime_32x32, "__LoadingAnime_32x32", 16 * 1024, pos, 1, NULL, 0);
 }
 
-void LoadingAnime_32x32_Stop()
-{
+void LoadingAnime_32x32_Stop() {
     xSemaphoreTake(_xSemaphore_LoadingAnime, portMAX_DELAY);
     _loading_anime_eixt_flag = true;
     xSemaphoreGive(_xSemaphore_LoadingAnime);

src/global_setting.h

@@ -7,8 +7,7 @@
 
 #define WALLPAPER_NUM 3
 
-enum
-{
+enum {
     LANGUAGE_EN = 0,    // default, English
     LANGUAGE_JA, // Japanese
     LANGUAGE_ZH // Simplified Chinese

src/main.cpp

@@ -3,8 +3,7 @@
 #include "frame/frame.h"
 #include "systeminit.h"
 
-void setup()
-{
+void setup() {
     pinMode(M5EPD_MAIN_PWR_PIN, OUTPUT);
     M5.enableMainPower();
 
@@ -12,7 +11,6 @@ void setup()
 }
 
 
-void loop()
-{
+void loop() {
     EPDGUI_MainLoop();
 }

src/systeminit.cpp

@@ -8,22 +8,18 @@
 
 QueueHandle_t xQueue_Info = xQueueCreate(20, sizeof(uint32_t));
 
-void WaitForUser(void)
-{
+void WaitForUser(void) {
     SysInit_UpdateInfo("$ERR");
-    while(1)
-    {
+    while(1) {
         M5.update();
-        if(M5.BtnP.wasReleased())
-        {
+        if(M5.BtnP.wasReleased()) {
             SysInit_UpdateInfo("$RESUME");
             return;
         }
     }
 }
 
-void SysInit_Start(void)
-{
+void SysInit_Start(void) {
     bool ret = false;
     Serial.begin(115200);
     Serial.flush();
@@ -54,22 +50,18 @@ void SysInit_Start(void)
     bool is_factory_test;
     SPI.begin(14, 13, 12, 4);
     ret = SD.begin(4, SPI, 20000000);
-    if(ret == false)
-    {
+    if(ret == false) {
         is_factory_test = true;
         SetInitStatus(0, 0);
         // log_e("Failed to initialize SD card.");
         // SysInit_UpdateInfo("[ERROR] Failed to initialize SD card.");
         // WaitForUser();
-    }
-    else
-    {
+     } else {
         is_factory_test = SD.exists("/__factory_test_flag__");
     }
 
     SysInit_UpdateInfo("Initializing Touch pad...");
-    if(M5.TP.begin(21, 22, 36) != ESP_OK)
-    {
+    if(M5.TP.begin(21, 22, 36) != ESP_OK) {
         SetInitStatus(1, 0);
         log_e("Touch pad initialization failed.");
         SysInit_UpdateInfo("[ERROR] Failed to initialize Touch pad.");
@@ -80,25 +72,19 @@ void SysInit_Start(void)
     LoadSetting();
     
     M5EPD_Canvas _initcanvas(&M5.EPD);
-    if((!is_factory_test) && SD.exists("/font.ttf"))
-    {
+    if((!is_factory_test) && SD.exists("/font.ttf")) {
         _initcanvas.loadFont("/font.ttf", SD);
         SetTTFLoaded(true);
-    }
-    else
-    {
+     } else {
         _initcanvas.loadFont(binaryttf, sizeof(binaryttf));
         SetTTFLoaded(false);
         SetLanguage(LANGUAGE_EN);
         is_factory_test = true;
     }
 
-    if(is_factory_test)
-    {
+    if(is_factory_test) {
         SysInit_UpdateInfo("$OK");
-    }
-    else
-    {
+     } else {
         SysInit_UpdateInfo("Initializing system...");
     }
 
@@ -108,8 +94,7 @@ void SysInit_Start(void)
     EPDGUI_PushFrame(frame_main);
     Frame_FactoryTest *frame_factorytest = new Frame_FactoryTest();
     EPDGUI_AddFrame("Frame_FactoryTest", frame_factorytest);
-    if(!is_factory_test)
-    {
+    if(!is_factory_test) {
         Frame_Setting *frame_setting = new Frame_Setting();
         EPDGUI_AddFrame("Frame_Setting", frame_setting);
         Frame_Setting_Wallpaper *frame_wallpaper = new Frame_Setting_Wallpaper();
@@ -129,20 +114,16 @@ void SysInit_Start(void)
         Frame_Home *frame_home = new Frame_Home();
         EPDGUI_AddFrame("Frame_Home", frame_home);
 
-        if(isWiFiConfiged())
-        {
+        if(isWiFiConfiged()) {
             SysInit_UpdateInfo("Connect to " + GetWifiSSID() + "...");
             WiFi.begin(GetWifiSSID().c_str(), GetWifiPassword().c_str());
             uint32_t t = millis();
-            while (1)
-            {
-                if(millis() - t > 8000)
-                {
+            while (1) {
+                if(millis() - t > 8000) {
                     break;
                 }
 
-                if(WiFi.status() == WL_CONNECTED)
-                {
+                if(WiFi.status() == WL_CONNECTED) {
                     frame_wifiscan->SetConnected(GetWifiSSID(), WiFi.RSSI());
                     break;
                 }
@@ -154,8 +135,7 @@ void SysInit_Start(void)
 
     while(uxQueueMessagesWaiting(xQueue_Info));
     
-    if(!is_factory_test)
-    {
+    if(!is_factory_test) {
         SysInit_UpdateInfo("$OK");
     }
     
@@ -164,8 +144,7 @@ void SysInit_Start(void)
     delay(500);
 }
 
-void SysInit_Loading(void *pvParameters)
-{
+void SysInit_Loading(void *pvParameters) {
     const uint16_t kPosy = 548;
     const uint8_t *kLD[] = {
         ImageResource_loading_01_96x96,
@@ -200,51 +179,39 @@ void SysInit_Loading(void *pvParameters)
     int i = 0;
     char *p;
     uint32_t time = 0;
-    while (1)
-    {
-        if(millis() - time > 250)
-        {
+    while (1) {
+        if(millis() - time > 250) {
             time = millis();
             LoadingIMG.pushImage(0, 0, 96, 96, kLD[i]);
             LoadingIMG.pushCanvas(220, kPosy + 80, UPDATE_MODE_DU4);
             i++;
-            if (i == 16)
-            {
+            if (i == 16) {
                 i = 0;
             }
         }
         
-        if(xQueueReceive(xQueue_Info, &p, 0))
-        {
+        if(xQueueReceive(xQueue_Info, &p, 0)) {
             String str(p);
             free(p);
-            if(str.indexOf("$OK") >= 0)
-            {
+            if(str.indexOf("$OK") >= 0) {
                 LoadingIMG.pushImage(0, 0, 96, 96, ImageResource_loading_success_96x96);
                 LoadingIMG.pushCanvas(220, kPosy + 80, UPDATE_MODE_GL16);
                 break;
-            }
-            else if(str.indexOf("$ERR") >= 0)
-            {
+             } else if(str.indexOf("$ERR") >= 0) {
                 LoadingIMG.pushImage(0, 0, 96, 96, ImageResource_loading_error_96x96);
                 LoadingIMG.pushCanvas(220, kPosy + 80, UPDATE_MODE_GL16);
                 LoadingIMG.fillCanvas(0);
-                while(1)
-                {
-                    if(xQueueReceive(xQueue_Info, &p, 0))
-                    {
+                while(1) {
+                    if(xQueueReceive(xQueue_Info, &p, 0)) {
                         String str(p);
                         free(p);
-                        if(str.indexOf("$RESUME") >= 0)
-                        {
+                        if(str.indexOf("$RESUME") >= 0) {
                             LoadingIMG.pushCanvas(220, kPosy + 80, UPDATE_MODE_GC16);
                             break;
                         }
                     }
                 }
-            }
-            else
-            {
+             } else {
                 Info.fillCanvas(0);
                 Info.drawString(str, 270, 20);
                 Info.pushCanvas(0, kPosy, UPDATE_MODE_DU);
@@ -254,13 +221,11 @@ void SysInit_Loading(void *pvParameters)
     vTaskDelete(NULL);
 }
 
-void SysInit_UpdateInfo(String info)
-{
+void SysInit_UpdateInfo(String info) {
     char *p = (char*)malloc(info.length() + 1);
     memcpy(p, info.c_str(), info.length());
     p[info.length()] = '\0';
-    if(xQueueSend(xQueue_Info, &p, 0) == 0)
-    {
+    if(xQueueSend(xQueue_Info, &p, 0) == 0) {
         free(p);
     }
 }