home *** CD-ROM | disk | FTP | other *** search
/ M.u.C.S. Disc 2000 / MUCS2000.iso / anwend / qed453 / src / wp_print.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-18  |  7.8 KB  |  425 lines
  1. /*
  2.  * Dieses Modul basiert auf einem Modula2-Quelltext von Uwe Mindrup @ LB
  3. */
  4. #include <string.h>
  5. #include <osbind.h>
  6. #include <time.h>
  7.  
  8. #include "global.h"
  9. #include "wp-print.h"
  10.  
  11.  
  12. #define MAX_SEQUENCE        0x4F
  13. #define MAXTRANSLATIONS 0xFF
  14. /* es folgen die Konstanten für den Tabelleneingang der Funktionen: */
  15. #define VERTPOS            5
  16. #define BOLD                6
  17. #define ITALIC             0xA
  18. #define LIGHT                0xE
  19. #define SUPERSCRIPT        0x12
  20. #define SUBSCRIPT         0x16
  21. #define _UNDERLINE         0x1A
  22. #define HORZINIT            0x1F
  23. #define VERTINIT            0x20
  24. #define PRINTERINIT        0x21
  25.  
  26. #define _1STTYPE            0x28
  27. #define _1STCOLOR         0x30
  28. #define PROP                0x35
  29. #define FORMFEED            0x1E
  30. #define WRITELN            1
  31. #define TAB                 0x09
  32.  
  33. typedef struct
  34. {
  35.     int    len;
  36.     int    pos;
  37. } TABLEENTRY;
  38.  
  39.  
  40. /*
  41.  * lokale Variablen
  42. */
  43. static TABLEENTRY    seq_table[MAX_SEQUENCE + 1],
  44.                          trans_table[MAXTRANSLATIONS + 1];
  45. static char         *cfg_ptr;
  46. static int            prn_hdl,
  47.                         char_pos,                     /* Position des Zeichens in der aktuellen Zeile */
  48.                         nr_spaces,                    /* Anzahl Leerzeichen */
  49.                         nlq_set,                        /* [0..2] */
  50.                         akt_mode, akt_color,
  51.                         tab_size,
  52.                         prop_size;
  53. static bool            proportional,
  54.                         config_read = FALSE;
  55. static char            cfg_name[256];
  56.  
  57. /*
  58.  * lokale Prozeduren
  59. */
  60. static void init_tables(void)                        /* Tabellen initialisieren */
  61. {
  62.     int    i;
  63.  
  64.     for (i = 0; i <= MAX_SEQUENCE; i++)
  65.         seq_table[i].len = 0;
  66.     for (i = 0; i <= MAXTRANSLATIONS; i++)
  67.         trans_table[i].len = 0;
  68.     char_pos = 0;
  69. }
  70.  
  71. static bool out(char ch)
  72. {
  73.     if (prn_hdl == -2)
  74.         Cauxout(ch);
  75.     else if (prn_hdl == -3)
  76.         Cprnout(ch);
  77.     else
  78.         Fwrite(prn_hdl, 1, &ch);
  79.     return TRUE;
  80. }
  81.  
  82.  
  83. static bool print_seq(int which)
  84. {
  85.     int        i;
  86.     bool    ok;
  87.  
  88.     for (i = seq_table[which].pos; i <= seq_table[which].pos + seq_table[which].len - 1; i++)
  89.     {
  90.         ok = out(cfg_ptr[i]);
  91.         if (!ok)
  92.             break;
  93.     }
  94.     return ok;
  95. }
  96.  
  97.  
  98. static bool print(int entry, bool set)        /* Ausgabe der angewählten Steuersequenz */
  99. {
  100.     if (!set)
  101.         entry++;
  102.     return print_seq(entry + nlq_set);
  103. }
  104.  
  105.  
  106. static bool write_char(char ch)
  107. {
  108.     int        i;
  109.     bool    ok;
  110.  
  111.     if (trans_table[ch].len > 0)
  112.     {
  113.         for (i = trans_table[ch].pos; i <= trans_table[ch].pos + trans_table[ch].len - 1; i++)
  114.         {
  115.             ok = out(cfg_ptr[i]);
  116.             if (!ok)
  117.                 break;
  118.         }
  119.         char_pos++;
  120.     }
  121.     else
  122.     {
  123.         ok = out(ch);
  124.         char_pos++;
  125.     }
  126.     return ok;
  127. }
  128.  
  129.  
  130. static bool set_head(void)                            /*  Druckkopf neu positionieren */
  131. {
  132.     int        i, len, pos;
  133.     bool    ok;
  134.  
  135.     len = seq_table[VERTPOS].len;
  136.     pos = seq_table[VERTPOS].pos;
  137.     for (i = pos; i <= pos + len - 1; i++)
  138.     {
  139.         if (cfg_ptr[i] == 0x80)
  140.             ok = out((char_pos * 60 / prop_size) % 256);
  141.         else if (cfg_ptr[i] == 0x81)
  142.             ok = out((char_pos * 60 / prop_size) / 256);
  143.         else
  144.             ok = out(cfg_ptr[i]);
  145.         if (!ok)
  146.             break;
  147.     }
  148.     nr_spaces = 0;
  149.     return ok;
  150. }
  151.  
  152.  
  153. /*
  154.  * exportierte Prozeduren
  155. */
  156. bool wp_load_cfgfile(char *name)
  157. {
  158.     long    length, err;
  159.     int    f, i, j, Pos, Len;
  160.  
  161.     if ((strcmp(name, cfg_name) == 0) && config_read)    /* Config bereits geladen */
  162.         return TRUE;
  163.     else
  164.     {
  165.         strcpy(cfg_name, name);
  166.         config_read = FALSE;
  167.     }
  168.  
  169.     err = Fopen(name, 0);
  170.     if (err < 0)
  171.         return FALSE;
  172.     f = (int)err;
  173.  
  174.     if (cfg_ptr != NULL)
  175.         Mfree(cfg_ptr);
  176.  
  177.     length = Fseek(0, f, 2);                        /* ganz ans Ende */
  178.  
  179.     cfg_ptr = Malloc(length);
  180.     if (cfg_ptr == NULL)
  181.     {
  182.         Fclose(f);
  183.         return FALSE;
  184.     }
  185.  
  186.     Fseek(0, f, 0);                                    /* zurück zum Anfang */
  187.     err = Fread(f, length, cfg_ptr);
  188.     Fclose(f);
  189.  
  190.     init_tables();
  191.  
  192.     /* Kennung überprüfen: */
  193.     if (strncmp(cfg_ptr, "GST-CFG:", 8) != 0)
  194.         return FALSE;                                    /* keine GST-CFG-Datei !!! */
  195.  
  196.     /* Jetzt müssen die Tabellen aufgebaut werden: */
  197.     i = 8;                                                /* Druckernamen überspringen */
  198.     while (cfg_ptr[i] != '\0')
  199.         i++;
  200.     i += 7;                                                /* Druckeranpassungen interessieren nicht.  */
  201.  
  202.     /* zunächst die Tabelle der Druckerbesonderheiten:  */
  203.     while (cfg_ptr[i] != '\0')                        /* Tabelle wird mit einem NUL-Byte beendet */
  204.     {
  205.         Len = cfg_ptr[i];
  206.         Pos = cfg_ptr[i+1];                            /* Tabelleneintrag */
  207.         seq_table[Pos].len = Len - 2;
  208.         seq_table[Pos].pos = i + 2;
  209.         i += Len;
  210.     }
  211.     i++;                                                    /* Tabellenende überspringen */
  212.  
  213.     /* jetzt die ÜbersetzungsTabelle:    */
  214.     while (cfg_ptr[i] != '\0')                        /* Tabelle wird mit einem NUL-Byte beendet */
  215.     {
  216.         Len = cfg_ptr[i];
  217.         Pos = cfg_ptr[i+1];
  218.         trans_table[Pos].len = Len - 2;
  219.         trans_table[Pos].pos = i + 2;
  220.         i += Len;
  221.     }
  222.  
  223.     /* Optimierung der Druckercharakteristik-Tabelle: */
  224.     /* 1. die Texteffekte: */
  225.     for (i = BOLD; i <= _UNDERLINE; i+=4)
  226.         for (j = i; j <= i+1; j++)
  227.         {
  228.             if ((seq_table[j].len == 0) && (seq_table[j+2].len != 0))
  229.                 seq_table[j] = seq_table[j+2];
  230.             if ((seq_table[j+2].len == 0) && (seq_table[j].len != 0))
  231.                 seq_table[j+2] = seq_table[j];
  232.         }
  233.  
  234.     /* 2. die Schriftarten: */
  235.     for (i = _1STTYPE; i <= _1STTYPE + 6; i+=2)
  236.     {
  237.         if ((seq_table[i].len == 0) && (seq_table[i+1].len != 0))
  238.             seq_table[i] = seq_table[i+1];
  239.         if ((seq_table[i+1].len == 0) && (seq_table[i].len != 0))
  240.             seq_table[i+1] = seq_table[i];
  241.     }
  242.     config_read = TRUE;
  243.     return TRUE;
  244. }
  245.  
  246.  
  247. void wp_get_prnname(char *Printername, int max_len)
  248. {
  249.     int    i;
  250.  
  251.     if (cfg_ptr != NULL)
  252.     {
  253.         i = 8;
  254.         while ((cfg_ptr[i] != '\0') && (i < (max_len + 8)))
  255.         {
  256.             Printername[i-8] = cfg_ptr[i];
  257.             i++;
  258.         }
  259.         Printername[i - 8] = '\0';
  260.     }
  261.     else
  262.         Printername[0] = '\0';
  263. }
  264.  
  265. bool wp_send_init(bool use_nlq)
  266. {
  267.     bool    ok;
  268.  
  269.     if (use_nlq)
  270.         nlq_set = 2;
  271.     else
  272.         nlq_set = 0;
  273.     ok = print_seq(PRINTERINIT);        /* allgemeiner Init */
  274.     if (ok)
  275.     {
  276.         print_seq(HORZINIT);                    /* Horizontale Initialisierung */
  277.         print_seq(VERTINIT);                    /* Vertikale Initialisierung    */
  278.         print(BOLD, FALSE);                    /* Fettschrift aus.                */
  279.         print(ITALIC, FALSE);                /* Kursivschrift aus.             */
  280.         print(LIGHT, FALSE);                    /* Light aus.                        */
  281.         print(SUPERSCRIPT, FALSE);            /* Superscript aus.                */
  282.         print(SUBSCRIPT, FALSE);            /* Subscript aus.                    */
  283.         print(_UNDERLINE, FALSE);            /* Unterstreichung aus.            */
  284.           akt_mode = -1;
  285.          print_seq(_1STTYPE);                    /* PICA (10 CPI)                    */
  286.         akt_color = -1;
  287.         print_seq(_1STCOLOR);                /* Color-Einstellung: Black.    */
  288.         proportional = FALSE;
  289.         print_seq(PROP + 1);                    /* proportional-Schrift aus.    */
  290.     }
  291.     return ok;
  292. }
  293.  
  294.  
  295. bool wp_send_exit(void)
  296. {
  297.     return print_seq(PRINTERINIT);
  298. }
  299.  
  300.  
  301. bool wp_set_mode(int mode)
  302. {
  303.     bool    ok = TRUE;
  304.  
  305.     if ((mode >= PICA) && (mode <= EXPANDED))
  306.     {
  307.         if (mode != akt_mode)
  308.         {
  309.             ok = print_seq(2 * mode + _1STTYPE + (nlq_set / 2));
  310.             akt_mode = mode;
  311.         }
  312.     }
  313.     return ok;
  314. }
  315.  
  316.  
  317. bool wp_formfeed(void)
  318. {
  319.     return print_seq(FORMFEED);
  320. }
  321.  
  322.  
  323. void wp_set_tabsize(int tab)
  324. {
  325.     tab_size = tab;
  326. }
  327.  
  328.  
  329. bool wp_write_ln(void)
  330. {
  331.     bool    ok;
  332.  
  333.     ok = print_seq(WRITELN);
  334.     char_pos = 0;
  335.     return ok;
  336. }
  337.  
  338.  
  339. bool wp_write(char ch)
  340. {
  341.     int        i;
  342.     bool    ok;
  343.  
  344.     if ((ch == TAB) || (ch == ' '))
  345.     {
  346.         if (proportional)
  347.         {
  348.             if  (ch == ' ')
  349.             {
  350.                 char_pos++;
  351.                 nr_spaces++;
  352.             }
  353.             else
  354.             {
  355.                 char_pos += tab_size;
  356.                 nr_spaces += tab_size;
  357.             }
  358.         }
  359.         else
  360.         {
  361.               if (ch == ' ')
  362.                 ok = write_char(' ');
  363.             else
  364.                  for (i = 1; i <= tab_size; i++)
  365.                     ok = write_char(' ');
  366.         }
  367.     }
  368.     else
  369.     {
  370.         if (nr_spaces > 1)
  371.             ok = set_head();
  372.         else if (nr_spaces == 1)
  373.         {
  374.             ok = write_char(' ');
  375.             nr_spaces = 0;
  376.         }
  377.         ok = write_char(ch);
  378.     }
  379.     return ok;
  380. }
  381.  
  382.  
  383. bool wp_write_string(char *Str)
  384. {
  385.     int        i;
  386.     bool    ok = TRUE;
  387.  
  388.     i = 0;
  389.     while ((Str[i] != '\0') && ok)
  390.     {
  391.         ok = wp_write(Str[i]);
  392.         i++;
  393.     }
  394.     return ok;
  395. }
  396.  
  397.  
  398. bool wp_open(char *name)
  399. {
  400.     long    err;
  401.  
  402.     if (strcmp(name, "PRN:") == 0)
  403.         prn_hdl = -3;
  404.     else if (strcmp(name, "AUX:") == 0)
  405.         prn_hdl = -2;
  406.     else
  407.     {
  408.         err = Fopen(name, 1);
  409.         if (err == -33)
  410.             err = Fcreate(name, 0);
  411.         else if (err > 0)
  412.         {
  413.             prn_hdl = (int) err;
  414.             Fseek(0, prn_hdl, 2);
  415.         }
  416.     }
  417.     return (prn_hdl > -31);
  418. }
  419.  
  420.  
  421. void wp_close(void)
  422. {
  423.     Fclose(prn_hdl);
  424. }
  425.