mail/nedit.c

#pragma strict_types

/* nedit.c
   Editor fuer news, mail usw.
   Version 1 (C) 1993 Loco
   Version 2 (C) 1995 Wargon

   Verwendung ausserhalb von Morgengrauen ist gestattet unter folgenden
   Bedingungen:
   - Benutzung erfolgt auf eigene Gefahr. Jegliche Verantwortung wird
     abgelehnt.
   - Auch in veraenderten oder abgeleiteten Objekten muss ein Hinweis auf
     die Herkunft erhalten bleiben.
   Ein Update-Service besteht nicht.

   Anwendung:
    #inherit "/mail/nedit";      (zusaetzlich zu anderen inherits)

     nedit(string funcname);                    oder
    nedit(string funcname,string pretext);
    Nach Beendigung des Editors wird die Funktion funcname aufgerufen.
    Sie bekommt als Argument einen string mit dem fertigen editierten Text
    uebergeben bzw. 0, wenn der Editor mit ~q abgebrochen wurde.
    Optionales Argument pretext ist der zu editierende Text. Wenn 0 oder nicht
    uebergeben, wird ein neuer Text begonnen.
*/

#include <properties.h>
#include <wizlevels.h>
#include <defines.h>
#include <input_to.h>
#include <regexp.h>

#define TP this_player()

#define F_OVR 1  // Overwrite-Modus
#define F_BLK 2  // Blocksatz

#define MAX_LINES 1000

static mixed nedittext, nexitfunc, editor_used;
static int bstart, bend;  // Anfang und Ende des Blocks
static int cur;           // Aktuelle Zeile
static int len;           // Laenge des Gesamttextes
static int flags;          // Overwritemodus

static int get_edit_line(string str);
static int ShowWritten(int f, int l, int num);
static int ShowHelp();
static int delLine(int l);
static void delBlock();
static int input_func();
varargs static void moveBlock(int start, int end, int real);
protected string killctrl(string str);

void init_rescue() {
  add_action("RescueText","~r");
}

private string nedit_prompt()
{
  if (sizeof(nedittext) <= MAX_LINES)
    return("]");
  else {
    nedittext = nedittext[0..MAX_LINES-1];
    len = MAX_LINES;
    if (cur >= MAX_LINES)
      cur = MAX_LINES-1;
    if (bstart >= MAX_LINES)
      bstart = MAX_LINES-1;
    if (bend >= MAX_LINES)
      bend = MAX_LINES-1;
    return sprintf("*** Mehr als %d Zeilen! Text wurde abgeschnitten! ***\n]", MAX_LINES);
  }
}

static varargs int nedit(string exitfunc,string pretext) {
  if (editor_used) {
    write("Offensichtlich schreibt hier schon jemand dran. Sorry.\n"+
                        "(Falls du es selbst bist, tippe ~r zur Wiederaufnahme einer verlorenen Sitzung)\n");
    return -1;
  }
  if (!pretext) nedittext=({""});
  else nedittext=explode(pretext,"\n");
  bstart = 0;
  bend = cur = len = sizeof(nedittext)-1;
  nexitfunc=exitfunc;
  flags = 0;
  editor_used=({string})TP->query_real_name();
  if (pretext)
    get_edit_line("~z");
  else {
    //nedit_prompt();
    input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
  }
  return 1;
}

