/*File Svg21a.java,
Copyright 2011, R.G.Baldwin

Revised 08/07/11 to support the addition of a title 
parameter to each element for IVEO compatibility. If the
output SVG file is opened in IVEO, the title for the svg
element is spoken when the user opens the file, and the
titles for the individual elements are spoken when the
user touches a corresponding shape on the touchpad or
clicks on that shape on the screen. If the SVG file won't
be used with IVEO, just leave the title strings unchanged.

This program requires access to the file 
named SvgLib21.java

This is a demonstration program.

This program uses JDOM 1.1.1 and an SVG graphics library 
class of my own design named SvgLib21 to draw an 
abbreviated version of the mass-pulley system shown in 
http://cnx.org/content/m38211/latest/#Figure_4

Only one line of text is drawn by this program. Otherwise,
the drawing produced by this program is the same as
the drawing in the file named Phy1150a1.svg used in
that module titled Force and Motion -- Units of Force. The
original drawing was produced by a sighten person using
Inkscape. This drawing was produced by a sighted person
using Baldwin's svg drawing library.

Tested using J2SE 6, JDOM 1.1.1, and Firefox 5
running under Windows Vist Home Premium Edition.
*********************************************************/
import java.io.*;
import org.jdom.*;

public class Svg21a{
  public static void main(String[] args){

    //DO NOT MODIFY ANY OF THE CODE ABOVE THIS LINE.
    //##################################################//
    //ONLY THE CODE BELOW THIS LINE CAN BE MODIFIED
    
    //CREATE A DRAWING CANVAS
    //This must be the first statement that you write in
    // the program and it must appear only once.
    //The following statement creates a canvas that is
    // 8.5x11 inches in size in a landscape layout.
    Element svg = SvgLib21.makeSvg(ns,
                                   "Document Title",
                                   11,//width
                                   8.5  //height
                                   );
                                          

    //DO NOT MODIFY THE FOLLOWING STATEMENT
    //This statement must immediately follow the call to
    // the makeSvg method above and this statement MUST
    // NOT BE MODIFIED.
    Document doc = new Document(svg,docType);

    //Draw a rectangular border on the canvas.
    Element border = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      0.015,
                                      0.015,
                                      10.97,
                                      8.47
                                      );
    
    //Draw the floor.
    Element floor = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      0.5,
                                      0.5,
                                      10.5,
                                      0.5
                                      );

    //Draw the wall.
    Element wall = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      1.0,
                                      0.5,
                                      1.0,
                                      7.5
                                      );

    //Draw the table top.
    Element tableTop = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      1.0,
                                      3.0,
                                      7.0,
                                      1.0
                                      );


    //Draw the table leg.
    Element tableLeg = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      6.5,
                                      0.5,
                                      0.5,
                                      2.5
                                      );
    
    
    //Draw Mass C
    Element massC = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      2.0,
                                      4.0,
                                      2.0,
                                      2.0
                                      );  
    
    
    //Draw Mass B
    Element massB = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      5.0,
                                      4.0,
                                      2.0,
                                      2.0
                                      );


    //Draw Mass A
    Element massA = SvgLib21.makePolygon(svg,
                                         ns,
                                         "polygon",
                                         new double[]{
                                           7.5,1.0,
                                           9.5,1.0,
                                           8.5,2.5
                                         });

    //Draw pully support
    Element pullySupport = SvgLib21.makeRect(svg,
                                             ns,
                                             "rectangle",
                                             7.883,
                                             3.595,
                                             0.392,
                                             1.06
                                             );

    //Draw the pulley wheel.
    Element pulleyWheel = SvgLib21.makeCircle(svg,
                                              ns,
                                              "circle",
                                              8.05,
                                              4.56,
                                              0.45
                                              );

    //Draw cord from wall to Mass C
    Element cordR = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      1.0,
                                      5.0,
                                      2,
                                      5.0
                                      );


    //Draw cord from Mass C to Mass B
    Element cordQ = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      4.0,
                                      5.0,
                                      5.0,
                                      5.0
                                      );


    //Draw cord from Mass B to the top of the pulley.
    Element cordP1 = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      7.0,
                                      5.0,
                                      8.05,
                                      5.0
                                      );


    //Draw the cord from the right side of the pulley to
    // Mass A
    Element cordP2 = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      8.5,
                                      4.5,
                                      8.5,
                                      2.5
                                      );
                                      
    //Set the line thicknesses for various objects.
    SvgLib21.setStrokeWidth(border,0.03);
    SvgLib21.setStrokeWidth(floor,0.1);
    SvgLib21.setStrokeWidth(wall,0.1);
    SvgLib21.setStrokeWidth(tableTop,0.03);
    SvgLib21.setStrokeWidth(tableLeg,0.03);
    SvgLib21.setStrokeWidth(massC,0.05); 
    SvgLib21.setStrokeWidth(massB,0.05);
    SvgLib21.setStrokeWidth(massA,0.05);
    SvgLib21.setStrokeWidth(pullySupport,0.05);
    SvgLib21.setStrokeWidth(pulleyWheel,0.05);
    SvgLib21.setStrokeWidth(cordR,0.03);
    SvgLib21.setStrokeWidth(cordQ,0.03);
    SvgLib21.setStrokeWidth(cordP1,0.03);
    SvgLib21.setStrokeWidth(cordP2,0.03);

    //Draw text
    Element textA = SvgLib21.makeText(
                                    svg,
                                    ns,
                                    2.5,
                                    3.3,
                                    "arial",
                                    32,
                                    "Friction free table."
                                    );

    //WRITE OUTPUT FILE
    //Don't include extension in output file name.
    SvgLib21.writePrettyFile("Svg21a",doc);
    
    //ONLY THE CODE ABOVE THIS LINE CAN BE MODIFIED
    //##################################################//
    //DO NOT MODIFY ANY OF THE FOLLOWING CODE.    
  }//end main
  //----------------------------------------------------//

  //Create a String variable containing the namespace
  // URI to reduce the amount of typing that is required
  // later. Note that the variable name is short and
  // easy to type.
  static String ns = "http://www.w3.org/2000/svg";
  
  //For clarity, create strings containing the name of
  // the element that is constrained by the DTD (the
  // root element), the Public ID of the DTD, and the
  // System ID of the DTD.
  static String dtdConstrainedElement = "svg";
  static String dtdPublicID = "-//W3C//DTD SVG 1.1//EN";
  static String dtdSystemID = 
     "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd";
     
  
  static DocType docType = new DocType(
         dtdConstrainedElement,dtdPublicID,dtdSystemID);

}//end class Svg21a

