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.xwiki;
 
 import  org.xwiki.rendering.block.Block;
 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;

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

   
.
 
    private static final Map<StringAdmonitionKindadmonitions = new HashMap<StringAdmonitionKind>();

   
.
 
    private static final EnumMap<Format, TextFormatformatMapping = new EnumMap<Format, TextFormat>(Format.class);

   
.
 
    private static final EnumMap<ListType, ListKindmapping = new EnumMap<ListType, ListKind>(ListType.class);
 
    static
    {
       .put(ListType.BULLETED, .);
       .put(ListType.NUMBERED, .);
    }
 
    static
    {
       .put("note".);
       .put("info".);
       .put("important".);
       .put("tip".);
       .put("caution".);
       .put("warning".);
    }
 
    static
    {
       .put(Format.BOLD, .);
       .put(Format.ITALIC, .);
       .put(Format.MONOSPACE, .);
       .put(Format.SUPERSCRIPT, .);
       .put(Format.SUBSCRIPT, .);
       .put(Format.UNDERLINED, .);
       .put(Format.STRIKEDOUT, .);
    }

   
.
 
    private DocbookBuilder builder;

   
.
 
 
    {
       this. = context;
      this. = builder;
   }
   public void beginDocument(Map<StringStringparameters)
   {
   }
   public void endDocument(Map<StringStringparameters)
   {
   }
   public void beginParagraph(Map<StringStringparameters)
   {
      .beginParagraph();
   }
   public void endParagraph(Map<StringStringparameters)
   {
      .endParagraph();
   }
   //
   public void beginSection(Map<StringStringparameters)
   {
      .beginSection();
   }
   public void endSection(Map<StringStringparameters)
   {
      .endSection();
   }
   public void beginHeader(HeaderLevel levelString idMap<StringStringparameters)
   {
      .beginHeader();
   }
   public void endHeader(HeaderLevel levelString idMap<StringStringparameters)
   {
      .endHeader();
   }
   //
   public void onWord(String word)
   {
      .onText(word);
   }
   public void onSpace()
   {
      .onText(" ");
   }
   public void onNewLine()
   {
      // For now we dont take in account line breaks
      .onText(" ");
   }
   public void onSpecialSymbol(char symbol)
   {
      // For now it will be ok
      .onText(Character.toString(symbol));
   }
   public void beginFormat(Format formatMap<StringStringparameters)
   {
      TextFormat textFormat = .get(format);
      if (textFormat == null)
      {
         .onValidationError("Format " + format + " is not yet supported");
      }
      else
      {
         .beginFormat(textFormat);
      }
   }
   public void endFormat(Format formatMap<StringStringparameters)
   {
      TextFormat textFormat = .get(format);
      if (textFormat == null)
      {
         .onValidationError("Format " + format + " is not yet supported");
      }
      else
      {
         .endFormat(textFormat);
      }
   }
   //
   public void beginList(ListType listTypeMap<StringStringparameters)
   {
      String style = parameters.get("style");
      ListKind lk = .get(listType);
      .beginList(lkstyle);
   }
   public void endList(ListType listTypeMap<StringStringparameters)
   {
      String style = parameters.get("style");
      ListKind lk = .get(listType);
      .endList(lkstyle);
   }
   public void beginListItem()
   {
      .beginListItem();
   }
   public void endListItem()
   {
      .endListItem();
   }
   //
   public void onMacro(String idMap<StringStringmacroParametersString contentboolean isInline)
   {
      _onMacro(idmacroParameterscontent.isInlineContext());
   }
   private void _onMacro(String idMap<StringStringmacroParametersString contentboolean isInline)
   {
      AdmonitionKind admonition = .get(id);
      if (admonition != null)
      {
         WikiLoader loader = new WikiLoader();
         Block block = loader.load(new StringReader(content), null);
         //
         .beginAdmonition(admonition);
         block.traverse(this);
         .endAdmonition(admonition);
      }
      else if ("screen".equals(id))
      {
         .beginScreen();
         .onText(content);
         .endScreen();
      }
      else if ("anchor".equals(id))
      {
         String anchor = macroParameters.get("id");
         .onAnchor(anchor);
      }
      else if ("docbook".equals(id))
      {
         try
         {
            Transformer transformer = XML.createTransformer(new OutputFormat(2, true));
            // Perform identity transformation
            DOMResult result = new DOMResult();
            //
            transformer.transform(new StreamSource(new StringReader(content)), result);
            //
            .onDocbook(((Document)result.getNode()).getDocumentElement());
         }
         catch (Exception e)
         {
            throw new WikbookException(e);
         }
      }
      else if ("code".equals(id) || "java".equals(id) || "xml".equals(id))
      {
         if (isInline)
         {
            .beginFormat(.);
            .onText(content);
            .endFormat(.);
         }
         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();
               }
            }
            //
            .onCode(
               languageSyntax,
               indent,
               content
            );
         }
      }
      else if ("example".equals(id))
      {
         if (isInline)
         {
            throw new UnsupportedOperationException();
         }
         WikiLoader loader = new WikiLoader();
         Block block = loader.load(new StringReader(content), ..getLast());
         .beginExample(macroParameters.get("title"));
         block.traverse(this);
         .endExample(macroParameters.get("title"));
      }
      else
      {
         .onValidationError("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 = .......;
            }
            .beginLink(typeref);
            break;
         default:
            .onValidationError("Unsupported link type " + link.getType());
      }
   }
   public void endLink(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 = .......;
            }
            .endLink(typeref);
            break;
         default:
            .onValidationError("Unsupported link type " + link.getType());
      }
   }
   //
   public void beginTable(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .beginTable(title);
   }
   public void beginTableRow(Map<StringStringparameters)
   {
      .beginTableRow(parameters);
   }
   public void beginTableCell(Map<StringStringparameters)
   {
      .beginTableCell(parameters);
   }
   public void beginTableHeadCell(Map<StringStringparameters)
   {
      .beginTableHeadCell(parameters);
   }
   public void endTable(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .endTable(title);
   }
   public void endTableRow(Map<StringStringparameters)
   {
      .endTableRow(parameters);
   }
   public void endTableCell(Map<StringStringparameters)
   {
      .endTableCell(parameters);
   }
   public void endTableHeadCell(Map<StringStringparameters)
   {
      .endTableHeadCell(parameters);
   }
   //
   public void beginGroup(Map<StringStringparameters)
   {
      .beginGroup();
   }
   public void endGroup(Map<StringStringparameters)
   {
      .endGroup();
   }
   //
   public void beginDefinitionList(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .beginDefinitionList(title);
   }
   public void beginDefinitionTerm()
   {
   }
   public void endDefinitionTerm()
   {
   }
   public void beginDefinitionDescription()
   {
   }
   public void endDefinitionDescription()
   {
   }
   public void endDefinitionList(Map<StringStringparameters)
   {
      String title = parameters.get("title");
      .endDefinitionList(title);
   }
   //
   public void beginMacroMarker(String nameMap<StringStringmacroParametersString contentboolean isInline)
   {
      .onValidationError("Not supported");
   }
   public void endMacroMarker(String nameMap<StringStringmacroParametersString contentboolean isInline)
   {
      .onValidationError("Not supported");
   }
   public void beginQuotation(Map<StringStringparameters)
   {
      .beginQuotation();
   }
   public void endQuotation(Map<StringStringparameters)
   {
      .endQuotation();
   }
   public void beginQuotationLine()
   {
   }
   public void endQuotationLine()
   {
   }
   public void onId(String name)
   {
      .onValidationError("Not supported");
   }
   public void onHorizontalLine(Map<StringStringparameters)
   {
   }
   public void onEmptyLines(int count)
   {
      // Nothing to do really
   }
   public void onVerbatim(String protectedStringboolean isInlineMap<StringStringparameters)
   {
      .onVerbatim(protectedString);
   }
   public void onRawText(String rawContent, Syntax syntax)
   {
      .onValidationError("Not supported");
   }
   public void onImage(Image imageboolean isFreeStandingURIMap<StringStringparameters)
   {
      .onImage(image.getName(), parameters);
   }
New to GrepCode? Check out our FAQ X