// Maxim_scala.cpp

#include <Maxim_scala.h>

/////////
    // Beschreibung von Konstruktor. xo,yo,xu,yu - äußere Maße von Rahmen.
    // verthor 0/1 vertikal/horizontal, nulluo 0 = Null unten/links, 1 = Null oben/rechts 
    // Andere Einstellungen default:
    // Scala vertikal, 7 Marker, einfarbig, einfachen Ziffer links
Maxim_scala::Maxim_scala(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu, boolean _verthor, boolean _nulluo, GigaDisplay_GFX *ein_display){
    mein_display=ein_display;
    
    setscalaxy(_xo, _yo, _xu, _yu);
    setmodescala(1, 1, _verthor, _nulluo, 0, 0);
    setmodemetka(1, 1, 1, 1, 1);
    setmodezif(1, 0, 0, 0);

    setvollscala(1023.0); // Wert für volle (100%) Scala
    setrammetka(4, 7, 14, 4, 10, 2); // rdicke,mzahl,m_metka,m_mdicke,metka,mdicke
    setabstand(50, 6, 10, 6); // zifscala_xl,zifscala_yl,zifscala_xr,zifscala_yr
    setfarbe(ROT, GELB, GELB, WASSER, BLAU, SCHWARZ); // scala,scalaanf,rahmen,ziffer,grund,hintergrund
    setzif(6, -1);  // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt
    setsymbol(NULL, 5); // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker
}

////////////////////
// Hauptfunktion
    // Scala zeichnen. xx - Scalawert. rahmen - 1 = Scala, Marker und Zeichen zeichnen, 0 = Nur Scala selbst zeichnen
void Maxim_scala::scala(uint16_t xx, uint8_t rahmen) {
  if(rahmen){ 
    scala_rahmen(1);
    scala_m_metka(1);
    scala_metka(1);
    scala_ziffer(1);
  }
  scala_inhalt(xx);  // Zeichnen der Scalen
}