import java.io.*;
import org.jdom.*;
import org.jdom.output.XMLOutputter;
import org.jdom.output.Format;

/**
File SvgLib21.java
<p>
Copyright 2011, R.G.Baldwin
<p>
Revised 08/11/11 to add a method named setDescription
that can be called to add a <desc> element to any other
element. The description can be spoken in IVEO by first
selecting the element an pressing Ctrl+d.
<p>
Revised 08/07/11 to add a parameter for the title to
allow the user to pass in a string for the title element.
<p>
Revised 08/06/11 to add a title element to each shape
element. As a result, when the SVG file is
opened in IVEO and you click on the shape, the name of
the shape is spoken by IVEO. Note, however, that you 
must be careful about the order in which you add the
shapes to the drawing. For example, a rectangle that
is added after a line is added can cover the line
and prevent the information about the line from being
spoken even though the rectangle may be transparent. 
Therefore, for IVEO compatibility, you must not allow
one shape object to cover another shape object.
<p>
DESCRIPTION
<p>
This is a graphics library that is designed to eliminate
much of the pain involved in writing JDOM code to
create SVG output. The library contains individual
static methods that are used to construct and return
all of the SVG basic shape elements, text elements,
description elements and comment elements.
<p>
In addition there are methods to set various attributes
on shape elements and text elements.

This library provides methods to instantiate, return,
and manipulate the following types of SVG elements:
<ul>
<li>line</li>
<li>rect</li>
<li>circle</li>
<li>ellipse</li>
<li>polyline</li>
<li>polygon</li>
<li>desc</li>
<li>comment</li>
<li>text</li>
</ul>
<p>
Methods that return elements set the stroke attribute
value to black and set the stroke-width attribute 
value to 1.
<p>
All of the methods that accept coordinate values or
dimensions as input require those values to be in
inches or fractions thereof. They are then converted 
to svg units using a scale factor of 90 svg units 
per inch.
<p>
All incoming vertical coordinate values are modified
to cause the origin to be at the lower-left corner. 
Positive x is to the right and positive y is up the 
page. Therefore, the user can think in terms of a
typical graphing assignment with the origin at the 
lower-left corner.
<p>
One svg unit equals approximately 0.011 inch. An svg 
unit is not necessarily the same size as a pixel on a
monitor or a printer. However, dimensions specified in 
inches should be very close when you print the image.
<p>
In addition to the methods mentioned above, this library
provides two different methods for writing the final
SVG/XML out to a file. One is named writePrettyFile and
the other is named writeCompactFile.
<p>
Tested using J2SE 6.0, JDOM 1.1.1, Firefox 5, running 
under Windows Vista Home Premius Edition.
<p>
author: Richard G. Baldwin
*/
public class SvgLib21{
  
/*The following instance variable is used to cause the
origin to be at the bottom left corner of the 
drawing.
*/
  private static double svgHeight = 11.0;
  
  //----------------------------------------------------//
  
  /**This method constructs and returns a circle node for
   *a given parent in a given namespace.  By default,the
   *stroke is black, the stroke-width is 1, and the fill
   *is none. Other methods can be called to change these
   *default values later.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param cx the x-coordinate of the center in inches
   * @param cy the y-coordinate of the center in inches
   * @param r the radius of the circle in inches
   *
   * @return A reference to an object that represents an
   *SVG circle element
   */
  public static Element makeCircle(
                  Element parent,
                  String namespace,
                  String elementTitle,
                  double cx,//Center coordinate in inches
                  double cy,//Center coordinate in inches
                  double r  //Radius in inches
                  ){
    Element circle = new Element("circle",namespace);
    parent.addContent(circle);
    
    //Set default attribute vales
    circle.setAttribute("fill","none");
    circle.setAttribute("stroke","black");
    circle.setAttribute("stroke-width","1");
    
    //Set user specified attribute values.
    int cxInPix = (int)(Math.round(cx*90));
    int cyInPix = 
               (int)(Math.round((svgHeight-cy)*90));
    int rInPix = (int)(Math.round(r*90));

    circle.setAttribute("cx",""+cxInPix);
    circle.setAttribute("cy",""+cyInPix);
    circle.setAttribute("r",""+rInPix);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    circle.addContent(title);
    
    return circle;
  }//end makeCircle
  //----------------------------------------------------//
  
  /**This method constructs and returns a comment node
   *for a given given parent.
   *
   * @param parent the SVG parent element
   * @param text the text content for this comment element
   *
   *@return A reference to an object that represents an
   *SVG comment element.
  */
  public static Comment makeComment(
              Element parent,//The parent of this element.
              String text//Text content for this element.
              ){
    Comment comment = new Comment(text);
    parent.addContent(comment);

    return comment;
  }//end makeComment
  //----------------------------------------------------//
  
  /**
   *DEPRECATED This method has been deprecated Use the
   *method named setDescription instead.
   *
   *This method constructs and returns a description node
   *for a given namespace and a given parent.
   *
   * @param parent the SVG parent element
   * @param nameSpace the SVG namespace
   * @param text the text content for this desc element
   *
   *@return A reference to an object that represents an
   *SVG desc element.
   */
  public static Element makeDescription(
              Element parent,//The parent of this element.
              String nameSpace,//The namespace.
              String text//Text content for this element.
              ){
    Element desc = new Element("desc",nameSpace);
    parent.addContent(desc);
    desc.setText(text);

    return desc;
  }//end makeDescription
  //----------------------------------------------------//