static int get_edit_line(string str) {
  int err;
  int spaces;
  int fflag;
  int sl;

  if (!str) str="";
  // Kontrollzeichen rausfiltern
  str = killctrl(str);

  fflag = 0;

  sl = sizeof(str);

  if (str=="**" || str=="~." || str==".") {
    editor_used=0;
    str = implode(nedittext, "\n");
    nedittext = 0;
    ({mixed})call_other(this_object(),nexitfunc,str);
    return 1;
  }
  if (str[0..0]== "~" && sl >= 2) {
    if (sl == 2) {
      switch(str[0..1]) {
      // Abbruch:
      case "~q":
        editor_used = 0;
        return ({mixed})call_other(this_object(), nexitfunc, 0);
      // Temporaer rausgehen:
      case "~!":
        write("Mit ~r kannst Du weiterschreiben.\n");
        init_rescue();
        return 1;
      // Gesamten Text anzeigen
      case "~R":
        fflag = 1;
      case "~r":
        return ShowWritten(0, len, fflag);
      // Ausschnitt um Cursor anzeigen
      case "~Z":
        fflag = 1;
      case "~z":
        int f = (cur > 5) ? cur-5 : 0;
        int l = (cur < len-5) ? cur + 5 : len;
        return ShowWritten(f, l, fflag);
      // Hilfeseite anzeigen:
      case "~h":
        return ShowHelp();
      // Zeile ueber Cursor loeschen:
      case "~d":
        return delLine(cur-1);
      // Block loeschen:
      case "~D":
        delBlock();
        write( "Block geloescht.\n" );
        return input_func();
      // Overwrite-Modus toggeln:
      case "~v":
        flags ^= F_OVR;
        printf("%smodus eingeschaltet.\n",
              (flags & F_OVR) ? "Ueberschreib" : "Einfuege");
        return input_func();
      // Blocksatz toggeln:
      case "~b":
        flags ^= F_BLK;
        printf("%ssatz aktiviert.\n",
              (flags & F_BLK) ? "Block" : "Flatter");
        return input_func();
      // Statusinfo anzeigen:
      case "~s":
        printf("Zeile: %d | Laenge: %d | BStart: %d | BEnde: %d | "
               "Modus: %s/%s.\n",
                cur, len, bstart, bend, (flags&F_OVR)?"Ueber.":"Einfg.",
                (flags&F_BLK)?"Blocksatz":"Flattersatz");
        return input_func();
      // Block verschieben:
      case "~m":
        moveBlock(bstart, bend, 1);
        return input_func();
      // Block umformatieren:
      case "~F":
        int bs = bstart;
        str = implode(nedittext[bstart..bend], " ");
        delBlock();
        bstart = bend = cur = bs;
        fflag = -1;
        write("Block wurde umformatiert.\n");
        break;
      // Zeile umformatieren:
      case "~f":
        str = nedittext[cur];
        nedittext = nedittext[0..cur-1] + nedittext[cur+1..];
        if (cur <= bstart)
          bstart--;
        if (cur <= bend)
          bend--;
        len --;
        fflag = -1;
        write("Zeile wurde umformatiert.\n");
        break;
      } // switch
    } // if (sl == 2)
    else {
      // Cursorbewegungen an bestimmte Stellen:
      if (str[0..1] == "~c" && sl == 3) {
        fflag = 1;
        switch(str[2]) {
          case 'u': spaces = -1;           break;
          case 'd': spaces = 1;            break;
          case 't': spaces = -len;         break;
          case 'b': spaces = len;          break;
          case 's': spaces = bstart - cur; break;
          case 'e': spaces = bend - cur;   break;
          default:  spaces = 0;
                    fflag = 0;
                    break;
        }
      }
      // Cursorbewegung mit Zeilennummern:
      if (spaces || sscanf(str, "~c%d", spaces) == 1) {
        if (fflag>0 || str[2..2] == "+" || str[2..2] == "-")
          cur += spaces;
        else
          cur = spaces-1;

        if (cur < 0)
          cur = 0;
        else if (cur > len)
          cur = len;

        printf("%s\n",nedittext[cur]);
        return input_func();
      }
      // Blockgrenzen setzen:
      if ((err = (str[0..2] == "~bs")) || (str[0..2]=="~be")) {
        string out, p;
        int pos;

        int valid = -1;

        if (sl == 3)
          pos = valid = cur;
        else if (sscanf(str[3..], "%d%s", pos, p) == 2 && p=="")
          valid = pos--;

        if (valid >= 0) {
          if (err) {
            bstart = pos;
            if (pos > bend)
              bend = len;
            out = "Blockanfang";
          }
          else {
            if (pos < bstart)
              bstart = 0;
            bend = pos;
            if (len && bend == len)
              bend--;
            out = "Blockende";
          }
          printf("%s gesetzt.\n", out);
          return input_func();
        }
      }

      // Ersetzen:
      if ((sizeof(str) >= 8) && str[0..1] == "~s") {
        string *s1, *s2;
        int m;

        m = (str[2] == ' ') ? 3 : 2;

        if (sizeof(s1 = explode(str[m..], str[m..m])) == 4) {
          s2 = explode(nedittext[cur], s1[1]);
          if (sizeof(s2) > 1) {
            s2[1] = s2[0]+s1[2]+s2[1];
            nedittext[cur] = implode(s2[1..], s1[1]);
            if (s1[3] == "p")
              printf("%s\n", nedittext[cur]);
            else
              write("OK.\n");
            //nedit_prompt();
          }
          else {
            printf("\"%s\" nicht gefunden!\n", s1[1]);
            //nedit_prompt();
          }

          input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
          return 1;
        }
      }
    } // if (sl > 2)
  } // if (str[0..0] == "~")

  spaces=(sizeof(str) && (str[0]==' ' || str[0]=='\t'));
  if (spaces) str="$"+str;  /* Kleiner hack wegen fuehrenden Leerzeichen */
  str=break_string(str,78,0,(flags&F_BLK) ? BS_BLOCK|BS_NO_PARINDENT : 0);
  if (spaces) str=str[1..<1];
  if ( ((str[0..1]=="~r" && sizeof(str)>2) || str[0..1]=="~i") && 
       IS_LEARNER(TP) ) 
  {
    str=str[2..<2];
    if (str[0..0]==" ") str=str[1..<1];
    if (!str || catch(err=file_size(str=({string})"/secure/master"->_get_path(str,getuid(TP)))) || err<0) {
      write("File nicht gefunden.\n");
      //nedit_prompt();
      input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
      return 1;
    }
    str=read_file(str);
    if (!str){
      write("Zu gross!\n");
      //nedit_prompt();
      input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
      return 1;
    }
    write("Ok.\n");
  }
  if (str=="" || !str) str="\n";
  {
    string *x;
    int sx;

    x = explode(str, "\n")[0..<2];
    sx = sizeof(x);

    if (flags&F_OVR && !fflag) {
      nedittext = nedittext[0..cur-1] + x + nedittext[cur+1..];
      sx--;
    }
    else
      nedittext = nedittext[0..cur-1] + x + nedittext[cur..];

    if (cur < bstart)
      bstart += sx;
    if (cur <= bend)
      bend += (sx + fflag);
    cur += (sx + fflag + ((flags&F_OVR) ? 1:0));
    len += sx;

    // Kann beim Umformatieren des letzten Abschnitts vorkommen.
    if (nedittext[len] != "") {
      nedittext += ({ "" });
      len++;
    }
  }
  //nedit_prompt();
  input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
  return 1;
}

