View difference between Paste ID: ciqWynfA and mwKEhfr4

 #include <MI0283QT2.h>
 #include <ADS7846.h>
 #include <fonts.h>
 
 #include "lcdGUI.h"
 
 #ifdef BUTTON
 #ifndef lcdGUI_BUTTON
 #define lcdGUI_BUTTON
 void Gui::addButton(uint16_t _left, uint16_t _top, uint16_t _width, uint16_t _height, char * _caption, uint8_t _size,uint8_t _id)
 {
   Button * btn = (Button*)malloc(sizeof(Button));
 
   if(btn != NULL)
   {
     btn->next          = NULL;
     btn->x             = _left;
     btn->y             = _top;
     btn->width         = _width;
     btn->height        = _height;
     btn->size          = _size;
 
     if (strlen(_caption) == 0)
       btn->text = NULL;
     else
     {
       btn->text = (char *)malloc(strlen(_caption) + 1);
       if (btn->text != NULL)
         strcpy(btn->text, _caption);
     }
 
     btn->id            = _id;
 
     if (btnPtr == NULL)
       btnPtr = btn;
     else
       lastBtnPtr->next = btn;
 
     lastBtnPtr = btn;
   }
   btn->draw(lcd, false);
 }
 #endif
 #endif
 
 #ifndef lcdGUI_cpp
 #define lcdGUI_cpp
 
 void buttonPressed(Button*);
 void buttonReleased(Button*);
 void sliderValueChanged(Slider*);
 
 Gui::Gui(lcdPtr _lcd, tpPtr _tp)
 {
   lcd = _lcd;
   tp = _tp;
 }
 
 void Gui::addTextbox(uint16_t X, uint16_t Y, uint16_t W, char * T, char * DFT, uint8_t S, uint8_t ID)
 {
   TextBox * txtBox = (TextBox*)malloc(sizeof(TextBox));
 
   if(txtBox != NULL)
   {
     txtBox->x = X;
     txtBox->y = Y;
     txtBox->width = W;
     txtBox->id = ID;
     txtBox->size = S;
     txtBox->next = NULL;
   }
 
   if(strlen(T) == 0)
     txtBox->text = NULL;
   else
   {
     txtBox->text = (char*)malloc(strlen(T)+1);
     if(txtBox->text != NULL)
       strcpy(txtBox->text, T);
   }
 
   if(strlen(DFT) == 0)
     txtBox->defaultText = NULL;
   else
   {
     txtBox->defaultText = (char*)malloc(strlen(DFT)+1);
     if(txtBox->defaultText != NULL)
       strcpy(txtBox->defaultText, DFT);
   }
 
   if(txtPtr == NULL)
     txtPtr = txtBox;
   else
     lastTxtPtr->next = txtBox;
 
   lastTxtPtr = txtBox;
 
   txtBox->draw(lcd, false);
 }
 
 void Gui::addSlider(uint16_t X, uint16_t Y, uint16_t W, uint16_t H, float V, uint8_t ID)
 {
   Slider * sld = (Slider*)malloc(sizeof(Slider));
 
   if(sld != NULL)
   {
     sld->x = X;
     sld->y = Y;
     sld->width = W;
     sld->height = H;
     sld->value = V;
     sld->id = ID;
     sld->next = NULL;
   }
 
   if(sldPtr == NULL)
     sldPtr = sld;
   else
     lastSldPtr->next = sld;
 
   lastSldPtr = sld;
   sld->draw(lcd, false);
 }
 
 void Gui::addStatusBar(char * T, uint8_t S)
 {
   if(statBarPtr == NULL)
   {
     StatusBar * stbr = (StatusBar*)malloc(sizeof(StatusBar));
     if(stbr != NULL)
     {
       if(strlen(T) == NULL)
         return;
       else
       {
         stbr->size = S;
         stbr->text = (char*)malloc(strlen(T)+1);
         if(stbr->text != NULL)
           strcpy(stbr->text, T);
       }
     }
     statBarPtr = stbr;
     stbr->draw(lcd);
   }
 }
 
 void Gui::addCheckbox(uint16_t X, uint16_t Y, char * T, bool A, uint8_t ID)
 {
   CheckBox * chk = (CheckBox*)malloc(sizeof(CheckBox));
 
   if(chk != NULL)
   {
     chk->x = X;
     chk->y = Y;
     chk->isActive = A;
     chk->next = NULL;
     chk->id = ID;
     if(strlen(T) == 0)
       chk->text = NULL;
     else
     {
       chk->text  = (char*)malloc(strlen(T)+1);
       if(chk->text != NULL)
         strcpy(chk->text, T);
     }
     if(chkPtr == NULL)
       chkPtr = chk;
     else
       lastChkPtr->next = chk;
 
     lastChkPtr = chk;
 
     chk->draw(lcd, false);
   }
 }
 
 void Gui::service(bool draw)
 {
   if(draw)
   {
     lcd->clear(COLOR_BG);
 
     //draw statusbar
     if(statBarPtr != NULL)
       statBarPtr->draw(lcd);
     //draw buttons
     Button * tmpBtnPtr = btnPtr;
     while(tmpBtnPtr != NULL)
     {
       tmpBtnPtr->draw(lcd, false);
       tmpBtnPtr = tmpBtnPtr->next;
     }
     //draw textboxes
     TextBox * tmpTxtPtr = txtPtr;
     while(tmpTxtPtr != NULL)
     {
       tmpTxtPtr->draw(lcd, false);
       tmpTxtPtr = tmpTxtPtr->next;
     }
     //draw sliders
     Slider * tmpSldPtr = sldPtr;
     while(tmpSldPtr != NULL)
     {
       tmpSldPtr->draw(lcd, false);
       tmpSldPtr = tmpSldPtr->next;
     }
     //draw checkboxes
     CheckBox * tmpChkPtr = chkPtr;
     while(tmpChkPtr != NULL)
     {
       tmpChkPtr->draw(lcd, false);
       tmpChkPtr = tmpChkPtr->next;
     }
   }
 
   //check buttons
   tp->service();
 
   uint8_t currPress = tp->getPressure();
 
   if(currPress > MIN_PRESSURE)
   {
     //check buttons
     Button * btn = buttonFromPos(tp->getX(), tp->getY());
     if(lastBtnPressed != btn && lastBtnPressed != NULL)
     {
       lastBtnPressed->draw(lcd, false);
       if(lastBtnPressed == buttonFromPos(tp->getX(), tp->getY()))
         buttonReleased(lastBtnPressed);
       lastBtnPressed = NULL;
     }
     if(btn != NULL && btn != lastBtnPressed)
     {
       btn->draw(lcd, true);
       lastBtnPressed = btn;
       buttonPressed(btn);
     }
 
     //check textboxes
     TextBox * txt = textboxFromPos(tp->getX(), tp->getY());
     if(lastTxtPressed != txt && lastTxtPressed != NULL)
     {
       lastTxtPressed->draw(lcd, false);
       lastTxtPressed = NULL;
     }
     if(txt != NULL && txt != lastTxtPressed)
     {
       txt->draw(lcd, true);
       lastTxtPressed = txt;
     }
 
     //check sliders
     Slider * sld = sliderFromPos(tp->getX(), tp->getY());
     if(sld != NULL)
     {
       float oldVal = sld->value;
       sld->value = (float)(tp->getX()-sld->x)/sld->width*1024;
       if(oldVal != sld->value)
         sliderValueChanged(sld);
     }
     if(lastSldPressed != sld && lastSldPressed != NULL)
     {
       lastSldPressed->draw(lcd, false);
       lastSldPressed = NULL;
     }
     if(sld != NULL && sld != lastSldPressed)
     {
       sld->draw(lcd, true);
       lastSldPressed = sld;
     }
     if(sld != NULL && sld == lastSldPressed)
       sld->draw(lcd, true);
 
     //check checkboxes
     CheckBox * chk = checkboxFromPos(tp->getX(), tp->getY());
     if(lastChkPressed != chk && lastChkPressed != NULL)
     {
       lastChkPressed->draw(lcd, false);
       lastChkPressed = NULL;
     }
     if(chk != NULL && chk != lastChkPressed)
     {
       chk->isActive = !chk->isActive;
       chk->draw(lcd, true);
       lastChkPressed = chk;
     }
 
   }
   else
   {
     //deselect selected buttons
     if(lastBtnPressed != NULL)
     {
       buttonReleased(lastBtnPressed);
       lastBtnPressed->draw(lcd, false);
       lastBtnPressed = NULL;
     }
     //deselect selected sliders
     if(lastSldPressed != NULL)
     {
       lastSldPressed->draw(lcd, false);
       lastSldPressed = NULL;
     }
 
     if(lastChkPressed != NULL)
     {
       lastChkPressed->draw(lcd, false);
       lastChkPressed = NULL;
     }
   }
 }
 
 void Gui::service()
 {
   service(false);
 }
 
 void Gui::refresh()
 {
   service(true);
 }
 
 void Gui::deleteButton(Button * _button)
 {
   if (_button != NULL)
   {
     lcd->fillRect(_button->x, _button->y, _button->x + _button->width, _button->y + _button->height, COLOR_BG);
 
     Button * btn  = btnPtr;
     Button * prev = NULL;
     while (btn != NULL)
     {
       if (btn == _button)
       {
         if (prev == NULL)
           btnPtr = btn->next;
         else
           prev->next = btn->next;
 
         if (btn->text != NULL)
           free(btn->text);
 
         free(btn);
         return;
       }
       prev = btn;
       btn  = btn->next;
     }
   }
 }
 
 void Gui::deleteTextbox(TextBox * txt)
 {
   if (txt != NULL)
   {
     lcd->fillRect(txt->x, txt->y, txt->x + txt->width, txt->y + FONT_HEIGHT+4, COLOR_BG);
 
     TextBox * tmpTxtPtr  = txtPtr;
     TextBox * prev = NULL;
     while (tmpTxtPtr != NULL)
     {
       if (tmpTxtPtr == txt)
       {
         if (prev == NULL)
           txtPtr = tmpTxtPtr->next;
         else
           prev->next = tmpTxtPtr->next;
 
         if (tmpTxtPtr->text != NULL)
           free(tmpTxtPtr->text);
         if(tmpTxtPtr->defaultText != NULL)
           free(tmpTxtPtr->defaultText);
 
         free(tmpTxtPtr);
         return;
       }
       prev = tmpTxtPtr;
       tmpTxtPtr  = tmpTxtPtr->next;
     }
   }
 }
 
 void Gui::deleteSlider(Slider * sld)
 {
   if (sld != NULL)
   {
     lcd->fillRect(sld->x, sld->y, sld->x + sld->width, sld->y + sld->height, COLOR_BG);
 
     Slider * tmpSldPtr  = sldPtr;
     Slider * prev = NULL;
     while (tmpSldPtr != NULL)
     {
       if (tmpSldPtr == sld)
       {
         if (prev == NULL)
           sldPtr = tmpSldPtr->next;
         else
           prev->next = tmpSldPtr->next;
 
         free(tmpSldPtr);
         return;
       }
       prev = tmpSldPtr;
       tmpSldPtr  = tmpSldPtr->next;
     }
   }
 }
 
 void Gui::deleteStatusbar()
 {
   if(statBarPtr != NULL)
   {
     lcd->fillRect(0,0,lcd->getWidth(),statBarPtr->size*FONT_HEIGHT+4,COLOR_BG);
     free(statBarPtr->text);
     free(statBarPtr);
     statBarPtr = NULL;
   }
 }
 
 void Gui::deleteCheckbox(CheckBox * chk)
 {
   if (chk != NULL)
   {
     lcd->fillRect(chk->x, chk->y, chk->x + strlen(chk->text)*FONT_WIDTH+FONT_HEIGHT+10, chk->y + FONT_HEIGHT+4, COLOR_BG);
 
     CheckBox * tmpChkPtr  = chkPtr;
     CheckBox * prev = NULL;
     while (tmpChkPtr != NULL)
     {
       if (tmpChkPtr == chk)
       {
         if (prev == NULL)
           chkPtr = tmpChkPtr->next;
         else
           prev->next = tmpChkPtr->next;
 
         if (tmpChkPtr->text != NULL)
           free(tmpChkPtr->text);
 
         free(tmpChkPtr);
         return;
       }
       prev = tmpChkPtr;
       tmpChkPtr  = tmpChkPtr->next;
     }
   }
 }
 
 Button * Gui::buttonFromId(uint8_t _id)
 {
   Button * btn = btnPtr;
 
   while (btn != NULL)
   {
     if (btn->id == _id)
         return btn;
     btn = (Button*)btn->next;
   }
   return NULL;
 }
 
 TextBox * Gui::textboxFromId(uint8_t _id)
 {
   TextBox * txt = txtPtr;
 
   while (txt != NULL)
   {
     if (txt->id == _id)
         return txt;
     txt = (TextBox*)txt->next;
   }
   return NULL;
 }
 
 Slider * Gui::sliderFromId(uint8_t _id)
 {
   Slider * sld = sldPtr;
 
   while (sld != NULL)
   {
     if (sld->id == _id)
         return sld;
     sld = (Slider*)sld->next;
   }
   return NULL;
 }
 
 CheckBox * Gui::checkboxFromId(uint8_t _id)
 {
   CheckBox * chk = chkPtr;
 
   while (chk != NULL)
   {
     if (chk->id == _id)
         return chk;
     chk = (CheckBox*)chk->next;
   }
   return NULL;
 }
 
 Button * Gui::buttonFromPos(uint16_t _x, uint16_t _y)
 {
   Button * btn = (Button*)btnPtr;
   while (btn != NULL)
   {
     if ((_x >= btn->x) && (_x < btn->x + btn->width) &&
         (_y >= btn->y)  && (_y < btn->y  + btn->height))
     {
       return btn;
     }
     btn = (Button*)btn->next;
   }
   return NULL;
 }
 
 TextBox * Gui::textboxFromPos(uint16_t _x, uint16_t _y)
 {
   TextBox * txt = (TextBox*)txtPtr;
   while (txt != NULL)
   {
     uint16_t height = FONT_HEIGHT*txt->size+4;
     if ((_x >= txt->x) && (_x < txt->x + txt->width) &&
         (_y >= txt->y)  && (_y < txt->y  + height))
     {
       return txt;
     }
     txt = (TextBox*)txt->next;
   }
   return NULL;
 }
 
 Slider * Gui::sliderFromPos(uint16_t _x, uint16_t _y)
 {
   Slider * sld = sldPtr;
   while (sld != NULL)
   {
     if ((_x >= sld->x) && (_x < sld->x + sld->width) &&
         (_y >= sld->y)  && (_y < sld->y  + sld->height))
     {
       return sld;
     }
     sld = sld->next;
   }
   return NULL;
 }
 
 CheckBox * Gui::checkboxFromPos(uint16_t _x, uint16_t _y)
 {
   CheckBox * chk = chkPtr;
   while (chk != NULL)
   {
     if ((_x >= chk->x) && (_x < chk->x + strlen(chk->text)*FONT_WIDTH+FONT_HEIGHT+10) &&
         (_y >= chk->y)  && (_y < chk->y  + FONT_HEIGHT+2))
     {
       return chk;
     }
     chk = chk->next;
   }
   return NULL;
 }
 
 
 /*
 --------------------------------------------
 BUTTON
 --------------------------------------------
 */
 
 void Button::draw(lcdPtr lcd, bool isDown)
 {
   uint16_t clr = (isDown) ? COLOR_BUTTON_PRESSED : COLOR_BUTTON;
   uint16_t clrUpLine = (isDown) ? COLOR_BUTTON_PRESSED_UPPERLINE : COLOR_BUTTON_UPPERLINE;
   uint16_t clrLwLine = (isDown) ? COLOR_BUTTON_PRESSED_LOWERLINE : COLOR_BUTTON_LOWERLINE;
   lcd->fillRect(x, y+1, x + width, y + height-1, clr);
   lcd->drawLine(x+1,y,x+width-1,y,clrUpLine);
   lcd->drawLine(x+1,y+height,x+width-1,y+height,clrLwLine);
   lcd->drawText(x + (width-strlen(text)*FONT_WIDTH*size)/2, y + (height-FONT_HEIGHT*size)/2, text, size, COLOR_BUTTON_TEXT, clr);
 }
 
 /*
 --------------------------------------------
 TEXTBOX
 --------------------------------------------
 */
 
 void TextBox::draw(lcdPtr lcd, bool isDown)
 {
   uint16_t clr = (isDown) ? COLOR_TEXTBOX_PRESSED : COLOR_TEXTBOX;
   uint8_t height = FONT_HEIGHT*size+4;
 
   lcd->drawLine(x,y+height-3,x,y+height,clr);
   lcd->drawLine(x+width,y+height-3,x+width,y+height,clr);
   lcd->drawLine(x,y+height-1,x+width,y+height-1,clr);
   if(isDown)
     lcd->drawLine(x,y+height,x+width,y+height,clr);
   else
     lcd->drawLine(x,y+height,x+width,y+height,COLOR_BG);
 
   char * content = (text == NULL) ? defaultText : text;
 
   char * tmpTxt = "";
   for(int i=0; i<width/(FONT_WIDTH*size); i++)
     strcat(tmpTxt, " ");
 
   content = (isDown) ? tmpTxt : content;
 
   uint16_t clrTxt = (text == NULL) ? COLOR_TEXTBOX_TEXT_DEFAULT : COLOR_TEXTBOX_TEXT;
 
   if(strlen(content)*FONT_WIDTH*size < width)
     lcd->drawText(x+4, y+2, content, size, clrTxt, COLOR_BG);
   else
   {
     uint8_t i = 0;
     while(i*FONT_WIDTH*size < width - 4*FONT_WIDTH*size)
     {
       lcd->drawChar(x+4+i*FONT_WIDTH,y+2,content[i++],size,clrTxt,COLOR_BG);
     }
     lcd->drawText(x+4+i*FONT_WIDTH,y+2,"...",size,clrTxt,COLOR_BG);
   }
 }
 
 void TextBox::changeText(lcdPtr lcd, char * T)
 {
   if(T != NULL)
   {
     if(strlen(T) == 0)
       text = NULL;
     else
     {
       free(text);
       text = (char*)malloc(strlen(T)+1);
       if(text != NULL)
         strcpy(text, T);
     }
     draw(lcd, false);
   }
 }
 
 void TextBox::addText(lcdPtr lcd, char * T)
 {
   if(strlen(T) != NULL)
   {
     if(text != NULL)
     {
       char * tmpTxt = (char*)malloc(strlen(text)+strlen(T)+1);
       if(tmpTxt != NULL)
       {
         strcpy(tmpTxt, text);
         strcat(tmpTxt, T);
         free(text);
         text = tmpTxt;
         draw(lcd, false);
       }
     }
   }
 }
 /*
 --------------------------------------------
 SLIDER
 --------------------------------------------
 */
 
 void Slider::draw(lcdPtr lcd, bool isDown)
 {
   if(value>1023)
     value = 1023;
   if(value<0)
     value = 0;
 
   float valToX = (float)value/1024*width;
 
   lcd->fillRect(x,y+(height-2)/2,x+valToX,y+height/2,COLOR_SLIDER_VALUE);
   lcd->fillRect(x+valToX,y+(height-2)/2,x+width,y+height/2,COLOR_SLIDER);
 
   lcd->fillRect(x-10,y,x+width+10,y+(height-2)/2-1,COLOR_BG);
   lcd->fillRect(x-10,y+height/2+1,x+width+10,y+height,COLOR_BG);
   lcd->fillRect(x-10,y,x-1,y+height,COLOR_BG);
   lcd->fillRect(x+width+1,y,x+width+10,y+height,COLOR_BG);
 
   lcd->fillCircle(x+valToX,y+height/2,height/2,COLOR_SLIDER_CIRCLE);
   lcd->fillCircle(x+valToX,y+height/2,2,COLOR_SLIDER_VALUE);
   lcd->drawCircle(x+valToX,y+height/2,height/2,COLOR_SLIDER_VALUE);
 }
 
 /*
 --------------------------------------------
 STATUSBAR
 --------------------------------------------
 */
 
 void StatusBar::draw(lcdPtr lcd)
 {
   lcd->fillRect(0,0,lcd->getWidth(), size*FONT_HEIGHT+4,COLOR_STATUSBAR);
   lcd->drawText(2,2,text,size,COLOR_STATUSBAR_TEXT,COLOR_STATUSBAR);
 }
 
 /*
 --------------------------------------------
 CHECKBOX
 --------------------------------------------
 */
 
 void CheckBox::draw(lcdPtr lcd, bool isDown)
 {
   uint16_t clr = (isDown) ? COLOR_CHECK_PRESSED : COLOR_CHECK ;
   if(!isActive && !isDown)
   {
     lcd->fillRect(x,y,x+FONT_HEIGHT,y+FONT_HEIGHT,clr);
     lcd->fillRect(x+1,y+1,x+FONT_HEIGHT-1,y+FONT_HEIGHT-1,COLOR_BG);
     lcd->fillRect(x+FONT_HEIGHT,y,x+FONT_HEIGHT+2,y+FONT_HEIGHT,COLOR_BG);
   }
   lcd->drawRect(x,y,x+FONT_HEIGHT,y+FONT_HEIGHT,clr);
   lcd->drawText(x+FONT_HEIGHT+8,y+1,text,1,COLOR_CHECK_TEXT,COLOR_BG);
 
   if(isActive)
   {
     //line 1 (upper)
     lcd->drawLine(x+2,y+6,x+6,y+10,COLOR_CHECK_PRESSED);
     lcd->drawLine(x+7,y+10,x+FONT_HEIGHT+2,y+3,COLOR_CHECK_PRESSED);
     //line 2 (middle)
     lcd->drawLine(x+2,y+5,x+6,y+9,COLOR_CHECK_PRESSED);
     lcd->drawLine(x+7,y+9,x+FONT_HEIGHT+2,y+2,COLOR_CHECK_PRESSED);
     //line 3 (middle)
-}
+
     lcd->drawLine(x+7,y+8,x+FONT_HEIGHT+1,y+2,COLOR_CHECK_PRESSED);
     //line 4 (lower)
     lcd->drawLine(x+3,y+4,x+6,y+7,COLOR_CHECK_PRESSED);
     lcd->drawLine(x+7,y+7,x+FONT_HEIGHT+1,y+1,COLOR_CHECK_PRESSED);
   }
 }
 #endif