  /**This method constructs and returns an ellipse node
   *for a given parent in a given namespace. By default,
   *the stroke is black, the stroke-width is 1, and the
   *fill is none.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param cx the x-coordinate of the center in inches
   * @param cy the y-coordinate of the center in inches
   * @param rx the horizontal radius of the ellipse
   * in inches
   * @param ry the vertical radius of the ellipse
   * in inches
   *
   * @return A reference to an object that represents an
   *SVG ellipse element
   */
  public static Element makeEllipse(
                  Element parent,
                  String namespace,
                  String elementTitle,
                  double cx,//Center coordinate in inches
                  double cy,//Center coordinate in inches
                  double rx,//Horizontal radius in inches
                  double ry //Vertical radius in inches
                  ){
    Element ellipse = new Element("ellipse",namespace);
    parent.addContent(ellipse);
    
    //Set default attribute vales
    ellipse.setAttribute("fill","none");
    ellipse.setAttribute("stroke","black");
    ellipse.setAttribute("stroke-width","1");
    
    //Set user specified attribute values.
    int cxInPix = (int)(Math.round(cx*90));
    int cyInPix = 
                (int)(Math.round((svgHeight-cy)*90));
    int rxInPix = (int)(Math.round(rx*90));
    int ryInPix = (int)(Math.round(ry*90));

    ellipse.setAttribute("cx",""+cxInPix);
    ellipse.setAttribute("cy",""+cyInPix);
    ellipse.setAttribute("rx",""+rxInPix);
    ellipse.setAttribute("ry",""+ryInPix);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    ellipse.addContent(title);
    
    return ellipse;
  }//end makeEllipse
  //----------------------------------------------------//
  
  /**This method constructs and returns a line node for a
   *given parent in a given namespace.  By default, the
   *stroke is black and the stroke-width is 1.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param x1 start x-coordinate in inches
   * @param y1 start y-coordinate in inches
   * @param x2 end x-coordinate in inches
   * @param y2 end y-coordinate in inches
   *
   * @return A reference to an object that represents an
   *SVG line element
   */
  public static Element makeLine(
                  Element parent,
                  String namespace,
                  String elementTitle,
                  double x1,//Start coordinate in inches
                  double y1,//Start coordinate in inches
                  double x2,//End coordinate in inches
                  double y2 //End coordinate in inches
                                ){
    Element line = new Element("line",namespace);
    parent.addContent(line);
    
    //Set default attribute vales
    line.setAttribute("stroke","black");
    line.setAttribute("stroke-width","1");
    
    //Set user specified attribute values.
    int x1InPix = (int)(Math.round(x1*90));
    int y1InPix = 
                (int)(Math.round((svgHeight-y1)*90));
    int x2InPix = (int)(Math.round(x2*90));
    int y2InPix = 
                (int)(Math.round((svgHeight-y2)*90));

    line.setAttribute("x1",""+x1InPix);
    line.setAttribute("y1",""+y1InPix);
    line.setAttribute("x2",""+x2InPix);
    line.setAttribute("y2",""+y2InPix);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    line.addContent(title);
    
    return line;
  }//end makeLine
  //----------------------------------------------------//
  
  /**This method constructs and returns a polygon node for
   *a given parent in a given namespace.
   *<p>
   *The array of type double[], which contains the
   *coordinates for each point in the polygon, must
   *contain an even number of values for the polygon
   *to be drawn correctly. Otherwise, it simply won't be
   *drawn.
   *<p>
   *The values are extracted from the array, converted
   *to svg units as type int, and treated as coordinate
   *values x1,y1, x2,y2, x3,y3 ... etc.
   *<p>
   *The stroke is set to black one pixel wide with no
   *fill.
   *<p>
   *The main difference between a polygon and a polyline
   *is that a polygon is automatically closed by 
   *connecting the last point to the first point.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param points an array of x-y coordinate pairs in
   * inches that define the locations of the vertices of
   * the polygon.
   *
   * @return A reference to an object that represents an
   *SVG polygon element
   */
  public static Element makePolygon(Element parent,
                             String namespace,
                             String elementTitle,
                             double[] points){
    Element polygon = new Element("polygon",namespace);
    parent.addContent(polygon);
    
    //Set default attributes.
    polygon.setAttribute("stroke","black");
    polygon.setAttribute("stroke-width","1");
    polygon.setAttribute("fill","none");
    
    //Set user specified attributes.
    String dataPoints = "";
    for(int cnt=0;cnt<points.length;cnt++){
      //Correct all of the y coordinates to place the
      // origin at the bottom left.
      if(cnt%2==0){
        //even values
        dataPoints += "" + 
             (int)(Math.round(points[cnt]*90)) + " ";
      }else{
        //odd values
        dataPoints += "" + 
             (int)(Math.round((svgHeight-points[cnt])
                                         *90)) + " ";
      }//end else
    }//end for loop
    
    polygon.setAttribute("points",dataPoints);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    polygon.addContent(title);

    return polygon;
  }//end makePolygon
  //----------------------------------------------------//

  /**This method constructs and returns a polyline node
   *for a given parent in a given namespace.
   *<p>
   *The array of type double[], which contains the
   *coordinates for each point in the polyline, must
   *contain an even number of values for the polyline
   *to be drawn correctly. Otherwise, it simply won't be
   *drawn.
   *<p>
   *The values are extracted from the array, converted
   *to svg units as type int, and treated as coordinate
   *values x1,y1, x2,y2, x3,y3 ... etc.
   *<p>
   *The stroke is set to black one pixel wide with no
   *fill.
   *<p>
   *The main difference between a polyline and a polygon
   *is that a polygon is automatically closed by 
   *connecting the last point to the first point.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param points an array of x-y coordinate pairs in
   * inches that define the locations of the end points
   * and the vertices of the polyline.
   *
   * @return A reference to an object that represents an
   *SVG polyline element
   */
  public static Element makePolyline(Element parent,
                              String namespace,
                              String elementTitle,
                              double[] points){
    Element polyline = new Element("polyline",namespace);
    parent.addContent(polyline);

    //Set default attributes
    polyline.setAttribute("stroke","black");
    polyline.setAttribute("stroke-width","1");
    polyline.setAttribute("fill","none");
    
    //Set user specified attributes.
    String dataPoints = "";
    for(int cnt=0;cnt<points.length;cnt++){
      //Correct all of the y coordinates to place the
      // origin at the bottom left.
      if(cnt%2==0){
        //even values
        dataPoints += "" + 
             (int)(Math.round(points[cnt]*90)) + " ";
      }else{
        //odd values
        dataPoints += "" + 
            (int)(Math.round((svgHeight-points[cnt])
                                         *90)) + " ";
      }//end else
    }//end for loop
    
    polyline.setAttribute("points",dataPoints);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    polyline.addContent(title);
    
    return polyline;
  }//end makePolyline
  //----------------------------------------------------//