/////
        // Einstellungen
    // scalaein: 1 = Scala einschalten, 
    // rahmenein: 1 = Rahmen einschalten, 
    // verthor: 0 = vertikal, 1 = horizontal, 
    // nulluo: 0 = Null unten/links / 1 = Null oben/rechts, 
    // gradient: 0 = einfarbig-Scala, 1 = gradient-Scala, 
    // grund = leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe
  void Maxim_scala::setmodescala(boolean _scalaein, boolean _rahmenein, boolean _verthor, boolean _nulluo, boolean _gradient, boolean _grund){
    set_scalaein(_scalaein);
    set_rahmenein(_rahmenein);
    set_verthor(_verthor);
    set_nulluo(_nulluo);
    set_gradient(_gradient);
    set_grund(_grund);
  }

    // mitme: 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe, 
    // mitmetl: 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, 
    // mitmetr: 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl) eingeschaltet, 
    // metlinks: 1 = Marker (außer in der Mitte) links/oben eingeschaltet, 
    // metrechts: 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet
  void Maxim_scala::setmodemetka(boolean _mitme, boolean _mitmetl, boolean _mitmetr, boolean _metlinks, boolean _metrechts){
    set_mitme(_mitme);
    set_mitmetl(_mitmetl);
    set_mitmetr(_mitmetr);
    set_metlinks(_metlinks);
    set_metrechts(_metrechts);
  }

    // ziflinks: 1 = Zeichen links/oben eingeschaltet, 
    // zifrechts: 1 = Zeichen rechts/unten eingeschaltet, 
    // zifpos: 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker 
    // ziftyp: 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif
  void Maxim_scala::setmodezif(boolean _ziflinks, boolean _zifrechts, boolean _zifpos, boolean _ziftyp){
    set_ziflinks(_ziflinks);
    set_zifrechts(_zifrechts);
    set_zifpos(_zifpos);
    set_ziftyp(_ziftyp);
  }

      // Scalamodi
  void Maxim_scala::set_scalaein(boolean xx){  // 1 = Scala einschalten (Scala selbst, ohne Rahmen)
    if(xx){ mode |= (1<<0); }else{ mode &= ~(1<<0);} }
  boolean Maxim_scala::get_scalaein(void){
    if(mode & (1<<0)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_rahmenein(boolean xx){ // 1 = Rahmen einschalten
    if(xx){ mode |= (1<<1); }else{ mode &= ~(1<<1);} }
  boolean Maxim_scala::get_rahmenein(void){
    if(mode & (1<<1)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_mitme(boolean xx){ // 1 = Marker in der Mitte besondere Größe, 0 = Marker in der Mitte allgemeine Größe
    if(xx){ mode |= (1<<2); }else{ mode &= ~(1<<2);} }
  boolean Maxim_scala::get_mitme(void){
    if(mode & (1<<2)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_mitmetl(boolean xx){ // 1 = Marker in der Mitte links/oben mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl)
    if(xx){ mode |= (1<<3); }else{ mode &= ~(1<<3);} }
  boolean Maxim_scala::get_mitmetl(void){
    if(mode & (1<<3)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_mitmetr(boolean xx){ // 1 = Marker in der Mitte rechts/unten mit einer ungeraden Anzahl von Marker (und zwei Marker mit einer geraden Anzahl)
    if(xx){ mode |= (1<<4); }else{ mode &= ~(1<<4);} }
  boolean Maxim_scala::get_mitmetr(void){
    if(mode & (1<<4)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_metlinks(boolean xx){  // 1 = Marker (außer in der Mitte) links/oben eingeschaltet
    if(xx){ mode |= (1<<5); }else{ mode &= ~(1<<5);} }
  boolean Maxim_scala::get_metlinks(void){
    if(mode & (1<<5)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_metrechts(boolean xx){ // 1 = Marker (außer in der Mitte) rechts/unten eingeschaltet
    if(xx){ mode |= (1<<6); }else{ mode &= ~(1<<6);} }
  boolean Maxim_scala::get_metrechts(void){
    if(mode & (1<<6)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_ziflinks(boolean xx){  // 1 = Zeichen links/oben eingeschaltet
    if(xx){ mode |= (1<<7); }else{ mode &= ~(1<<7);} }
  boolean Maxim_scala::get_ziflinks(void){
    if(mode & (1<<7)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_zifrechts(boolean xx){ // 1 = Zeichen rechts/unten eingeschaltet
    if(xx){ mode |= (1<<8); }else{ mode &= ~(1<<8);} }
  boolean Maxim_scala::get_zifrechts(void){
    if(mode & (1<<8)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_zifpos(boolean xx){  // 0 = Zeichen gegen Marker, 1 = Zeichen zwischen Marker
    if(xx){ mode |= (1<<9); }else{ mode &= ~(1<<9);} }
  boolean Maxim_scala::get_zifpos(void){
    if(mode & (1<<9)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_ziftyp(boolean xx){  // 0 = Ziffer, es gelten anfzif und difzif, 1 = string, es gelten *sym und symzif
    if(xx){ mode |= (1<<10); }else{ mode &= ~(1<<10);} }
  boolean Maxim_scala::get_ziftyp(void){
    if(mode & (1<<10)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_nulluo(boolean xx){  // 0 = Null unten/links / 1 = Null oben/rechts
    if(xx){ mode |= (1<<11); }else{ mode &= ~(1<<11);} }
  boolean Maxim_scala::get_nulluo(void){
    if(mode & (1<<11)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_verthor(boolean xx){ // 0 = vertikal, 1 = horizontal
    if(xx){ mode |= (1<<12); }else{ mode &= ~(1<<12);} }
  boolean Maxim_scala::get_verthor(void){
    if(mode & (1<<12)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_grund(boolean xx){ // leere Scala-Teil mit Farbe: 0 = Grundfarbe, 1 = Hintergrundfarbe
    if(xx){ mode |= (1<<13); }else{ mode &= ~(1<<13);} }
  boolean Maxim_scala::get_grund(void){
    if(mode & (1<<13)){ return 1; }else{ return 0; } }

  void Maxim_scala::set_gradient(boolean xx){  // 0 = einfarbig-Scala, 1 = gradient-Scala
    if(xx){ mode |= (1<<14); }else{ mode &= ~(1<<14);} }
  boolean Maxim_scala::get_gradient(void){
    if(mode & (1<<14)){ return 1; }else{ return 0; } }


  // Einstellungsmethoden
    // xo,yo - Ecke oben links von Scala (mit Rahmen zusammen), 
    // xu,yu - Ecke unten rechts von Scala (mit Rahmen zusammen)
  void Maxim_scala::setscalaxy(int16_t _xo, int16_t _yo, int16_t _xu, int16_t _yu){
    xo = _xo;
    yo = _yo;
    xu = _xu;
    yu = _yu;
  }

    // Wert für volle (100%) Scala
  void Maxim_scala::setvollscala(float _vollscala){
    vollscala = _vollscala;
  }

    // rdicke: Dicke von Rahmen, 
    // mzahl: Zahl von Marker
    // m_metka: Länge für mittlere Marker (von Rahmen nach außen), 
    // m_mdicke: Dicke für mittlere Marker
    // metka: Länge für restlichen Marker (von Rahmen nach außen), 
    // mdicke: Dicke für restlichen Marker
  void Maxim_scala::setrammetka(int16_t _rdicke, uint8_t _mzahl, int16_t _m_metka, int16_t _m_mdicke, int16_t _metka, int16_t _mdicke){
    rdicke = _rdicke;
    mzahl = _mzahl;
    m_metka = _m_metka;
    m_mdicke = _m_mdicke;
    metka = _metka;
    mdicke = _mdicke;
  }

    // zifscala_xl = horizontale (vertikale) Zeichenabstand von Rahmen links (oben), 
    // zifscala_yl = vertikale (horizontale) Zeichenabstand von Rahmen links (oben),
    // zifscala_xr = horizontale (vertikale) Zeichenabstand von Rahmen rechts (unten), 
    // zifscala_yr = vertikale (horizontale) Zeichenabstand von Rahmen rechts (unten)
  void Maxim_scala::setabstand(int16_t _zifscala_xl, int16_t _zifscala_yl, int16_t _zifscala_xr, int16_t _zifscala_yr){
    zifscala_xl = _zifscala_xl;
    zifscala_yl = _zifscala_yl;
    zifscala_xr = _zifscala_xr;
    zifscala_yr = _zifscala_yr;
  }

    // scalafarbe = Farbe für wirkende Scalateil, auch Farbe für Ende von wirkenden Scalateil für Gradientscala, 
    // scalafarbeanf = Farbe für Anfang von wirkenden Scalateil für Gradientscala
    // rahmenfarbe = Farbe für Rahmen und Marker
    // zifferfarbe = Farbe für Zeichen
    // grundfarbe = Farbe für Leere Teil von Scala
    // hintergrundfarbe = Grundfarbe von Bildschirm. Wird z.B. für Zeichen gebraucht
  void Maxim_scala::setfarbe(uint16_t _scalafarbe, uint16_t _scalafarbeanf, uint16_t _rahmenfarbe, uint16_t _zifferfarbe, uint16_t _grundfarbe, uint16_t _hintergrundfarbe){
    scalafarbe = _scalafarbe;
    scalafarbeanf = _scalafarbeanf;
    rahmenfarbe = _rahmenfarbe;
    zifferfarbe = _zifferfarbe;
    grundfarbe = _grundfarbe;
    hintergrundfarbe = _hintergrundfarbe;
  }

    // anfzif = Wert für oberste/rechte Ziffer bei Marker, difzif = Zifferschritt
  void Maxim_scala::setzif(int16_t _anfzif, int16_t _difzif){
    anfzif = _anfzif;
    difzif = _difzif;
  }

    // *sym = Zeiger auf Zeichenarray für Scala, symzif = Zahl von Zeichen in Zeile einschließlich \0 in der Zeile bei Marker
  void Maxim_scala::setsymbol(char *_sym, uint8_t _symzif){
    sym = _sym;
    symzif = _symzif;
  }

///////////////////////////////
  // Methoden (Funktionen) zum Zeichnen einer Scala
    // Rahmen zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Rahmen vom Bildschirm entfernen)
void Maxim_scala::scala_rahmen(uint8_t einaus){

    if(0 == get_rahmenein()) return;
    if(rdicke < 1) return;

    uint16_t farbe = hintergrundfarbe;
    if(einaus) farbe = rahmenfarbe; 
    
    int16_t breite = xu-xo+1;
    int16_t hoehe = yu-yo+1;
    mein_display->fillRect(xo,yo,rdicke,hoehe,farbe); // links
    mein_display->fillRect(xo+breite-rdicke,yo,rdicke,hoehe,farbe); // rechts
    mein_display->fillRect(xo+rdicke,yo,breite-rdicke*2,rdicke,farbe); // obere
    mein_display->fillRect(xo+rdicke,yo+hoehe-rdicke,breite-rdicke*2,rdicke,farbe); // untere
  }

    // Marker in der Mitte zeichnen. einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen)
void Maxim_scala::scala_m_metka(uint8_t einaus){

    // wenn mittlere Marker von keiner Seite eingeschaltet, aus
  if((0 == get_mitmetl()) && (0 == get_mitmetr())) return;

  uint16_t farbe = hintergrundfarbe;
    if(einaus) farbe = rahmenfarbe; 
  int16_t _m_metka;
  int16_t _m_mdicke;
  if(get_mitme()){   // wenn eigene Größe mittleres Markers
    _m_metka = m_metka;
    _m_mdicke = m_mdicke;
  }else{
    _m_metka = metka;
    _m_mdicke = mdicke;
  }

  if(get_verthor()){ // horizontal
    int16_t ym = yo-_m_metka; // obere y-Koordinate des oberen Markers
    int16_t ymu = yu+1;   // obere y-Koordinate des unteren Markers
    if(mzahl % 2){ // wenn eine ungerade Anzahl von Marker
        int16_t xm = xo+(xu-xo+1-_m_mdicke)/2; // obere x-Koordinate des Markers
        if(get_mitmetl()){  // wenn obere mittlere Marker ein
            mein_display->fillRect(xm,ym,_m_mdicke,_m_metka,farbe); // oberhalb des Rahmens
        }
        if(get_mitmetr()){  // wenn untere mittlere Marker ein
            mein_display->fillRect(xm,ymu,_m_mdicke,_m_metka,farbe); // unterhalb des Rahmens
        }
    }else{ // wenn eine gerade Anzahl von Marker
        int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // zwischen Marker
        int16_t xml = xo+(xu-xo+1-_m_mdicke)/2 - diff/2; // linke x-Koordinate des linken Markers
        int16_t xmr = xo+(xu-xo+1-_m_mdicke)/2 + diff/2; // linke x-Koordinate der rechten Markers
        if(get_mitmetl()){  // wenn obere mittlere Marker ein
            mein_display->fillRect(xml,ym,_m_mdicke,_m_metka,farbe); // links, oberhalb des Rahmens
            mein_display->fillRect(xmr,ym,_m_mdicke,_m_metka,farbe); // rechts, oberhalb des Rahmens
        }
        if(get_mitmetr()){  // wenn untere mittlere Marker ein
            mein_display->fillRect(xml,ymu,_m_mdicke,_m_metka,farbe); // links, unterhalb des Rahmens
            mein_display->fillRect(xmr,ymu,_m_mdicke,_m_metka,farbe); // rechts, unterhalb des Rahmens
        }
    }  
  }else{ // vertikal
    int16_t xm = xo-_m_metka; // obere x-Koordinate des linken Markers
    int16_t xmr = xu+1;   // obere x-Koordinate des rechten Markers
    if(mzahl % 2){ // wenn eine ungerade Anzahl von Marker
        int16_t ym = yo+(yu-yo+1-_m_mdicke)/2; // obere y-Koordinate des Markers
        if(get_mitmetl()){  // wenn linke mittlere Marker eingschaltet
            mein_display->fillRect(xm,ym,_m_metka,_m_mdicke,farbe); // links von Rahmen
        }
        if(get_mitmetr()){  // wenn rechte mittlere Marker eingschaltet
            mein_display->fillRect(xmr,ym,_m_metka,_m_mdicke,farbe); // rechts von Rahmen
        }  
    }else{ // wenn eine gerade Anzahl von Marker
        int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // zwischen Marker
        int16_t ymo = yo+(yu-yo+1-_m_mdicke)/2 + diff/2; // Linke y-Koordinate des oberen mittleren Markers
        int16_t ymu = yo+(yu-yo+1-_m_mdicke)/2 - diff/2; // Linke y-Koordinate des unteren mittleren Markers
        if(get_mitmetl()){  // wenn linke mittlere Marker eingschaltet
            mein_display->fillRect(xm,ymo,_m_metka,_m_mdicke,farbe); // oben, links von Rahmen
            mein_display->fillRect(xm,ymu,_m_metka,_m_mdicke,farbe); // unten, links von Rahmen
        }
        if(get_mitmetr()){  // wenn rechte mittlere Marker eingschaltet
            mein_display->fillRect(xmr,ymo,_m_metka,_m_mdicke,farbe); // oben, rechts von Rahmen
            mein_display->fillRect(xmr,ymu,_m_metka,_m_mdicke,farbe); // unten, rechts von Rahmen
        }  
    } 
  }  
}

    // Marker zeichnen (außer mittleren). einaus: Wenn 0, hintergrundfarbe verwenden (Marker vom Bildschirm entfernen)
void Maxim_scala::scala_metka(uint8_t einaus){
      // wenn Marker weder links noch rechts eingeschaltet, aus
    if((0 == get_metlinks()) && (0 == get_metrechts())) return;

    uint16_t farbe = hintergrundfarbe;
      if(einaus) farbe = rahmenfarbe; 
    int16_t innenscala = (yu - yo) - 2 * rdicke;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
      if(get_verthor()){ innenscala = (xu - xo) - 2 * rdicke;  } // Horizontale Scala

    if(get_verthor()){  // horizontal
      int16_t mitte = (xo + xu - mdicke) / 2;
      int16_t ymo = yo - metka;
      int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // Scala zwischen Marker
      if(mzahl % 2){  // Bei einer ungeraden Anzahl von Marker von der Mitte nach oben und unten
        if(get_metlinks()){ // wenn obere Marker ein
          for(int16_t i = mitte+diff;i<xu-mdicke;i+=diff){
            mein_display->fillRect(i,ymo,mdicke,metka,farbe);
          }
          for(int16_t i = mitte-diff;i>xo+mdicke;i-=diff){
          mein_display->fillRect(i,ymo,mdicke,metka,farbe);
          }
        }
        if(get_metrechts()){ // wenn untere Marker ein
          for(int16_t i = mitte+diff;i<xu-mdicke;i+=diff){
            mein_display->fillRect(i,yu,mdicke,metka,farbe);
          }
          for(int16_t i = mitte-diff;i>xo+mdicke;i-=diff){
          mein_display->fillRect(i,yu,mdicke,metka,farbe);
          }
        }
      }else{  // Bei einer geraden Anzahl von Marker von der Mitte nach oben und unten, erste Marker überspringen
        if(get_metlinks()){ // wenn obere Marker ein
          for(int16_t i = mitte+diff+diff/2;i<xu-mdicke;i+=diff){
            mein_display->fillRect(i,ymo,mdicke,metka,farbe);
          }
          for(int16_t i = mitte-diff-diff/2;i>xo+mdicke;i-=diff){
          mein_display->fillRect(i,ymo,mdicke,metka,farbe);
          }
        }
        if(get_metrechts()){ // wenn untere Marker ein
          for(int16_t i = mitte+diff+diff/2;i<xu-mdicke;i+=diff){
            mein_display->fillRect(i,yu,mdicke,metka,farbe);
          }
          for(int16_t i = mitte-diff-diff/2;i>xo+mdicke;i-=diff){
          mein_display->fillRect(i,yu,mdicke,metka,farbe);
          }
        }
      }
    }else{ // vertikal
      int16_t mitte = (yo + yu - mdicke) / 2;
      int16_t xmo = xo - metka;
      int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // Scala zwischen Marker
      if(mzahl % 2){  // Bei einer ungeraden Anzahl von Marker von der Mitte nach oben und unten
        if(get_metlinks()){ // wenn linke Marker ein
          for(int16_t i = mitte+diff;i<yu-mdicke;i+=diff){
            mein_display->fillRect(xmo,i,metka,mdicke,farbe);
          }
          for(int16_t i = mitte-diff;i>yo+mdicke;i-=diff){
          mein_display->fillRect(xmo,i,metka,mdicke,farbe);
          }
        }
        if(get_metrechts()){ // wenn rechte Marker ein
          for(int16_t i = mitte+diff;i<yu-mdicke;i+=diff){
            mein_display->fillRect(xu,i,metka,mdicke,farbe);
          }
          for(int16_t i = mitte-diff;i>yo+mdicke;i-=diff){
          mein_display->fillRect(xu,i,metka,mdicke,farbe);
          }
        }
      }else{  // Bei einer geraden Anzahl von Marker von der Mitte nach oben und unten, erste Marker überspringen
        if(get_metlinks()){ // wenn linke Marker ein
          for(int16_t i = mitte+diff+diff/2;i<yu-mdicke;i+=diff){
            mein_display->fillRect(xmo,i,metka,mdicke,farbe);
          }
          for(int16_t i = mitte-diff-diff/2;i>yo+mdicke;i-=diff){
          mein_display->fillRect(xmo,i,metka,mdicke,farbe);
          }
        }
        if(get_metrechts()){ // wenn rechte Marker ein
          for(int16_t i = mitte+diff+diff/2;i<yu-mdicke;i+=diff){
            mein_display->fillRect(xu,i,metka,mdicke,farbe);
          }
          for(int16_t i = mitte-diff-diff/2;i>yo+mdicke;i-=diff){
          mein_display->fillRect(xu,i,metka,mdicke,farbe);
          }
        }
      }
    }
}

    // Zeichen zeichnen. einaus: Wenn 0, Wenn 0, hintergrundfarbe verwenden (Zeichen vom Bildschirm entfernen)
void Maxim_scala::scala_ziffer(uint8_t einaus){
    // wenn weder rechte noch linke Marker eingeschaltet, aus
  if((0 == get_ziflinks()) && (0 == get_zifrechts())) return;

  uint16_t farbe = hintergrundfarbe;
    if(einaus) farbe = zifferfarbe; 
  int16_t breite = xu - xo + 1;
  int16_t hoehe = yu - yo + 1;

  mein_display->setFont(NULL);
  mein_display->setTextSize(2); //adjust text size
  mein_display->setTextColor(farbe,hintergrundfarbe);

  if(get_verthor()){  // horizontal
    int16_t mitte = (xo + xu) / 2; // Scalamitte nach Länge
    int16_t diff = (xu-xo-2*rdicke)/(mzahl - 1); // zwischen Marker
    int16_t metxo = mitte + diff/2 + diff * ((mzahl / 2) - 1);  // x-Position des linken Markers
        if(mzahl % 2) metxo = mitte + diff * (mzahl / 2); // wenn die Anzahl des Markers ungerade ist
        if(get_zifpos()) metxo -= diff/2; // wenn Zeichenlage zwischen Marker
    int8_t zifnum = anfzif;  // einfache Bezifferung
    if(get_ziftyp()) zifnum = 0; // string-Bezifferung

      for(int16_t i=0;i<mzahl;i++){
        if(get_ziflinks()){ // wenn obere Marker ein
          mein_display->setCursor(metxo + zifscala_yl, yo -zifscala_xl); //x,y
          if(get_ziftyp()){ // string-Bezifferung
            int8_t zz = zifnum;
            for(uint8_t y=0;y<symzif-1;y++){
              mein_display->print(sym[zz]);
              zz++;
            }
          }else{ // einfache Bezifferung
            if((zifnum < 10)&&(zifnum >= 0)) mein_display->print(" ");
            mein_display->print(zifnum);
          }
        }
        if(get_zifrechts()){ // wenn untere Marker ein
          mein_display->setCursor(metxo + zifscala_yr, yo + hoehe + zifscala_xr); //x,y
          if(get_ziftyp()){ // string-Bezifferung
            int8_t zz = zifnum;
            for(uint8_t y=0;y<symzif-1;y++){
              mein_display->print(sym[zz]);
              zz++;
            }
          }else{ // einfache Bezifferung
            if((zifnum < 10)&&(zifnum >= 0)) mein_display->print(" ");
            mein_display->print(zifnum);
          }
        }
        if(get_ziftyp()){
          zifnum += symzif; // string-Bezifferung
        }else{
          zifnum += difzif; // einfache Bezifferung
        }
        metxo -= diff;
        if(metxo < xo+rdicke) break;
      }
    }else{ // vertikal
      int16_t mitte = (yo + yu) / 2; // Scalamitte nach Höhe
      int16_t diff = (yu-yo-2*rdicke)/(mzahl - 1); // zwischen Marker
      int16_t metyo = mitte - diff/2 - diff * ((mzahl / 2) - 1);  // y-Position des linken Markers
          if(mzahl % 2) metyo = mitte - diff * (mzahl / 2); // wenn die Anzahl des Markers ungerade ist
          if(get_zifpos()) metyo += diff/2; // wenn Zeichenlage zwischen Marker
      int8_t zifnum = anfzif;  // einfache Bezifferung
      if(get_ziftyp()) zifnum = 0; // string-Bezifferung

      for(int16_t i=0;i<mzahl;i++){
        if(get_ziflinks()){ // wenn linke Marker ein
          mein_display->setCursor(xo - zifscala_xl, metyo - zifscala_yl); //x,y
          if(get_ziftyp()){ // string-Bezifferung
            int8_t zz = zifnum;
            for(uint8_t y=0;y<symzif-1;y++){
              mein_display->print(sym[zz]);
              zz++;
            }
          }else{ // einfache Bezifferung
            if((zifnum < 10)&&(zifnum >= 0)) mein_display->print(" ");
            mein_display->print(zifnum);
          }
        }
        if(get_zifrechts()){ // wenn rechte Marker ein
          mein_display->setCursor(xo + breite + zifscala_xr, metyo - zifscala_yr); //x,y
          if(get_ziftyp()){ // string-Bezifferung
            int8_t zz = zifnum;
            for(uint8_t y=0;y<symzif-1;y++){
              mein_display->print(sym[zz]);
              zz++;
            }
          }else{ // einfache Bezifferung
            if((zifnum < 10)&&(zifnum >= 0)) mein_display->print(" ");
          mein_display->print(zifnum);
          }
        }
        if(get_ziftyp()){
          zifnum += symzif; // string-Bezifferung
        }else{
          zifnum += difzif; // einfache Bezifferung
        }
        metyo += diff;
        if(metyo > yu-rdicke) break;
      }
    }
}

    // Gradientscala zeichnen. xx ist der Skalanwert
void Maxim_scala::scala_gradient(uint16_t xx){
  int16_t af = scalafarbeanf;  // Anfangsfarbe der Scala
  int16_t ef = scalafarbe;     // Endfarbe der Scala
  int16_t innenscala = (yu - yo) - 2 * rdicke;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
    if(get_verthor()){ innenscala = (xu - xo) - 2 * rdicke;  } // Horizontale Scala
  int16_t saule = (int16_t)(((float)xx/vollscala)*innenscala); // Höhe (Länge) des wirksamen Teils der Skala (ohne Rahmen)
  int16_t leer = innenscala - saule;  // Höhe (Länge) des leeren Teils der Skala (ohne Rahmen)
  
      // Farben entpacken
  int16_t fru = (int16_t)((af & 0xf800)>>1);		// Anfangsfarbe Rot
	int16_t fgu = (int16_t)((af & 0x07e0)<<4);		// Anfangsfarbe Grün
	int16_t fbu = (int16_t)((af & 0x001f)<<10);	  // Anfangsfarbe Blau
	int16_t fro = (int16_t)((ef & 0xf800)>>1);		// Endfarbe Rot
	int16_t fgo = (int16_t)((ef & 0x07e0)<<4);		// Endfarbe Grün
	int16_t fbo = (int16_t)((ef & 0x001f)<<10);	  // Endfarbe Blau

  int16_t frd = (fro - fru)/(int16_t)innenscala;	// Gradient Rot
	int16_t fgd = (fgo - fgu)/(int16_t)innenscala;	// Gradient Grün
	int16_t fbd = (fbo - fbu)/(int16_t)innenscala;	// Gradient Blau 

  if(get_verthor()){ // Horizontal
    if(get_nulluo()){ // Null rechts
      for(int16_t i=0;i<saule+1;i++){
        mein_display->writeFastVLine(xo+innenscala+rdicke-i, yo+rdicke, yu-yo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }else{ // Null links
      for(int16_t i=0;i<saule+1;i++){
        mein_display->writeFastVLine(xo+rdicke+i, yo+rdicke, yu-yo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }
  }else{ // Vertikal
    if(get_nulluo()){ // Null oben
      for(int16_t i=0;i<saule+1;i++){
        mein_display->writeFastHLine(xo+rdicke, yo+rdicke+i, xu-xo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }else{ // Null unten
      for(int16_t i=0;i<saule+1;i++){
        mein_display->writeFastHLine(xo+rdicke, yo+rdicke+innenscala-i, xu-xo-2*rdicke+1,
            FARBE((uint8_t)(fru>>9),(uint8_t)(fgu>>9),(uint8_t)(fbu>>9))); 
				fru += frd;
				fgu += fgd;
				fbu += fbd;
      }
    }
  }
}

    // Skala zeichnen (einfach oder Gradient)
void Maxim_scala::scala_inhalt(uint16_t xx){
  int16_t breite = xu-xo+1;
  int16_t hoehe = yu-yo+1;
  uint16_t _grundfarbe = grundfarbe;
    if(get_grund()) _grundfarbe = hintergrundfarbe;

  int16_t innenscala = (yu - yo) - 2 * rdicke;;  // Höhe (Länge) der Skala ohne Rahmen, vertikale Scala
    if(get_verthor()) innenscala = (xu - xo) - 2 * rdicke;  // Horizontale Scala
  int16_t saule = (int16_t)(((float)xx/vollscala)*innenscala); // Höhe (Länge) des wirkenden Teils der Skala (ohne Rahmen)
  int16_t leer = innenscala - saule;  // Höhe (Länge) des leeren Teils der Scala (ohne Rahmen)

  int16_t xoram = xo+rdicke;
  int16_t yoram = yo+rdicke;
  int16_t brram = breite-2*rdicke;
  int16_t horam = hoehe-2*rdicke;

  if(get_verthor()){  // horizontal
    if(get_nulluo()){ // Null rechts
      if(get_scalaein()){
        mein_display->fillRect(xoram,yoram,leer+1,horam,_grundfarbe); // leere Scalateil
        if(saule != 0){
          if(get_gradient()){ // Gradientscala
            scala_gradient(xx);
          }else{ // einfarbige Scala
            mein_display->fillRect(xoram+leer,yoram,saule+1,horam,scalafarbe); 
          }
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        mein_display->fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); 
      }
    }else{  // Null links
      if(get_scalaein()){
        mein_display->fillRect(xoram+saule,yoram,leer+1,horam,_grundfarbe); // leere Scalateil
        if(saule != 0){
          if(get_gradient()){ // Gradientscala
            scala_gradient(xx);
          }else{ // einfarbige Scala
            mein_display->fillRect(xoram,yoram,saule+1,horam,scalafarbe); 
          }
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        mein_display->fillRect(xoram,yoram,innenscala,horam,hintergrundfarbe); 
      }
    }
  }else{  // vertikal
    if(get_nulluo()){ // Null oben
      if(get_scalaein()){
        mein_display->fillRect(xoram,yoram+saule,brram,leer+1,_grundfarbe); // leere Scalateil
        if(saule != 0){
          if(get_gradient()){ // Gradientscala
            scala_gradient(xx);
          }else{ // einfarbige Scala
            mein_display->fillRect(xoram,yoram,brram,saule+1,scalafarbe); 
          }
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        mein_display->fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe); 
      }
    }else{  // Null unten
      if(get_scalaein()){
        mein_display->fillRect(xoram,yoram,brram,leer+1,_grundfarbe); // leere Scalateil
        if(saule != 0){
          if(get_gradient()){ // Gradientscala
            scala_gradient(xx);
          }else{ // einfarbige Scala
            mein_display->fillRect(xoram,yoram+leer,brram,saule+1,scalafarbe); 
          }
        }
      }else{ // Wenn die Scala ausgeschaltet, Scala voll mit Hintergrundfarbe (löschen)
        mein_display->fillRect(xoram,yoram,brram,innenscala,hintergrundfarbe);
      }    
    }
  }
}