home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 09_10 / praxis / mumic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-29  |  13.4 KB  |  651 lines
  1. /* ----------------------------------------------------- */
  2. /*    MUMIC Version 1.0,   der   Mini  Editor  in  C.    */
  3. /*    Ein multilinguales Experiment in drei Sprachen.    */
  4. /*         C-Version in Turbo C++ ab Version 1.0         */
  5. /*           (c) 1991 toolbox & Ulrich Schmitz           */
  6. /* ----------------------------------------------------- */
  7. #include<stdio.h>
  8. #include<conio.h>
  9. #include<alloc.h>
  10. #include<dos.h>
  11.  
  12. /* -- KONSTANTEN --------------------------------------- */
  13. #define LIGHT_GRAY 7
  14. #define COLOR_SEG 0xB800
  15. #define MONO_SEG  0xB000
  16. #define TRUE 1
  17. #define FALSE 0
  18. #define MIN_ZEILEN 0
  19. #define MAX_ZEILEN 24
  20. #define MIN_SPALTEN 0
  21. #define MAX_SPALTEN 79
  22. #define TEXTSPEICHER 60000   /* Puffergröße */
  23. #define MAX_ZEICHEN 1920     /* 24 Zeilen x 80 Zeichen  */
  24. #define MIN_ZEICHEN 1840     /* 23 Zeilen x 80 Zeichen  */
  25. #define CR 256
  26.  
  27. /* -- STRUKTUREN --------------------------------------- */
  28. typedef unsigned char byte;
  29.  
  30. struct crtchar
  31. {
  32.  char ch;
  33.  byte at;
  34. };
  35.  
  36. struct crtchar crtpage[25][80];
  37.  
  38.  
  39. /* -- TYPENDEKLARATTIONEN ------------------------------ */
  40. typedef struct crtchar SCREEN[25][80];
  41. typedef unsigned int word;
  42.  
  43. /* -- PROTOTYPEN DER MULTILINGUALEN FUNKTIONEN --------- */
  44. word GetKey(void);
  45. void Scroll(int);
  46. void InsertLine(int Zeile);
  47. void DeleteLine(int Zeile);
  48. void ShowPosition(int Zeile, int Spalte);
  49. void ShowFilename(char* Filename);
  50. int LoadFile(char* Filename);
  51. int SaveFile(char* Filename);
  52. void QuitProgramm(void);
  53. void EditLine(int Zeilennr, int Position, char Zeichen);
  54.  
  55.  
  56. /* -- ALLGEMEINE PROTOTYPEN ---------------------------- */
  57. void scroll_up(void);
  58. void scroll_down(void);
  59. void video_init(void);
  60. int video_modus(void);
  61. void sondertasten(byte key);
  62. void init(void);
  63. void Scrolling(int);
  64. void select_file(void);
  65.  
  66. /* -- GLOBALE VARIABLEN -------------------------------- */
  67. SCREEN far *screen;
  68. int zeile = 0, spalte = 0, abs_zeile = 0, abs_spalte = 0, ende_zeiger;
  69. byte Toggle_Insert = TRUE;
  70. char *text, *textstart, dokument[20];
  71.  
  72.  
  73. /* -- PROGRAMM ----------------------------------------- */
  74.  
  75. void main(argc,argv)
  76. char **argv;
  77. int argc;
  78. {
  79. word taste;
  80. char *xtext[30];
  81. int i;
  82.  
  83. init();
  84.  
  85. //---------------  Datei einladen
  86.  
  87.  if (argc == 2)    // Dateiname wurde als Parameter übergeben
  88.     {
  89.      strcpy(dokument, argv[1]);
  90.      LoadFile(dokument);
  91.     }
  92.     else
  93.     {
  94.      strcpy( dokument,"NEU.DOC");
  95.     }
  96.  
  97. //--------------
  98.  textbackground(LIGHTGRAY);
  99.  textcolor(BLACK);
  100.  gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  101.  strcpy(xtext," Datei: ");
  102.  strncat(xtext, dokument, 20);
  103.  cprintf("  Zeile:%03d  Spalte:%03d   /\\  F2-SPEICHERN  F3-LADEN  /\\ %21.21s ", abs_zeile + 1, spalte + 1,  xtext);
  104.  gotoxy(spalte + 1, zeile +1);
  105.  textbackground(BLACK);
  106.  textcolor(LIGHTGRAY);
  107.  
  108.  do
  109.  {
  110.  if (abs_zeile < 0)
  111.      abs_zeile = 0;
  112.  
  113.  if (spalte < 0)
  114.      spalte = 0;
  115.  
  116.  textbackground(LIGHTGRAY);
  117.  textcolor(BLACK);
  118.  gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  119.  cprintf("  Zeile:%03d  Spalte:%03d ", abs_zeile + 1, spalte + 1);
  120.  gotoxy(spalte + 1, zeile +1);
  121.  if ( ende_zeiger <= abs_zeile )
  122.       ende_zeiger = abs_zeile;
  123.  textbackground(BLACK);
  124.  textcolor(LIGHTGRAY);
  125.  
  126. //------------------------------------------------------------
  127.  
  128.  taste = GetKey();
  129.  
  130.  switch ( taste )
  131.   {
  132.    case 0:   /*--- Es wurde eine Steuersequenz aktiviert */
  133.          sondertasten( GetKey() );
  134.    break;
  135.  
  136.    case  8:  /*--- Backspace */
  137.          if ( spalte > 0 )
  138.         {
  139.          gotoxy(spalte, zeile + 1);
  140.          (*screen)[zeile][spalte--].at = LIGHTGRAY;
  141.          (*screen)[zeile][spalte].ch = 32;
  142.         }
  143.    break;
  144.  
  145.    case 13:  /*--- Return ---> Zeilenende  */
  146.          if ( zeile < MAX_ZEILEN - 1)
  147.         {
  148.          gotoxy(1, zeile + 2);
  149.          (*screen)[zeile][MAX_SPALTEN].at = LIGHTGRAY;
  150.          (*screen)[zeile++][MAX_SPALTEN].ch = CR;
  151.          spalte = 0;
  152.          abs_zeile++;
  153.         }
  154.          else
  155.         {
  156.          Scroll(+1);
  157.          gotoxy(1, zeile + 1);
  158.          spalte = 0;
  159.         }
  160.    break;
  161.  
  162.    default:  /*--- normale Tastatureingabe, OVERWRITE und INSERT */
  163.         if (Toggle_Insert == FALSE)
  164.            {
  165.         gotoxy(spalte + 2, zeile + 1);
  166.         (*screen)[zeile][spalte].at = LIGHTGRAY;
  167.         (*screen)[zeile][spalte++].ch = taste;
  168.            }
  169.         else
  170.            {
  171.         for ( i = MAX_SPALTEN; i > spalte; i-- )
  172.             {
  173.               (*screen)[zeile][i].ch = (*screen)[zeile][i-1].ch;
  174.             }
  175.         (*screen)[zeile][spalte].at = LIGHTGRAY;
  176.         (*screen)[zeile][spalte++].ch = taste;
  177.            }
  178.    break;
  179.   }
  180.  } while (taste != 0x1B); /* Ausstieg mit ESCAPE */
  181.  
  182. QuitProgramm();
  183. }
  184.  
  185.  
  186. /* -- PROZEDUREN --------------------------------------- */
  187.  
  188. word GetKey(void)
  189. {
  190.  return(getch());
  191. }
  192.  
  193. /* ----------------------------------------------------- */
  194. void select_file()
  195. {
  196. char *xtext[30];
  197.  
  198.  textbackground(LIGHTGRAY);
  199.  textcolor(BLACK);
  200.  
  201.  gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  202.  cprintf("                                                                              ");
  203.  
  204.  gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  205.  cprintf("  Bitte geben Sie einen Dateinamen an: ");
  206.  cscanf("%s", dokument);
  207.  
  208.  strcpy(xtext," Datei: ");
  209.  strncat(xtext, dokument, 20);
  210.  cprintf("  Zeile:%03d  Spalte:%03d   /\\  F2-SPEICHERN  F3-LADEN  /\\ %21.21s ", abs_zeile + 1, spalte + 1,  xtext);
  211.  
  212.  getch();
  213.  
  214.  gotoxy(spalte + 1, zeile +1);
  215.  textbackground(BLACK);
  216.  textcolor(LIGHTGRAY);
  217. }
  218.  
  219. /* ----------------------------------------------------- */
  220.  
  221. int SaveFile(char* Filename)
  222. {
  223. int i, z;
  224. char c;
  225. FILE *datei;
  226. strcpy( Filename, Filename);
  227. datei = fopen ( Filename, "w");  /* im Textmode  */
  228.  
  229.  /* Bildschirmspeicher mit in den Textpuffer sichern  */
  230.  /* 256 ist als CR-Kennung definiert */
  231.  
  232.  text = textstart;
  233.  
  234.  for (i=0; i <= (79 * MAX_ZEILEN); i++)
  235.      {
  236.        text[i] = (*screen)[MIN_ZEILEN][i].ch;
  237.      }
  238.  
  239.      for ( z=0; z <= ende_zeiger; z++ )
  240.       {
  241.        for ( i=0; i <= 78; i++)
  242.            {
  243.          c = text[i+z*80];
  244.          if ( !c )
  245.              c = ' ';
  246.          fputc( c, datei);
  247.            }
  248.        fputc( 13, datei );      // Carriage Return und
  249.        fputc( 10, datei );      // Line Feed als Zeilenabschluß
  250.       }
  251.  
  252. fclose(datei);
  253. return(TRUE);
  254. }
  255.  
  256. /* ----------------------------------------------------- */
  257.  
  258. int LoadFile(char* Filename)
  259. {
  260. int i, z, zeile;
  261. char c;
  262. FILE *datei;
  263. strcpy( Filename, Filename);
  264. datei = fopen ( Filename, "r+t");        /* im Textmode  */
  265.  
  266. if (datei == NULL)
  267.     fopen ( Filename, "w+t" );           /* Neue Datei öffnen */
  268.  
  269. text = textstart;
  270.  
  271.  
  272. //-------- Bildschirm und Speicher füllen
  273.  
  274. zeile = 0;
  275. c = ' ';
  276. while ( c != EOF )
  277. {
  278. i = -1;
  279.  
  280.  //------- Jeweils eine Zeile
  281.  do {
  282.      // Ausnahmegel: CR oder LF
  283.      if ( c == 13 || c == 10)
  284.     {
  285.      for ( z = i; z < 80; z++)
  286.          {
  287.            c = ' ';
  288.            text[(zeile * 80) + i++] = c;
  289.          }
  290.     }
  291.     else
  292.     {
  293.      text[(zeile * 80) + i++] = c;
  294.      c = fgetc(datei);
  295.     }
  296.  } while ( (c != EOF) && (i < 80) );
  297.  //-------  Zeile Ende
  298. zeile++;
  299. }
  300.  
  301. gotoxy(1,1);
  302. printf("%s", text);
  303.  
  304. //--------  Resttext in Puffer kopieren
  305. while ( c != EOF )
  306. {
  307. i = -1;
  308.  
  309. //------- Jeweils eine Zeile
  310.  
  311.  do {
  312.      // Ausnahmegel: CR oder LF
  313.      if ( c == 13 || c == 10)
  314.     {
  315.      for ( z = i; z < 80; z++)
  316.          {
  317.            c = ' ';
  318.            text[(zeile * 80) + i++] = c;
  319.          }
  320.     }
  321.     else
  322.     {
  323.      text[(zeile * 80) + i++] = c;
  324.      c = fgetc(datei);
  325.     }
  326.   } while ( (c != EOF) && (i < 80) );
  327.  
  328. zeile++;
  329. }
  330.  
  331. ende_zeiger = --zeile - 1;
  332.  
  333. fclose(datei);
  334. return(TRUE);
  335. }
  336. /* ----------------------------------------------------- */
  337.  
  338. void Scroll(int x)
  339. {
  340. int i;
  341.  
  342.  switch (x)
  343.  {
  344.   case 1:
  345.     scroll_up();
  346.   break;
  347.  
  348.   case 23:
  349.       if (abs_zeile < ende_zeiger)
  350.       {
  351.          for (i = 1; i <= 23; i++)
  352.          {
  353.           if ( zeile < MAX_ZEILEN - 1)
  354.              {
  355.               gotoxy(spalte + 1, ++zeile +1);
  356.               abs_zeile++;
  357.              }
  358.           else if ( zeile == MAX_ZEILEN - 1 )
  359.               Scroll ( 1 );
  360.           }
  361.       }
  362.   break;
  363.  
  364.   case 99:
  365.       while (abs_zeile < ende_zeiger)
  366.       {
  367.           if ( zeile < MAX_ZEILEN - 1)
  368.              {
  369.               gotoxy(spalte + 1, ++zeile +1);
  370.               abs_zeile++;
  371.              }
  372.           else if ( zeile == MAX_ZEILEN - 1 )
  373.               Scroll ( 1 );
  374.  
  375.        gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  376.        cprintf("  Zeile:%03d  Spalte:%03d ", abs_zeile + 1, spalte + 1);
  377.       }
  378.   break;
  379.  
  380.   case -1:
  381.        scroll_down();
  382.   break;
  383.  
  384.   case -23:
  385.        for (i = 1; i <= 23; i++)
  386.         {
  387.          if ( zeile > MIN_ZEILEN )
  388.         {
  389.           gotoxy(spalte + 1, --zeile +1);
  390.           abs_zeile--;
  391.         }
  392.          else if ( zeile == MIN_ZEILEN )
  393.                Scroll ( -1 );
  394.          }
  395.    break;
  396.  
  397.    case -99:
  398.        while ( abs_zeile )
  399.         {
  400.          if ( zeile > MIN_ZEILEN )
  401.         {
  402.           gotoxy(spalte + 1, --zeile +1);
  403.           abs_zeile--;
  404.         }
  405.          else if ( zeile == MIN_ZEILEN )
  406.              {
  407.               gotoxy(MIN_SPALTEN + 1, MAX_ZEILEN + 1);
  408.               cprintf("  Zeile:%03d  Spalte:%03d ", abs_zeile + 1, spalte + 1);
  409.               Scroll ( -1 );
  410.              }
  411.         }
  412.  
  413.  
  414.    break;
  415.  
  416.  }
  417. }
  418. /* ----------------------------------------------------- */
  419.  
  420. void QuitProgramm()
  421. {
  422.  clrscr();
  423.  _setcursortype(_NORMALCURSOR);
  424.  exit(0);
  425. }
  426.  
  427.  
  428. /* ----------------------------------------------------- */
  429. int video_modus ()
  430. {
  431.  union REGS regs;
  432.  regs.h.ah = 0x0F;
  433.  int86(0x10, ®s, ®s);
  434.  return(regs.h.al);
  435. }
  436.  
  437. /* ------------------------------------------------------ */
  438. void video_init ()
  439. {
  440.  if (video_modus() == 7)
  441.     {
  442.      screen = MK_FP( MONO_SEG, 0 );
  443.     }
  444.     else
  445.     {
  446.      screen = MK_FP( COLOR_SEG, 0 );
  447.     }
  448. }
  449. /* ----------------------------------------------------- */
  450.  
  451. void init()
  452. {
  453. long i;
  454.  textstart = malloc(TEXTSPEICHER);
  455.  
  456.  video_init();
  457.  
  458.  for (i = 0; i <= TEXTSPEICHER; i++)
  459.       textstart[i] = 0;
  460.  
  461.  clrscr();
  462. }
  463.  
  464.  
  465. /* ----------------------------------------------------- */
  466.  
  467. void scroll_up()
  468. {
  469.  union REGS regs;
  470.  int i;
  471.  char far *copy_screen;
  472.  
  473.  // oberste Zeile retten!
  474.  
  475.  text = textstart + (abs_zeile - MAX_ZEILEN + 1) * 80;
  476.  
  477.  for (i=0; i <= 79; i++)
  478.      {
  479.        text[i] = (*screen)[MIN_ZEILEN][i].ch;
  480.      }
  481.  
  482.       abs_zeile++;
  483.       regs.h.ah = 0x06;
  484.       regs.h.al = 1;             /* Anzahl zu scrollender Zeilen */
  485.       regs.h.ch = 0;             /* obere linke Zeile    */
  486.       regs.h.cl = 0;             /* obere linke Spalte   */
  487.       regs.h.dh = 23;            /* untere rechte Zeile  */
  488.       regs.h.dl = 79;            /* untere rechte Spalte */
  489.       regs.h.bh = 7;             /* Farbattribut für Leerzeilen */
  490.       int86(0x10, ®s, ®s);
  491.  
  492.   // unterste Zeile schreiben!
  493.  
  494.      text = textstart + (abs_zeile) * 80;
  495.  
  496.      for (i=0; i <= 79; i++)
  497.      {
  498.        (*screen)[MAX_ZEILEN - 1][i].ch = text[i];  // OK
  499.      }
  500. }
  501.  
  502. /* ----------------------------------------------------- */
  503.  
  504. void scroll_down()
  505. {
  506.  union REGS regs;
  507.  int i;
  508.  char far *copy_screen;
  509.  
  510.  if (abs_zeile > 0)  /* nach unten scrollen */
  511.      {
  512.       // unterste Zeile in Speicher retten
  513.  
  514.       text = textstart + (abs_zeile + MAX_ZEILEN - 1) * 80;
  515.  
  516.       for (i=0; i <= 79; i++)
  517.        {
  518.         text[i] = (*screen)[MAX_ZEILEN - 1][i].ch;
  519.        }
  520.  
  521.       abs_zeile--;
  522.       regs.h.ah = 0x07;
  523.       regs.h.al = 1;             /* Anzahl zu scrollender Zeilen */
  524.       regs.h.ch = 0;             /* obere linke Zeile    */
  525.       regs.h.cl = 0;             /* obere linke Spalte   */
  526.       regs.h.dh = 23;            /* untere rechte Zeile  */
  527.       regs.h.dl = 79;            /* untere rechte Spalte */
  528.       regs.h.bh = 7;             /* Farbattribut für Leerzeilen */
  529.       int86(0x10, ®s, ®s);
  530.  
  531.       // oberste Zeile aufbauen!
  532.  
  533.       text = textstart + (abs_zeile) * 80;
  534.       for (i=0; i <= 79; i++)
  535.        {
  536.         (*screen)[MIN_ZEILEN][i].ch = text[i];    // OK
  537.        }
  538.     }
  539. }
  540.  
  541. /* ----------------------------------------------------- */
  542.  
  543.  
  544. void sondertasten(byte key)
  545. {
  546. int i;
  547.   switch ( key )
  548.   {
  549.  
  550.    case 0x48:  /*--- Cursor up */
  551.          if ( zeile > MIN_ZEILEN )
  552.         {
  553.           gotoxy(spalte + 1, --zeile +1);
  554.           abs_zeile--;
  555.         }
  556.          else if ( zeile == MIN_ZEILEN )
  557.                Scroll ( -1 );
  558.    break;
  559.  
  560.  
  561.    case 0x50:  /*--- Cursor down */
  562.          if ( zeile < MAX_ZEILEN - 1)
  563.         {
  564.           gotoxy(spalte + 1, ++zeile +1);
  565.           abs_zeile++;
  566.         }
  567.          else if ( zeile == MAX_ZEILEN - 1 )
  568.                Scroll ( 1 );
  569.    break;
  570.  
  571.  
  572.    case 0x4D:  /*--- Cursor right */
  573.  
  574.           if ( spalte < MAX_SPALTEN )
  575.            gotoxy(spalte++ + 1, zeile +1);
  576.  
  577.    break;
  578.  
  579.  
  580.    case 0x4B:  /*--- Cursor left */
  581.  
  582.           if ( spalte > MIN_SPALTEN )
  583.            gotoxy(spalte-- + 1, zeile +1);
  584.  
  585.    break;
  586.  
  587.    case 0x52:  /*--- INSERT */
  588.           if (Toggle_Insert)
  589.          {
  590.           Toggle_Insert = FALSE;
  591.           _setcursortype(_SOLIDCURSOR);
  592.          }
  593.           else
  594.          {
  595.           Toggle_Insert = TRUE;
  596.           _setcursortype(_NORMALCURSOR);
  597.          }
  598.    break;
  599.  
  600.    case 0x53:  /*--- DELETE */
  601.         for ( i = spalte + 1; i < MAX_SPALTEN; i++ )
  602.             {
  603.               (*screen)[zeile][i-1].ch = (*screen)[zeile][i].ch;
  604.             }
  605.    break;
  606.  
  607.    case 0x3B:  /*--- F1 */
  608.    break;
  609.  
  610.    case 0x3C:  /*--- F2 */
  611.         SaveFile(dokument);
  612.    break;
  613.  
  614.    case 0x3D:  /*--- F3 */
  615.         select_file();
  616.         LoadFile(dokument);
  617.    break;
  618.  
  619.    case 0x47:  /*--- POS1 */
  620.         spalte = MIN_SPALTEN;
  621.         gotoxy(spalte + 1, zeile +1);
  622.    break;
  623.  
  624.    case 0x4F:  /*--- END */
  625.    break;
  626.  
  627.    case 0x49:  /*--- Page up */
  628.         Scroll(-23);
  629.    break;
  630.  
  631.    case 0x51:  /*--- Page down */
  632.         Scroll(23);
  633.    break;
  634.  
  635.    case 0x84:  /*--- CTRL + Page up */
  636.         Scroll(-99);
  637.    break;
  638.  
  639.    case 0x76:  /*--- CTRL + Page down */
  640.         Scroll(99);
  641.    break;
  642.  
  643.    default:
  644.    break;
  645.   }
  646.  
  647. }
  648.  
  649. /* ----------------------------------------------------- */
  650. /* -                  Ende von MUMIC.C                   */
  651.