  /**This method constructs and returns a rect node for a
   *given parent in a given namespace.  By default,the
   *stroke is black, the stroke-width is 1, and the fill
   *is none.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param elementTitle the title for IVEO compatibility
   * @param x x-coordinate of lower left corner in inches
   * @param y y-coordinate of lower left corner in inches
   * @param width width in inches
   * @param height height in inches
   *
   * @return A reference to an object that represents an
   *SVG rect element
   */
  public static Element makeRect(
                  Element parent,
                  String namespace,
                  String elementTitle,
                  double x,//Lower-left corner in inches.
                  double y,//Lower-left corner in inches.
                  double width,//in inches
                  double height//in inches
                  ){
    Element rect = new Element("rect",namespace);
    parent.addContent(rect);
    
    //Set default attribute values.
    rect.setAttribute("fill","none");
    rect.setAttribute("stroke","black");
    rect.setAttribute("stroke-width","1");
    
    //Set user specified attribute values.
    int xInPix = (int)(Math.round(x*90));
    int yInPix = 
          (int)(Math.round((svgHeight-y-height)*90));
    int widthInPix = (int)(Math.round(width*90));
    int heightInPix = (int)(Math.round(height*90));

    rect.setAttribute("x",""+xInPix);
    rect.setAttribute("y",""+yInPix);
    rect.setAttribute("width",""+widthInPix);
    rect.setAttribute("height",""+heightInPix);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",namespace);
    title.addContent(elementTitle);
    rect.addContent(title);
    
    return rect;
  }//end makeRect
  //----------------------------------------------------//
 
  /**This method constructs and returns a reference to an
   *SVG root element node named svg.
   *
   *The svg element represents the canvas on which
   *various shapes can be drawn. The width and height
   *attribute values of the svg element establish the
   *physical size of the canvas on the screen and on
   *the printer.
   *
   *The preserveAspectRatio defaults to none.
   *
   * @param ns the SVG namespace URI
   * @param documentTitle the title for IVEO compatibility
   * @param dWidth the width of the canvas in inches
   * @param dHeight the height of the canvas in inches
   *
   * @return A reference to an SVG element object
   */
  public static Element makeSvg(
                      String ns,//namespace URI
                      String documentTitle,
                      double dWidth,
                      double dHeight
                      ){
    Element svg = new Element("svg",ns);
    
    //Save the height of the canvas. This is used later
    // to make corrections to y-coordinate values to put
    // the origin at the lower-left corner of the canvas.
    svgHeight = dHeight;
    
    int width = (int)(Math.round(dWidth*90));
    int height = (int)(Math.round(dHeight*90));
    
    //Set default attribute values.
    svg.setAttribute("version","1.1");
    svg.setAttribute("width",""+width);
    svg.setAttribute("height",""+height);
    
    //Add a title element for IVEO compatibility
    Element title = new Element("title",ns);
    title.addContent(documentTitle);
    svg.addContent(title);
    
    return svg;
  }//end makeSvg
  //----------------------------------------------------//

  /**This method constructs and returns a text node for a
   *given parent in a given namespace.  By default,the
   *stroke is black, and the fill is none.
   *
   * @param parent the SVG parent element
   * @param namespace the SVG namespace
   * @param x x-coordinate of lower left corner of first
   * character in inches
   * @param y y-coordinate of lower left corner of first
   * character in inches
   * @param fontFamily font family such as arial
   * @param fontSize font size in points such as 32
   * @param textIn the text to be displayed
   *
   * @return A reference to an object that represents an
   *SVG text element
   */
  public static Element makeText(
              Element parent,
              String namespace,
              double x,//Beginning coordinate in inches
              double y,//Beginning coordinate in inches
              String fontFamily,  //Font face
              int fontSize, //font size in points
              String textIn //text to be displayed
              ){
    Element text = new Element("text",namespace);
    parent.addContent(text);
    
    //Set default attribute values
    text.setAttribute("fill","black");
    text.setAttribute("stroke","black");
    
    //Set user specified attribute values.
    int xInPix = (int)(Math.round(x*90));
    int yInPix = (int)(Math.round((svgHeight-y)*90));
    
    text.setAttribute("x",""+xInPix);
    text.setAttribute("y",""+yInPix);
    text.addContent(textIn);
    text.setAttribute("font-size","" +fontSize);
    text.setAttribute("font-family",fontFamily);
    
    return text;
  }//end makeText
  //----------------------------------------------------//

  /**This method can be used to set the fill color for
   *closed shapes such as rectangles, circles, ellipses,
   *and polygons. It can also be applied to polylines,
   *but the results may not be what you expect.
   *<p>
   *The fill color can be set to "none" or to any of the
   *color names at
   *<p>
<a href="http://www.w3.org/TR/SVG/types.html#ColorKeywords">
http://www.w3.org/TR/SVG/types.html#ColorKeywords</a>
   *<p>
   *There may be other possibilities as well.
   *
   *@param element the element for which the fill will be
   *set
   *@param fillColor the new color for the fill
   */
  public static void setFill(Element element,
                             String fillColor){
    element.setAttribute("fill",fillColor);
  }//end setFill
  //----------------------------------------------------//
  
