Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2010 eXo Platform SAS.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
   * the License, or (at your option) any later version.
   *
   * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 
 package org.wikbook.core.transform;
 
 import  org.xwiki.rendering.block.XDOM;
 import  org.xwiki.rendering.listener.Format;
 import  org.xwiki.rendering.listener.HeaderLevel;
 import  org.xwiki.rendering.listener.Image;
 import  org.xwiki.rendering.listener.Link;
 import  org.xwiki.rendering.listener.ListType;
 import  org.xwiki.rendering.listener.Listener;
 import  org.xwiki.rendering.syntax.Syntax;
 
 import java.util.Map;
 import java.util.Set;

Author(s):
Julien Viet
Version:
$Revision$
 
 public class XDOMTransformer implements Listener
 {

   
.
 
    private static final Set<Stringadmonitions = new HashSet<String>();

   
.
 
    private static final EnumMap<Format, TextFormatformatMapping = new EnumMap<Format, TextFormat>(Format.class);
 
    static
    {
       .add("note");
       .add("important");
       .add("tip");
       .add("caution");
       .add("warning");
    }
 
    static
    {
       .put(Format.BOLD, .);
       .put(Format.ITALIC, .);
       .put(Format.MONOSPACE, .);
       .put(Format.SUPERSCRIPT, .);
       .put(Format.SUBSCRIPT, .);
      .put(Format.UNDERLINED, .);
      .put(Format.STRIKEDOUT, .);
   }

   
.
   private final WikletContext context;

   
.
   private DocbookContext bookContext;

   
.
   private BookElement book;
   {
      this. = context;
   }
   public DocbookElement transform(XDOM dom)
   {
       = new BookElement();
       = new DocbookContext();
      dom.traverse(this);
      .close();
      return ;
   }
   public void beginDocument(Map<StringStringparameters)
   {
   }
   public void endDocument(Map<StringStringparameters)
   {
   }
   public void beginParagraph(Map<StringStringparameters)
   {
      .push(new ParagraphElement());
   }
   public void endParagraph(Map<StringStringparameters)
   {
      .merge();
   }
   
   //
   public void beginSection(Map<StringStringparameters)
   {
      .push(new ComponentElement());
   }
   public void endSection(Map<StringStringparameters)
   {
      .merge();
   }
   public void beginHeader(HeaderLevel levelString idMap<StringStringparameters)
   {
   }
   public void endHeader(HeaderLevel levelString idMap<StringStringparameters)
   {
   }
   //
   
   public void onWord(String word)
   {
      .merge(new TextElement(word));
   }
   public void onSpace()
   {
      .merge(new TextElement(" "));
   }
   public void onNewLine()
   {
      // For now we dont take in account line breaks
      .merge(new TextElement(" "));
   }
   public void onSpecialSymbol(char symbol)
   {
      // For now it will be ok
      .merge(new TextElement(Character.toString(symbol)));
   }
   public void beginFormat(Format formatMap<StringStringparameters)
   {
      TextFormat textFormat = .get(format);
      if (textFormat == null)
      {
         throw new UnsupportedOperationException("Format " + format + " is not yet handled");
      }
      .push(new FormatElement(textFormat));
   }
   public void endFormat(Format formatMap<StringStringparameters)
   {
      .merge();
   }
   //
   public void beginList(ListType listTypeMap<StringStringparameters)
   {
      String style = parameters.get("style");
      .push(new ListElement(listTypestyle));
   }
   public void endList(ListType listTypeMap<StringStringparameters)
   {
      .merge();
   }
   public void beginListItem()
   {
      ((ListElement).peek()).beginItem();
   }
   public void endListItem()
   {
      ((ListElement).peek()).endItem();
   }
   //
   public void onMacro(String idMap<StringStringmacroParametersString contentboolean isInline)
   {
      if (.contains(id))
      {
         if (isInline)
         {
            throw new UnsupportedOperationException("todo");
         }
         else
         {
            AdmonitionElement admonitionElt = new AdmonitionElement(id);
            //
            WikiLoader loader = new WikiLoader();
            XDOM dom = loader.load(new StringReader(content), null);
            //
            .push(admonitionElt);
            dom.traverse(this);
            .merge();
         }
      }
      else if ("screen".equals(id))
      {
         ScreenElement screenElt = new ScreenElement();
         screenElt.append(new TextElement(content));
         .merge(screenElt);
      }
      else if ("anchor".equals(id))
      {
         String anchor = macroParameters.get("id");
         .merge(new AnchorElement(anchor));
      }
      else if ("docbook".equals(id))
      {
         try
         {
            Transformer transformer = XML.createTransformer(new OutputFormat(2, true));
            // Output buffer
            StringWriter writer = new StringWriter();
            // Perform identity transformation
            DOMResult result = new DOMResult();
            //
            transformer.transform(new StreamSource(new StringReader(content)), result);
            //
            .merge(new DOMElement(((Document)result.getNode()).getDocumentElement()));
         }
         catch (Exception e)
         {
            e.printStackTrace();
         }
      }
      else if ("code".equals(id) || "java".equals(id) || "xml".equals(id))
      {
         if (isInline)
         {
            .push(new FormatElement(.));
            .merge(new TextElement(content));
            .merge();
         }
         else
         {
            LanguageSyntax languageSyntax = .;
            if ("java".equals(id))
            {
               languageSyntax = .;
            }
            else if ("xml".equals(id))
            {
               languageSyntax = .;
            }
            else
            {
               String language = macroParameters.get("language");
               if ("java".equalsIgnoreCase(language))
               {
                  languageSyntax = .;
               }
               else if ("xml".equalsIgnoreCase(language))
               {
                  languageSyntax = .;
               }
            }
            //
            Integer indent = null;
            if (macroParameters.get("indent") != null)
            {
               try
               {
                  indent = Integer.parseInt(macroParameters.get("indent"));
               }
               catch (NumberFormatException e)
               {
                  e.printStackTrace();
               }
            }
            //
            ProgramListingElement programListingElt = .push(new ProgramListingElement(
               ,
               languageSyntax,
               indent,
               content,
               .getHighlightCode()));
            //
            programListingElt.process(this);
            //
            .merge();
         }
      }
      else if ("example".equals(id))
      {
         WikiLoader loader = new WikiLoader();
         XDOM dom = loader.load(new StringReader(content), null);
         .push(new ExampleElement(macroParameters.get("title")));
         dom.traverse(this);
         .merge();
      }
      else
      {
         throw new UnsupportedOperationException("Unsupported macro " + id);
      }
   }
   //
   public void beginLink(Link linkboolean isFreeStandingURIMap<StringStringparameters)
   {
      switch (link.getType())
      {
         case URI:
            String ref = link.getReference();
            org.wikbook.core.model.content.inline.LinkType type;
            if (ref.startsWith("#"))
            {
               ref = ref.substring(1);
               type = .......;
            }
            else
            {
               type = .......;
            }
            .push(new LinkElement(typeref));
            break;
         default:
            throw new UnsupportedOperationException();
      }
   }
   public void endLink(Link linkboolean isFreeStandingURIMap<StringStringparameters)
   {
      switch (link.getType())
      {
         case URI:
            .merge();
            break;
         default:
            throw new UnsupportedOperationException();
      }
   }
   //
   public void beginTable(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .push(new TableElement(title));
   }
   public void beginTableRow(Map<StringStringparameters)
   {
      ((TableElement).peek()).doBeginTableRow(parameters);
   }
   public void beginTableCell(Map<StringStringparameters)
   {
      ((TableElement).peek()).doBeginTableCell(parameters);
   }
   public void beginTableHeadCell(Map<StringStringparameters)
   {
      ((TableElement).peek()).doBeginTableHeadCell(parameters);
   }
   public void endTable(Map<StringStringparameters)
   {
      .merge();
   }
   public void endTableRow(Map<StringStringparameters)
   {
      ((TableElement).peek()).doEndTableRow(parameters);
   }
   public void endTableCell(Map<StringStringparameters)
   {
      ((TableElement).peek()).doEndTableCell(parameters);
   }
   public void endTableHeadCell(Map<StringStringparameters)
   {
      ((TableElement).peek()).doEndTableHeadCell(parameters);
   }
   //
   public void beginGroup(Map<StringStringparameters)
   {
      .push(new GroupElement());
   }
   public void endGroup(Map<StringStringparameters)
   {
      .merge();
   }
   //
   public void beginDefinitionList(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .push(new VariableListElement(title));
   }
   public void beginDefinitionTerm()
   {
      .push(new TermElement());
   }
   public void endDefinitionTerm()
   {
      .merge();
   }
   public void beginDefinitionDescription()
   {
      .push(new ListItemElement());
   }
   public void endDefinitionDescription()
   {
      .merge();
   }
   public void endDefinitionList(Map<StringStringparameters)
   {
      .merge();
   }
   //
   public void beginMacroMarker(String nameMap<StringStringmacroParametersString contentboolean isInline)
   {
      throw new UnsupportedOperationException();
   }
   public void endMacroMarker(String nameMap<StringStringmacroParametersString contentboolean isInline)
   {
      throw new UnsupportedOperationException();
   }
   public void beginQuotation(Map<StringStringparameters)
   {
      .push(new BlockQuotationElement());
   }
   public void endQuotation(Map<StringStringparameters)
   {
      .merge();
   }
   public void beginQuotationLine()
   {
   }
   public void endQuotationLine()
   {
   }
   public void onId(String name)
   {
      throw new UnsupportedOperationException();
   }
   public void onHorizontalLine(Map<StringStringparameters)
   {
   }
   public void onEmptyLines(int count)
   {
      // Nothing to do really
   }
   public void onVerbatim(String protectedStringboolean isInlineMap<StringStringparameters)
   {
      .merge(new TextElement(protectedString));
   }
   public void onRawText(String rawContent, Syntax syntax)
   {
      throw new UnsupportedOperationException();
   }
   public void onImage(Image imageboolean isFreeStandingURIMap<StringStringparameters)
   {
      .merge(new ImageElement(image.getName(), parameters));
   }
New to GrepCode? Check out our FAQ X