home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / print / dcfvba / dcfamp.c next >
Encoding:
C/C++ Source or Header  |  1994-02-03  |  10.9 KB  |  430 lines
  1. /**
  2. ***  This is a part of the DCFVBA project.   This set of functions handle
  3. ***  The PCL datastreams beginning with:  <Esc>&
  4. **/
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include "dcfvba.h"
  10.  
  11. /* -------------------------------------------------------------------------- */
  12.  
  13. void pcl_ampersand(void)
  14.    {
  15.    char pcl_command;
  16.  
  17.    double number;  /* holds PCL argument */
  18.    next_char();
  19.    pcl_command = (char)toupper(*current);
  20.    switch(pcl_command)
  21.       {
  22.       case 'A':
  23.          {
  24.          do
  25.             {
  26.             next_char();
  27.             pcl_ampersand_A();
  28.             }
  29.          while(strchr(PCL_END_SET,*current) == NULL);
  30.          break;
  31.          } /* case 'A' */
  32.       case 'D':
  33.          {
  34.          do
  35.             {
  36.             next_char();
  37.             number = get_pcl_arg();
  38.             pcl_ampersand_D(number);
  39.             }
  40.          while(strchr(PCL_END_SET,*current) == NULL);
  41.          break;
  42.          } /* case 'D' */
  43.       case 'K': /* Font pitch */
  44.          {
  45.          do
  46.             {
  47.             next_char();
  48.             number = get_pcl_arg();
  49.             pcl_ampersand_K(number);
  50.             }
  51.          while(strchr(PCL_END_SET,*current) == NULL);
  52.          break;
  53.          } /* case 'K' */
  54.       case 'L':
  55.          {
  56.          do
  57.             {
  58.             next_char();
  59.             number = get_pcl_arg();
  60.             pcl_ampersand_L(number);
  61.             }
  62.          while(strchr(PCL_END_SET,*current) == NULL);
  63.          break;
  64.          } /* case 'L' */
  65.       case 'S': /* End of line wrap */
  66.          {
  67.          error("End-of-line wrap not supported.",0);
  68.          break;
  69.          }
  70.       case '1':
  71.       case '2':
  72.       case '3':
  73.       case '4':
  74.       case '5':
  75.       case '6':
  76.       case '7':
  77.       case '8':
  78.       case '9':
  79.          {
  80.          number = get_pcl_arg();
  81.          pcl_ampersand_number(number);
  82.          break;
  83.          }
  84.       default:
  85.          {
  86.          char error_message[255];
  87.  
  88.          sprintf(error_message,"Unsupported PCL command: <Esc>&%c",*current);
  89.          error(error_message,8);
  90.          } /* default */
  91.       } /* switch */
  92.    } /* pcl_ampersand */
  93.  
  94. /* -------------------------------------------------------------------------- */
  95.  
  96. void pcl_ampersand_A(void)
  97.    {
  98.    double number;
  99.    int  signed_arg = NOSIGN; /* Flag indicating whether the argument was signed */
  100.    int  target_row;      /* Target output row on the page. */
  101.    char pcl_char;
  102.  
  103.    switch(*current)
  104.       {
  105.       case '+':
  106.          {
  107.          signed_arg = POSITIVE;
  108.          next_char();
  109.          break;
  110.          }
  111.       case '-':
  112.          {
  113.          signed_arg = NEGATIVE;
  114.          next_char();
  115.          break;
  116.          }
  117.       } /* switch */
  118.  
  119.    number = get_pcl_arg();
  120.    pcl_char = (char)toupper(*current);
  121.    switch(pcl_char)
  122.       {
  123.       case 'C': /* Absolute column positioning */
  124.          {
  125.          switch(signed_arg)
  126.             {
  127.             case POSITIVE:
  128.                {
  129.                strpad((int)number+strlen(line));
  130.                break;
  131.                }
  132.             case NOSIGN:
  133.                {
  134.                strpad((int)number);
  135.                break;
  136.                }
  137.             case NEGATIVE:
  138.                {
  139.                strpad((int)number-strlen(line));
  140.                break;
  141.                }
  142.             } /* switch(signed_arg) */
  143.          break;
  144.          } /* case 'C' */
  145.       case 'H': /* Absolute horizontal positioning by decipoint */
  146.          {
  147.          switch(signed_arg)
  148.             {
  149.             case POSITIVE:
  150.                {
  151.                strpad(column_by_decipoint(number)+strlen(line));
  152.                break;
  153.                }
  154.             case NOSIGN:
  155.                {
  156.                strpad(column_by_decipoint(number));
  157.                break;
  158.                }
  159.             case NEGATIVE:
  160.                {
  161.                strpad(column_by_decipoint(number)-strlen(line));
  162.                break;
  163.                }
  164.             } /* switch(signed_arg) */
  165.          break;
  166.          }
  167.       case 'L': /* Left margin (column number) */
  168.          {
  169.          switch(signed_arg)
  170.             {
  171.             case POSITIVE:
  172.                {
  173.                lmargin += (int)number;
  174.                break;
  175.                }
  176.             case NOSIGN:
  177.                {
  178.                lmargin = (int)number;
  179.                break;
  180.                }
  181.             case NEGATIVE:
  182.                {
  183.                lmargin -= (int)number;
  184.                break;
  185.                }
  186.             } /* switch(signed_arg) */
  187.          lmargin = (int)number;
  188.          break;
  189.          }
  190.       case 'M': /* Right margin (column number) */
  191.          {
  192.          switch(signed_arg)
  193.             {
  194.             case POSITIVE:
  195.                {
  196.                rmargin += (int)number;
  197.                break;
  198.                }
  199.             case NOSIGN:
  200.                {
  201.                rmargin = (int)number;
  202.                break;
  203.                }
  204.             case NEGATIVE:
  205.                {
  206.                rmargin -= (int)number;
  207.                break;
  208.                }
  209.             } /* switch(signed_arg) */
  210.          break;
  211.          }
  212.       case 'R': /* Absolute row number of page */
  213.          {
  214.          target_row = (int)number;
  215.          switch(signed_arg)
  216.             {
  217.             case POSITIVE:
  218.                {
  219.                position_vertical(logical_vpos+target_row);
  220.                break;
  221.                }
  222.             case NOSIGN:
  223.                {
  224.                if (target_row < logical_vpos)
  225.                   {
  226.                   error("Negative vertical positioning may not work as expected.",0);
  227.                   logical_vpos = target_row;
  228.                   }
  229.                else
  230.                   position_vertical(target_row);
  231.                break;
  232.                }
  233.             case NEGATIVE:
  234.                {
  235.                error("Negative vertical positioning may not work as expected.",0);
  236.                logical_vpos -= target_row;
  237.                break;
  238.                }
  239.             } /* switch */
  240.          break;
  241.          } /* case 'V' */
  242.       case 'V': /* Absolute vertical decipoint of page */
  243.          {
  244.          target_row = row_by_decipoint(number);
  245.          switch(signed_arg)
  246.             {
  247.             case POSITIVE:
  248.                {
  249.                position_vertical(logical_vpos+target_row);
  250.                break;
  251.                }
  252.             case NOSIGN:
  253.                {
  254.                if (target_row < logical_vpos)
  255.                   {
  256.                   error("Negative vertical positioning may not work as expected.",0);
  257.                   logical_vpos = target_row;
  258.                   }
  259.                else
  260.                   position_vertical(target_row);
  261.                break;
  262.                }
  263.             case NEGATIVE:
  264.                {
  265.                error("Negative vertical positioning may not work as expected.",0);
  266.                logical_vpos -= target_row;
  267.                break;
  268.                }
  269.             } /* switch */
  270.          break;
  271.          } /* case 'V' */
  272.       default:
  273.          error("Invalid PCL data stream",0);
  274.       } /* switch */
  275.    } /* pcl_ampersand_A */
  276.  
  277. /* -------------------------------------------------------------------------- */
  278.  
  279. void pcl_ampersand_D(double number)
  280.    {
  281.    char pcl_char;
  282.  
  283.    pcl_char = (char)toupper(*current);
  284.    switch(pcl_char)
  285.       {
  286.       case 'D':
  287.          {
  288.          if ((number == 1) ||
  289.              (number == 0))
  290.             {
  291.             new_line();
  292.             fputs(".us on\n",vba_file);
  293.             underscore = 1;
  294.             }
  295.          else
  296.             error("Invalid PCL datastream.",0);
  297.          break;
  298.          }
  299.       case '@':
  300.          {
  301.          if (underscore)
  302.             {
  303.             new_line();
  304.             fputs(".us off\n",vba_file);
  305.             strcpy(line,".ct ");
  306.             underscore = 0;
  307.             }
  308.          break;
  309.          }
  310.       default:
  311.          error("Invalid PCL data stream",0);
  312.       } /* switch */
  313.    }
  314.  
  315. /* -------------------------------------------------------------------------- */
  316.  
  317. void pcl_ampersand_K(double number)
  318.    {
  319.    char pcl_char;
  320.  
  321.    pcl_char = (char)toupper(*current);
  322.    switch(pcl_char)
  323.       {
  324.       case 'G': /* End of line termination */
  325.          break;
  326.       case 'S': /* Font pitch (alternate method) */
  327.          {
  328.          if (number != 0)  /* 10 CPI */
  329.             error("Unsupported pitch",0);
  330.          break;
  331.          }
  332.       default:
  333.          error("Invalid PCL datastream",12);
  334.       } /* switch */
  335.    }
  336.  
  337. /* -------------------------------------------------------------------------- */
  338.  
  339. void pcl_ampersand_L(double number)
  340.    {
  341.    char pcl_char;
  342.  
  343.    pcl_char = (char)toupper(*current);
  344.    switch(pcl_char)
  345.       {
  346.       case 'A': /* Page size */
  347.          {
  348.          if (number != 2)  /* Letter size paper */
  349.             error("Unsupported paper size",0);
  350.          break;
  351.          }
  352.       case 'C': /* Vertical motion index */
  353.          {
  354.          error("VMI PCL command not supported",0);
  355.          break;
  356.          }
  357.       case 'D': /* Lines per inch */
  358.          {
  359.          if (number != 6)
  360.             error("Only 6 LPI supported",0);
  361.          break;
  362.          }
  363.       case 'E': /* Top margin */
  364.          {
  365.          error("Top margin specification not supported",0);
  366.          break;
  367.          }
  368.       case 'F': /* Text length */
  369.          {
  370.          error("Text length PCL command not supported",0);
  371.          break;
  372.          }
  373.       case 'H': /* Paper input control */
  374.          {
  375.          if (number == 0)  /* Eject page */
  376.             new_page();
  377.          break;
  378.          }
  379.       case 'L': /* Perf skip mode */
  380.          {
  381.          error("Perforation skip mode not supported",0);
  382.          break;
  383.          }
  384.       case 'O': /* Orientation */
  385.          {
  386.          if (number == 1)
  387.             error("Landscape orientation not supported",0);
  388.          break;
  389.          }
  390.       case 'P': /* Page length (in number of lines) */
  391.          {
  392.          error("Page length PCL command unsupported",0);
  393.          break;
  394.          }
  395.       case 'S': /* Duplex */
  396.          {
  397.          error("Duplexing not supported",0);
  398.          break;
  399.          }
  400.       case 'X': /* Number of copies */
  401.          {
  402.          if (number != 1)
  403.              error("'Copies' PCL command not supported",0);
  404.          break;
  405.          }
  406.       default:
  407.          error("Invalid PCL datastream",12);
  408.       } /* switch */
  409.    }
  410.  
  411. /* -------------------------------------------------------------------------- */
  412.  
  413. void pcl_ampersand_number(double number)
  414.    {
  415.    if (toupper(*current) == 'D')
  416.       {
  417.       if (number == 3)
  418.          fputs(".us on\n",vba_file);
  419.       else
  420.          error("Invalid PCL data stream.",12);
  421.       }
  422.    else
  423.       {
  424.       char error_message[255];
  425.  
  426.       sprintf(error_message,"Unsupported PCL command: <Esc>&%f.0%c",number,*current);
  427.       error(error_message,8);
  428.       } /* default */
  429.    }
  430.