  /**This method can be used to set the fill opacity for
   *all closed shapes such as rectangles, circles,
   *ellipses, and polygons.
   *<p>
   *The fill opacity can be set to any value between 
   *0,0 and 1.0 inclusive, where 0.0 is totally
   *transparent and 1.0 is totally opaque.
   *
   *@param element the element for which the opacity
   *will be set
   *@param opacity the numeric opacity value
   */
  public static void setFillOpacity(Element element,
                                    double opacity){
    element.setAttribute("fill-opacity","" + opacity);
  }//end setFillOpacity
  //----------------------------------------------------//

  /**This method can be used to set the font style
   *for text.
   *<p>
   *The font-style can be set to
   *<p>
   *normal | italic | oblique
   *
   *@param element the text element for which the font
   *style will be set
   *@param fontStyle the new font style
   */
  public static void setFontStyle(Element element,
                                  String fontStyle){
    element.setAttribute("font-style","" + fontStyle);
  }//end setFontStyle
  //----------------------------------------------------//

  /**This method can be used to set the font weight
   *for text.
   *<p>
   *The font-weight can be set to
   *<p>
   *normal | bold | bolder | lighter | 100 | 200 | 300| 
   *400 | 500 | 600 | 700 | 800 | 900 |
   *
   *@param element the text element for which the font
   *weight will be set
   *@param fontWeight the new font weight
   */
  public static void setFontWeight(Element element,
                                   String fontWeight){
    element.setAttribute("font-weight","" + fontWeight);
  }//end setFontWeight
  //----------------------------------------------------//

  /**This method can be used to set the stroke color for
   *all shapes.
   *<p>
   *The stroke color can be set to "none" or any of the
   *color names at 
   *<p>
<a href="http://www.w3.org/TR/SVG/types.html#ColorKeywords">
http://www.w3.org/TR/SVG/types.html#ColorKeywords</a>
   *<p>
   *There may be other possibilities as well.
   *
   *@param element the element for which the stroke color
   *will be set
   *@param strokeColor the new stroke color
   */
  public static void setStroke(Element element,
                               String strokeColor){
    element.setAttribute("stroke",strokeColor);
  }//end setStroke
  //----------------------------------------------------//

  /**This method can be used to set the stroke opacity
   *for all shapes.
   *<p>
   *The stroke opacity can be set to any value between
   *0,0 and 1.0 inclusive, where 0.0 is totally
   *transparent and 1.0 is totally opaque.
   *
   *@param element the element for which the stroke color
   *will be set
   *@param opacity the numeric opacity value
   */
  public static void setStrokeOpacity(Element element,
                                      double opacity){
    element.setAttribute("stroke-opacity","" + opacity);
  }//end setStrokeOpacity
  //----------------------------------------------------//
  
  /**This method can be used to set the stroke width 
   *for rectangles, circles, ellipses, lines, polylines,
   *and polygons.
   *
   *@param element the element for which the stroke color
   *will be set
   *@param widthInInches the new stroke width in inches
   *or parts thereof
   */
  public static void setStrokeWidth(Element element,
                                    double widthInInches){
    //Scale and round the double width value to an 
    // int value in svg units where there are 90 svg
    // units per inch.
    int widthInPix = 
                 (int)(Math.round(widthInInches*90));
    element.setAttribute("stroke-width","" + widthInPix);
  }//end setStrokeWidth
  //----------------------------------------------------//
  
  /**This method can be used to add a description <desc>
   *element to any other element
   *
   * @param parent the element to which the description
   *will be added
   * @param namespace the SVG namespace
   *@param description the text for the new description.
   */
  public static void setDescription(Element parent,
                                    String namespace,
                                    String description){
    Element desc = new Element("desc",namespace);
    parent.addContent(desc);
    desc.addContent(description);
  }//end setStrokeWidth
  //----------------------------------------------------//
  
  /**This method writes the SVG code into an output file
   *in whitespace-normalized format, which is more
   *efficient than the prettyPrint format.
   *@param fname path and name of output SVG file
   *including the .svg filename extension
   *@param doc a reference to an object of type Document
   *which was instantiated as
   *<p>
   *new Document(svg,docType)
   *<p>
   *where svg is the root element of the SVG document
   *<p>
   *and docType was instantiated as
   *<p>
   *DocType docType = new DocType( 
   * dtdConstrainedElement,dtdPublicID,dtdSystemID);
   */
  public static void writeCompactFile(
                              String fname, Document doc){
    try{
      FileOutputStream out = new FileOutputStream(fname);

      XMLOutputter xmlOut = 
              new XMLOutputter(Format.getCompactFormat());
      xmlOut.output(doc,out);

      out.flush();
      out.close();
    }catch (IOException e){
      System.err.println(e);
    }//end catch
  }//end writePrettyFile
  //----------------------------------------------------//

  /**This method writes the SVG code into an output file
   *in pretty-print format. The pretty-print format
   *is less efficient than the compact format, but it
   *is very useful during test and debugging because
   *you can view source in your browser and the XML
   *code will be reasonably well formatted.
   *<p>
   *Note that the extension is automatically appended to
   *the output file name, so it should not be included
   *in the file name input parameter.
   *
   *@param fname path and name of output SVG file
   *excluding the .svg filename extension
   *@param doc a reference to an object of type Document
   *which was instantiated as
   *<p>
   *new Document(svg,docType)
   *<p>
   *where svg is the root element of the SVG document
   *<p>
   *and docType was instantiated as
   *<p>
   *DocType docType = new DocType( 
   * dtdConstrainedElement,dtdPublicID,dtdSystemID);
   */
  public static void writePrettyFile(
                              String fname, Document doc){
    try{
      FileOutputStream out = 
                     new FileOutputStream(fname + ".svg");

      XMLOutputter xmlOut = 
               new XMLOutputter(Format.getPrettyFormat());
      xmlOut.output(doc,out);

      out.flush();
      out.close();
    }catch (IOException e){
      System.err.println(e);
    }//end catch
  }//end writePrettyFile
  //----------------------------------------------------//
  
}//end class SvgLib21

