home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / gpr140s / gdos.c < prev    next >
C/C++ Source or Header  |  1994-09-10  |  30KB  |  852 lines
  1. /********************************************
  2.  * Ausgabe auf Drucker ueber VDI und GDOS
  3.  * sk 07.93 - 09.94
  4. ********************************************/
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include <portab.h>
  9. #include <osbind.h>
  10. #include <vdibind.h>
  11. #include <aesbind.h>
  12. #include "gdos.h"
  13. #include "gprint.h"
  14.  
  15. PROGRAMFLAGS PF;
  16. FONT *fontp, *afp;
  17. char datei[200], null_string[4];
  18. char fname[40], fpath[200], lpath[200], spath[200];
  19. int  work_in[12], work_out[57], cb[256];
  20. int  ldrive, sdrive, xo, pagen, einr;
  21.  
  22. /*********************************************************/
  23. /* Diese Funktionen sind global verfuegbar               */
  24. void print_vek_on_workstation (int wk_handle, char *pmem, long tlen);
  25. void print_pix_on_workstation (int wk_handle, char *pmem, long tlen);
  26. int open_wkst(int wk_handle);
  27. void m_v_clswk(int handle);
  28.  
  29. /*********************************************************/
  30. /* Diese Funktionen werden nur in diesem Modul verwendet */
  31. void update        (int wkh, int *pa);
  32. void put_raster    (int wkh);
  33. int  get_ext       (int wkh, char *ps);
  34. void make_headline (int wkh, int xoff, int c_h);
  35. int  print         (int wkh, int xoff, int c_h, int texty, int pagey,
  36.                     int page, int *ab, char *ps);
  37. void new_page_norm (int wkh, int xoff, int c_h, long tlen,
  38.                     int *page, int *ty, long *text);
  39. int  new_page_quer (int wkh, int xoff, int c_h, long textende,
  40.                     int *pagenumber, int *texty, int *spalte, int *printy, long *text);
  41. char *korr_textzeiger(char *pmem, char *string, int *ab);
  42. int  einruecken      (char *last, char *neu);
  43. void underline       (int wkh, int y);
  44. void rahmen          (int wkh);
  45. void locher_marke    (int wkh, int page);
  46.  
  47. /*****************************************************************/
  48. /* Mit einem Vektorfont auf die geoeffnete Workstation ausgeben  */
  49. /*****************************************************************/
  50. void print_vek_on_workstation(int wk_handle, char *pmem, long tlen)
  51. {
  52.   char *hpmem;
  53.   char hs[1000], h2[1000], h3[1000], ls[1000];
  54.   static int y, fak, sp_breite, absf, py, pymax, sw, i;
  55.   static int char_width, char_height, cell_width, cell_height;
  56.   static int advx, advy, remx, remy;
  57.  
  58.   pagen = 1;                                       /* Seitennummer           */
  59.   y = 0;                                           /* Oben anfangen          */
  60.   fak = 1;                                         /* Spaltenindikator (1/2) */
  61.   einr = absf = FALSE;
  62.   *ls = 0x0;
  63.  
  64.   vswr_mode(wk_handle, MD_REPLACE);
  65.   vst_color(wk_handle, BLACK);
  66.   vst_height(wk_handle, PF.height, &char_width, &char_height,
  67.              &cell_width, &cell_height);
  68.  
  69.   for(i = 32; i < 256; i++)
  70.   {
  71.     vqt_advance(wk_handle, i, &advx, &advy, &remx, &remy);
  72.     if(remx > 7500)
  73.       advx++;
  74.     cb[i] = advx;
  75.   }
  76.   if(PF.rahmen)                                    /* Rahmen um den Text     */
  77.     rahmen(wk_handle);
  78.   if(PF.locher)                                    /* Markierung fuer Lochen */
  79.     locher_marke(wk_handle, pagen);
  80.  
  81.   if(PF.headline || PF.datum || PF.pagenum)        /* Kopfzeile ?            */
  82.   {
  83.     make_headline(wk_handle, PF.xo, cell_height);
  84.     if(PF.strich)                                  /* Kopfzeile untersteichen*/
  85.       underline(wk_handle, y + cell_height + cell_height / 2);
  86.     if(!PF.pagequer)                               /* norm. Seite: Leerzeile */
  87.       y += 2 * cell_height;
  88.   }
  89.  
  90.   if(PF.pagequer)                        /* maximale Spaltenbreite ermitteln */
  91.   {
  92.     underline    (wk_handle, work_out[1] / 2 + 1);
  93.     vst_rotation (wk_handle, 900);
  94.     sp_breite = work_out[1] / 2 - 90;              /* maximale Textbreite    */
  95.     py        = work_out[1];                  /* unten auf d. Seite anfangen */
  96.     pymax     = work_out[0] - PF.xo - cell_height;
  97.   }
  98.   else
  99.   {
  100.     vst_rotation(wk_handle, 0);                    /* Seite normal bedrucken */
  101.     if(PF.print_all)                             /* alle Seiten nacheinander */
  102.       sp_breite = work_out[0] - PF.xo - 30;
  103.     else                                 /* sonst: rechts Platz fuer Lochung */
  104.       sp_breite = work_out[0] - 2 * PF.xo;
  105.     pymax       = work_out[1] - 2 * cell_height;
  106.   }
  107.  
  108.   do
  109.   {
  110.     sw  = i = 0;
  111.     *hs = 0x0;                                     /* Strings loeschen       */
  112.     *h2 = 0x0;
  113.     *h3 = 0x0;
  114.  
  115.     if(einr)                        /* Einrueckung einer umgebrochenen Zeile */
  116.       einr = einruecken(ls, hs);
  117.  
  118.     while(*(hs + i))
  119.     {
  120.       sw += cb[(int)*(hs + i)];
  121.       i++;
  122.     }
  123.     hpmem = pmem;                             /* Kopie auf Anfang des Textes */
  124.     if(!PF.absatz)                            /* Text einfach ausgeben       */
  125.     {
  126.                    /* bis zum Zeilenende oder bis Spaltenbreite erreicht ist */
  127.       while(*pmem != 0xA && *pmem != 0xD && sw < sp_breite && pmem < (char *)tlen)
  128.       {
  129.         sw += cb[(int)*pmem];                 /* Textbreite berechnen     */
  130.         pmem++;
  131.       }
  132.  
  133.       strncat(hs, hpmem, pmem - hpmem);
  134.  
  135.       while(sw > sp_breite)                      /* Spaltenbreite erreicht ? */
  136.       {
  137.         while(*pmem != 0x20 && *pmem != 0x2D)    /* zurück bis SPACE oder '-'*/
  138.         {
  139.           pmem--;
  140.           sw -= cb[(int)*pmem];
  141.         }
  142.         if(pmem < hpmem) break;                  /* zu weit zurueck?         */
  143.         if(*pmem == 0x2D)                        /* zeigt auf '-' ?          */
  144.                                            /* Bindestrich ans Ende der Zeile */
  145.           hs[(int)((char *)pmem - (char *)hpmem) + 1] = 0x00;
  146.         else                               /* Das SPACE mit Null ueberschr.  */
  147.           hs[(int)((char *)pmem - (char *)hpmem)] = 0x00;
  148.  
  149.         strcpy(ls, hs);                          /* String kopieren          */
  150.         einr = TRUE;                             /* naechste Zeile einruecken*/
  151.         pmem--;
  152.       }
  153.       pmem += 2;                                 /* '\r\n' übergehen         */
  154.       if(*pmem == 0x0A)
  155.         pmem++;
  156.     }
  157.     else                               /* Absatzmodus: Text neu formatieren  */
  158.     {
  159.       static int sl, cc;
  160.       cc = 0;                                    /* Char-Counter             */
  161.       sl = (int)strlen(hpmem);                   /* Zeichenzahl des Absatzes */
  162.  
  163.       do
  164.       {
  165.         while(*pmem == 0x20 || *pmem == 0x2D)
  166.         {
  167.           sw += cb[(int)*pmem]; /* '-' und ' ' zu Beginn der Zeile uebergehen */
  168.           pmem++;               /* und Breite mitzaehlen                     */
  169.           cc++;
  170.         }
  171.                               /* vorwaerts bis Zeiger auf ' ' oder '-' zeigt */
  172.         while(*pmem != 0x20 && *pmem != 0x2D && *pmem != 0x00 && sw < sp_breite)
  173.         {
  174.           sw += cb[(int)*pmem];                        /* Breite des Textes  */
  175.           pmem++;
  176.           cc++;                                        /* Anzahl der Zeichen */
  177.         }
  178.  
  179.         strncpy(h2, hpmem, cc + 1) ;                   /* der Text           */
  180.         h2[cc + 1] = 0x00;                             /* Stringende         */
  181.         strcpy(h3, hs);                          /* Leerzeichenstring retten */
  182.         strcat(hs, h2);                                /* Text anhaengen     */
  183.         strcpy(hs, h3);                         /* Leerzeichenstring zurueck */
  184.  
  185.       } while((sw < sp_breite) && (*pmem != 0x00) && pmem < (char *)tlen);
  186.  
  187.       if(sw > sp_breite)   /* Text zu breit: letztes SPACE muss also OK sein */
  188.       {
  189.         pmem--;
  190.         sw -= cb[(int)*pmem];
  191.         while(*pmem != 0x20 && *pmem != 0x2D)
  192.         {
  193.           sw -= cb[(int)*pmem];                          /* zurueck im Text  */
  194.           pmem--;
  195.           cc--;
  196.         }
  197.         strncpy(h2, hpmem, cc);                          /* gueltiger Text   */
  198.         h2[cc] = 0x00;                                   /* Stringende       */
  199.         einr = TRUE;                                     /* Umbruch merken   */
  200.       }
  201.       strcat(hs, h2);
  202.       strcpy(ls, hs);                                /* Kopie für einruecken */
  203.  
  204.       pmem = korr_textzeiger(pmem, hs, &absf);
  205.     }
  206.  
  207.     y = print(wk_handle, PF.xo, cell_height, y, py, pagen, &absf, hs);
  208.  
  209.     if(y >= pymax)                                  /* Seitenende erreicht ? */
  210.     {
  211.       if(!PF.pagequer)                              /* Seite normal drucken  */
  212.       {
  213.         new_page_norm(wk_handle, PF.xo, cell_height, tlen, &pagen, &y, (long *)&pmem);
  214.       }
  215.       else                         /* Seite gedreht mit zwei Spalten drucken */
  216.       {
  217.         fak = new_page_quer(wk_handle, PF.xo, cell_height, tlen,
  218.                             &pagen, &y, &fak, &py, (long *)&pmem);
  219.       }
  220.     }
  221.   } while(pmem < (char *)tlen);         /* das alles bis der Text zuende ist */
  222.  
  223.            /* falls der Text auf eine Seite passt:                   y<pymax */
  224.            /* wenn nichts auf der Seite ist, würde sonst ein FF folgen: y!=0 */
  225.   if(y < pymax && y != 0 && PF.sparmod) /* Raster ueberlagern?               */
  226.     put_raster(wk_handle);
  227.  
  228. } /* print_vek_on_workstation() */
  229.  
  230. /*****************************************************/
  231. /* Pixelzeichensatz-Ausgabe                          */
  232. /* Die Zeilenbreite laesst sich schneller berechnen. */
  233. /* Ausserdem andere VDI-Aufrufe                      */
  234. /*****************************************************/
  235. void print_pix_on_workstation(int wk_handle, char *pmem, long tlen)
  236. {
  237.   char *hpmem;
  238.   char hs[800], help[800], ls[800];
  239.   static int y, fak, len, rlen, py, pymax, absf, sp_breite;
  240.   int char_width, char_height, cell_width, cell_height;
  241.  
  242.   pagen = 1;
  243.   y = 0;
  244.   fak = 1;
  245.   einr = FALSE;
  246.   *ls = 0x0;
  247.  
  248.   vst_height(wk_handle, PF.height, &char_width, &char_height,
  249.              &cell_width, &cell_height);
  250.  
  251.   if(PF.rahmen)
  252.     rahmen(wk_handle);
  253.   if(PF.locher)
  254.     locher_marke(wk_handle, pagen);
  255.   if(PF.headline || PF.datum || PF.pagenum)
  256.   {
  257.     make_headline(wk_handle, PF.xo, cell_height);
  258.     if(PF.strich)
  259.       underline(wk_handle, y + cell_height + cell_height / 2);
  260.     if(!PF.pagequer)
  261.       y += 2 * cell_height;
  262.   }
  263.  
  264.   if(PF.pagequer)
  265.   {
  266.     underline    (wk_handle, work_out[1] / 2 + 1);
  267.     vst_rotation (wk_handle, 900);
  268.     sp_breite = work_out[1] / 2 - 20;
  269.     py        = work_out[1] / fak;
  270.     pymax     = work_out[0] - PF.xo - 2 * cell_height;
  271.   }
  272.   else
  273.   {
  274.     vst_rotation(wk_handle, 0);
  275.     if(PF.print_all)
  276.       sp_breite = work_out[0] - PF.xo;
  277.     else
  278.       sp_breite = work_out[0] - 2 * PF.xo;
  279.     pymax       = work_out[1] - 2 * cell_height;
  280.   }
  281.  
  282.   len = sp_breite / cell_width;
  283.  
  284.   do
  285.   {
  286.     *hs = 0x0;
  287.     if(einr)                        /* Einrueckung einer umgebrochenen Zeile */
  288.     {
  289.       einr = einruecken(ls, hs);
  290.     }
  291.     hpmem = pmem;
  292.     if(!PF.absatz)
  293.     {
  294.       while(*pmem != 0xA && *pmem != 0xD && pmem < (char *)tlen)
  295.       {
  296.         strncat(hs, pmem++, 1);
  297.       }
  298.  
  299.       pmem++;
  300.       if(*pmem == 0xA)
  301.         pmem++;
  302.     }
  303.     else                                           /* Absatz neu formatieren */
  304.     {
  305.       static int cc;
  306.       cc = 0;
  307.       while(*pmem != 0x00 && cc < len && pmem < (char *)tlen)
  308.       {
  309.         pmem++;
  310.         cc++;
  311.       }
  312.       if(*pmem != 0x00)
  313.       {
  314.         pmem--;
  315.         while(*pmem != 0x20 && *pmem !=0x2D)
  316.         {
  317.           pmem--;
  318.           cc--;
  319.         }
  320.         einr = TRUE;
  321.       }
  322.       strncat(hs, hpmem, cc);
  323.       hs[cc] = 0x00;
  324.  
  325.       strcpy(ls, hs);
  326.  
  327.       pmem = korr_textzeiger(pmem, hs, &absf);
  328.     }
  329.  
  330.     if(!PF.pagequer)
  331.     {
  332.       if((strlen(hs) * cell_width) > sp_breite)
  333.       {
  334.         do
  335.         {
  336.           strncpy(help, hs, len--);
  337.         } while(len > 1  && *(help + len) != 32 && *(help + len) != 45);
  338.         *(help + len + 1) = 0x0;
  339.  
  340.         rlen = (int)strlen(hs) - len;
  341.         pmem = pmem - rlen - 1;
  342.         strcpy(hs, help);
  343.         strcpy(ls, help);
  344.         einr = TRUE;
  345.       }
  346.     }
  347.     else
  348.     {
  349.       if((strlen(hs) * cell_width) > sp_breite)            /* String zu lang */
  350.       {
  351.         len = sp_breite / cell_width;                /* max- Laenge bestimmen */
  352.  
  353.         do
  354.         {
  355.           strncpy(help, hs, len--);                    /* solange verkuerzen */
  356.           *(help + len + 1) = 0x0;
  357.         } while(len > 1  && *(help + len) != 32 && *(help + len) != 45);
  358.                                     /* bis ein SPACE oder "-" gefunden wurde */
  359.  
  360.         rlen = (int)strlen(hs) - len; /* restl. Laenge der urspruenglichen Zeile  */
  361.         pmem = pmem - rlen - 1 ; /* den glob. Textzeiger auf das SPACE setzen */
  362.  
  363.         strcpy(hs, help);       /* Hilfsstring in die zu druckende Var. kop. */
  364.         strcpy(ls, help);                        /* 2. Kopie fuer einruecken */
  365.         einr = TRUE;
  366.       }
  367.     }
  368.  
  369.     y = print(wk_handle, PF.xo, cell_height, y, py, pagen, &absf, hs);
  370.  
  371.     if(y >= pymax)
  372.     {
  373.       if(!PF.pagequer)                               /* Seite normal drucken */
  374.       {
  375.         new_page_norm(wk_handle, PF.xo, cell_height, tlen, &pagen, &y, (long *)&pmem);
  376.       }
  377.       else                         /* Seite gedreht mit zwei Spalten drucken */
  378.       {
  379.         fak = new_page_quer(wk_handle, PF.xo, cell_height, tlen,
  380.                             &pagen, &y, &fak, &py, (long *)&pmem);
  381.       }
  382.     }
  383.   } while(pmem < (char *)tlen);
  384.  
  385.   if(y < pymax && y != 0 && PF.sparmod)
  386.     put_raster(wk_handle);
  387.  
  388. } /* print_pix_on_workstation() */
  389.  
  390. /********************************************************/
  391. /* gewuenschte Workstation oeffnen                      */
  392. /* korrekte Schriftgroesse und Aufloesung berechnen     */
  393. /********************************************************/
  394. int open_wkst(int wk_handle)
  395. {
  396.     int i;
  397.     float f;
  398.  
  399.     ausgabe_vorbereiten();
  400.  
  401.     work_in[0] = wk_handle;
  402.     for(i = 1; i < 10; work_in[i++] = 1);
  403.     work_in[10] = 2;
  404.  
  405.     if(wk_handle > 20)
  406.     {
  407.       PF.dev_typ = TRUE;        /* Drucker */
  408.       v_opnwk(work_in, &wk_handle, work_out);
  409.       if(wk_handle)
  410.         f = 25400 / work_out[3];
  411.     }
  412.     else  /* Dieser Teil ist nur zum debuggen, da keine Screen-ID möglich ist */
  413.     {
  414.       PF.dev_typ = FALSE;
  415.       v_opnvwk(work_in, &wk_handle, work_out);
  416.       if(wk_handle)
  417.         f = 25400 / 90;
  418.     }
  419.  
  420.     if(wk_handle == 0)
  421.       form_alert(1, "[3][ GDOS-Print: |  Workstation konnte  |    nicht geöffnet  |       werden! |Drucker eingeschaltet ?][Abbruch]");
  422.     else
  423.     {
  424.       PF.res = (int)f;
  425.       PF.xo = (int)(PF.leftspace * PF.res / 25.4) - 118;  /* 118 -> Rand ATARI SLM 605 */
  426.       PF.height *= PF.res;
  427.       PF.height /= 72;
  428.     }
  429.  
  430.     return wk_handle;
  431. } /* open_wkst() */
  432.  
  433. /********************************************************/
  434. void m_v_clswk(int handle)
  435. {
  436.   if(PF.dev_typ == TRUE)
  437.     v_clswk(handle);
  438.   else
  439.     v_clsvwk(handle);
  440. } /* m_v_clswk() */
  441.  
  442. /****************************************************************************/
  443. /* Anfang einer umgebrochenen Zeile  wie die vorangehende Zeile einruecken  */
  444. /****************************************************************************/
  445. int einruecken(char *last, char *neu)
  446. {
  447.   int cp = 0;
  448.  
  449.   if(last[0] == '-')                    /* Alle fuehrenden '-' uebergehen    */
  450.   {
  451.     strcat(neu, " ");
  452.     cp++;
  453.   }
  454.   while(last[cp] == ' ')               /* für jedes SPACE in der alten Zeile */
  455.   {
  456.     strcat(neu, " ");                  /* eins in die neue einfuegen         */
  457.     cp++;
  458.   };
  459.   return FALSE;                        /* Das Einrueckflag zuruecksetzen     */
  460. } /* einruecken() */
  461.  
  462. /*******************************************************/
  463. /* Kopfzeile erzeugen (Dateiname, Datum, Seitennummer) */
  464. /*******************************************************/
  465. void make_headline(int wkh, int xoff, int c_h)
  466. {
  467.   char akt_datum[10], hl[250];
  468.  
  469.   *hl = 0x0;
  470.   if(PF.headline)
  471.     strcpy(hl, datei);
  472.   strcat(hl, "            ");
  473.   if(PF.datum)                                    /* Datum in die Kopfzeile? */
  474.   {
  475.     long t, ht, hm, hj;
  476.     t = Gettime();
  477.     hj = t & 0xFE000000L;
  478.     hj = (hj>>25) + 80;
  479.     hm = t &  0x1E00000L;
  480.     hm = (hm>>21);
  481.     ht = t &   0x1F0000L;
  482.     ht = (ht>>16);
  483.  
  484.     *akt_datum = 0x0;
  485.     sprintf(akt_datum, "%ld.%ld.%ld", ht, hm, hj);
  486.     strcat(hl, akt_datum);
  487.   }
  488.   if(PF.print_all)
  489.     strcat(hl, "            ");
  490.  
  491.   if(PF.pagenum && PF.print_all)                           /* Seitennummer?  */
  492.   {
  493.     sprintf(akt_datum, "%d", pagen);
  494.     strcat(hl, akt_datum);
  495.   }
  496.   else if(PF.pagenum && !PF.print_all)  /* gerade/ungerade: Sonderbehandlung */
  497.     sprintf(akt_datum, "%d", pagen);
  498.  
  499.   if(PF.pagequer)                 /* bei Querdruck: Textwinkel zuruecksetzen */
  500.     vst_rotation(wkh, 0);
  501.  
  502.   if(pagen >= PF.beginpage)           /* Soll diese Seite gedruckt werden?   */
  503.   {
  504.     if(PF.print_all ||                /* Alle Seiten drucken                 */
  505.       ((pagen & 1) && PF.print_odd) ||/* ungerade Seite UND ungerade drucken */
  506.       (!(pagen & 1) && PF.print_even))/* gerade Seite UND gerade drucken     */
  507.                           /* alle anderen Seiten MUESSEN leer bleiben: sonst */
  508.                           /* wird ein leeres Blatt mit Kopfzeile ausgegeben  */
  509.     {
  510.       if(afp->font_prop)              /* Proportionaler Zeichensatz (Speedo) */
  511.       {
  512.         if(PF.print_all)              /* ALLE SEITEN: normale Kopfzeile      */
  513.           v_ftext(wkh, xoff, c_h, hl);
  514.  
  515.         if(PF.pagenum && PF.print_odd) /* SEITENNUMMER und UNGERADE SEITEN   */
  516.         {
  517.           v_ftext(wkh, xoff, c_h, hl);      /* Dateiname und Datum links     */
  518.                                             /* Seitennummer rechts drucken   */
  519.           v_ftext(wkh, work_out[0] - get_ext(wkh, akt_datum) - xoff, c_h, akt_datum);
  520.         }
  521.         if(PF.pagenum && PF.print_even) /* SEITENNUMMER und GERADE SEITEN    */
  522.         {                               /* Dateiname und Datum rechts        */
  523.           v_ftext(wkh, work_out[0] - get_ext(wkh, hl) - xoff, c_h, hl);
  524.           v_ftext(wkh, xoff, c_h, akt_datum);  /* Seitennummer links drucken */
  525.         }
  526.       }
  527.       else                            /* normaler GDOS-Zeichensatz           */
  528.       {
  529.         if(PF.print_all)                       /* analog zu Proportionalfont */
  530.           v_gtext(wkh, xoff, c_h, hl);
  531.  
  532.         if(PF.pagenum && PF.print_odd)
  533.         {
  534.           v_gtext(wkh, xoff, c_h, hl);
  535.           v_gtext(wkh, work_out[0] - get_ext(wkh, akt_datum) - xoff, c_h, akt_datum);
  536.         }
  537.         if(PF.pagenum && PF.print_even)
  538.         {
  539.           v_gtext(wkh, work_out[0] - get_ext(wkh, hl) - xoff, c_h, hl);
  540.           v_gtext(wkh, xoff, c_h, akt_datum);
  541.         }
  542.       }
  543.     }
  544.   }
  545.  
  546.   if(PF.pagequer)                     /* Textwinkel bei Bedarf zuruecksetzen */
  547.     vst_rotation(wkh, 900);
  548. } /* make_headline() */
  549.  
  550. /**********************************************/
  551. /* Die Breite eines Textes in Pixel ermitteln */
  552. /**********************************************/
  553. int get_ext(int wkh, char *ps)
  554. {
  555.   int i, sw;
  556.   sw = i = 0;
  557.  
  558.   while(*(ps + i))
  559.   {
  560.     sw += cb[*ps + i];              /* Breite der einzelnen Zeichen addieren */
  561.   }
  562.   return sw;
  563. } /* get_ext() */
  564.  
  565. /******************************************/
  566. /* Die Seite zum Drucker schicken,        */
  567. /* Seitenzaehler erhoehen                 */
  568. /* bei Bedarf die Seite wegwerfen         */
  569. /* (gerade/ungerade)                      */
  570. /******************************************/
  571. void update(int wkh, int *seitennummer)
  572. {
  573.  
  574.   if(*seitennummer >= PF.beginpage &&
  575.     (  PF.print_all                       ||     /* entweder: alles          */
  576.      ((*seitennummer & 1) && PF.print_odd)||     /* ungerade Seite           */
  577.      (!(*seitennummer & 1) && PF.print_even) ) ) /* gerade Seite             */
  578.   {
  579.     int i;
  580.     PF.ask = TRUE;  /* Flag um zu Verhindern, dass z.B. beim Verwerfen einer */
  581.                     /* geraden Seite beim Drucken der ungeraden Seiten       */
  582.                     /* gefragt wird, ob weitergedruckt werden soll           */
  583.     if(PF.sparmod)
  584.     {
  585.       put_raster(wkh);
  586.     }
  587.  
  588.     for(i = 1; i <= PF.anz_copies; i++)           /* mehrere Kopien?         */
  589.       v_updwk(wkh);
  590.     v_clrwk(wkh);
  591.   }
  592.  
  593.   (*seitennummer)++;
  594. } /* update() */
  595.  
  596. /******************************************************************************/
  597. /* Toner-Sparmodus (aehnlich HP 4L)                                           */
  598. /* Durch Verknuepfung mit einem Raster werden nicht mehr alle Punkte gedruckt */
  599. /******************************************************************************/
  600. void put_raster(int wkh)
  601. {
  602.   int pxyarray[4];
  603.  
  604.   pxyarray[0] = 0;                                           /* Rechteck mit */
  605.   pxyarray[1] = 0;                                           /* Seitengroesse*/
  606.   pxyarray[2] = work_out[0];
  607.   pxyarray[3] = work_out[1];
  608.   vswr_mode    (wkh, MD_ERASE);                              /* Zeichenmodus */
  609.   vsf_color    (wkh, WHITE);
  610.   vsf_interior (wkh, IP_2PATT);                              /* gemustert    */
  611.   vsf_perimeter(wkh, IP_HOLLOW);                             /* kein Rahmen  */
  612.   vsf_style    (wkh, IP_5PATT);                              /* Fuellstil    */
  613.   v_bar        (wkh, pxyarray);
  614.   vswr_mode    (wkh, MD_REPLACE);
  615.  
  616. } /* put_raster() */
  617.  
  618. /***********************************************/
  619. /* Kopfzeile unterstreichen oder bei Querdruck */
  620. /* die Seite in der Mitte unterteilen          */
  621. /***********************************************/
  622. void underline(int wkh, int y)
  623. {
  624.   int pxyarray[4];
  625.  
  626.   if(PF.print_all || ((pagen & 1) && PF.print_odd) )
  627.   {
  628.     pxyarray[0] = PF.xo - 10;              /* wegen Zwischenraum Rahmen/Text */
  629.     pxyarray[2] = work_out[0];             /* bis zum rechten Rand           */
  630.   }
  631.   else if(!(pagen & 1) && PF.print_even)
  632.   {
  633.     pxyarray[0] = 0;                       /* gerade Seiten links anfangen   */
  634.     pxyarray[2] = work_out[0] - PF.xo;     /* rechts Rand zum Lochen         */
  635.   }
  636.   pxyarray[1] = y;
  637.   pxyarray[3] = y;
  638.   vswr_mode    (wkh, MD_REPLACE);
  639.   vsl_color    (wkh, BLACK);
  640.   vsf_interior (wkh, IP_1PATT);
  641.   vsf_perimeter(wkh, IP_HOLLOW);
  642.   vsf_style    (wkh, IP_5PATT);
  643.   if(pagen >= PF.beginpage && ( PF.print_all ||
  644.     ((pagen & 1) && PF.print_odd) || (!(pagen & 1) && PF.print_even) ) )
  645.   {
  646.     v_pline    (wkh, 2, pxyarray);
  647.   }
  648.   vswr_mode    (wkh, MD_REPLACE);
  649.  
  650. } /* underline() */
  651.  
  652. /*******************************************/
  653. /* Text mit einem Rahmen umgeben           */
  654. /*******************************************/
  655. void rahmen(int wkh)
  656. {
  657.   int pxyarray[4];
  658.  
  659.   if(PF.print_all || ((pagen & 1) && PF.print_odd) )
  660.   {
  661.     pxyarray[0] = PF.xo - 10;
  662.     pxyarray[2] = work_out[0];
  663.   }
  664.   else if(!(pagen & 1) && PF.print_even)
  665.   {
  666.     pxyarray[0] = 0;
  667.     pxyarray[2] = work_out[0] - PF.xo;
  668.   }
  669.   pxyarray[1] = 0;
  670.   pxyarray[3] = work_out[1];
  671.   vswr_mode    (wkh, MD_REPLACE);
  672.   vsl_color    (wkh, BLACK);
  673.   vsf_color    (wkh, BLACK);
  674.   vsf_interior (wkh, IP_HOLLOW);
  675.   vsf_style    (wkh, IP_HOLLOW);
  676.   if(pagen >= PF.beginpage && ( PF.print_all ||
  677.     ((pagen & 1) && PF.print_odd) || (!(pagen & 1) && PF.print_even) ) )
  678.   {
  679.     v_bar      (wkh, pxyarray);
  680.   }
  681.   vswr_mode    (wkh, MD_REPLACE);
  682.  
  683. } /* rahmen() */
  684.  
  685. /**********************************************/
  686. /* Mitte der Seite fuer den Locher markieren  */
  687. /**********************************************/
  688. void locher_marke(int wkh, int page)
  689. {
  690.   int pxyarray[4];
  691.  
  692.   if(page & 1)                  /* nur auf ungeraden Seiten */
  693.   {
  694.     pxyarray[0] = 0;
  695.     pxyarray[1] = work_out[1] / 2;
  696.     pxyarray[2] = 10;
  697.     pxyarray[3] = work_out[1] / 2;
  698.     vswr_mode    (wkh, MD_REPLACE);
  699.     vsf_color    (wkh, BLACK);
  700.     vsf_interior (wkh, IP_1PATT);
  701.     vsf_perimeter(wkh, IP_HOLLOW);
  702.     vsf_style    (wkh, IP_5PATT);
  703.     v_pline      (wkh, 2, pxyarray);
  704.     vswr_mode    (wkh, MD_REPLACE);
  705.   }
  706. } /* locher_marke() */
  707.  
  708. /***********************************************/
  709. /* Den Text einer Zeile ueber das VDI ausgeben */
  710. /***********************************************/
  711. int print(int wkh, int xoff, int c_h, int texty, int pagey, int page, int *ab, char *ps)
  712. {
  713.   if(page >= PF.beginpage &&
  714.     ( PF.print_all ||                     /* Das uebliche zur Unterdrueckung */
  715.     ((page & 1) && PF.print_odd) ||       /* leerer Seiten                   */
  716.     (!(page & 1) && PF.print_even) ) )
  717.   {
  718.     if(afp->font_prop)                              /* Speedo-Zeichensaetze  */
  719.     {
  720.       if(PF.pagequer)                               /* Seite quer?           */
  721.         v_ftext(wkh, xoff + texty + c_h, pagey, ps);
  722.       else
  723.         v_ftext(wkh, xoff, texty + c_h, ps);
  724.     }
  725.     else                                            /* Pixel-Zeichensaetze   */
  726.     {
  727.       if(PF.pagequer)
  728.         v_gtext(wkh, xoff + texty + c_h, pagey, ps);
  729.       else
  730.         v_gtext(wkh, xoff, texty + c_h, ps);
  731.     }
  732.   }
  733.  
  734.   texty += c_h;                                     /* neue Zeichenposition  */
  735.  
  736.   if(PF.absatz && *ab)                              /* Absatzmodus?          */
  737.   {
  738.     texty += c_h;                                   /* Leerzeile nicht verg. */
  739.     *ab = FALSE;
  740.   }
  741.   return(texty);                        /* neue Y-Pos. auf der Seite zurueck */
  742. } /* print() */
  743.  
  744. /*******************************************/
  745. /* Zeilenumbrueche und Leerzeichen am Ende */
  746. /* einer Zeile uebergehen                   */
  747. /*******************************************/
  748. char *korr_textzeiger(char *pmem, char *string, int *ab)
  749. {
  750.   if(*pmem == 0x00)                                 /* wirklich Stringende?  */
  751.   {
  752.     pmem++;                                         /* uebergehen            */
  753.     if(*pmem == 0x0A)                               /* newline?              */
  754.     {
  755.       pmem++;                                       /* uebergehen            */
  756.       *ab = TRUE;                                   /* Absatzflag setzen     */
  757.     }
  758.   }
  759.   else if(*pmem == 0x20)                /* Leerzeichen nur am Ende der Zeile */
  760.     pmem++;
  761.  
  762.   if(string[strlen(string) - 1] == 0x2D && *pmem == 0x2D)/* '-' am Zeilenanfang weg */
  763.     pmem++;                             /* weil das ein Trennstrich war      */
  764.  
  765.   return(pmem);                         /* neue Position im Text             */
  766. } /* korr_textzeiger() */
  767.  
  768. /******************************************/
  769. /* Seitenende                             */
  770. /* Seite ausgeben                         */
  771. /* evtl. auf Benutzereingabe warten       */
  772. /******************************************/
  773. void new_page_norm(int wkh, int xoff, int c_h, long textende,
  774.                    int *pagenumber, int *texty, long *text)
  775. {
  776.   int fb;
  777.   update(wkh, pagenumber);                 /* Seite ausgeben                 */
  778.   *texty = 0;
  779.  
  780.   if(PF.pagebreak && PF.ask)               /* Seitenweise und warten noetig? */
  781.   {
  782.     fb = form_alert(2, "[2][ GDOS-Print: |  Wollen Sie weiterdrucken?  ][Nein| Ja ]");
  783.     if(fb == 1)                            /* Abbruch                        */
  784.      *text = textende + 1;                 /* Textzeiger hinter den Text     */
  785.     if(!PF.print_all)                      /* Flag zuruecksetzen             */
  786.       PF.ask = FALSE;
  787.   }
  788.  
  789.   if(*text < textende)                     /* Text zu Ende?                  */
  790.   {
  791.     if(PF.rahmen)                          /* neue Seite vorbereiten         */
  792.       rahmen(wkh);
  793.     if(PF.locher)
  794.       locher_marke(wkh, *pagenumber);
  795.     if(PF.headline || PF.datum || PF.pagenum)
  796.     {
  797.       make_headline(wkh, xoff, c_h);
  798.       if(PF.strich)
  799.         underline(wkh, *texty + c_h + c_h / 2);
  800.  
  801.       *texty += 2 * c_h;
  802.     }
  803.   }
  804. } /* new_page_norm() */
  805.  
  806. /******************************************/
  807. /* Seitenende beim Querdruck              */
  808. /******************************************/
  809. int new_page_quer(int wkh, int xoff, int c_h, long textende,
  810.                   int *pagenumber, int *texty, int *spalte, int *printy, long *text)
  811. {
  812.   int fb;
  813.   *texty = 0;
  814.  
  815.   if(*spalte == 2)                             /* zweite Spalte schon voll?  */
  816.   {
  817.     update(wkh, pagenumber);                   /* dann ausgeben              */
  818.     *printy = work_out[1];  /* Zeichenposition an unteren Rand zuruecksetzen */
  819.  
  820.     if(PF.pagebreak && PF.ask)              /* auf Benutzerentscheid warten? */
  821.     {
  822.       fb = form_alert(2, "[2][ GDOS-Print: |  Wollen Sie weiterdrucken?  ][Nein| Ja ]");
  823.       if(fb == 1)
  824.         *text = textende + 1;                  /* s. new_page_norm()         */
  825.       if(!PF.print_all)
  826.         PF.ask = FALSE;
  827.     }
  828.  
  829.     if(*text < textende)
  830.     {
  831.       if(PF.rahmen)                         /* Rahmen, Locher-Marke und      */
  832.         rahmen(wkh);                        /* Mittelstrich sind unabhaengig */
  833.       if(PF.locher)                         /* von der Kopfzeile             */
  834.         locher_marke(wkh, *pagenumber);
  835.       underline(wkh, work_out[1] / 2 + 1);
  836.       if(PF.headline || PF.datum || PF.pagenum)
  837.       {
  838.         make_headline(wkh, xoff, c_h);
  839.         if(PF.strich)                       /* abhaengig von Kopfzeile       */
  840.           underline(wkh, *texty + c_h + c_h / 2);
  841.       }
  842.       return(1);                            /* Spaltennummer 1 zureuckgeben  */
  843.     }
  844.   }
  845.   else if(*spalte == 1)                     /* wenn erst in Spalte eins      */
  846.   {
  847.     *printy = work_out[1] / 2;              /* Text jetzt ab Mitte der Seite */
  848.     return(2);                              /* Spaltennummer gleich zwei     */
  849.   }
  850.   return(1);                            /* bis hier sollte man nicht kommen! */
  851. } /* new_page_quer() */
  852.