static int delLine(int l)
{
  string pr;
  if (l < 0)
    pr="Da ist nix mehr zum Loeschen!\n]";
  else {
    if (bstart >= l)
      bstart--;
    if (bend >= l)
      bend--;
    if (cur >= l)
      cur--;
    len--;
    nedittext=(nedittext[0..l-1]+nedittext[l+1..]);
    write("Vorherige Zeile geloescht.\n");
    pr=nedit_prompt();
  }
  input_to("get_edit_line", INPUT_PROMPT, pr);
  return 1;
}

static void delBlock()
{
  if (cur > bstart) {
    if (cur <= bend)
      cur = bstart;
    else
      cur -= (bend - bstart + 1);
  }
  if (bend == len)
    nedittext = nedittext[0..bstart-1];
  else
    nedittext = nedittext[0..bstart-1] + nedittext[bend+1..];

  bend = len = sizeof(nedittext)-1;
  bstart = 0;
  if (cur > len)
    cur = len;
}

varargs static void moveBlock(int start, int end, int real)
{
  int blen;
  string *block;

  if (cur >= start && cur <= end)
    write("Aber der Cursor steht innerhalb des Blocks!\n");
  else {
    block = nedittext[start..end];
    blen = sizeof(block)-1;
    delBlock();
    nedittext = nedittext[0..cur-1] + block + nedittext[cur..];
    if (real) {
      bstart = cur;
      bend = cur + blen;
    }
    len += (blen+1);
    write("OK.\n");
  }
}

// Remove ASCII control characters.
protected string killctrl(string str)
{
  return regreplace(str,"[[:cntrl:]]","",RE_PCRE|RE_GLOBAL);
}

mixed RescueText() {
  if (!nedittext || !editor_used)
    return notify_fail("Du hast nix angefangen zu schreiben!\n"),0;
  if (({string})TP->query_real_name()!=editor_used)
    return notify_fail("Hier schreibt "+capitalize(editor_used)+"!\n"),0;
  if (query_input_pending(TP))
    return notify_fail("Du schreibst gerade schon irgendwas. Sorry...\n"),0;
  return ShowWritten(0, len, 0);
}