/*File Svg21.java,
Copyright 2011, R.G.Baldwin

Revised 08/07/11 to support the addition of a title 
parameter to each element for IVEO compatibility. If the
output SVG file is opened in IVEO, the title for the svg
element is spoken when the user opens the file, and the
titles for the individual elements are spoken when the
user touches a corresponding shape on the touchpad or
clicks on that shape on the screen. If the SVG file won't
be used with IVEO, just leave the title strings unchanged.

This program requires access to the file 
named SvgLib21.java

This is a demonstration program.

This program uses JDOM 1.1.1 and an SVG graphics library 
class of my own design named SvgLib21 to create an XML 
file named Svg21.svg that draws at least one of each of 
the following six basic SVG shapes when rendered in an 
SVG graphics engine such as Firefox 5.

    * rectangle
    * circle
    * ellipse
    * line
    * polyline
    * polygon

In addition, the program illustrates the creation of the
following two types of elements in the output SVG file.

    * description
    * comment

The main purpose is to demonstrate how to create an SVG 
file using the JDOM SVG graphics library that can be
displayed using Firefox 5 or IE 9. The file can also
be opened in other programs such as InkScape and IVEO.

All coordinate values are in inches and fractions of
inches.

One svg unit equals approximately 0.011 inch. An svg
unit is not necessarily the same size as a pixel on your
monitor or your printer. However, dimensions specified
in inches should be very close when you print the image.

By default, all lines that define the geometric shapes 
are black and are one pixel wide. This can be changed
by calling appropriate methods to change attribute values.

By default, the fill attribute for all geometric shapes
is "none". This can be changed by calling appropriate 
methods to change attribute values.

This program creates a canvas that is 8.5x11 inch in 
a portrait orientation.

The origin is at the lower-left corner. Positive x is
to the right and positive y is up the page.

Tested using J2SE 6, JDOM 1.1.1, and Firefox 5
running under Windows Vist Home Premium Edition.
*********************************************************/
import java.io.*;
import org.jdom.*;

