fixed toxcore deprecations

[bioacid.git] / miniedit.d

/* coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
 * Understanding is not required. Only obedience.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
module miniedit is aliced;
private:
import arsd.color;
import arsd.simpledisplay;

import iv.cmdcon;
import iv.cmdcon.gl;
import iv.nanovega;
import iv.strex;
import iv.sdpyutil;
import iv.unarray;
import iv.utfutil;
import iv.vfs.io;


// ////////////////////////////////////////////////////////////////////////// //
public final class MiniEdit {
private import iv.utfutil : Utf8Decoder;
private:
  dchar[] dtext;
  NVGGlyphPosition[8192] glyphs;
  Utf8Decoder ec; // encoder for clipboard gets
  char[8] clipbuf;
  uint clipbufused;

private:
  void putChar (char ch) {
    //if (ch <= ' ' || ch >= 127) conprintf("new char: 0x%02x\n", cast(ubyte)ch); else conprintf("char: '%s'\n", ch);
    dchar dc = ec.decode(cast(ubyte)ch);
    if (dc <= dchar.max) {
      // decoded
      if (dc >= ' ' || dc == '\n') {
        dtext ~= dc;
        glconPostScreenRepaint();
      }
    }
  }

public:
  this () {}

  string text () const nothrow {
    import iv.utfutil : utf8Encode;
    string res;
    res.reserve(dtext.length*4);
    foreach (dchar dc; dtext) {
      char[4] buf = void;
      auto len = utf8Encode(buf[], dc);
      res ~= buf[0..len];
    }
    return res;
  }

  void clear () {
    if (dtext.length) {
      dtext.length = 0;
      dtext.assumeSafeAppend;
    }
  }

  void setFont (NVGContext nvg) {
    nvg.fontSize = 20;
    nvg.fontFace = "ui";
    nvg.textAlign(NVGTextAlign.H.Left, NVGTextAlign.V.Top);
  }

  static struct HeightInfo {
    float height = 0;
    int lines = 0;
    float lineh = 0;

    void newline () nothrow @safe @nogc { ++lines; height += lineh; }
  }

  // return `false` from delegate to stop
  // `line` in delegate cannot be empty
  // if `line` ends with '\n', this is hard newline, otherwise it is a wrap
  void byLine (NVGContext nvg, int width, scope bool delegate (const(dchar)[] line) dg) {
    assert(nvg !is null);
    assert(dg !is null);

    setFont(nvg);
    if (width < 1) width = 1; // just for fun

    uint curpos = 0;
    while (curpos < dtext.length) {
      // new line; always here
      uint epos = 0;
      nvg.textGlyphPositions(0, 0, dtext[curpos..$], delegate (NVGGlyphPosition gpos) {
        if (gpos.maxx >= width) return false; // doesn't fit: stop
        if (dtext[curpos+gpos.strpos] == '\n') return false; // eol hit: stop
        epos = cast(uint)gpos.strpos+1; // swallow the glyph
        return true; // continue
      });
      // no glyphs fit, but the line is not empty: swallow at least one glyph
      if (epos == 0 && dtext[curpos] != '\n') ++epos;
      // if we hit (or about to hit) EOL, swallow it too
           if (epos == 0) { assert(dtext[curpos] == '\n'); ++epos; }
      else if (curpos+epos < dtext.length && dtext[curpos+epos] == '\n') ++epos;
      if (dg(dtext[curpos..curpos+epos])) break;
      curpos += epos;
    }
  }

  // for the given width
  HeightInfo calcHeight (NVGContext nvg, int width) {
    setFont(nvg);

    HeightInfo res;
    nvg.textMetrics(null, null, &res.lineh);

    byLine(nvg, width, delegate (line) {
      res.newline();
      return false;
    });

    if (dtext.length && dtext[$-1] == '\n') res.newline();

    // we always has at least one line
    if (res.lines == 0) res.newline();

    return res;
  }

  void draw (NVGContext nvg, float x, float y, int width, int height) {
    if (height < 1) return;

    setFont(nvg);

    float lineh;
    nvg.textMetrics(null, null, &lineh);

    //nvg.beginPath();
    nvg.fillColor = NVGColor.k8orange;
    //nvg.text(x, y, text[0..repos]);

    float ex = x;
    float ey = y;
    byLine(nvg, width, delegate (line) {
      if (line[$-1] == '\n') {
        // hard wrap
        ex = x;
        ey = y+lineh;
        nvg.text(x, y, line[0..$-1]);
      } else {
        // soft wrap
        ex = nvg.text(x, y, line);
        ey = y;
      }
      y += lineh;
      return false;
    });

    nvg.beginPath();
    nvg.strokeColor = NVGColor.yellow;
    nvg.rect(cast(int)ex, cast(int)ey, 1, height); // ensure that cursor looks a little blurry
    nvg.stroke();
  }

  bool onKey (KeyEvent event) {
    // enter
    if (event.key == Key.Enter) {
      if (event.pressed) {
        dtext ~= '\n';
        glconPostScreenRepaint();
      }
      return true;
    }

    // bs
    if (event.key == Key.Backspace) {
      if (event.pressed && dtext.length > 0) {
        dtext.length -= 1;
        dtext.assumeSafeAppend;
        glconPostScreenRepaint();
      }
      return true;
    }

    // C-Y
    if (event == "D-C-Y" || event == "U-C-Y") {
      if (event.pressed && dtext.length > 0) {
        clear();
        glconPostScreenRepaint();
      }
      return true;
    }

    if (event == "D-S-Insert" || event == "U-S-Insert") {
      if (event.pressed) glconCtlWindow.getClipboardText(delegate (str) { foreach (immutable char ch; str) putChar(ch); });
      return true;
    }

    if (event == "D-C-Insert" || event == "U-C-Insert") {
      if (event.pressed) glconCtlWindow.setClipboardText(text);
      return true;
    }

    return false;
  }

  bool onChar (dchar ch) {
    if (ch >= ' ') {
      dtext ~= ch;
      glconPostScreenRepaint();
      return true;
    }

    return false;
  }
}