static int ShowWritten(int f, int l, int num) {
  string s, t, c, p, indent;
  int i;

  if (num) {
    if (l >= 100) {
      p = "%3d%s%s";
      indent = " ";
    }
    else {
      p = "%2d%s%s";
      indent = "  ";
    }
  }
  else
    indent = "";

  for (t="", i=l-1; i>=f; i--) {
    if (i == cur)
      c = ( ((i == bend) || (i == bstart)) ? "#" : "*");
    else if (i==bstart || i==bend)
      c = ">";
    else c = ":";

    if (num)
      t = (sprintf(p, i+1, c, nedittext[i])[0..75] + "\n" + t);
    else
      t = (c + nedittext[i]+"\n" + t);
  }

  if (l==len) {
    if (len == cur)
      c = ( (len == bend) ? "#" : "*");
    else if (len==bend)
      c = ">";
    else c = " ";
  }
  else c= " ";

  s="Das hast Du bisher geschrieben:\n"+indent+" \
--------------------------\n\
"+t+indent+c+"\
--------------------------";
  ({void})this_player()->More(s,0,symbol_function("input_func",this_object()));
  return 1;
}

static int ShowHelp() {
  ({void})this_player()->More("\
--------------------------\n\
Der Editor versteht folgende Befehle:\n\
--- Dateikommandos:\n\
~h            diese Hilfsseite\n\
~r / ~R     zeigt an, was Du bisher geschrieben hast\n\
~z / ~Z     zeigt den Textausschnitt um den Cursor herum\n\
"+(IS_WIZARD(TP) ? "\
~i filename fuegt eine Datei in den Text ein (auch ~r filename)\n\
" : "" )+ "\
~q            bricht ab\n\
** oder .   beendet sauber\n\
!<cmd>            fuehrt <cmd> aus, wie wenn Du gerade nicht schreiben wuerdest\n\
~!            verlaesst den Editor voruebergehend\n\
~s            Statusinformationen anzeigen\n\
~b            Wechselt zwischen Flatter- (default) und Blocksatz\n\
--- zeilenorientierte Kommandos:\n\
~d            loescht die letzte Zeile (Text-, nicht Eingabezeile)\n\
~v            wechselt zwischen Einfuege- (default) und Ueberschreibmodus\n\
~s !s1!s2!  Ersetzt das erste Vorkommnis des Strings s1 durch den String s2\n\
            in der aktuellen Zeile.\n\
            Statt durch ! koennen die Strings auch durch beliebige andere\n\
            Zeichen getrennt werden, die weder in s1 noch in s2 vorkommen.\n\
~f            Formatiert die aktuelle Zeile neu\n\
--- Cursorkommandos:\n\
~cu / ~cd   Cursor um eine Zeile nach oben/unten bewegen\n\
~ct / ~cb   Cursor an Anfang/Ende des Textes bewegen\n\
~cs / ~ce   Cursor an Blockanfang/Blockende bewegen\n\
~c<nr>            Cursor nach Zeile <nr> bewegen\n\
~c+<nr>     Cursor um <nr> Zeilen nach unten bewegen\n\
~c-<nr>     Cursor um <nr> Zeilen nach oben bewegen\n\
--- blockorientierte Kommandos:\n\
~bs/~bs<nr> setzt Blockanfang auf Cursorposition bzw. auf Zeile <nr>\n\
~be/~be<nr> setzt Blockende auf Cursorposition bzw. auf Zeile <nr>\n\
~F            formatiert den Block neu\n\
~D            loescht den markierten Block\n\
~m            verschiebt den markierten Block an die Cursorposition\n\
---\n\
Alles andere gilt als Text. Ueberlange Zeilen werden auf eine maximale\n\
Laenge von 78 Zeichen umgebrochen.\n\
Nach ~!, oder wenn man waehrend des Schreibens netztot wird, kann man mit\n\
 ~r wieder in den Editor einsteigen.\n\
--------------------------\n\
", 0, symbol_function("input_func", this_object()));
  return 1;
}

static int input_func() {
  //nedit_prompt();
  input_to("get_edit_line", INPUT_PROMPT, nedit_prompt());
  return 1;
}