public class Svg21{
  public static void main(String[] args){

    //DO NOT MODIFY ANY OF THE CODE ABOVE THIS LINE.
    //##################################################//
    //ONLY THE CODE BELOW THIS LINE CAN BE MODIFIED
    
    //CREATE A DRAWING CANVAS
    //This must be the first statement that you write in
    // the program and it must appear only once.
    //The following statement creates a canvas that is
    // 8.5x11 inches in size in a portrait layout. The
    // size of the canvas can be changed by changing the
    // width and height parameters in the method call.
    Element svg = SvgLib21.makeSvg(ns,
                                   "Document Title",
                                   8.5,//width
                                   11  //height
                                   );
                                          

    //DO NOT MODIFY THE FOLLOWING STATEMENT
    //This statement must immediately follow the call to
    // the makeSvg method above and this statement MUST
    // NOT BE MODIFIED.
    Document doc = new Document(svg,docType);
    
    //DESCRIPTION ELEMENT
    //The following code can be used to add a <desc>
    // element to the svg file if you want one. Replace
    // the text in quotation marks with your description.
    // Don't make any other changes to the code.
    SvgLib21.makeDescription(svg,
                             ns,
                             "The basic SVG shapes."
                             );
      
    //XML/SVG COMMENT
    //The following code can be used to insert a comment
    // into the svg file if you want one. Replace the
    // text in quotatin marks with your comment text.
    // Don't make any other changes to the code. You can
    // insert as many statements of this type as you
    // need, one for each comment. A comment will be
    // inserted into the svg file each time you insert a
    // makeComment statement.
    SvgLib21.makeComment(svg,
                         "Show outline of canvas."
                         );

    //Create some geometrical shapes.
    
    //LINE SEGMENT
    //The following code can be used to draw a line
    // segment.
    //Set the values of the first two parameters
    // following ns to specify the x and y coordinates of
    // one end of the line segment.
    //Set the final two parameters to specify the other
    // end of the line segment.
    //By default the line segment (the stroke) is one
    // pixel wide and black.
    //You can insert as many statements of this type as
    // you need, one for each line segment.
    //Give each line segment a unique name such as lineA,
    // lineB, lineC, etc.
    //Don't make any other changes to the code, and in
    // particular, don't delete the commas.
    //The line segment drawn by the following statement
    // extends from the lower-left to the upper-right
    // corner of the canvas.
    Element lineA = SvgLib21.makeLine(svg,
                                      ns,
                                      "line",
                                      0,
                                      0,
                                      8.5,
                                      11.0
                                      );

    //RECTANGLE
    //The following code can be used to draw a
    // rectangle whose sides are parallel to the
    // horizontal and vertical axes.
    //Set the values of the first two parameters
    // following ns to specify the x and y coordinates of
    // the lower-left corner of the rectangle.
    //Set the final two parameters to specify the width
    // and height of the rectangle. 
    //By default the outline of the rectangle (the stroke)
    // is one pixel wide and black.
    //You can insert as many statements of this type as
    // you need, one for each rectangle.
    //Give each rectangle a unique name such as rectA,
    // rectB, rectC, etc.
    //Don't make any other changes to the code.
    //The rectangle drawn by this statement barely fits
    // inside the 8.5x11 inch canvas with a portrait
    // layout.
    Element rectA = SvgLib21.makeRect(svg,
                                      ns,
                                      "rectangle",
                                      0.05,
                                      0.05,
                                      8.4,
                                      10.9
                                      );

    //CIRCLE
    //The following code can be used to draw a circle.
    //Set the first two parameters following ns to
    // specify the x and y coordinates of the center of
    // the circle. 
    //Set the third parameter to specify the radius of
    // the circle.
    //By default the outline of the circle (the stroke)
    // is one pixel wide and black.
    //You can insert as many statements of this type as
    // you need, one for each circle.
    //Give each circle a unique name such as circleA,
    // circleB, circleC, etc.
    //Don't make any other changes to the code.
    // The circle drawn by this statement is centered in
    // the canvas. The radius is slightly less than half
    // the width of the canvas.
    Element circleA = SvgLib21.makeCircle(svg,
                                          ns,
                                          "circle",
                                          4.25,
                                          5.5,
                                          4.15
                                          );

    //ELLIPSE
    //The following code can be used to draw an ellipse
    // whose major and minor axes are parallel to the
    // horizontal and vertical axes.
    //Set the first two parameters following ns to
    // specify the x and y coordinates of the center of
    // the ellipse. 
    //Set the third parameter to specify the horizontal
    // radius of the ellipse.
    //Set the fourth parameter to specify the vertical
    // radius. 
    //By default the outline of the ellipse (the stroke)
    // is one pixel wide and black.
    //You can insert as many statements of this type as
    // you need, one for each ellipse.
    //Give each ellipse a unique name such as ellipseA,
    // ellipseB, ellipseC, etc.
    //Don't make any other changes to the code.
    //The ellipse drawn by this statement is centered in
    // the canvas. It is two inches wide and one inch
    // high.
    Element ellipseA = SvgLib21.makeEllipse(svg,
                                            ns,
                                            "ellipse",
                                            4.25,
                                            5.5,
                                            1.0,
                                            0.5
                                            );
    
    //POLYLINE
    //The following code can be used to draw a polyline,
    // which is a line constructed from a set of line
    // segments that extend from one set of x,y
    // coordinate values to the next set of x,y
    // coordinate values.
    //This is the most versatile of all of the shapes.
    // With enough patience, it can be used to draw any
    // shape that can be drawn with curved lines. To
    // draw a curved line, approximate it using a large
    // number of short line segments.
    //Insert any number of x,y coordinate-pairs inside
    // the curly brackets.
    //By default, the polyline is black with a line width
    // (thickness) of one pixel.
    //You can insert as many statements of this type as
    // you need, one for each polyline.
    //Give each polyline a unique name such as polylineA,
    // polylineB, polylineC, etc.
    //Don't make any other changes to the code.
    //The polyline drawn by the coordinate values used
    // here consists of two line segments that form two
    // sides of a triangle with the third or top side
    // missing.
    Element polylineA = SvgLib21.makePolyline(
                                            svg,
                                            ns,
                                            "polyline",
                                            new double[]{
                                              3.25,4.02,
                                              4.25,3.01,
                                              5.25,4.02
                                            });

    //POLYGON
    //The following code can be used to draw a polygon,
    // which is like a polyline except that an extra line
    // is automatically drawn to connect the last point
    // to the first point. You can use a polygon to draw
    // any closed shape.
    //For example, you could use a polygon to draw a
    // rectangle whose sides are not parallel to the
    // horizontal and vertical axes, or an ellipse whose
    // axes are not parallel to the horizontal and
    // vertical axes.
    //Insert any number of x,y coordinate-pairs inside
    // the curly brackets.
    //By default, the polygon is black with a line
    // thickness of one pixel.
    //You can insert as many statements of this type as
    // you need, one for each polygon.
    //Give each polygon a unique name such as polygonA,
    // polygonB, polygonC, etc.
    //Don't make any other changes to the code.
    //The polygon drawn by the coordinate values used
    // here draws two line segments that form two sides of
    // a triangle with the third or top side being
    // automatically drawn.
    Element polygonA = SvgLib21.makePolygon(svg,
                                            ns,
                                            "polygon",
                                            new double[]{
                                              3.25,8.02,
                                              4.25,7.01,
                                              5.25,8.02
                                            });


    //TEXT
    //The following code can be used to add one line of
    // text to the drawing.
    //Set the values of the first two parameters
    // following ns to specify the x and y coordinates of
    // the bottom left corner of the first letter in the
    // line of text.
    //Set the third parameter following ns to the name of
    // the font family. If no name or an invalid name is
    // entered between the quotation marks, a default
    // font family will be used.
    //Set the fourth parameter following ns to the
    // desired size of the text in points.
    //Set the last parameter to the string of text that
    // is to be drawn.
    //By default the text is normal (not bold, not
    // italic, etc.).
    //You can insert as many statements of this type as
    // you need, one for each line of text.
    //Give each line of text a unique name such as textA,
    // textB, textC, etc.
    //Don't make any other changes to the code.
    //The line of text drawn by the following statement
    // is positioned 2.125 inches from the left edge of
    // the canvas one inch up from the bottom.
    //The bold italic decoration will be applied later.
    Element textA = SvgLib21.makeText(
                        svg,
                        ns,
                        2.125,
                        1.00,
                        "arial",
                        36,
                        "Here is some bold italic text."
                        );
    
    //Decorate the objects in the drawing.
    
    //FONT STYLE
    //The following code can be used to set the font
    // style to normal | italic | oblique where
    // the | character means you must specify one of the
    // choices as a parameter.
    //Set the value of the first parameter to the name of
    // the line of text being modified.
    //Set the value of the second parameter to one of the
    // available choices.
    //Each time you call this method, you must pass a
    // reference to an existing text object as the first
    // parameter.
    //Don't make any other changes to the code.
    //The following statement changes the style of textA
    // from normal to italic.
    SvgLib21.setFontStyle(textA,
                          "italic"
                          );
    
    //FONT WEIGHT
    //The following code can be used to set the font
    // weight to normal | bold | bolder | lighter | 100 |
    // 200 | 300| 400 | 500 | 600 | 700 | 800 | 900
    // where the | character means you must specify one
    // of the choices as a parameter.
    //Set the value of the first parameter to the name of
    // the line of text being modified.
    //Set the value of the second parameter to one of the
    // available choices.
    //Each time you call this method, you must pass a
    // reference to an existing text object as the first
    // parameter.
    //Don't make any other changes to the code.
    //The following statement statement changes the
    // weight of textA from its previous weight to bold.
    SvgLib21.setFontWeight(textA,
                           "bold"
                           );


    //LINE WIDTH
    //The following code can be used to specify the
    // stroke (line) width for rectangles, circles,
    // ellipses, lines, polylines, and polygons.
    //Set the value of the first parameter to the name of
    // the object whose line width is being modified.
    //Set the second parameter to the value of the
    // desired line width in inches.
    //Each time you call the method, you must pass a
    // reference to an existing object as the first
    // parameter
    //Don't make any other changes to the code.
    //Note that when you increase the thickness of a line,
    // the original one-pixel line remains in the center
    // of the new thicker line. In other words, the
    // thickness of the line increases on both sides of
    // the original line.
    
    // The following statement changes the line width of
    // the rectangle to 0.1 inch.
    SvgLib21.setStrokeWidth(rectA,0.1);

    // The following statement changes the line width of
    // the ellipse to 0.25 inch.
    SvgLib21.setStrokeWidth(ellipseA,0.25);

    // The following statement changes the line width of
    // the polyline to 0.15 inch.
    SvgLib21.setStrokeWidth(polylineA,0.15);

    // The following statement changes the line width of
    // the polygon to 0.15 inch.
    SvgLib21.setStrokeWidth(polygonA,0.15);

    // The following statement changes the line width of
    // the line to 0.1 inch.
    SvgLib21.setStrokeWidth(lineA,0.1);

    // The following statement changes the line width of
    // the circle to 0.1 inch.
    SvgLib21.setStrokeWidth(circleA,0.1); 
    
    //With the exception of the code to write the output
    // file, the following code may not be of interest
    // to blind students. However, it may be of interest
    // to students with low vision, so I am including it
    // for completeness.
    
    //STROKE OPACITY
    //The following code can be used to specify the
    // stroke opacity for rectangles, circles, ellipses,
    // lines, polylines, and polygons.
    //Set the value of the first parameter to the name of
    // the object whose stroke opacity is being modified.
    //Set the second parameter to the value of the
    // desired opacity level. A value of 0.0 causes the
    // stroke to be totally transparent. A value of 1.0 
    // causes the stroke to be completely opaque. Values
    // between 0.0 and 1.0 result in a proportional
    // opacity level.
    //Each time you call the method, you must pass a
    // reference to an existing object as the first
    // parameter
    //Don't make any other changes to the code.
    //The following statement changes the line to be 
    //40-percent opaque, or 60-percent transparent,
    // whichever you prefer.
    SvgLib21.setStrokeOpacity(lineA,0.4);   

    //FILL COLOR
    //The following code can be used to specify the fill
    // color for closed shapes such as rectangles,
    // circles, ellipses, and polygons. It can also be
    // applied to polylines, but the results may not be
    // what you expect.
    //Set the value of the first parameter to the name of
    // the object whose fill color is being modified.
    //Set the second parameter to the name of the desired
    // color.  The fill color can be set to "none" or to
    // the name of any of the colors at 
    // http://www.w3.org/TR/SVG/types.html#ColorKeywords,
    // and possibly some other values as well.
    //Each time you call the method, you must pass a
    // reference to an existing object as the first
    // parameter
    //Don't make any other changes to the code.
    //The following statement changes the fill color for
    // the polygon from its previous fill color to dark
    // blue.
    SvgLib21.setFill(polygonA,"blue");

    //FILL OPACITY
    //The following code can be used to specify the fill
    // opacity for rectangles, circles, ellipses,
    // polylines, and polygons. (As with fill color, it
    // might not work as expected with polylines.)
    //Set the value of the first parameter to the name of
    // the object whose fill opacity is being modified.
    //Set the second parameter to the value of the
    // desired opacity level (see the discussion regarding
    // opacity values above).
    // Each time you call the method, you must pass a
    // reference to an existing object as the first
    // parameter
    //Don't make any other changes to the code.
    //The following statement changes the dark blue fill
    // for the polygon to become only 30-percent opaque.
    // Because the background underneath the fill is
    // white, this causes the visible color of the fill
    // to change to a light blue.
    SvgLib21.setFillOpacity(polygonA,0.3);

    //STROKE COLOR
    //The following code can be used to specify the
    // stroke color for rectangles, circles, ellipses,
    // lines, polylines, and polygons.
    //Set the value of the first parameter to the name of
    // the object whose stroke color is being modified.
    //Set the second parameter to the name of the desired
    // color.  (See the discussion of available colors
    // above.)
    //Each time you call the method, you must pass a
    // reference to an existing object as the first
    // parameter.
    //Don't make any other changes to the code.
    //The following statement changes the stroke color
    // for the polygon from its previous color to red.
    SvgLib21.setStroke(polygonA,"red");

    //WRITE OUTPUT FILE
    //The following code can be used to write an output
    // file containing the instructions needed by an svg
    // processor (such as a browser) to display the
    // drawing.
    //This must be the last statement that you write in
    // your program. Otherwise, you will get an
    // incomplete file.
    //Set the value of the first parameter to the desired
    // path and name for the file. Always specify the
    // extension to be svg.
    //Don't make any other changes to the code.
    //The following code writes the output file with the
    // name Svg21.svg in the folder from which the
    // program is being executed (the current folder).
    //Don't include extension in output file name.
    SvgLib21.writePrettyFile("Svg21",doc);
    
    //ONLY THE CODE ABOVE THIS LINE CAN BE MODIFIED
    //##################################################//
    //DO NOT MODIFY ANY OF THE FOLLOWING CODE.    
  }//end main
  //----------------------------------------------------//

  //Create a String variable containing the namespace
  // URI to reduce the amount of typing that is required
  // later. Note that the variable name is short and
  // easy to type.
  static String ns = "http://www.w3.org/2000/svg";
  
  //For clarity, create strings containing the name of
  // the element that is constrained by the DTD (the
  // root element), the Public ID of the DTD, and the
  // System ID of the DTD.
  static String dtdConstrainedElement = "svg";
  static String dtdPublicID = "-//W3C//DTD SVG 1.1//EN";
  static String dtdSystemID = 
     "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd";
   
  static DocType docType = new DocType(
         dtdConstrainedElement,dtdPublicID,dtdSystemID);
}//end class Svg21