home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 9 / IOPROG_9.ISO / contrib / iis4 / iis4_07.cab / HTMLTableStream.java < prev    next >
Encoding:
Java Source  |  1997-09-05  |  11.9 KB  |  453 lines
  1. /**
  2.  * HTMLTableStream: stream out a pretty HTML Table based on attributes set by the caller
  3.  */
  4.  
  5. package IISSample;
  6.  
  7. import java.io.*;
  8.  
  9. public class HTMLTableStream
  10. {
  11.     // General Constants
  12.     private static final String        STR_NOT_SET  = null;
  13.     private static final int        INT_NOT_SET  = 0xdeadbeef;
  14.     private static final boolean    BOOL_NOT_SET = false;  // This seems useless, but it is for consistency.
  15.     private static final String        INTERNAL_ERROR_MSG = new String("HTMLTableStream: Internal error encountered.");
  16.  
  17.     // Table Alignment Constants
  18.     private static final int ALIGN_BASE        = 0xF0000000;
  19.     private static final int ALIGN_BOUNDS      = 6;
  20.     public  static final int ALIGN_LEFT        = ALIGN_BASE + 1;
  21.     public  static final int ALIGN_CENTER      = ALIGN_BASE + 2;
  22.     public  static final int ALIGN_RIGHT       = ALIGN_BASE + 3;
  23.     public  static final int ALIGN_BLEED_LEFT  = ALIGN_BASE + 4;
  24.     public  static final int ALIGN_BLEED_RIGHT = ALIGN_BASE + 5;
  25.     public  static final int ALIGN_JUSTIFY     = ALIGN_BASE + 6;
  26.  
  27.     // Clear Constants
  28.     private static final int CLEAR_BASE   = 0xF1000000;
  29.     private static final int CLEAR_BOUNDS = 4;
  30.     public  static final int CLEAR_NO     = CLEAR_BASE + 1;
  31.     public  static final int CLEAR_LEFT   = CLEAR_BASE + 2;
  32.     public  static final int CLEAR_RIGHT  = CLEAR_BASE + 3;
  33.     public  static final int CLEAR_ALL    = CLEAR_BASE + 4;
  34.  
  35.     // Frame Type Constants
  36.     private static final int FRAME_BASE   = 0xF2000000;
  37.     private static final int FRAME_BOUNDS = 9;
  38.     public  static final int FRAME_BORDER = FRAME_BASE + 1;
  39.     public  static final int FRAME_VOID   = FRAME_BASE + 2;
  40.     public  static final int FRAME_ABOVE  = FRAME_BASE + 3;
  41.     public  static final int FRAME_BELOW  = FRAME_BASE + 4;
  42.     public  static final int FRAME_HSIDES = FRAME_BASE + 5;
  43.     public  static final int FRAME_LHS    = FRAME_BASE + 6;
  44.     public  static final int FRAME_RHS    = FRAME_BASE + 7;
  45.     public  static final int FRAME_VSIDES = FRAME_BASE + 8;
  46.     public  static final int FRAME_BOX    = FRAME_BASE + 9;
  47.  
  48.     // Rules Constants
  49.     private static final int RULES_BASE   = 0xF3000000;
  50.     private static final int RULES_BOUNDS = 5;
  51.     public  static final int RULES_NONE   = RULES_BASE + 1;
  52.     public  static final int RULES_GROUPS = RULES_BASE + 2;
  53.     public  static final int RULES_ROWS   = RULES_BASE + 3;
  54.     public  static final int RULES_COLS   = RULES_BASE + 4;
  55.     public  static final int RULES_ALL    = RULES_BASE + 5;
  56.  
  57.     // Vertical Alignment Constants
  58.     private static final int VALIGN_BASE     = 0xF4000000;
  59.     private static final int VALIGN_BOUNDS   = 4;
  60.     public  static final int VALIGN_TOP      = VALIGN_BASE + 1;
  61.     public  static final int VALIGN_MIDDLE   = VALIGN_BASE + 2;
  62.     public  static final int VALIGN_BOTTOM   = VALIGN_BASE + 3;
  63.     public  static final int VALIGN_BASELINE = VALIGN_BASE + 4;
  64.  
  65.     // Internal use streams
  66.     private StreamTokenizer tokIn = null;
  67.     private Reader readIn = null;
  68.  
  69.     // Internal use variables
  70.     private int        m_iAlignment            = INT_NOT_SET;
  71.     private String    m_strBackground            = STR_NOT_SET;
  72.     private String    m_strBackgroundColor    = STR_NOT_SET;
  73.     private int        m_iBorderWidth            = INT_NOT_SET;
  74.     private String    m_strBorderColor        = STR_NOT_SET;
  75.     private String    m_strBorderColorDark    = STR_NOT_SET;
  76.     private String    m_strBorderColorLight    = STR_NOT_SET;
  77.     private int        m_iCellPadding            = INT_NOT_SET;
  78.     private int        m_iCellSpacing            = INT_NOT_SET;
  79.     private int        m_iClear                = INT_NOT_SET;
  80.     private String    m_strClass                = STR_NOT_SET;
  81.     private int        m_iColumns                = INT_NOT_SET;
  82.     private int        m_iFrameType            = INT_NOT_SET;
  83.     private int        m_iID                    = INT_NOT_SET;
  84.     private boolean    m_fNoWrap                = BOOL_NOT_SET;
  85.     private int        m_iRules                = INT_NOT_SET;
  86.     private String    m_strStyle                = STR_NOT_SET;
  87.     private int        m_iVertAlignment        = INT_NOT_SET;
  88.     private String    m_strWidth                = STR_NOT_SET;
  89.  
  90.     // Constructor
  91.     public HTMLTableStream(InputStream in)
  92.     {
  93.         readIn = new BufferedReader(new InputStreamReader(in));
  94.         tokIn  = new StreamTokenizer(readIn);
  95.         tokIn.eolIsSignificant(true);
  96.         tokIn.quoteChar((int)',');
  97.     }
  98.  
  99.     public void setDelimiter(char c)
  100.     {
  101.         tokIn.quoteChar((int) c);
  102.     }
  103.  
  104.     public void setAlign(int iAlign)
  105.     {
  106.         int iAlignVal = iAlign & (~ALIGN_BASE);
  107.  
  108.         if ( (iAlignVal != 0) && (iAlignVal <= ALIGN_BOUNDS) ) {
  109.             m_iAlignment = iAlign;
  110.         }
  111.         else {
  112.             throw new IllegalArgumentException("Align constant out of bounds.");
  113.         }
  114.     }
  115.  
  116.     private String TestString(String s)
  117.     {
  118.         if (s == null) {
  119.             throw new IllegalArgumentException("Null string.");
  120.         }
  121.         else if (s.equals("")) {
  122.             throw new IllegalArgumentException("Zero length string.");
  123.         }
  124.         else return s;
  125.     }
  126.     
  127.     private int TestNonNegative(int i)
  128.     {
  129.         if (i < 0) {
  130.             throw new IllegalArgumentException("Negative integer.");
  131.         }
  132.         else return i;
  133.     }
  134.  
  135.     public void setBackground(String strBackground) {
  136.         m_strBackground = TestString(strBackground);
  137.     }
  138.  
  139.     public void setBackgroundColor(String strBackgroundColor) {
  140.         m_strBackgroundColor = TestString(strBackgroundColor);
  141.     }
  142.  
  143.     public void setBorderWidth(int iWidth) {
  144.         m_iBorderWidth = TestNonNegative(iWidth);
  145.     }
  146.  
  147.     public void setBorderColor(String strBorderColor) {
  148.         m_strBorderColor = TestString(strBorderColor);
  149.     }
  150.  
  151.     public void setBorderColorDark(String strBorderColorDark) {
  152.         m_strBorderColorDark = TestString(strBorderColorDark);
  153.     }
  154.  
  155.     public void setBorderColorLight(String strBorderColorLight) {
  156.         m_strBorderColorLight = TestString(strBorderColorLight);
  157.     }
  158.  
  159.     public void setCellPadding(int iCellPadding) {
  160.         m_iCellPadding = TestNonNegative(iCellPadding);
  161.     }
  162.  
  163.     public void setCellSpacing(int iCellSpacing) {
  164.         m_iCellSpacing = TestNonNegative(iCellSpacing);
  165.     }
  166.  
  167.     public void setClear(int iClear) {
  168.         int iClearVal = iClear & (~CLEAR_BASE);
  169.  
  170.         if ( (iClearVal != 0) && (iClearVal <= CLEAR_BOUNDS) ) {
  171.             m_iClear = iClear;
  172.         }
  173.         else {
  174.             throw new IllegalArgumentException("Clear constant out of bounds.");
  175.         }
  176.     }
  177.  
  178.     public void setClass(String iClass) {
  179.         m_strClass = TestString(iClass);
  180.     }
  181.  
  182.     public void setCols(int iCols) {
  183.         m_iColumns = TestNonNegative(iCols);
  184.     }
  185.  
  186.     public void setFrameType(int iFrameType) {
  187.         int iFrameTypeVal = iFrameType & (~FRAME_BASE);
  188.  
  189.         if ( (iFrameTypeVal != 0) && (iFrameTypeVal <= FRAME_BOUNDS) ) {
  190.             m_iFrameType = iFrameType;
  191.         }
  192.         else {
  193.             throw new IllegalArgumentException("Frame type constant out of bounds.");
  194.         }
  195.     }
  196.  
  197.     public void setID(int iID) {
  198.         m_iID = iID;        // Don't care what the value is here.
  199.     }
  200.  
  201.     public void setNoWrap(boolean fNoWrap) {
  202.         m_fNoWrap = fNoWrap;
  203.     }
  204.  
  205.     public void setRules(int iRules)
  206.     {
  207.         int iRulesVal = iRules & (~RULES_BASE);
  208.  
  209.         if ( (iRulesVal != 0) && (iRulesVal <= RULES_BOUNDS) ) {
  210.             m_iRules = iRules;
  211.         }
  212.         else {
  213.             throw new IllegalArgumentException("Rules constant out of bounds.");
  214.         }
  215.     }
  216.  
  217.     public void setStyle(String strStyle) {
  218.         m_strStyle = TestString(strStyle);
  219.     }
  220.  
  221.     public void setVerticalAlign(int iVAlign)
  222.     {
  223.         int iVAlignVal = iVAlign & (~VALIGN_BASE);
  224.  
  225.         if ( (iVAlignVal != 0) && (iVAlignVal <= VALIGN_BOUNDS) ) {
  226.             m_iVertAlignment = iVAlign;
  227.         }
  228.         else {
  229.             throw new IllegalArgumentException("VAlign constant out of bounds.");
  230.         }
  231.     }
  232.  
  233.     public void setWidth(int iWidth) {
  234.         m_strWidth = Integer.toString(iWidth);
  235.     }
  236.  
  237.     public void setWidth(String strWidth) {
  238.         m_strWidth = TestString(strWidth);
  239.     }
  240.  
  241.     public void OutputTable(OutputStream out)
  242.     {
  243.         OutputStreamWriter osw = new OutputStreamWriter(out);
  244.  
  245.         try {
  246.             osw.write("<TABLE");
  247.             if (m_iAlignment != INT_NOT_SET) {
  248.                 osw.write(" ALIGN=");
  249.                 switch (m_iAlignment) {
  250.                 case ALIGN_LEFT:
  251.                     osw.write("LEFT");
  252.                     break;
  253.                 case ALIGN_CENTER:
  254.                     osw.write("CENTER");
  255.                     break;
  256.                 case ALIGN_RIGHT:
  257.                     osw.write("RIGHT");
  258.                     break;
  259.                 case ALIGN_BLEED_LEFT:
  260.                     osw.write("BLEEDLEFT");
  261.                     break;
  262.                 case ALIGN_BLEED_RIGHT:
  263.                     osw.write("BLEEDRIGHT");
  264.                     break;
  265.                 case ALIGN_JUSTIFY:
  266.                     osw.write("JUSTIFY");
  267.                     break;
  268.                 default:
  269.                     throw new RuntimeException(INTERNAL_ERROR_MSG);
  270.                 }
  271.             }
  272.         
  273.             if (m_strBackground != STR_NOT_SET) {
  274.                 osw.write(" BACKGROUND=\"" + m_strBackground + "\"");
  275.             }
  276.  
  277.             if (m_strBackgroundColor != STR_NOT_SET) {
  278.                 osw.write(" BGCOLOR=\"" + m_strBackgroundColor + "\"");
  279.             }
  280.  
  281.             if (m_iBorderWidth != INT_NOT_SET) {
  282.                 osw.write(" BORDER=" + m_iBorderWidth);
  283.             }
  284.  
  285.             if (m_strBorderColor != STR_NOT_SET) {
  286.                 osw.write(" BORDERCOLOR=\"" + m_strBorderColor + "\"");
  287.             }
  288.  
  289.             if (m_strBorderColorDark != STR_NOT_SET) {
  290.                 osw.write(" BORDERCOLORDARK=\"" + m_strBorderColorDark + "\"");
  291.             }
  292.         
  293.             if (m_strBorderColorLight != STR_NOT_SET) {
  294.                 osw.write(" BORDERCOLORLIGHT=\"" + m_strBorderColorLight + "\"");
  295.             }
  296.  
  297.             if (m_iCellPadding != INT_NOT_SET) {
  298.                 osw.write(" CELLPADDING=" + m_iCellPadding);
  299.             }
  300.  
  301.             if (m_iCellSpacing != INT_NOT_SET) {
  302.                 osw.write(" CELLSPACING=" + m_iCellSpacing);
  303.             }
  304.  
  305.             if (m_iClear != INT_NOT_SET) {
  306.                 osw.write(" CLEAR=");
  307.                 switch (m_iClear) {
  308.                 case CLEAR_NO:
  309.                     osw.write("NO");
  310.                     break;
  311.                 case CLEAR_LEFT:
  312.                     osw.write("LEFT");
  313.                     break;
  314.                 case CLEAR_RIGHT:
  315.                     osw.write("RIGHT");
  316.                     break;
  317.                 case CLEAR_ALL:
  318.                     osw.write("ALL");
  319.                     break;
  320.                 default:
  321.                     throw new RuntimeException(INTERNAL_ERROR_MSG);
  322.                 }
  323.             }
  324.  
  325.             if (m_iColumns != INT_NOT_SET) {
  326.                 osw.write(" COLUMNS=" + m_iColumns);
  327.             }
  328.             
  329.             if (m_iFrameType != INT_NOT_SET) {
  330.                 osw.write(" FRAME=");
  331.                 switch (m_iFrameType) {
  332.                 case FRAME_BORDER:
  333.                     osw.write("BORDER");
  334.                     break;
  335.                 case FRAME_VOID:
  336.                     osw.write("VOID");
  337.                     break;
  338.                 case FRAME_ABOVE:
  339.                     osw.write("ABOVE");
  340.                     break;
  341.                 case FRAME_BELOW:
  342.                     osw.write("BELOW");
  343.                     break;
  344.                 case FRAME_HSIDES:
  345.                     osw.write("HSIDES");
  346.                     break;
  347.                 case FRAME_LHS:
  348.                     osw.write("LHS");
  349.                     break;
  350.                 case FRAME_RHS:
  351.                     osw.write("RHS");
  352.                     break;
  353.                 case FRAME_VSIDES:
  354.                     osw.write("VSIDES");
  355.                     break;
  356.                 case FRAME_BOX:
  357.                     osw.write("BOX");
  358.                     break;
  359.                 default:
  360.                     throw new RuntimeException(INTERNAL_ERROR_MSG);
  361.                 }
  362.             }
  363.  
  364.             if (m_iID != INT_NOT_SET) {
  365.                 osw.write(" ID=" + m_iID);
  366.             }
  367.  
  368.             if (m_fNoWrap != BOOL_NOT_SET) {
  369.                 osw.write(" NOWRAP");
  370.             }
  371.  
  372.             if (m_iRules != INT_NOT_SET) {
  373.                 osw.write(" RULES=");
  374.                 switch (m_iRules) {
  375.                 case RULES_NONE:
  376.                     osw.write("NONE");
  377.                     break;
  378.                 case RULES_GROUPS:
  379.                     osw.write("GROUPS");
  380.                     break;
  381.                 case RULES_ROWS:
  382.                     osw.write("ROWS");
  383.                     break;
  384.                 case RULES_COLS:
  385.                     osw.write("COLS");
  386.                     break;
  387.                 case RULES_ALL:
  388.                     osw.write("ALL");
  389.                     break;
  390.                 default:
  391.                     throw new RuntimeException(INTERNAL_ERROR_MSG);
  392.                 }
  393.             }
  394.  
  395.             if (m_strStyle != STR_NOT_SET) {
  396.                 osw.write(" STYLE=\"" + m_strStyle + "\"");
  397.             }
  398.  
  399.             if (m_iVertAlignment != INT_NOT_SET) {
  400.                 osw.write(" VALIGN=");
  401.                 switch (m_iVertAlignment) {
  402.                 case VALIGN_TOP:
  403.                     osw.write("TOP");
  404.                     break;
  405.                 case VALIGN_MIDDLE:
  406.                     osw.write("MIDDLE");
  407.                     break;
  408.                 case VALIGN_BOTTOM:
  409.                     osw.write("BOTTOM");
  410.                     break;
  411.                 case VALIGN_BASELINE:
  412.                     osw.write("BASELINE");
  413.                     break;
  414.                 default:
  415.                     throw new RuntimeException(INTERNAL_ERROR_MSG);
  416.                 }
  417.             }
  418.  
  419.             osw.write(">\n");
  420.             osw.flush();
  421.         }
  422.         catch (IOException ioe) {
  423.             return;
  424.         }
  425.  
  426.         
  427.         // Do the parsing from the input stream.
  428.         int ttype;
  429.         try {
  430.             ttype = tokIn.nextToken();
  431.             osw.write("<TR>");
  432.             while (ttype != StreamTokenizer.TT_EOF) {
  433.                 if (ttype == StreamTokenizer.TT_EOL) {
  434.                     osw.write("</TR>\n");
  435.                     osw.flush();
  436.                 }
  437.                 if (ttype == StreamTokenizer.TT_NUMBER) {
  438.                     osw.write("<TD>" + tokIn.nval + "</TD>");
  439.                 }
  440.                 if (ttype == StreamTokenizer.TT_WORD) {
  441.                     osw.write("<TD>" + tokIn.sval + "</TD>");
  442.                 }
  443.                 ttype = tokIn.nextToken();
  444.             }
  445.             osw.write("</TABLE>");
  446.             osw.close();
  447.         }
  448.         catch (IOException ioe) {
  449.             return;
  450.         }
  451.     }        
  452. }
  453.