XHTMLText.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */

  18. package org.jivesoftware.smackx.xhtmlim;

  20. import org.jivesoftware.smack.packet.Message;
  21. import org.jivesoftware.smack.util.XmlStringBuilder;

  23. /**
  24.  * An XHTMLText represents formatted text. This class also helps to build valid 
  25.  * XHTML tags.
  26.  *
  27.  * @author Gaston Dombiak
  28.  */
  29. public class XHTMLText {

  31.     public static final String NAMESPACE = "http://www.w3.org/1999/xhtml";

  33.     private final XmlStringBuilder text = new XmlStringBuilder();

  35.     /**
  36.      * Creates a new XHTMLText with body tag params.
  37.      * 
  38.      * @param style the XHTML style of the body
  39.      * @param lang the language of the body
  40.      */
  41.     public XHTMLText(String style, String lang) {
  42.         appendOpenBodyTag(style, lang);
  43.     }

  45.     public static final String A = "a";
  46.     public static final String HREF = "href";
  47.     public static final String STYLE = "style";

  49.     /**
  50.      * Appends a tag that indicates that an anchor section begins.
  51.      * 
  52.      * @param href indicates the URL being linked to
  53.      * @param style the XHTML style of the anchor
  54.      */
  55.     public XHTMLText appendOpenAnchorTag(String href, String style) {
  56.         text.halfOpenElement(A);
  57.         text.optAttribute(HREF, href);
  58.         text.optAttribute(STYLE, style);
  59.         text.rightAngleBracket();
  60.         return this;
  61.     }

  63.     /**
  64.      * Appends a tag that indicates that an anchor section ends.
  65.      * 
  66.      */
  67.     public XHTMLText appendCloseAnchorTag() {
  68.         text.closeElement(A);
  69.         return this;
  70.     }

  72.     public static final String BLOCKQUOTE = "blockquote";
  73.     /**
  74.      * Appends a tag that indicates that a blockquote section begins.
  75.      * 
  76.      * @param style the XHTML style of the blockquote
  77.      */
  78.     public XHTMLText appendOpenBlockQuoteTag(String style) {
  79.         text.halfOpenElement(BLOCKQUOTE);
  80.         text.optAttribute(STYLE, style);
  81.         text.rightAngleBracket();
  82.         return this;
  83.     }

  85.     /**
  86.      * Appends a tag that indicates that a blockquote section ends.
  87.      * 
  88.      */
  89.     public XHTMLText appendCloseBlockQuoteTag() {
  90.         text.closeElement(BLOCKQUOTE);
  91.         return this;
  92.     }

  94.     /**
  95.      * Appends a tag that indicates that a body section begins.
  96.      * 
  97.      * @param style the XHTML style of the body
  98.      * @param lang the language of the body
  99.      */
  100.     private XHTMLText appendOpenBodyTag(String style, String lang) {
  101.         text.halfOpenElement(Message.BODY);
  102.         text.xmlnsAttribute(NAMESPACE);
  103.         text.optElement(STYLE, style);
  104.         text.xmllangAttribute(lang);
  105.         text.rightAngleBracket();
  106.         return this;
  107.     }

  109.     public XHTMLText appendCloseBodyTag() {
  110.         text.closeElement(Message.BODY);
  111.         return this;
  112.     }

  114.     public static final String BR = "br";
  115.     public static final String CITE = "cite";
  116.     public static final String CODE = "code";

  118.     /**
  119.      * Appends a tag that inserts a single carriage return.
  120.      * 
  121.      */
  122.     public XHTMLText appendBrTag() {
  123.         text.emptyElement(BR);
  124.         return this;
  125.     }

  127.     /**
  128.      * Appends a tag that indicates a reference to work, such as a book, report or web site.
  129.      * 
  130.      */
  131.     public XHTMLText appendOpenCiteTag() {
  132.         text.openElement(CITE);
  133.         return this;
  134.     }

  136.     /**
  137.      * Appends a tag that indicates text that is the code for a program.
  138.      * 
  139.      */
  140.     public XHTMLText appendOpenCodeTag() {
  141.         text.openElement(CODE);
  142.         return this;
  143.     }

  145.     /**
  146.      * Appends a tag that indicates end of text that is the code for a program.
  147.      * 
  148.      */
  149.     public XHTMLText appendCloseCodeTag() {
  150.         text.closeElement(CODE);
  151.         return this;
  152.     }

  154.     public static final String EM = "em";

  156.     /**
  157.      * Appends a tag that indicates emphasis.
  158.      * 
  159.      */
  160.     public XHTMLText appendOpenEmTag() {
  161.         text.openElement(EM);
  162.         return this;
  163.     }

  165.     /**
  166.      * Appends a tag that indicates end of emphasis.
  167.      * 
  168.      */
  169.     public XHTMLText appendCloseEmTag() {
  170.         text.closeElement(EM);
  171.         return this;
  172.     }

  174.     public static final String H = "h";

  176.     /**
  177.      * Appends a tag that indicates a header, a title of a section of the message.
  178.      * 
  179.      * @param level the level of the Header. It must be a value between 1 and 3
  180.      * @param style the XHTML style of the blockquote
  181.      */
  182.     public XHTMLText appendOpenHeaderTag(int level, String style) {
  183.         if (level > 3 || level < 1) {
  184.             throw new IllegalArgumentException("Level must be between 1 and 3");
  185.         }
  186.         text.halfOpenElement(H + Integer.toString(level));
  187.         text.optAttribute(STYLE, style);
  188.         text.rightAngleBracket();
  189.         return this;
  190.     }

  192.     /**
  193.      * Appends a tag that indicates that a header section ends.
  194.      * 
  195.      * @param level the level of the Header. It must be a value between 1 and 3
  196.      */
  197.     public XHTMLText appendCloseHeaderTag(int level) {
  198.         if (level > 3 || level < 1) {
  199.             throw new IllegalArgumentException("Level must be between 1 and 3");
  200.         }
  201.         text.closeElement(H + Integer.toBinaryString(level));
  202.         return this;
  203.     }

  205.     public static final String IMG = "img";

  207.     /**
  208.      * Appends a tag that indicates an image.
  209.      * 
  210.      * @param align how text should flow around the picture
  211.      * @param alt the text to show if you don't show the picture
  212.      * @param height how tall is the picture
  213.      * @param src where to get the picture
  214.      * @param width how wide is the picture
  215.      */
  216.     public XHTMLText appendImageTag(String align, String alt, String height, String src, String width) {
  217.         text.halfOpenElement(IMG);
  218.         text.optAttribute("align", align);
  219.         text.optAttribute("alt", alt);
  220.         text.optAttribute("height", height);
  221.         text.optAttribute("src", src);
  222.         text.optAttribute("width", width);
  223.         text.rightAngleBracket();
  224.         return this;
  225.     }

  227.     public static final String LI = "li";
  228.     public static final String OL = "ol";

  230.     /**
  231.      * Appends a tag that indicates the start of a new line item within a list.
  232.      * 
  233.      * @param style the style of the line item
  234.      */
  235.     public XHTMLText appendLineItemTag(String style) {
  236.         text.halfOpenElement(LI);
  237.         text.optAttribute(STYLE, style);
  238.         text.rightAngleBracket();
  239.         return this;
  240.     }

  242.     /**
  243.      * Appends a tag that indicates that a line item section ends.
  244.      *
  245.      */
  246.     public XHTMLText appendCloseLineItemTag() {
  247.         text.closeElement(LI);
  248.         return this;
  249.     }

  251.     /**
  252.      * Appends a tag that creates an ordered list. "Ordered" means that the order of the items 
  253.      * in the list is important. To show this, browsers automatically number the list. 
  254.      * 
  255.      * @param style the style of the ordered list
  256.      */
  257.     public XHTMLText appendOpenOrderedListTag(String style) {
  258.         text.halfOpenElement(OL);
  259.         text.optAttribute(STYLE, style);
  260.         text.rightAngleBracket();
  261.         return this;
  262.     }

  264.     /**
  265.      * Appends a tag that indicates that an ordered list section ends.
  266.      * 
  267.      */
  268.     public XHTMLText appendCloseOrderedListTag() {
  269.         text.closeElement(OL);
  270.         return this;
  271.     }

  273.     public static final String UL = "ul";

  275.     /**
  276.      * Appends a tag that creates an unordered list. The unordered part means that the items 
  277.      * in the list are not in any particular order.
  278.      * 
  279.      * @param style the style of the unordered list
  280.      */
  281.     public XHTMLText appendOpenUnorderedListTag(String style) {
  282.         text.halfOpenElement(UL);
  283.         text.optAttribute(STYLE, style);
  284.         text.rightAngleBracket();
  285.         return this;
  286.     }

  288.     /**
  289.      * Appends a tag that indicates that an unordered list section ends.
  290.      * 
  291.      */
  292.     public XHTMLText appendCloseUnorderedListTag() {
  293.         text.closeElement(UL);
  294.         return this;
  295.     }

  297.     public static final String P = "p";

  299.     /**
  300.      * Appends a tag that indicates the start of a new paragraph. This is usually rendered 
  301.      * with two carriage returns, producing a single blank line in between the two paragraphs.
  302.      * 
  303.      * @param style the style of the paragraph
  304.      */
  305.     public XHTMLText appendOpenParagraphTag(String style) {
  306.         text.halfOpenElement(P);
  307.         text.optAttribute(STYLE, style);
  308.         text.rightAngleBracket();
  309.         return this;
  310.     }

  312.     /**
  313.      * Appends a tag that indicates the end of a new paragraph. This is usually rendered 
  314.      * with two carriage returns, producing a single blank line in between the two paragraphs.
  315.      * 
  316.      */
  317.     public XHTMLText appendCloseParagraphTag() {
  318.         text.closeElement(P);
  319.         return this;
  320.     }

  322.     public static final String Q = "q";

  324.     /**
  325.      * Appends a tag that indicates that an inlined quote section begins.
  326.      * 
  327.      * @param style the style of the inlined quote
  328.      */
  329.     public XHTMLText appendOpenInlinedQuoteTag(String style) {
  330.         text.halfOpenElement(Q);
  331.         text.optAttribute(STYLE, style);
  332.         text.rightAngleBracket();
  333.         return this;
  334.     }

  336.     /**
  337.      * Appends a tag that indicates that an inlined quote section ends.
  338.      * 
  339.      */
  340.     public XHTMLText appendCloseInlinedQuoteTag() {
  341.         text.closeElement(Q);
  342.         return this;
  343.     }

  345.     public static final String SPAN = "span";

  347.     /**
  348.      * Appends a tag that allows to set the fonts for a span of text.
  349.      * 
  350.      * @param style the style for a span of text
  351.      */
  352.     public XHTMLText appendOpenSpanTag(String style) {
  353.         text.halfOpenElement(SPAN);
  354.         text.optAttribute(STYLE, style);
  355.         text.rightAngleBracket();
  356.         return this;
  357.     }

  359.     /**
  360.      * Appends a tag that indicates that a span section ends.
  361.      * 
  362.      */
  363.     public XHTMLText appendCloseSpanTag() {
  364.         text.closeElement(SPAN);
  365.         return this;
  366.     }

  368.     public static final String STRONG = "strong";

  370.     /**
  371.      * Appends a tag that indicates text which should be more forceful than surrounding text.
  372.      * 
  373.      */
  374.     public XHTMLText appendOpenStrongTag() {
  375.         text.openElement(STRONG);
  376.         return this;
  377.     }

  379.     /**
  380.      * Appends a tag that indicates that a strong section ends.
  381.      * 
  382.      */
  383.     public XHTMLText appendCloseStrongTag() {
  384.         text.closeElement(STRONG);
  385.         return this;
  386.     }

  388.     /**
  389.      * Appends a given text to the XHTMLText.
  390.      * 
  391.      * @param textToAppend the text to append   
  392.      */
  393.     public XHTMLText append(String textToAppend) {
  394.         text.escape(textToAppend);
  395.         return this;
  396.     }

  398.     /**
  399.      * Returns the text of the XHTMLText.
  400.      * 
  401.      * @return the text of the XHTMLText   
  402.      */
  403.     public String toString() {
  404.         return text.toString();
  405.     }

  407.     public XmlStringBuilder toXML() {
  408.         return text;
  409.     }
  410. }
Created with JaCoCo 0.7.4.201502262128