first commit

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/Box.java

@@ -0,0 +1,75 @@
+package org.pptx4j;
+
+public class Box {
+  Point offset;
+  
+  Point extent;
+  
+  public Box(long offsetX, long offsetY, long extentX, long extentY) {
+    this.offset = new Point(offsetX, offsetY);
+    this.extent = new Point(extentX, extentY);
+    System.out.println(debug());
+  }
+  
+  public void flipH() {
+    this.offset.x += this.extent.x;
+    this.extent.x = -this.extent.x;
+    System.out.println("FlipH--> " + debug());
+  }
+  
+  public void flipV() {
+    this.offset.y += this.extent.y;
+    this.extent.y = -this.extent.y;
+    System.out.println("FlipV--> " + debug());
+  }
+  
+  public Point getOtherCorner() {
+    return this.offset.add(this.extent);
+  }
+  
+  public void toPixels() {
+    this.offset = this.offset.toPixels();
+    this.extent = this.extent.toPixels();
+  }
+  
+  public void rotate(int units) {
+    Point centre = new Point((long)Math.round((float)this.offset.x + 0.5F * (float)this.extent.x), (long)Math.round((float)this.offset.y + 0.5F * (float)this.extent.y));
+    float degree = (float)(-units / 60000);
+    System.out.println("Rotating " + degree);
+    float radians = (float)Math.toRadians((double)degree);
+    Point otherCorner = getOtherCorner();
+    Point otherCornerDash = otherCorner.subtract(centre);
+    Point otherCornerDash2 = rotate(otherCornerDash, radians);
+    Point otherCornerDash3 = otherCornerDash2.add(centre);
+    Point offsetDash = this.offset.subtract(centre);
+    Point offsetDash2 = rotate(offsetDash, radians);
+    Point offsetDash3 = offsetDash2.add(centre);
+    this.offset = offsetDash3;
+    this.extent = otherCornerDash3.subtract(this.offset);
+    System.out.println("Rotated--> " + debug());
+  }
+  
+  private Point rotate(Point p, float radians) {
+    long xDash = Math.round((double)p.x * Math.cos((double)radians) - (double)p.y * Math.sin((double)radians));
+    long yDash = Math.round((double)p.x * Math.sin((double)radians) + (double)p.y * Math.cos((double)radians));
+    return new Point(xDash, yDash);
+  }
+  
+  public String debug() {
+    return "offset " + this.offset.debug() + "; extent " + this.extent.debug();
+  }
+  
+  public Point getOffset() {
+    return this.offset;
+  }
+  
+  public Point getExtent() {
+    return this.extent;
+  }
+  
+  public static void main(String[] args) {
+    Box b = new Box(0L, 0L, 1L, 0L);
+    b.rotate(5400000);
+    System.out.println();
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/Point.java

@@ -0,0 +1,54 @@
+package org.pptx4j;
+
+public class Point {
+  public static final int extentToPixelConversionFactor = 9525;
+  
+  long x;
+  
+  long y;
+  
+  Point(long x, long y) {
+    this.x = x;
+    this.y = y;
+  }
+  
+  public long getX() {
+    return this.x;
+  }
+  
+  public String getXAsString() {
+    return Long.toString(this.x);
+  }
+  
+  public void setX(long x) {
+    this.x = x;
+  }
+  
+  public long getY() {
+    return this.y;
+  }
+  
+  public String getYAsString() {
+    return Long.toString(this.y);
+  }
+  
+  public void setY(long y) {
+    this.y = y;
+  }
+  
+  Point add(Point point2) {
+    return new Point(this.x + point2.x, this.y + point2.y);
+  }
+  
+  Point subtract(Point point2) {
+    return new Point(this.x - point2.x, this.y - point2.y);
+  }
+  
+  Point toPixels() {
+    return new Point((long)Math.round((float)(this.x / 9525L)), (long)Math.round((float)(this.y / 9525L)));
+  }
+  
+  public String debug() {
+    return "(" + this.x + ", " + this.y + ")";
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/Pptx4jException.java

@@ -0,0 +1,15 @@
+package org.pptx4j;
+
+public class Pptx4jException extends Exception {
+  public Pptx4jException(String msg) {
+    super(msg);
+  }
+  
+  public Pptx4jException(String msg, Exception e) {
+    super(msg, e);
+  }
+  
+  public Pptx4jException(String msg, Throwable t) {
+    super(msg, t);
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/convert/out/AbstractPmlConversionContext.java

@@ -0,0 +1,36 @@
+package org.pptx4j.convert.out;
+
+import org.docx4j.convert.out.AbstractConversionSettings;
+import org.docx4j.convert.out.common.AbstractConversionContext;
+import org.docx4j.convert.out.common.writer.AbstractMessageWriter;
+import org.docx4j.openpackaging.packages.OpcPackage;
+import org.docx4j.openpackaging.packages.PresentationMLPackage;
+import org.pptx4j.convert.out.svginhtml.SvgExporter;
+
+public abstract class AbstractPmlConversionContext extends AbstractConversionContext {
+  protected AbstractPmlConversionContext(AbstractMessageWriter messageWriter, AbstractConversionSettings conversionSettings, PresentationMLPackage localPmlPackage) {
+    super(messageWriter, conversionSettings, localPmlPackage);
+  }
+  
+  protected void initializeSettings(AbstractConversionSettings settings, OpcPackage opcPackage) {
+    SvgExporter.SvgSettings svgSettings = null;
+    if (settings == null) {
+      settings = new SvgExporter.SvgSettings();
+    } else if (!(settings instanceof SvgExporter.SvgSettings)) {
+      throw new IllegalArgumentException("The class of the settings isn't SvgExporter.SvgSettings, it is " + settings.getClass().getName());
+    } 
+    svgSettings = (SvgExporter.SvgSettings)settings;
+    super.initializeSettings(svgSettings, opcPackage);
+  }
+  
+  protected OpcPackage initializeOpcPackage(AbstractConversionSettings settings, OpcPackage opcPackage) {
+    OpcPackage ret = super.initializeOpcPackage(settings, opcPackage);
+    if (!(ret instanceof PresentationMLPackage))
+      throw new IllegalArgumentException("The opcPackage isn't a PresentationMLPackage, it is a " + ret.getClass().getName()); 
+    return ret;
+  }
+  
+  public PresentationMLPackage getPmlPackage() {
+    return (PresentationMLPackage)getOpcPackage();
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/convert/out/svginhtml/PictureExporter.java

@@ -0,0 +1,82 @@
+package org.pptx4j.convert.out.svginhtml;
+
+import javax.xml.bind.JAXBException;
+import org.docx4j.XmlUtils;
+import org.docx4j.dml.CTBlip;
+import org.docx4j.dml.CTPoint2D;
+import org.docx4j.dml.CTPositiveSize2D;
+import org.docx4j.model.images.AbstractWordXmlPicture;
+import org.docx4j.openpackaging.parts.Part;
+import org.pptx4j.jaxb.Context;
+import org.pptx4j.pml.Pic;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.traversal.NodeIterator;
+
+public class PictureExporter extends AbstractWordXmlPicture {
+  protected static Logger log = LoggerFactory.getLogger(PictureExporter.class);
+  
+  public static DocumentFragment createHtmlImg(SvgConversionContext context, NodeIterator wpInline) {
+    PictureExporter converter = createPicture(context, wpInline);
+    DocumentFragment df = getHtmlDocumentFragment(converter);
+    CTPoint2D offset = converter.pic.getSpPr().getXfrm().getOff();
+    AbstractWordXmlPicture.Dimensions xy = converter.readDimensions(offset.getX(), offset.getY());
+    Element div = df.getOwnerDocument().createElement("div");
+    div.setAttribute("style", "position:absolute; left:" + xy.width + "px; top:" + xy.height + "px;");
+    Node img = df.getFirstChild();
+    df.removeChild(img);
+    df.appendChild(div);
+    div.appendChild(img);
+    return df;
+  }
+  
+  Pic pic = null;
+  
+  public static PictureExporter createPicture(SvgConversionContext context, NodeIterator anchorOrInline) {
+    PictureExporter converter = new PictureExporter();
+    try {
+      Node n = anchorOrInline.nextNode();
+      converter.pic = (Pic)XmlUtils.unmarshal(n, Context.jcPML, Pic.class);
+    } catch (JAXBException e1) {
+      e1.printStackTrace();
+    } 
+    log.info("** image: " + converter.pic.getClass().getName());
+    if (converter.pic.getBlipFill() == null || converter.pic.getBlipFill().getBlip() == null) {
+      log.error("blip missing!!");
+      return null;
+    } 
+    CTBlip blip = converter.pic.getBlipFill().getBlip();
+    String imgRelId = blip.getEmbed();
+    if (imgRelId != null) {
+      converter.handleImageRel(context.getImageHandler(), imgRelId, (Part)(context.getResolvedLayout()).relationships.getSourceP());
+    } else if (blip.getLink() != null) {
+      converter.handleImageRel(context.getImageHandler(), blip.getLink(), (Part)(context.getResolvedLayout()).relationships.getSourceP());
+    } else {
+      log.error("not linked or embedded?!");
+    } 
+    converter.dimensions = converter.readDimensions(converter.pic.getSpPr().getXfrm().getExt());
+    return converter;
+  }
+  
+  private final int extentToPixelConversionFactor = 9525;
+  
+  private AbstractWordXmlPicture.Dimensions readDimensions(long x, long y) {
+    AbstractWordXmlPicture.Dimensions dimensions = new AbstractWordXmlPicture.Dimensions(this);
+    dimensions.width = (int)x / 9525;
+    dimensions.widthUnit = "px";
+    dimensions.height = (int)y / 9525;
+    dimensions.heightUnit = "px";
+    return dimensions;
+  }
+  
+  private AbstractWordXmlPicture.Dimensions readDimensions(CTPositiveSize2D size2d) {
+    if (size2d == null) {
+      log.warn("wp:inline/wp:extent missing!");
+      return null;
+    } 
+    return readDimensions(size2d.getCx(), size2d.getCy());
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/convert/out/svginhtml/SvgConversionContext.java

@@ -0,0 +1,39 @@
+package org.pptx4j.convert.out.svginhtml;
+
+import org.docx4j.convert.out.AbstractConversionSettings;
+import org.docx4j.convert.out.common.writer.AbstractMessageWriter;
+import org.docx4j.convert.out.html.HTMLConversionImageHandler;
+import org.docx4j.model.images.ConversionImageHandler;
+import org.docx4j.openpackaging.packages.PresentationMLPackage;
+import org.pptx4j.convert.out.AbstractPmlConversionContext;
+import org.pptx4j.model.ResolvedLayout;
+
+public class SvgConversionContext extends AbstractPmlConversionContext {
+  protected static final AbstractMessageWriter SVG_MESSAGE_WRITER = new AbstractMessageWriter() {
+      protected String getOutputSuffix() {
+        return "</div>";
+      }
+      
+      protected String getOutputPrefix() {
+        return "<div style=\"color:red\" >";
+      }
+    };
+  
+  protected ResolvedLayout resolvedLayout = null;
+  
+  protected SvgConversionContext(SvgExporter.SvgSettings conversionSettings, PresentationMLPackage localPmlPackage, ResolvedLayout resolvedLayout) {
+    super(SVG_MESSAGE_WRITER, conversionSettings, localPmlPackage);
+    this.resolvedLayout = resolvedLayout;
+  }
+  
+  protected ConversionImageHandler initializeImageHandler(AbstractConversionSettings settings, ConversionImageHandler handler) {
+    SvgExporter.SvgSettings svgSettings = (SvgExporter.SvgSettings)settings;
+    if (handler == null)
+      handler = new HTMLConversionImageHandler(svgSettings.getImageDirPath(), svgSettings.getImageTargetUri(), svgSettings.isImageIncludeUUID()); 
+    return handler;
+  }
+  
+  public ResolvedLayout getResolvedLayout() {
+    return this.resolvedLayout;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/convert/out/svginhtml/SvgExporter.java

@@ -0,0 +1,353 @@
+package org.pptx4j.convert.out.svginhtml;
+
+import java.io.ByteArrayOutputStream;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBElement;
+import javax.xml.bind.JAXBException;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Templates;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+import org.docx4j.XmlUtils;
+import org.docx4j.convert.out.AbstractConversionSettings;
+import org.docx4j.convert.out.html.HtmlCssHelper;
+import org.docx4j.dml.CTTextCharacterProperties;
+import org.docx4j.dml.CTTextParagraphProperties;
+import org.docx4j.dml.CTTransform2D;
+import org.docx4j.model.styles.StyleTree;
+import org.docx4j.model.styles.Tree;
+import org.docx4j.openpackaging.exceptions.Docx4JException;
+import org.docx4j.openpackaging.exceptions.InvalidFormatException;
+import org.docx4j.openpackaging.packages.PresentationMLPackage;
+import org.docx4j.openpackaging.parts.PresentationML.SlidePart;
+import org.docx4j.utils.ResourceUtils;
+import org.docx4j.wml.PPr;
+import org.docx4j.wml.RPr;
+import org.docx4j.wml.Style;
+import org.plutext.jaxb.svg11.Line;
+import org.plutext.jaxb.svg11.ObjectFactory;
+import org.plutext.jaxb.svg11.Svg;
+import org.pptx4j.Box;
+import org.pptx4j.Point;
+import org.pptx4j.jaxb.Context;
+import org.pptx4j.model.ResolvedLayout;
+import org.pptx4j.model.TextStyles;
+import org.pptx4j.pml.CxnSp;
+import org.pptx4j.pml.GroupShape;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.DocumentFragment;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Text;
+import org.w3c.dom.traversal.NodeIterator;
+
+public class SvgExporter {
+  public static class SvgSettings extends AbstractConversionSettings {
+    public static final String IMAGE_TARGET_URI = "imageTargetUri";
+    
+    public void setImageTargetUri(String imageTargetUri) {
+      this.settings.put("imageTargetUri", imageTargetUri);
+    }
+    
+    public String getImageTargetUri() {
+      return (String)this.settings.get("imageTargetUri");
+    }
+  }
+  
+  protected static Logger log = LoggerFactory.getLogger(SvgExporter.class);
+  
+  public static JAXBContext jcSVG;
+  
+  static ObjectFactory oFactory;
+  
+  static Templates xslt;
+  
+  private static String imageDirPath;
+  
+  static {
+    try {
+      jcSVG = JAXBContext.newInstance("org.plutext.jaxb.svg11");
+      oFactory = new ObjectFactory();
+      Source xsltSource = new StreamSource(ResourceUtils.getResource("org/pptx4j/convert/out/svginhtml/pptx2svginhtml.xslt"));
+      xslt = XmlUtils.getTransformerTemplate(xsltSource);
+    } catch (Exception e) {
+      e.printStackTrace();
+    } 
+  }
+  
+  public static void setImageDirPath(String _imageDirPath) {
+    imageDirPath = _imageDirPath;
+  }
+  
+  public static String svg(PresentationMLPackage presentationMLPackage, SlidePart slide) throws Exception {
+    return svg(presentationMLPackage, slide, null);
+  }
+  
+  public static String svg(PresentationMLPackage presentationMLPackage, SlidePart slide, SvgSettings settings) throws Exception {
+    ResolvedLayout rl = slide.getResolvedLayout();
+    return svg(presentationMLPackage, rl, settings);
+  }
+  
+  private static String svg(PresentationMLPackage presentationMLPackage, ResolvedLayout layout, SvgSettings settings) throws Exception {
+    ByteArrayOutputStream intermediate = new ByteArrayOutputStream();
+    Result intermediateResult = new StreamResult(intermediate);
+    svg(presentationMLPackage, layout, intermediateResult, settings);
+    return intermediate.toString("UTF-8");
+  }
+  
+  private static void svg(PresentationMLPackage presentationMLPackage, ResolvedLayout layout, Result result, SvgSettings settings) throws Exception {
+    SvgConversionContext context = null;
+    Document doc = XmlUtils.marshaltoW3CDomDocument(layout.getShapeTree(), Context.jcPML, "http://schemas.openxmlformats.org/presentationml/2006/main", "spTree", GroupShape.class);
+    if (settings == null)
+      settings = new SvgSettings(); 
+    if (settings.getImageDirPath() == null && imageDirPath != null)
+      settings.setImageDirPath(imageDirPath); 
+    context = new SvgConversionContext(settings, presentationMLPackage, layout);
+    XmlUtils.transform(doc, xslt, context.getXsltParameters(), result);
+  }
+  
+  public static boolean isDebugEnabled() {
+    return log.isDebugEnabled();
+  }
+  
+  public static DocumentFragment createBlockForP(SvgConversionContext context, String lvl, String cNvPrName, String phType, NodeIterator childResults, NodeIterator lvlNpPr) {
+    int level;
+    String pStyleVal;
+    StyleTree styleTree = null;
+    try {
+      styleTree = context.getPmlPackage().getStyleTree();
+    } catch (InvalidFormatException e1) {
+      e1.printStackTrace();
+    } 
+    log.debug("lvl:" + lvl);
+    if (lvl.equals("NaN")) {
+      level = 1;
+    } else {
+      level = Integer.parseInt(lvl);
+    } 
+    System.out.println("cNvPrName: " + cNvPrName + "; " + "phType: " + phType);
+    if (cNvPrName.toLowerCase().indexOf("subtitle") > -1 || phType.toLowerCase().indexOf("subtitle") > -1) {
+      pStyleVal = "Lvl" + level + "Master" + context.getResolvedLayout().getMasterNumber() + "Body";
+    } else if (cNvPrName.toLowerCase().indexOf("title") > -1 || phType.toLowerCase().indexOf("title") > -1) {
+      pStyleVal = "Lvl" + level + "Master" + context.getResolvedLayout().getMasterNumber() + "Title";
+    } else {
+      pStyleVal = "Lvl" + level + "Master" + context.getResolvedLayout().getMasterNumber() + "Other";
+    } 
+    System.out.println("--> " + pStyleVal);
+    try {
+      Document document = XmlUtils.getNewDocumentBuilder().newDocument();
+      Node xhtmlP = document.createElement("p");
+      document.appendChild(xhtmlP);
+      log.debug(pStyleVal);
+      Tree<StyleTree.AugmentedStyle> pTree = styleTree.getParagraphStylesTree();
+      org.docx4j.model.styles.Node<StyleTree.AugmentedStyle> asn = pTree.get(pStyleVal);
+      ((Element)xhtmlP).setAttribute("class", StyleTree.getHtmlClassAttributeValue(pTree, asn));
+      StringBuilder inlineStyle = new StringBuilder();
+      CTTextParagraphProperties lvlPPr = unmarshalFormatting(lvlNpPr);
+      if (lvlPPr != null) {
+        log.debug("We have lvlPPr");
+        log.debug(XmlUtils.marshaltoString(lvlPPr, true, true, Context.jcPML, "FIXME", "lvl1pPr", CTTextParagraphProperties.class));
+        PPr pPr = TextStyles.getWmlPPr(lvlPPr);
+        if (pPr != null)
+          HtmlCssHelper.createCss(context.getPmlPackage(), pPr, inlineStyle, false); 
+      } 
+      inlineStyle.append("margin-left:3px; margin-top:3px;");
+      if (!inlineStyle.toString().equals(""))
+        ((Element)xhtmlP).setAttribute("style", inlineStyle.toString()); 
+      Node n = childResults.nextNode();
+      do {
+        if (n.getNodeType() == 9) {
+          log.debug("handling DOCUMENT_NODE");
+          NodeList nodes = n.getChildNodes();
+          if (nodes != null)
+            for (int i = 0; i < nodes.getLength(); i++) {
+              if (nodes.item(i).getLocalName().equals("span") && !nodes.item(i).hasChildNodes()) {
+                log.debug(".. ignoring <span/> ");
+              } else {
+                XmlUtils.treeCopy(nodes.item(i), xhtmlP);
+              } 
+            }  
+        } else {
+          XmlUtils.treeCopy(n, xhtmlP);
+        } 
+        n = childResults.nextNode();
+      } while (n != null);
+      DocumentFragment docfrag = document.createDocumentFragment();
+      docfrag.appendChild(document.getDocumentElement());
+      return docfrag;
+    } catch (Exception e) {
+      log.error(e.getMessage(), (Throwable)e);
+      return null;
+    } 
+  }
+  
+  private static CTTextParagraphProperties unmarshalFormatting(NodeIterator lvlNpPr) {
+    try {
+      CTTextParagraphProperties pPr = null;
+      if (lvlNpPr != null) {
+        Node n = lvlNpPr.nextNode();
+        log.debug(n.getClass().getName());
+        String str = XmlUtils.w3CDomNodeToString(n);
+        if (!str.equals(""))
+          return (CTTextParagraphProperties)XmlUtils.unmarshalString(str, Context.jcPML, CTTextParagraphProperties.class); 
+      } 
+    } catch (Exception e) {
+      e.printStackTrace();
+    } 
+    return null;
+  }
+  
+  public static DocumentFragment createBlockForR(SvgConversionContext context, NodeIterator rPrNodeIt, NodeIterator childResults) {
+    DocumentFragment docfrag = null;
+    Document d = null;
+    Element span = null;
+    try {
+      d = XmlUtils.getNewDocumentBuilder().newDocument();
+      span = d.createElement("span");
+      d.appendChild(span);
+      CTTextCharacterProperties textCharProps = (CTTextCharacterProperties)nodeToObjectModel(rPrNodeIt.nextNode(), CTTextCharacterProperties.class);
+      RPr rPr = TextStyles.getWmlRPr(textCharProps);
+      StringBuilder inlineStyle = new StringBuilder();
+      HtmlCssHelper.createCss(context.getPmlPackage(), rPr, inlineStyle);
+      if (!inlineStyle.toString().equals(""))
+        span.setAttribute("style", inlineStyle.toString()); 
+      Node n = childResults.nextNode();
+      XmlUtils.treeCopy(n, span);
+    } catch (Exception e) {
+      log.error(e.getMessage(), (Throwable)e);
+      Node n = childResults.nextNode();
+      XmlUtils.treeCopy(n, span);
+    } 
+    docfrag = d.createDocumentFragment();
+    docfrag.appendChild(d.getDocumentElement());
+    return docfrag;
+  }
+  
+  public static String getCssForStyles(SvgConversionContext context) {
+    StringBuilder result = new StringBuilder();
+    StyleTree styleTree = null;
+    try {
+      styleTree = context.getPmlPackage().getStyleTree();
+    } catch (InvalidFormatException e) {
+      e.printStackTrace();
+    } 
+    result.append("\n /* PARAGRAPH STYLES */ \n");
+    Tree<StyleTree.AugmentedStyle> pTree = styleTree.getParagraphStylesTree();
+    for (org.docx4j.model.styles.Node<StyleTree.AugmentedStyle> n : pTree.toList()) {
+      Style s = n.getData().getStyle();
+      result.append("." + s.getStyleId() + " {display:block;");
+      if (s.getPPr() == null) {
+        log.debug("null pPr for style " + s.getStyleId());
+      } else {
+        HtmlCssHelper.createCss(context.getPmlPackage(), s.getPPr(), result, false);
+      } 
+      if (s.getRPr() == null) {
+        log.debug("null rPr for style " + s.getStyleId());
+      } else {
+        HtmlCssHelper.createCss(context.getPmlPackage(), s.getRPr(), result);
+      } 
+      result.append("}\n");
+    } 
+    if (log.isDebugEnabled())
+      return result.toString(); 
+    String debug = result.toString();
+    return debug;
+  }
+  
+  public static DocumentFragment shapeToSVG(SvgConversionContext context, NodeIterator shapeIt) {
+    DocumentFragment docfrag = null;
+    Document d = null;
+    try {
+      Object shape = null;
+      if (shapeIt != null) {
+        Node n = shapeIt.nextNode();
+        if (n == null) {
+          d = makeErr("[null node?!]");
+        } else {
+          log.debug("Handling " + n.getNodeName());
+          if (n.getNodeName().equals("p:cxnSp")) {
+            shape = nodeToObjectModel(n, CxnSp.class);
+            d = CxnSpToSVG((CxnSp)shape);
+          } else {
+            log.info("** TODO " + n.getNodeName());
+            d = makeErr("[" + n.getNodeName() + "]");
+          } 
+        } 
+      } 
+    } catch (Exception e) {
+      log.error(e.getMessage(), (Throwable)e);
+      d = makeErr(e.getMessage());
+    } 
+    docfrag = d.createDocumentFragment();
+    docfrag.appendChild(d.getDocumentElement());
+    return docfrag;
+  }
+  
+  public static Document CxnSpToSVG(CxnSp cxnSp) {
+    CTTransform2D xfrm = cxnSp.getSpPr().getXfrm();
+    Box b = new Box(xfrm.getOff().getX(), xfrm.getOff().getY(), xfrm.getExt().getCx(), xfrm.getExt().getCy());
+    if (xfrm.getRot() != 0)
+      b.rotate(xfrm.getRot()); 
+    if (xfrm.isFlipH())
+      b.flipH(); 
+    if (xfrm.isFlipV())
+      b.flipV(); 
+    b.toPixels();
+    Document document = XmlUtils.getNewDocumentBuilder().newDocument();
+    Element xhtmlDiv = document.createElement("div");
+    xhtmlDiv.setAttribute("style", "position: absolute; width:100%; height:100%; left:0px; top:0px;");
+    Node n = document.appendChild(xhtmlDiv);
+    Svg svg = oFactory.createSvg();
+    Line line = oFactory.createLine();
+    svg.getSVGDescriptionClassOrSVGAnimationClassOrSVGStructureClass().add(line);
+    line.setX1(b.getOffset().getXAsString());
+    line.setY1(b.getOffset().getYAsString());
+    Point otherEnd = b.getOtherCorner();
+    line.setX2(otherEnd.getXAsString());
+    line.setY2(otherEnd.getYAsString());
+    line.setStyle("stroke:rgb(99,99,99)");
+    Document d2 = XmlUtils.marshaltoW3CDomDocument(svg, jcSVG);
+    XmlUtils.treeCopy(d2, n);
+    return document;
+  }
+  
+  private static Document makeErr(String msg) {
+    Document d = XmlUtils.getNewDocumentBuilder().newDocument();
+    Element span = d.createElement("span");
+    span.setAttribute("style", "color:red;");
+    d.appendChild(span);
+    Text err = d.createTextNode(msg);
+    span.appendChild(err);
+    return d;
+  }
+  
+  public static Object nodeToObjectModel(Node n, Class declaredType) throws Docx4JException {
+    if (n == null)
+      throw new Docx4JException("null input"); 
+    Object jaxb = null;
+    try {
+      jaxb = XmlUtils.unmarshal(n, Context.jcPML, declaredType);
+    } catch (JAXBException e1) {
+      throw new Docx4JException("Couldn't unmarshall " + XmlUtils.w3CDomNodeToString(n), e1);
+    } 
+    try {
+      if (jaxb instanceof JAXBElement) {
+        JAXBElement jb = (JAXBElement)jaxb;
+        if (jb.getDeclaredType().getName().equals(declaredType.getName()))
+          return jb.getValue(); 
+        log.error("UNEXPECTED " + XmlUtils.JAXBElementDebug(jb));
+        throw new Docx4JException("Expected " + declaredType.getName() + " but got " + XmlUtils.JAXBElementDebug(jb));
+      } 
+      if (jaxb.getClass().getName().equals(declaredType.getName()))
+        return jaxb; 
+      log.error(jaxb.getClass().getName());
+      throw new Docx4JException("Expected " + declaredType.getName() + " but got " + jaxb.getClass().getName());
+    } catch (ClassCastException e) {
+      throw new Docx4JException("Expected " + declaredType.getName() + " but got " + jaxb.getClass().getName(), e);
+    } 
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/convert/out/svginhtml/pptx2svginhtml.xslt

@@ -0,0 +1,215 @@
+
+<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+	xmlns="http://www.w3.org/1999/xhtml" 
+    xmlns:p="http://schemas.openxmlformats.org/presentationml/2006/main"
+    xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+    xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"
+    xmlns:o="urn:schemas-microsoft-com:office:office"
+    xmlns:v="urn:schemas-microsoft-com:vml"
+    xmlns:WX="http://schemas.microsoft.com/office/word/2003/auxHint"
+    xmlns:aml="http://schemas.microsoft.com/aml/2001/core"
+    xmlns:w10="urn:schemas-microsoft-com:office:word"
+	xmlns:pkg="http://schemas.microsoft.com/office/2006/xmlPackage"		    
+	xmlns:java="http://xml.apache.org/xalan/java" 
+	xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+	xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
+	xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"
+	xmlns:xlink="http://www.w3.org/1999/xlink"
+    version="1.0"
+        exclude-result-prefixes="java w a o v WX aml w10 pkg wp pic xlink r p">	
+<!-- 	xmlns="http://www.w3.org/2000/svg"
+ -->        
+        <!--  Note definition of xmlns:r is different 
+              from the definition in an _rels file
+              (where it is http://schemas.openxmlformats.org/package/2006/relationships)  -->
+
+<!-- 
+	<xsl:output method="xml" encoding="utf-8" omit-xml-declaration="no" indent="no" />
+   -->
+<!--  indent="no" gives a better result for things like subscripts, because it stops
+      the user-agent from replacing a carriage return in the HTML with a space in the output. 
+      
+      but, for now, make indent yes-->
+<xsl:output method="xml" encoding="utf-8" omit-xml-declaration="no" indent="yes" 
+doctype-public="-//W3C//DTD XHTML 1.0 Transitional//EN"
+     doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"/>
+
+<!-- either strict or transitional work for inline SVG 
+
+	NB: file suffix must end with .xhtml in order to see the SVG in a browser
+
+--> 
+
+<!--  Input to this transform is a Shape Tree p:spTree. 
+
+	Output is SVG in HTML.
+
+ 	<text x="{$x}" y="{$y}"><xsl:value-of select="a:p/a:r/a:t"/></text>
+
+	  textArea (SVG 1.2 Tiny) - doesn't work in Chrome 4.0.249.64 or FF 3.5.7
+      so its not a feasible solution as at January 2010 :-(  
+      See http://www.w3.org/TR/SVGTiny12/examples/textArea01.svg
+      from http://www.w3.org/TR/SVGTiny12/text.html#TextInAnArea
+      Opera 9.5 apparently supports it though!
+
+	  Inkscape uses flowPara, but browsers can't render this.
+      
+      Could use mixed svg html, but that's unsatisfactory.  Will have to do for now.
+      Either svg in html, or html foreignObject in svg. 
+
+      carto textFlow.js works nicely in FF, but not Chrome :-(
+
+-->
+
+	<xsl:param name="conversionContext"/> <!-- select="'passed in'"-->	
+	
+
+
+<xsl:template match="/">
+	<html xmlns="http://www.w3.org/1999/xhtml" 
+      xmlns:svg="http://www.w3.org/2000/svg"
+      xmlns:xlink="http://www.w3.org/1999/xlink">
+		<head>
+			<title>Slide output proof of concept</title>
+	        <style>
+	          <xsl:comment>
+							
+					/* Word style definitions */
+					<xsl:copy-of select="java:org.pptx4j.convert.out.svginhtml.SvgExporter.getCssForStyles( 
+	  											$conversionContext)"/>
+	
+	          </xsl:comment>
+	        </style>
+			
+		</head>
+		<body>
+			<xsl:apply-templates/>		
+		</body>
+	</html>	
+</xsl:template>
+
+<xsl:template match="p:spTree">
+	<xsl:apply-templates/>
+</xsl:template>
+
+<xsl:template match="p:nvGrpSpPr"/>
+<xsl:template match="p:grpSpPr"/>
+
+ <xsl:template match="p:sp">
+ 	<xsl:apply-templates select="p:txBody"/>
+ </xsl:template>
+
+ <xsl:template match="p:txBody">
+ 
+    <!--  I'd like to get JAXB representation of a:lstStyle just once,
+          then pass it in to each a:p as a parameter,
+          but Xalan doesn't seem to allow an arbitrary
+          Java object to be passed around like that?
+          
+	    	<xsl:variable name="lstStyle"><xsl:value-of select="java:org.pptx4j.convert.out.svginhtml.SvgExporter.unmarshalFormatting(a:lstStyle)"/></xsl:variable>
+	    
+	    	with value-of, it becomes a string; with copy-of, its a node list.
+	    
+	 	<xsl:apply-templates select="a:p">
+	 		<xsl:with-param name="lstStyle" select="$lstStyle"/>
+	 	</xsl:apply-templates>
+
+           -->
+ 
+ 	<!--  Convert from EMU at 96dpi -->
+ 	<xsl:variable name="x"><xsl:value-of select="round(number(../p:spPr/a:xfrm/a:off/@x)*96 div 914400)"/></xsl:variable>
+ 	<xsl:variable name="y"><xsl:value-of select="round(number(../p:spPr/a:xfrm/a:off/@y)*96 div 914400)"/></xsl:variable>
+ 	<xsl:variable name="cx"><xsl:value-of select="round(number(../p:spPr/a:xfrm/a:ext/@cx)*96 div 914400)"/></xsl:variable>
+ 	<xsl:variable name="cy"><xsl:value-of select="round(number(../p:spPr/a:xfrm/a:ext/@cy)*96 div 914400)"/></xsl:variable>
+ 	
+ 	<!--  At present, docx4j doesn't do text boxes in its docx html,
+ 	      so handle the box here.  -->
+ 	<xsl:choose>
+ 		<xsl:when test="java:org.pptx4j.convert.out.svginhtml.SvgExporter.isDebugEnabled()">
+ 			
+ 			<!-- Use border: red dashed -->
+ 			
+		 	<div style="position: absolute; width:{$cx}px; height:{$cy}px; left:{$x}px; top:{$y}px; border: red dashed;">
+	 			<xsl:apply-templates select="a:p"/>
+ 			</div>
+ 		
+ 		</xsl:when>
+ 		<xsl:otherwise>
+ 		
+		 	<div style="position: absolute; width:{$cx}px; height:{$cy}px; left:{$x}px; top:{$y}px;">
+	 			<xsl:apply-templates select="a:p"/>
+ 			</div> 		
+ 		
+ 		</xsl:otherwise>
+ 	</xsl:choose>
+ 	      
+ </xsl:template>
+
+ <xsl:template match="p:cxnSp">
+
+		<xsl:variable name="shape" select="."/>
+
+	  	<xsl:copy-of select="java:org.pptx4j.convert.out.svginhtml.SvgExporter.shapeToSVG(
+	  		$conversionContext, $shape)" />
+ 
+ </xsl:template>
+
+
+ <xsl:template match="a:p">
+		<xsl:variable name="lvl"><xsl:value-of select="number(a:pPr/@lvl)"/></xsl:variable>
+		<xsl:variable name="cNvPrName"><xsl:value-of select="string(../../p:nvSpPr/p:cNvPr/@name)"/></xsl:variable>
+		<xsl:variable name="phType"><xsl:value-of select="string(../../p:nvSpPr/p:nvPr/p:ph/@type)"/></xsl:variable>
+		<xsl:variable name="childResults"><xsl:apply-templates select="a:r"/></xsl:variable>
+		<xsl:variable name="lvlPPr">
+			<xsl:choose>
+				<xsl:when test="count(../a:lstStyle)=0"/>
+				<xsl:when test="a:pPr/@lvl"><xsl:copy-of select="../a:lstStyle/*[$lvl]"/></xsl:when>
+				<xsl:otherwise><xsl:copy-of select="../a:lstStyle/*[1]"/></xsl:otherwise>
+			</xsl:choose>
+		</xsl:variable>
+	  	<xsl:copy-of select="java:org.pptx4j.convert.out.svginhtml.SvgExporter.createBlockForP(
+	  		$conversionContext,
+	  		$lvl,
+	  		$cNvPrName, $phType,
+	  		 $childResults, $lvlPPr)" />
+ </xsl:template>
+
+ <xsl:template match="a:r">
+		<xsl:variable name="rPr" select="a:rPr"/>
+		<xsl:variable name="childResults"><xsl:apply-templates select="a:t"/></xsl:variable>
+	  	<xsl:copy-of select="java:org.pptx4j.convert.out.svginhtml.SvgExporter.createBlockForR(
+	  		$conversionContext, $rPr,
+	  		 $childResults)" />
+ </xsl:template>
+
+  <xsl:template match="a:t">  	
+  	<xsl:value-of select="."/>
+  </xsl:template>  	
+
+  <!--  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+  <!--  +++++++++++++++++++ image support +++++++++++++++++++++++ -->
+  <!--  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+
+
+  <xsl:template match="p:pic">
+    		
+  	<xsl:copy-of select="java:org.pptx4j.convert.out.svginhtml.PictureExporter.createHtmlImg( 
+  			$conversionContext,
+  			.)" />
+    
+  </xsl:template>
+
+  <!--  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+  <!--  +++++++++++++++++++  no match     +++++++++++++++++++++++ -->
+  <!--  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
+
+  <xsl:template match="*" priority="-1"> 
+		      <div
+		        color="red">
+        NOT IMPLEMENTED: support for <xsl:value-of select="local-name(.)"/>
+      		</div> 
+      		 
+  </xsl:template>
+
+   
+</xsl:stylesheet>

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/jaxb/Context.java

@@ -0,0 +1,76 @@
+package org.pptx4j.jaxb;
+
+import java.io.File;
+import java.io.InputStream;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import org.docx4j.jaxb.NamespacePrefixMapperUtils;
+import org.docx4j.utils.ResourceUtils;
+import org.pptx4j.pml.ObjectFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Context {
+  public static JAXBContext jcPML;
+  
+  private static Logger log = LoggerFactory.getLogger(Context.class);
+  
+  public static ObjectFactory pmlObjectFactory;
+  
+  static {
+    log.info("java.vendor=" + System.getProperty("java.vendor"));
+    log.info("java.version=" + System.getProperty("java.version"));
+    org.docx4j.jaxb.Context.searchManifestsForJAXBImplementationInfo(ClassLoader.getSystemClassLoader());
+    if (Thread.currentThread().getContextClassLoader() == null) {
+      log.warn("ContextClassLoader is null for current thread");
+    } else if (ClassLoader.getSystemClassLoader() != Thread.currentThread().getContextClassLoader()) {
+      org.docx4j.jaxb.Context.searchManifestsForJAXBImplementationInfo(Thread.currentThread().getContextClassLoader());
+    } 
+    try {
+      Object namespacePrefixMapper = NamespacePrefixMapperUtils.getPrefixMapper();
+      try {
+        File f = new File("src/main/java/org/docx4j/wml/jaxb.properties");
+        if (f.exists()) {
+          log.info("MOXy JAXB implementation intended..");
+        } else {
+          InputStream is = ResourceUtils.getResource("org/docx4j/wml/jaxb.properties");
+          log.info("MOXy JAXB implementation intended..");
+        } 
+      } catch (Exception e2) {
+        log.warn(e2.getMessage());
+        try {
+          InputStream is = ResourceUtils.getResource("org/docx4j/wml/jaxb.properties");
+          log.info("MOXy JAXB implementation intended..");
+        } catch (Exception e3) {
+          log.warn(e3.getMessage());
+          if (namespacePrefixMapper.getClass().getName().equals("org.docx4j.jaxb.NamespacePrefixMapperSunInternal")) {
+            log.info("Using Java 6/7 JAXB implementation");
+          } else {
+            log.info("Using JAXB Reference Implementation");
+          } 
+        } 
+      } 
+    } catch (JAXBException e) {
+      log.error("PANIC! No suitable JAXB implementation available");
+      log.error(e.getMessage(), (Throwable)e);
+      e.printStackTrace();
+    } 
+    try {
+      ClassLoader classLoader = Context.class.getClassLoader();
+      jcPML = JAXBContext.newInstance("org.pptx4j.pml:org.docx4j.dml:org.docx4j.dml.chart:org.docx4j.dml.chartDrawing:org.docx4j.dml.compatibility:org.docx4j.dml.diagram:org.docx4j.dml.lockedCanvas:org.docx4j.dml.picture:org.docx4j.dml.wordprocessingDrawing:org.docx4j.dml.spreadsheetdrawing:org.docx4j.mce", classLoader);
+      if (jcPML.getClass().getName().equals("org.eclipse.persistence.jaxb.JAXBContext")) {
+        log.info("MOXy JAXB implementation is in use!");
+      } else {
+        log.info("Not using MOXy.");
+      } 
+    } catch (Exception ex) {
+      log.error("Cannot initialize context", (Throwable)ex);
+    } 
+  }
+  
+  public static ObjectFactory getpmlObjectFactory() {
+    if (pmlObjectFactory == null)
+      pmlObjectFactory = new ObjectFactory(); 
+    return pmlObjectFactory;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/model/ResolvedLayout.java

@@ -0,0 +1,139 @@
+package org.pptx4j.model;
+
+import java.util.List;
+import java.util.Map;
+import org.docx4j.XmlUtils;
+import org.docx4j.dml.CTShapeProperties;
+import org.docx4j.dml.CTTextBody;
+import org.docx4j.dml.CTTextListStyle;
+import org.docx4j.dml.CTTransform2D;
+import org.docx4j.openpackaging.packages.PresentationMLPackage;
+import org.docx4j.openpackaging.parts.PresentationML.SlideLayoutPart;
+import org.docx4j.openpackaging.parts.PresentationML.SlideMasterPart;
+import org.docx4j.openpackaging.parts.PresentationML.SlidePart;
+import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
+import org.docx4j.relationships.Relationship;
+import org.pptx4j.jaxb.Context;
+import org.pptx4j.pml.CTBackground;
+import org.pptx4j.pml.CTPlaceholder;
+import org.pptx4j.pml.GroupShape;
+import org.pptx4j.pml.Shape;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ResolvedLayout implements Cloneable {
+  protected static Logger log = LoggerFactory.getLogger(ResolvedLayout.class);
+  
+  private CTBackground bg;
+  
+  private GroupShape shapeTree;
+  
+  private int masterNumber;
+  
+  public RelationshipsPart relationships;
+  
+  public CTBackground getBg() {
+    return this.bg;
+  }
+  
+  public void setBg(CTBackground bg) {
+    this.bg = bg;
+  }
+  
+  public GroupShape getShapeTree() {
+    return this.shapeTree;
+  }
+  
+  public void setShapeTree(GroupShape shapeTree) {
+    this.shapeTree = shapeTree;
+  }
+  
+  public int getMasterNumber() {
+    return this.masterNumber;
+  }
+  
+  public static ResolvedLayout resolveSlideLayout(SlideLayoutPart slideLayoutPart) {
+    ResolvedLayout resolvedLayout = new ResolvedLayout();
+    SlideMasterPart master = slideLayoutPart.getSlideMasterPart();
+    ResolvedLayout masterLayout = master.getResolvedLayout();
+    Map<String, ShapeWrapper> masterPlaceholders = master.getIndexedPlaceHolders();
+    if (masterLayout.getBg() != null)
+      resolvedLayout.bg = XmlUtils.<CTBackground>deepCopy(masterLayout.getBg(), Context.jcPML); 
+    resolvedLayout.shapeTree = createEffectiveShapeTree(slideLayoutPart.getJaxbElement().getCSld().getSpTree(), masterPlaceholders);
+    resolvedLayout.masterNumber = 1;
+    return resolvedLayout;
+  }
+  
+  public static ResolvedLayout resolveSlideLayout(SlidePart slidePart) {
+    ResolvedLayout resolvedLayout = new ResolvedLayout();
+    SlideLayoutPart layoutPart = null;
+    resolvedLayout.relationships = slidePart.getRelationshipsPart();
+    Relationship rel = slidePart.getRelationshipsPart().getRelationshipByType("http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout");
+    if (rel == null) {
+      log.warn(slidePart.getPartName().getName() + " has no explicit layout!");
+      Map<String, ShapeWrapper> globalPlaceHolders = ((PresentationMLPackage)slidePart.getPackage()).getPlaceHoldersFromAcrossLayouts();
+      resolvedLayout.shapeTree = createEffectiveShapeTree(slidePart.getJaxbElement().getCSld().getSpTree(), globalPlaceHolders);
+    } else {
+      layoutPart = (SlideLayoutPart)slidePart.getRelationshipsPart().getPart(rel);
+      resolvedLayout.shapeTree = createEffectiveShapeTree(slidePart.getJaxbElement().getCSld().getSpTree(), layoutPart.getIndexedPlaceHolders());
+    } 
+    resolvedLayout.masterNumber = 1;
+    return resolvedLayout;
+  }
+  
+  public static GroupShape createEffectiveShapeTree(GroupShape shapeTree, Map<String, ShapeWrapper> placeholders) {
+    GroupShape effectiveShapeTree = XmlUtils.<GroupShape>deepCopy(shapeTree, Context.jcPML);
+    List<Object> possiblyShapes = effectiveShapeTree.getSpOrGrpSpOrGraphicFrame();
+    for (Object o : possiblyShapes) {
+      if (o instanceof Shape) {
+        Shape sp = (Shape)o;
+        if (sp.getNvSpPr() != null && sp.getNvSpPr().getNvPr() != null && sp.getNvSpPr().getNvPr().getPh() != null) {
+          CTPlaceholder placeholder = sp.getNvSpPr().getNvPr().getPh();
+          String placeholderType = placeholder.getType().toString();
+          log.info("Handling placeholder: " + placeholderType);
+          handle(placeholders, placeholderType, sp);
+        } 
+      } 
+    } 
+    return effectiveShapeTree;
+  }
+  
+  private static void handle(Map<String, ShapeWrapper> placeholders, String placeholderType, Shape sp) {
+    Shape layoutShape = null;
+    if (placeholders.get(placeholderType) != null) {
+      log.debug("Got it..");
+      layoutShape = placeholders.get(placeholderType).getSp();
+    } else {
+      log.debug("Missing..");
+      return;
+    } 
+    handleNvSpPr(sp.getNvSpPr(), layoutShape.getNvSpPr());
+    handleSpPr(sp.getSpPr(), layoutShape.getSpPr());
+    handleTxBody(sp.getTxBody(), layoutShape.getTxBody());
+  }
+  
+  private static void handleNvSpPr(Shape.NvSpPr sp, Shape.NvSpPr layoutShape) {}
+  
+  private static void handleSpPr(CTShapeProperties sp, CTShapeProperties layoutShape) {
+    if (sp.getXfrm() == null && layoutShape.getXfrm() != null)
+      sp.setXfrm(XmlUtils.<CTTransform2D>deepCopy(layoutShape.getXfrm(), Context.jcPML)); 
+  }
+  
+  private static void handleTxBody(CTTextBody sp, CTTextBody layoutShape) {
+    if (sp.getLstStyle() != null) {
+      log.warn("Slide shape contains lstStyle! (Not expected at that level)");
+      log.debug(XmlUtils.marshaltoString(sp.getLstStyle(), false, true, Context.jcPML, "FIXME", "lstStyle", CTTextListStyle.class));
+    } 
+    if (layoutShape.getLstStyle() != null)
+      sp.setLstStyle(XmlUtils.<CTTextListStyle>deepCopy(layoutShape.getLstStyle(), Context.jcPML)); 
+  }
+  
+  protected ResolvedLayout clone() throws CloneNotSupportedException {
+    ResolvedLayout clone = (ResolvedLayout)super.clone();
+    if (this.bg != null)
+      clone.bg = XmlUtils.<CTBackground>deepCopy(this.bg, Context.jcPML); 
+    if (this.shapeTree != null)
+      clone.shapeTree = XmlUtils.<GroupShape>deepCopy(this.shapeTree, Context.jcPML); 
+    return clone;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/model/ShapeWrapper.java

@@ -0,0 +1,34 @@
+package org.pptx4j.model;
+
+import org.docx4j.openpackaging.parts.PresentationML.JaxbPmlPart;
+import org.pptx4j.pml.Shape;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ShapeWrapper {
+  private static Logger log = LoggerFactory.getLogger(ShapeWrapper.class);
+  
+  String phType;
+  
+  Shape sp;
+  
+  JaxbPmlPart owner;
+  
+  public ShapeWrapper(Shape sp, String phType, JaxbPmlPart owner) {
+    this.sp = sp;
+    this.phType = phType;
+    this.owner = owner;
+  }
+  
+  public String getPhType() {
+    return this.phType;
+  }
+  
+  public Shape getSp() {
+    return this.sp;
+  }
+  
+  public JaxbPmlPart getOwner() {
+    return this.owner;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/model/SlideSizesWellKnown.java

@@ -0,0 +1,27 @@
+package org.pptx4j.model;
+
+public enum SlideSizesWellKnown {
+  LETTER("letter"),
+  A3("A3"),
+  A4("A4"),
+  B4JIS("B4JIS"),
+  SCREEN4x3("screen4x3"),
+  SCREEN16x9("screen16x9"),
+  SCREEN16x10("screen16x10"),
+  LEDGER("ledger"),
+  B4ISO("B4ISO"),
+  B5ISO("B5ISO"),
+  MM35("35mm"),
+  OVERHEAD("overhead"),
+  BANNER("banner");
+  
+  private final String value;
+  
+  SlideSizesWellKnown(String v) {
+    this.value = v;
+  }
+  
+  public String value() {
+    return this.value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/model/TextStyles.java

@@ -0,0 +1,204 @@
+package org.pptx4j.model;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import org.docx4j.XmlUtils;
+import org.docx4j.dml.BaseStyles;
+import org.docx4j.dml.CTTextCharacterProperties;
+import org.docx4j.dml.CTTextListStyle;
+import org.docx4j.dml.CTTextParagraphProperties;
+import org.docx4j.jaxb.Context;
+import org.docx4j.openpackaging.exceptions.InvalidFormatException;
+import org.docx4j.openpackaging.packages.PresentationMLPackage;
+import org.docx4j.openpackaging.parts.PartName;
+import org.docx4j.openpackaging.parts.PresentationML.MainPresentationPart;
+import org.docx4j.openpackaging.parts.PresentationML.SlideMasterPart;
+import org.docx4j.openpackaging.parts.ThemePart;
+import org.docx4j.wml.BooleanDefaultTrue;
+import org.docx4j.wml.HpsMeasure;
+import org.docx4j.wml.Jc;
+import org.docx4j.wml.JcEnumeration;
+import org.docx4j.wml.ObjectFactory;
+import org.docx4j.wml.PPr;
+import org.docx4j.wml.RFonts;
+import org.docx4j.wml.RPr;
+import org.docx4j.wml.Style;
+import org.docx4j.wml.U;
+import org.docx4j.wml.UnderlineEnumeration;
+import org.pptx4j.pml.CTSlideMasterTextStyles;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TextStyles {
+  private static final Logger log = LoggerFactory.getLogger(TextStyles.class);
+  
+  public static Style convertToWordStyle(CTTextParagraphProperties lvlPPr, String id, String name, String basedOn, BaseStyles.FontScheme fontScheme) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    Style style = factory.createStyle();
+    style.setType("paragraph");
+    style.setStyleId(id);
+    System.out.println("created " + id);
+    Style.Name styleName = factory.createStyleName();
+    styleName.setVal(name);
+    style.setName(styleName);
+    Style.BasedOn basedon = factory.createStyleBasedOn();
+    basedon.setVal(basedOn);
+    style.setBasedOn(basedon);
+    if (lvlPPr == null) {
+      log.warn("Empty style: " + id);
+      if (log.isDebugEnabled()) {
+        log.debug(XmlUtils.marshaltoString(lvlPPr, true, true, Context.jc, "URI", "lvl1pPr", CTTextParagraphProperties.class));
+        log.debug("Converted to: " + XmlUtils.marshaltoString(style, true, true));
+      } 
+      return style;
+    } 
+    style.setPPr(getWmlPPr(lvlPPr));
+    style.setRPr(getWmlRPr(lvlPPr, fontScheme));
+    if (log.isDebugEnabled()) {
+      log.debug(XmlUtils.marshaltoString(lvlPPr, true, true, Context.jc, "URI", "lvl1pPr", CTTextParagraphProperties.class));
+      log.debug("Converted to: " + XmlUtils.marshaltoString(style, true, true));
+    } 
+    return style;
+  }
+  
+  public static PPr getWmlPPr(CTTextParagraphProperties lvlPPr) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    PPr pPr = factory.createPPr();
+    if (lvlPPr.getAlgn() != null) {
+      Jc jc = factory.createJc();
+      String algn = lvlPPr.getAlgn().value();
+      log.debug("algn: " + algn);
+      if (algn.equals("l")) {
+        jc.setVal(JcEnumeration.LEFT);
+      } else if (algn.equals("ctr")) {
+        jc.setVal(JcEnumeration.CENTER);
+      } else if (algn.equals("r")) {
+        jc.setVal(JcEnumeration.RIGHT);
+      } else {
+        log.warn("How to handle algn: " + algn);
+      } 
+      pPr.setJc(jc);
+    } 
+    return pPr;
+  }
+  
+  public static RPr getWmlRPr(CTTextParagraphProperties lvlPPr, BaseStyles.FontScheme fontScheme) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    RPr rPr = factory.createRPr();
+    if (lvlPPr.getDefRPr() != null) {
+      if (lvlPPr.getDefRPr().getSz() != null)
+        rPr.setSz(convertFontSize(lvlPPr.getDefRPr().getSz())); 
+      if (lvlPPr.getDefRPr().getLatin() != null) {
+        RFonts rFonts = factory.createRFonts();
+        if (lvlPPr.getDefRPr().getLatin().getTypeface().startsWith("+mj")) {
+          rFonts.setAscii(fontScheme.getMajorFont().getLatin().getTypeface());
+        } else if (lvlPPr.getDefRPr().getLatin().getTypeface().startsWith("+mn")) {
+          rFonts.setAscii(fontScheme.getMinorFont().getLatin().getTypeface());
+        } 
+        rPr.setRFonts(rFonts);
+      } 
+    } 
+    return rPr;
+  }
+  
+  private static HpsMeasure convertFontSize(Integer in) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    HpsMeasure sz = factory.createHpsMeasure();
+    int halfPts = Math.round((float)(in / 50));
+    sz.setVal(BigInteger.valueOf((long)halfPts));
+    return sz;
+  }
+  
+  public static List<Style> generateWordStylesFromPresentationPart(CTTextListStyle textStyles, String suffix, BaseStyles.FontScheme fontScheme) {
+    List<Style> styles = new ArrayList<Style>();
+    if (textStyles == null)
+      return styles; 
+    styles.add(convertToWordStyle(textStyles.getLvl1PPr(), "Lvl1" + suffix, "Lvl1" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl2PPr(), "Lvl2" + suffix, "Lvl2" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl3PPr(), "Lvl3" + suffix, "Lvl3" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl4PPr(), "Lvl4" + suffix, "Lvl4" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl5PPr(), "Lvl5" + suffix, "Lvl5" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl6PPr(), "Lvl6" + suffix, "Lvl6" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl7PPr(), "Lvl7" + suffix, "Lvl7" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl8PPr(), "Lvl8" + suffix, "Lvl8" + suffix, "DocDefaults", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl9PPr(), "Lvl9" + suffix, "Lvl9" + suffix, "DocDefaults", fontScheme));
+    return styles;
+  }
+  
+  public static List<Style> generateWordStylesForMaster(CTSlideMasterTextStyles masterTextStyles, int mastern, BaseStyles.FontScheme fontScheme) {
+    List<Style> styles = new ArrayList<Style>();
+    if (masterTextStyles == null)
+      return styles; 
+    styles.addAll(generateLvlNMasterStyle(masterTextStyles.getTitleStyle(), "Master" + mastern + "Title", fontScheme));
+    styles.addAll(generateLvlNMasterStyle(masterTextStyles.getBodyStyle(), "Master" + mastern + "Body", fontScheme));
+    styles.addAll(generateLvlNMasterStyle(masterTextStyles.getOtherStyle(), "Master" + mastern + "Other", fontScheme));
+    return styles;
+  }
+  
+  private static List<Style> generateLvlNMasterStyle(CTTextListStyle textStyles, String suffix, BaseStyles.FontScheme fontScheme) {
+    List<Style> styles = new ArrayList<Style>();
+    if (textStyles == null)
+      textStyles = new CTTextListStyle(); 
+    styles.add(convertToWordStyle(textStyles.getLvl1PPr(), "Lvl1" + suffix, "Lvl1" + suffix, "Lvl1", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl2PPr(), "Lvl2" + suffix, "Lvl2" + suffix, "Lvl2", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl3PPr(), "Lvl3" + suffix, "Lvl3" + suffix, "Lvl3", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl4PPr(), "Lvl4" + suffix, "Lvl4" + suffix, "Lvl4", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl5PPr(), "Lvl5" + suffix, "Lvl5" + suffix, "Lvl5", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl6PPr(), "Lvl6" + suffix, "Lvl6" + suffix, "Lvl6", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl7PPr(), "Lvl7" + suffix, "Lvl7" + suffix, "Lvl7", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl8PPr(), "Lvl8" + suffix, "Lvl8" + suffix, "Lvl8", fontScheme));
+    styles.add(convertToWordStyle(textStyles.getLvl9PPr(), "Lvl9" + suffix, "Lvl9" + suffix, "Lvl9", fontScheme));
+    return styles;
+  }
+  
+  protected static Style createVirtualStylesForDocDefaults(BaseStyles.FontScheme fontScheme) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    Style style = factory.createStyle();
+    String ROOT_NAME = "DocDefaults";
+    style.setStyleId(ROOT_NAME);
+    style.setType("paragraph");
+    Style.Name styleName = factory.createStyleName();
+    styleName.setVal(ROOT_NAME);
+    style.setName(styleName);
+    RPr rPr = factory.createRPr();
+    style.setRPr(rPr);
+    RFonts rFonts = factory.createRFonts();
+    rFonts.setAscii(fontScheme.getMinorFont().getLatin().getTypeface());
+    rPr.setRFonts(rFonts);
+    return style;
+  }
+  
+  public static List<Style> generateStyles(PresentationMLPackage presentationMLPackage) throws InvalidFormatException {
+    ThemePart tp = (ThemePart)presentationMLPackage.getParts().getParts().get(new PartName("/ppt/theme/theme1.xml"));
+    BaseStyles.FontScheme fontScheme = tp.getFontScheme();
+    List<Style> styles = new ArrayList<Style>();
+    styles.add(createVirtualStylesForDocDefaults(fontScheme));
+    MainPresentationPart pp = (MainPresentationPart)presentationMLPackage.getParts().getParts().get(new PartName("/ppt/presentation.xml"));
+    styles.addAll(generateWordStylesFromPresentationPart(pp.getJaxbElement().getDefaultTextStyle(), "", fontScheme));
+    SlideMasterPart master = (SlideMasterPart)presentationMLPackage.getParts().getParts().get(new PartName("/ppt/slideMasters/slideMaster1.xml"));
+    styles.addAll(generateWordStylesForMaster(master.getJaxbElement().getTxStyles(), 1, fontScheme));
+    return styles;
+  }
+  
+  public static RPr getWmlRPr(CTTextCharacterProperties in) {
+    ObjectFactory factory = Context.getWmlObjectFactory();
+    RPr rPr = factory.createRPr();
+    if (in == null) {
+      System.out.println("Was passed null");
+      return rPr;
+    } 
+    if (in.isI() != null && in.isI())
+      rPr.setI(new BooleanDefaultTrue()); 
+    if (in.isB() != null && in.isB())
+      rPr.setB(new BooleanDefaultTrue()); 
+    if (in.getU() != null) {
+      U u = factory.createU();
+      u.setVal(UnderlineEnumeration.SINGLE);
+      rPr.setU(u);
+    } 
+    if (in.getSz() != null)
+      rPr.setSz(convertFontSize(in.getSz())); 
+    return rPr;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTBackground.java

@@ -0,0 +1,45 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTStyleMatrixReference;
+import org.docx4j.dml.STBlackWhiteMode;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Background", propOrder = {"bgPr", "bgRef"})
+public class CTBackground {
+  protected CTBackgroundProperties bgPr;
+  
+  protected CTStyleMatrixReference bgRef;
+  
+  @XmlAttribute(name = "bwMode")
+  protected STBlackWhiteMode bwMode;
+  
+  public CTBackgroundProperties getBgPr() {
+    return this.bgPr;
+  }
+  
+  public void setBgPr(CTBackgroundProperties value) {
+    this.bgPr = value;
+  }
+  
+  public CTStyleMatrixReference getBgRef() {
+    return this.bgRef;
+  }
+  
+  public void setBgRef(CTStyleMatrixReference value) {
+    this.bgRef = value;
+  }
+  
+  public STBlackWhiteMode getBwMode() {
+    if (this.bwMode == null)
+      return STBlackWhiteMode.WHITE; 
+    return this.bwMode;
+  }
+  
+  public void setBwMode(STBlackWhiteMode value) {
+    this.bwMode = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTBackgroundProperties.java

@@ -0,0 +1,130 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTBlipFillProperties;
+import org.docx4j.dml.CTEffectContainer;
+import org.docx4j.dml.CTEffectList;
+import org.docx4j.dml.CTGradientFillProperties;
+import org.docx4j.dml.CTGroupFillProperties;
+import org.docx4j.dml.CTNoFillProperties;
+import org.docx4j.dml.CTPatternFillProperties;
+import org.docx4j.dml.CTSolidColorFillProperties;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_BackgroundProperties", propOrder = {"noFill", "solidFill", "gradFill", "blipFill", "pattFill", "grpFill", "effectLst", "effectDag", "extLst"})
+public class CTBackgroundProperties {
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTNoFillProperties noFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTSolidColorFillProperties solidFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTGradientFillProperties gradFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTBlipFillProperties blipFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTPatternFillProperties pattFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTGroupFillProperties grpFill;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTEffectList effectLst;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main")
+  protected CTEffectContainer effectDag;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "shadeToTitle")
+  protected Boolean shadeToTitle;
+  
+  public CTNoFillProperties getNoFill() {
+    return this.noFill;
+  }
+  
+  public void setNoFill(CTNoFillProperties value) {
+    this.noFill = value;
+  }
+  
+  public CTSolidColorFillProperties getSolidFill() {
+    return this.solidFill;
+  }
+  
+  public void setSolidFill(CTSolidColorFillProperties value) {
+    this.solidFill = value;
+  }
+  
+  public CTGradientFillProperties getGradFill() {
+    return this.gradFill;
+  }
+  
+  public void setGradFill(CTGradientFillProperties value) {
+    this.gradFill = value;
+  }
+  
+  public CTBlipFillProperties getBlipFill() {
+    return this.blipFill;
+  }
+  
+  public void setBlipFill(CTBlipFillProperties value) {
+    this.blipFill = value;
+  }
+  
+  public CTPatternFillProperties getPattFill() {
+    return this.pattFill;
+  }
+  
+  public void setPattFill(CTPatternFillProperties value) {
+    this.pattFill = value;
+  }
+  
+  public CTGroupFillProperties getGrpFill() {
+    return this.grpFill;
+  }
+  
+  public void setGrpFill(CTGroupFillProperties value) {
+    this.grpFill = value;
+  }
+  
+  public CTEffectList getEffectLst() {
+    return this.effectLst;
+  }
+  
+  public void setEffectLst(CTEffectList value) {
+    this.effectLst = value;
+  }
+  
+  public CTEffectContainer getEffectDag() {
+    return this.effectDag;
+  }
+  
+  public void setEffectDag(CTEffectContainer value) {
+    this.effectDag = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isShadeToTitle() {
+    if (this.shadeToTitle == null)
+      return false; 
+    return this.shadeToTitle;
+  }
+  
+  public void setShadeToTitle(Boolean value) {
+    this.shadeToTitle = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTBuildList.java

@@ -0,0 +1,22 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlElements;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_BuildList", propOrder = {"bldPOrBldDgmOrBldOleChart"})
+public class CTBuildList {
+  @XmlElements({@XmlElement(name = "bldP", type = CTTLBuildParagraph.class), @XmlElement(name = "bldDgm", type = CTTLBuildDiagram.class), @XmlElement(name = "bldOleChart", type = CTTLOleBuildChart.class), @XmlElement(name = "bldGraphic", type = CTTLGraphicalObjectBuild.class)})
+  protected List<Object> bldPOrBldDgmOrBldOleChart;
+  
+  public List<Object> getBldPOrBldDgmOrBldOleChart() {
+    if (this.bldPOrBldDgmOrBldOleChart == null)
+      this.bldPOrBldDgmOrBldOleChart = new ArrayList(); 
+    return this.bldPOrBldDgmOrBldOleChart;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTComment.java

@@ -0,0 +1,81 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.datatype.XMLGregorianCalendar;
+import org.docx4j.dml.CTPoint2D;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Comment", propOrder = {"pos", "text", "extLst"})
+public class CTComment {
+  @XmlElement(required = true)
+  protected CTPoint2D pos;
+  
+  @XmlElement(required = true)
+  protected String text;
+  
+  protected CTExtensionListModify extLst;
+  
+  @XmlAttribute(name = "authorId", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long authorId;
+  
+  @XmlAttribute(name = "dt")
+  @XmlSchemaType(name = "dateTime")
+  protected XMLGregorianCalendar dt;
+  
+  @XmlAttribute(name = "idx", required = true)
+  protected long idx;
+  
+  public CTPoint2D getPos() {
+    return this.pos;
+  }
+  
+  public void setPos(CTPoint2D value) {
+    this.pos = value;
+  }
+  
+  public String getText() {
+    return this.text;
+  }
+  
+  public void setText(String value) {
+    this.text = value;
+  }
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+  
+  public long getAuthorId() {
+    return this.authorId;
+  }
+  
+  public void setAuthorId(long value) {
+    this.authorId = value;
+  }
+  
+  public XMLGregorianCalendar getDt() {
+    return this.dt;
+  }
+  
+  public void setDt(XMLGregorianCalendar value) {
+    this.dt = value;
+  }
+  
+  public long getIdx() {
+    return this.idx;
+  }
+  
+  public void setIdx(long value) {
+    this.idx = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCommentAuthor.java

@@ -0,0 +1,81 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CommentAuthor", propOrder = {"extLst"})
+@XmlRootElement(name = "cmAuthor")
+public class CTCommentAuthor {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "id", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long id;
+  
+  @XmlAttribute(name = "name", required = true)
+  protected String name;
+  
+  @XmlAttribute(name = "initials", required = true)
+  protected String initials;
+  
+  @XmlAttribute(name = "lastIdx", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long lastIdx;
+  
+  @XmlAttribute(name = "clrIdx", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long clrIdx;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public long getId() {
+    return this.id;
+  }
+  
+  public void setId(long value) {
+    this.id = value;
+  }
+  
+  public String getName() {
+    return this.name;
+  }
+  
+  public void setName(String value) {
+    this.name = value;
+  }
+  
+  public String getInitials() {
+    return this.initials;
+  }
+  
+  public void setInitials(String value) {
+    this.initials = value;
+  }
+  
+  public long getLastIdx() {
+    return this.lastIdx;
+  }
+  
+  public void setLastIdx(long value) {
+    this.lastIdx = value;
+  }
+  
+  public long getClrIdx() {
+    return this.clrIdx;
+  }
+  
+  public void setClrIdx(long value) {
+    this.clrIdx = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCommentAuthorList.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CommentAuthorList", propOrder = {"cmAuthor"})
+@XmlRootElement(name = "cmAuthorLst")
+public class CTCommentAuthorList {
+  protected List<CTCommentAuthor> cmAuthor;
+  
+  public List<CTCommentAuthor> getCmAuthor() {
+    if (this.cmAuthor == null)
+      this.cmAuthor = new ArrayList<CTCommentAuthor>(); 
+    return this.cmAuthor;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCommentList.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CommentList", propOrder = {"cm"})
+@XmlRootElement(name = "cmLst")
+public class CTCommentList {
+  protected List<CTComment> cm;
+  
+  public List<CTComment> getCm() {
+    if (this.cm == null)
+      this.cm = new ArrayList<CTComment>(); 
+    return this.cm;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCommonSlideViewProperties.java

@@ -0,0 +1,71 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CommonSlideViewProperties", propOrder = {"cViewPr", "guideLst"})
+public class CTCommonSlideViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonViewProperties cViewPr;
+  
+  protected CTGuideList guideLst;
+  
+  @XmlAttribute(name = "snapToGrid")
+  protected Boolean snapToGrid;
+  
+  @XmlAttribute(name = "snapToObjects")
+  protected Boolean snapToObjects;
+  
+  @XmlAttribute(name = "showGuides")
+  protected Boolean showGuides;
+  
+  public CTCommonViewProperties getCViewPr() {
+    return this.cViewPr;
+  }
+  
+  public void setCViewPr(CTCommonViewProperties value) {
+    this.cViewPr = value;
+  }
+  
+  public CTGuideList getGuideLst() {
+    return this.guideLst;
+  }
+  
+  public void setGuideLst(CTGuideList value) {
+    this.guideLst = value;
+  }
+  
+  public boolean isSnapToGrid() {
+    if (this.snapToGrid == null)
+      return true; 
+    return this.snapToGrid;
+  }
+  
+  public void setSnapToGrid(Boolean value) {
+    this.snapToGrid = value;
+  }
+  
+  public boolean isSnapToObjects() {
+    if (this.snapToObjects == null)
+      return false; 
+    return this.snapToObjects;
+  }
+  
+  public void setSnapToObjects(Boolean value) {
+    this.snapToObjects = value;
+  }
+  
+  public boolean isShowGuides() {
+    if (this.showGuides == null)
+      return false; 
+    return this.showGuides;
+  }
+  
+  public void setShowGuides(Boolean value) {
+    this.showGuides = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCommonViewProperties.java

@@ -0,0 +1,48 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTPoint2D;
+import org.docx4j.dml.CTScale2D;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CommonViewProperties", propOrder = {"scale", "origin"})
+public class CTCommonViewProperties {
+  @XmlElement(required = true)
+  protected CTScale2D scale;
+  
+  @XmlElement(required = true)
+  protected CTPoint2D origin;
+  
+  @XmlAttribute(name = "varScale")
+  protected Boolean varScale;
+  
+  public CTScale2D getScale() {
+    return this.scale;
+  }
+  
+  public void setScale(CTScale2D value) {
+    this.scale = value;
+  }
+  
+  public CTPoint2D getOrigin() {
+    return this.origin;
+  }
+  
+  public void setOrigin(CTPoint2D value) {
+    this.origin = value;
+  }
+  
+  public boolean isVarScale() {
+    if (this.varScale == null)
+      return false; 
+    return this.varScale;
+  }
+  
+  public void setVarScale(Boolean value) {
+    this.varScale = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTControl.java

@@ -0,0 +1,89 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Control", propOrder = {"extLst", "pic"})
+public class CTControl {
+  protected CTExtensionList extLst;
+  
+  protected Pic pic;
+  
+  @XmlAttribute(name = "name")
+  protected String name;
+  
+  @XmlAttribute(name = "showAsIcon")
+  protected Boolean showAsIcon;
+  
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")
+  protected String id;
+  
+  @XmlAttribute(name = "imgW")
+  protected Integer imgW;
+  
+  @XmlAttribute(name = "imgH")
+  protected Integer imgH;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public Pic getPic() {
+    return this.pic;
+  }
+  
+  public void setPic(Pic value) {
+    this.pic = value;
+  }
+  
+  public String getName() {
+    if (this.name == null)
+      return ""; 
+    return this.name;
+  }
+  
+  public void setName(String value) {
+    this.name = value;
+  }
+  
+  public boolean isShowAsIcon() {
+    if (this.showAsIcon == null)
+      return false; 
+    return this.showAsIcon;
+  }
+  
+  public void setShowAsIcon(Boolean value) {
+    this.showAsIcon = value;
+  }
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+  
+  public Integer getImgW() {
+    return this.imgW;
+  }
+  
+  public void setImgW(Integer value) {
+    this.imgW = value;
+  }
+  
+  public Integer getImgH() {
+    return this.imgH;
+  }
+  
+  public void setImgH(Integer value) {
+    this.imgH = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTControlList.java

@@ -0,0 +1,50 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlTransient;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.mce.AlternateContent;
+import org.jvnet.jaxb2_commons.ppp.Child;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ControlList", propOrder = {"control", "alternateContent"})
+public class CTControlList implements Child {
+  protected List<CTControl> control;
+  
+  @XmlElement(name = "AlternateContent", namespace = "http://schemas.openxmlformats.org/markup-compatibility/2006", required = true)
+  protected AlternateContent alternateContent;
+  
+  @XmlTransient
+  private Object parent;
+  
+  public List<CTControl> getControl() {
+    if (this.control == null)
+      this.control = new ArrayList<CTControl>(); 
+    return this.control;
+  }
+  
+  public AlternateContent getAlternateContent() {
+    return this.alternateContent;
+  }
+  
+  public void setAlternateContent(AlternateContent value) {
+    this.alternateContent = value;
+  }
+  
+  public Object getParent() {
+    return this.parent;
+  }
+  
+  public void setParent(Object parent) {
+    this.parent = parent;
+  }
+  
+  public void afterUnmarshal(Unmarshaller unmarshaller, Object parent) {
+    setParent(parent);
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCornerDirectionTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CornerDirectionTransition")
+public class CTCornerDirectionTransition {
+  @XmlAttribute(name = "dir")
+  protected STTransitionCornerDirectionType dir;
+  
+  public STTransitionCornerDirectionType getDir() {
+    if (this.dir == null)
+      return STTransitionCornerDirectionType.LU; 
+    return this.dir;
+  }
+  
+  public void setDir(STTransitionCornerDirectionType value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCustomShow.java

@@ -0,0 +1,56 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CustomShow", propOrder = {"sldLst", "extLst"})
+public class CTCustomShow {
+  @XmlElement(required = true)
+  protected CTSlideRelationshipList sldLst;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "name", required = true)
+  protected String name;
+  
+  @XmlAttribute(name = "id", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long id;
+  
+  public CTSlideRelationshipList getSldLst() {
+    return this.sldLst;
+  }
+  
+  public void setSldLst(CTSlideRelationshipList value) {
+    this.sldLst = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public String getName() {
+    return this.name;
+  }
+  
+  public void setName(String value) {
+    this.name = value;
+  }
+  
+  public long getId() {
+    return this.id;
+  }
+  
+  public void setId(long value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCustomShowId.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CustomShowId")
+public class CTCustomShowId {
+  @XmlAttribute(name = "id", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long id;
+  
+  public long getId() {
+    return this.id;
+  }
+  
+  public void setId(long value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCustomShowList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CustomShowList", propOrder = {"custShow"})
+public class CTCustomShowList {
+  protected List<CTCustomShow> custShow;
+  
+  public List<CTCustomShow> getCustShow() {
+    if (this.custShow == null)
+      this.custShow = new ArrayList<CTCustomShow>(); 
+    return this.custShow;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCustomerData.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CustomerData")
+public class CTCustomerData {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTCustomerDataList.java

@@ -0,0 +1,29 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_CustomerDataList", propOrder = {"custData", "tags"})
+public class CTCustomerDataList {
+  protected List<CTCustomerData> custData;
+  
+  protected CTTagsData tags;
+  
+  public List<CTCustomerData> getCustData() {
+    if (this.custData == null)
+      this.custData = new ArrayList<CTCustomerData>(); 
+    return this.custData;
+  }
+  
+  public CTTagsData getTags() {
+    return this.tags;
+  }
+  
+  public void setTags(CTTagsData value) {
+    this.tags = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTEightDirectionTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_EightDirectionTransition")
+public class CTEightDirectionTransition {
+  @XmlAttribute(name = "dir")
+  protected String dir;
+  
+  public String getDir() {
+    if (this.dir == null)
+      return "l"; 
+    return this.dir;
+  }
+  
+  public void setDir(String value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTEmbeddedFontDataId.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_EmbeddedFontDataId")
+public class CTEmbeddedFontDataId {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTEmbeddedFontList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_EmbeddedFontList", propOrder = {"embeddedFont"})
+public class CTEmbeddedFontList {
+  protected List<CTEmbeddedFontListEntry> embeddedFont;
+  
+  public List<CTEmbeddedFontListEntry> getEmbeddedFont() {
+    if (this.embeddedFont == null)
+      this.embeddedFont = new ArrayList<CTEmbeddedFontListEntry>(); 
+    return this.embeddedFont;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTEmbeddedFontListEntry.java

@@ -0,0 +1,62 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.TextFont;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_EmbeddedFontListEntry", propOrder = {"font", "regular", "bold", "italic", "boldItalic"})
+public class CTEmbeddedFontListEntry {
+  @XmlElement(required = true)
+  protected TextFont font;
+  
+  protected CTEmbeddedFontDataId regular;
+  
+  protected CTEmbeddedFontDataId bold;
+  
+  protected CTEmbeddedFontDataId italic;
+  
+  protected CTEmbeddedFontDataId boldItalic;
+  
+  public TextFont getFont() {
+    return this.font;
+  }
+  
+  public void setFont(TextFont value) {
+    this.font = value;
+  }
+  
+  public CTEmbeddedFontDataId getRegular() {
+    return this.regular;
+  }
+  
+  public void setRegular(CTEmbeddedFontDataId value) {
+    this.regular = value;
+  }
+  
+  public CTEmbeddedFontDataId getBold() {
+    return this.bold;
+  }
+  
+  public void setBold(CTEmbeddedFontDataId value) {
+    this.bold = value;
+  }
+  
+  public CTEmbeddedFontDataId getItalic() {
+    return this.italic;
+  }
+  
+  public void setItalic(CTEmbeddedFontDataId value) {
+    this.italic = value;
+  }
+  
+  public CTEmbeddedFontDataId getBoldItalic() {
+    return this.boldItalic;
+  }
+  
+  public void setBoldItalic(CTEmbeddedFontDataId value) {
+    this.boldItalic = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTEmpty.java

@@ -0,0 +1,9 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Empty")
+public class CTEmpty {}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTExtension.java

@@ -0,0 +1,38 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAnyElement;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Extension", propOrder = {"any"})
+public class CTExtension {
+  @XmlAnyElement(lax = true)
+  protected Object any;
+  
+  @XmlAttribute(name = "uri")
+  @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
+  @XmlSchemaType(name = "token")
+  protected String uri;
+  
+  public Object getAny() {
+    return this.any;
+  }
+  
+  public void setAny(Object value) {
+    this.any = value;
+  }
+  
+  public String getUri() {
+    return this.uri;
+  }
+  
+  public void setUri(String value) {
+    this.uri = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTExtensionList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ExtensionList", propOrder = {"ext"})
+public class CTExtensionList {
+  protected List<CTExtension> ext;
+  
+  public List<CTExtension> getExt() {
+    if (this.ext == null)
+      this.ext = new ArrayList<CTExtension>(); 
+    return this.ext;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTExtensionListModify.java

@@ -0,0 +1,33 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ExtensionListModify", propOrder = {"ext"})
+public class CTExtensionListModify {
+  protected List<CTExtension> ext;
+  
+  @XmlAttribute(name = "mod")
+  protected Boolean mod;
+  
+  public List<CTExtension> getExt() {
+    if (this.ext == null)
+      this.ext = new ArrayList<CTExtension>(); 
+    return this.ext;
+  }
+  
+  public boolean isMod() {
+    if (this.mod == null)
+      return false; 
+    return this.mod;
+  }
+  
+  public void setMod(Boolean value) {
+    this.mod = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTGraphicalObjectFrame.java

@@ -0,0 +1,55 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTTransform2D;
+import org.docx4j.dml.Graphic;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_GraphicalObjectFrame", propOrder = {"nvGraphicFramePr", "xfrm", "graphic", "extLst"})
+public class CTGraphicalObjectFrame {
+  @XmlElement(required = true)
+  protected CTGraphicalObjectFrameNonVisual nvGraphicFramePr;
+  
+  @XmlElement(required = true)
+  protected CTTransform2D xfrm;
+  
+  @XmlElement(namespace = "http://schemas.openxmlformats.org/drawingml/2006/main", required = true)
+  protected Graphic graphic;
+  
+  protected CTExtensionListModify extLst;
+  
+  public CTGraphicalObjectFrameNonVisual getNvGraphicFramePr() {
+    return this.nvGraphicFramePr;
+  }
+  
+  public void setNvGraphicFramePr(CTGraphicalObjectFrameNonVisual value) {
+    this.nvGraphicFramePr = value;
+  }
+  
+  public CTTransform2D getXfrm() {
+    return this.xfrm;
+  }
+  
+  public void setXfrm(CTTransform2D value) {
+    this.xfrm = value;
+  }
+  
+  public Graphic getGraphic() {
+    return this.graphic;
+  }
+  
+  public void setGraphic(Graphic value) {
+    this.graphic = value;
+  }
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTGraphicalObjectFrameNonVisual.java

@@ -0,0 +1,45 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTNonVisualDrawingProps;
+import org.docx4j.dml.CTNonVisualGraphicFrameProperties;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_GraphicalObjectFrameNonVisual", propOrder = {"cNvPr", "cNvGraphicFramePr", "nvPr"})
+public class CTGraphicalObjectFrameNonVisual {
+  @XmlElement(required = true)
+  protected CTNonVisualDrawingProps cNvPr;
+  
+  @XmlElement(required = true)
+  protected CTNonVisualGraphicFrameProperties cNvGraphicFramePr;
+  
+  @XmlElement(required = true)
+  protected NvPr nvPr;
+  
+  public CTNonVisualDrawingProps getCNvPr() {
+    return this.cNvPr;
+  }
+  
+  public void setCNvPr(CTNonVisualDrawingProps value) {
+    this.cNvPr = value;
+  }
+  
+  public CTNonVisualGraphicFrameProperties getCNvGraphicFramePr() {
+    return this.cNvGraphicFramePr;
+  }
+  
+  public void setCNvGraphicFramePr(CTNonVisualGraphicFrameProperties value) {
+    this.cNvGraphicFramePr = value;
+  }
+  
+  public NvPr getNvPr() {
+    return this.nvPr;
+  }
+  
+  public void setNvPr(NvPr value) {
+    this.nvPr = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTGuide.java

@@ -0,0 +1,36 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Guide")
+public class CTGuide {
+  @XmlAttribute(name = "orient")
+  protected STDirection orient;
+  
+  @XmlAttribute(name = "pos")
+  protected Integer pos;
+  
+  public STDirection getOrient() {
+    if (this.orient == null)
+      return STDirection.VERT; 
+    return this.orient;
+  }
+  
+  public void setOrient(STDirection value) {
+    this.orient = value;
+  }
+  
+  public int getPos() {
+    if (this.pos == null)
+      return 0; 
+    return this.pos;
+  }
+  
+  public void setPos(Integer value) {
+    this.pos = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTGuideList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_GuideList", propOrder = {"guide"})
+public class CTGuideList {
+  protected List<CTGuide> guide;
+  
+  public List<CTGuide> getGuide() {
+    if (this.guide == null)
+      this.guide = new ArrayList<CTGuide>(); 
+    return this.guide;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTHandoutMasterIdList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_HandoutMasterIdList", propOrder = {"handoutMasterId"})
+public class CTHandoutMasterIdList {
+  protected CTHandoutMasterIdListEntry handoutMasterId;
+  
+  public CTHandoutMasterIdListEntry getHandoutMasterId() {
+    return this.handoutMasterId;
+  }
+  
+  public void setHandoutMasterId(CTHandoutMasterIdListEntry value) {
+    this.handoutMasterId = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTHandoutMasterIdListEntry.java

@@ -0,0 +1,31 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_HandoutMasterIdListEntry", propOrder = {"extLst"})
+public class CTHandoutMasterIdListEntry {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTHeaderFooter.java

@@ -0,0 +1,72 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_HeaderFooter", propOrder = {"extLst"})
+public class CTHeaderFooter {
+  protected CTExtensionListModify extLst;
+  
+  @XmlAttribute(name = "sldNum")
+  protected Boolean sldNum;
+  
+  @XmlAttribute(name = "hdr")
+  protected Boolean hdr;
+  
+  @XmlAttribute(name = "ftr")
+  protected Boolean ftr;
+  
+  @XmlAttribute(name = "dt")
+  protected Boolean dt;
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+  
+  public boolean isSldNum() {
+    if (this.sldNum == null)
+      return true; 
+    return this.sldNum;
+  }
+  
+  public void setSldNum(Boolean value) {
+    this.sldNum = value;
+  }
+  
+  public boolean isHdr() {
+    if (this.hdr == null)
+      return true; 
+    return this.hdr;
+  }
+  
+  public void setHdr(Boolean value) {
+    this.hdr = value;
+  }
+  
+  public boolean isFtr() {
+    if (this.ftr == null)
+      return true; 
+    return this.ftr;
+  }
+  
+  public void setFtr(Boolean value) {
+    this.ftr = value;
+  }
+  
+  public boolean isDt() {
+    if (this.dt == null)
+      return true; 
+    return this.dt;
+  }
+  
+  public void setDt(Boolean value) {
+    this.dt = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTHtmlPublishProperties.java

@@ -0,0 +1,98 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_HtmlPublishProperties", propOrder = {"sldAll", "sldRg", "custShow", "extLst"})
+public class CTHtmlPublishProperties {
+  protected CTEmpty sldAll;
+  
+  protected CTIndexRange sldRg;
+  
+  protected CTCustomShowId custShow;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "showSpeakerNotes")
+  protected Boolean showSpeakerNotes;
+  
+  @XmlAttribute(name = "target")
+  protected String target;
+  
+  @XmlAttribute(name = "title")
+  protected String title;
+  
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public CTEmpty getSldAll() {
+    return this.sldAll;
+  }
+  
+  public void setSldAll(CTEmpty value) {
+    this.sldAll = value;
+  }
+  
+  public CTIndexRange getSldRg() {
+    return this.sldRg;
+  }
+  
+  public void setSldRg(CTIndexRange value) {
+    this.sldRg = value;
+  }
+  
+  public CTCustomShowId getCustShow() {
+    return this.custShow;
+  }
+  
+  public void setCustShow(CTCustomShowId value) {
+    this.custShow = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isShowSpeakerNotes() {
+    if (this.showSpeakerNotes == null)
+      return true; 
+    return this.showSpeakerNotes;
+  }
+  
+  public void setShowSpeakerNotes(Boolean value) {
+    this.showSpeakerNotes = value;
+  }
+  
+  public String getTarget() {
+    return this.target;
+  }
+  
+  public void setTarget(String value) {
+    this.target = value;
+  }
+  
+  public String getTitle() {
+    if (this.title == null)
+      return ""; 
+    return this.title;
+  }
+  
+  public void setTitle(String value) {
+    this.title = value;
+  }
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTInOutTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_InOutTransition")
+public class CTInOutTransition {
+  @XmlAttribute(name = "dir")
+  protected STTransitionInOutDirectionType dir;
+  
+  public STTransitionInOutDirectionType getDir() {
+    if (this.dir == null)
+      return STTransitionInOutDirectionType.OUT; 
+    return this.dir;
+  }
+  
+  public void setDir(STTransitionInOutDirectionType value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTIndexRange.java

@@ -0,0 +1,32 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_IndexRange")
+public class CTIndexRange {
+  @XmlAttribute(name = "st", required = true)
+  protected long st;
+  
+  @XmlAttribute(name = "end", required = true)
+  protected long end;
+  
+  public long getSt() {
+    return this.st;
+  }
+  
+  public void setSt(long value) {
+    this.st = value;
+  }
+  
+  public long getEnd() {
+    return this.end;
+  }
+  
+  public void setEnd(long value) {
+    this.end = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTKinsoku.java

@@ -0,0 +1,43 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Kinsoku")
+public class CTKinsoku {
+  @XmlAttribute(name = "lang")
+  protected String lang;
+  
+  @XmlAttribute(name = "invalStChars", required = true)
+  protected String invalStChars;
+  
+  @XmlAttribute(name = "invalEndChars", required = true)
+  protected String invalEndChars;
+  
+  public String getLang() {
+    return this.lang;
+  }
+  
+  public void setLang(String value) {
+    this.lang = value;
+  }
+  
+  public String getInvalStChars() {
+    return this.invalStChars;
+  }
+  
+  public void setInvalStChars(String value) {
+    this.invalStChars = value;
+  }
+  
+  public String getInvalEndChars() {
+    return this.invalEndChars;
+  }
+  
+  public void setInvalEndChars(String value) {
+    this.invalEndChars = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTModifyVerifier.java

@@ -0,0 +1,56 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ModifyVerifier")
+public class CTModifyVerifier {
+  @XmlAttribute(name = "algorithmName")
+  protected String algorithmName;
+  
+  @XmlAttribute(name = "hashValue")
+  protected byte[] hashValue;
+  
+  @XmlAttribute(name = "saltValue")
+  protected byte[] saltValue;
+  
+  @XmlAttribute(name = "spinValue")
+  @XmlSchemaType(name = "unsignedInt")
+  protected Long spinValue;
+  
+  public String getAlgorithmName() {
+    return this.algorithmName;
+  }
+  
+  public void setAlgorithmName(String value) {
+    this.algorithmName = value;
+  }
+  
+  public byte[] getHashValue() {
+    return this.hashValue;
+  }
+  
+  public void setHashValue(byte[] value) {
+    this.hashValue = value;
+  }
+  
+  public byte[] getSaltValue() {
+    return this.saltValue;
+  }
+  
+  public void setSaltValue(byte[] value) {
+    this.saltValue = value;
+  }
+  
+  public Long getSpinValue() {
+    return this.spinValue;
+  }
+  
+  public void setSpinValue(Long value) {
+    this.spinValue = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNormalViewPortion.java

@@ -0,0 +1,34 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NormalViewPortion")
+public class CTNormalViewPortion {
+  @XmlAttribute(name = "sz", required = true)
+  protected int sz;
+  
+  @XmlAttribute(name = "autoAdjust")
+  protected Boolean autoAdjust;
+  
+  public int getSz() {
+    return this.sz;
+  }
+  
+  public void setSz(int value) {
+    this.sz = value;
+  }
+  
+  public boolean isAutoAdjust() {
+    if (this.autoAdjust == null)
+      return true; 
+    return this.autoAdjust;
+  }
+  
+  public void setAutoAdjust(Boolean value) {
+    this.autoAdjust = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNormalViewProperties.java

@@ -0,0 +1,108 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NormalViewProperties", propOrder = {"restoredLeft", "restoredTop", "extLst"})
+public class CTNormalViewProperties {
+  @XmlElement(required = true)
+  protected CTNormalViewPortion restoredLeft;
+  
+  @XmlElement(required = true)
+  protected CTNormalViewPortion restoredTop;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "showOutlineIcons")
+  protected Boolean showOutlineIcons;
+  
+  @XmlAttribute(name = "snapVertSplitter")
+  protected Boolean snapVertSplitter;
+  
+  @XmlAttribute(name = "vertBarState")
+  protected STSplitterBarState vertBarState;
+  
+  @XmlAttribute(name = "horzBarState")
+  protected STSplitterBarState horzBarState;
+  
+  @XmlAttribute(name = "preferSingleView")
+  protected Boolean preferSingleView;
+  
+  public CTNormalViewPortion getRestoredLeft() {
+    return this.restoredLeft;
+  }
+  
+  public void setRestoredLeft(CTNormalViewPortion value) {
+    this.restoredLeft = value;
+  }
+  
+  public CTNormalViewPortion getRestoredTop() {
+    return this.restoredTop;
+  }
+  
+  public void setRestoredTop(CTNormalViewPortion value) {
+    this.restoredTop = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isShowOutlineIcons() {
+    if (this.showOutlineIcons == null)
+      return true; 
+    return this.showOutlineIcons;
+  }
+  
+  public void setShowOutlineIcons(Boolean value) {
+    this.showOutlineIcons = value;
+  }
+  
+  public boolean isSnapVertSplitter() {
+    if (this.snapVertSplitter == null)
+      return false; 
+    return this.snapVertSplitter;
+  }
+  
+  public void setSnapVertSplitter(Boolean value) {
+    this.snapVertSplitter = value;
+  }
+  
+  public STSplitterBarState getVertBarState() {
+    if (this.vertBarState == null)
+      return STSplitterBarState.RESTORED; 
+    return this.vertBarState;
+  }
+  
+  public void setVertBarState(STSplitterBarState value) {
+    this.vertBarState = value;
+  }
+  
+  public STSplitterBarState getHorzBarState() {
+    if (this.horzBarState == null)
+      return STSplitterBarState.RESTORED; 
+    return this.horzBarState;
+  }
+  
+  public void setHorzBarState(STSplitterBarState value) {
+    this.horzBarState = value;
+  }
+  
+  public boolean isPreferSingleView() {
+    if (this.preferSingleView == null)
+      return false; 
+    return this.preferSingleView;
+  }
+  
+  public void setPreferSingleView(Boolean value) {
+    this.preferSingleView = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNotesMasterIdList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NotesMasterIdList", propOrder = {"notesMasterId"})
+public class CTNotesMasterIdList {
+  protected CTNotesMasterIdListEntry notesMasterId;
+  
+  public CTNotesMasterIdListEntry getNotesMasterId() {
+    return this.notesMasterId;
+  }
+  
+  public void setNotesMasterId(CTNotesMasterIdListEntry value) {
+    this.notesMasterId = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNotesMasterIdListEntry.java

@@ -0,0 +1,31 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NotesMasterIdListEntry", propOrder = {"extLst"})
+public class CTNotesMasterIdListEntry {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNotesTextViewProperties.java

@@ -0,0 +1,31 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NotesTextViewProperties", propOrder = {"cViewPr", "extLst"})
+public class CTNotesTextViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonViewProperties cViewPr;
+  
+  protected CTExtensionList extLst;
+  
+  public CTCommonViewProperties getCViewPr() {
+    return this.cViewPr;
+  }
+  
+  public void setCViewPr(CTCommonViewProperties value) {
+    this.cViewPr = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTNotesViewProperties.java

@@ -0,0 +1,31 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_NotesViewProperties", propOrder = {"cSldViewPr", "extLst"})
+public class CTNotesViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonSlideViewProperties cSldViewPr;
+  
+  protected CTExtensionList extLst;
+  
+  public CTCommonSlideViewProperties getCSldViewPr() {
+    return this.cSldViewPr;
+  }
+  
+  public void setCSldViewPr(CTCommonSlideViewProperties value) {
+    this.cSldViewPr = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOleObject.java

@@ -0,0 +1,121 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OleObject", propOrder = {"embed", "link", "pic"})
+public class CTOleObject {
+  protected CTOleObjectEmbed embed;
+  
+  protected CTOleObjectLink link;
+  
+  protected Pic pic;
+  
+  @XmlAttribute(name = "progId")
+  protected String progId;
+  
+  @XmlAttribute(name = "name")
+  protected String name;
+  
+  @XmlAttribute(name = "showAsIcon")
+  protected Boolean showAsIcon;
+  
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships")
+  protected String id;
+  
+  @XmlAttribute(name = "imgW")
+  protected Integer imgW;
+  
+  @XmlAttribute(name = "imgH")
+  protected Integer imgH;
+  
+  @XmlAttribute(name = "spid")
+  protected String spid;
+  
+  public String getSpid() {
+    return this.spid;
+  }
+  
+  public void setSpid(String value) {
+    this.spid = value;
+  }
+  
+  public CTOleObjectEmbed getEmbed() {
+    return this.embed;
+  }
+  
+  public void setEmbed(CTOleObjectEmbed value) {
+    this.embed = value;
+  }
+  
+  public CTOleObjectLink getLink() {
+    return this.link;
+  }
+  
+  public void setLink(CTOleObjectLink value) {
+    this.link = value;
+  }
+  
+  public Pic getPic() {
+    return this.pic;
+  }
+  
+  public void setPic(Pic value) {
+    this.pic = value;
+  }
+  
+  public String getProgId() {
+    return this.progId;
+  }
+  
+  public void setProgId(String value) {
+    this.progId = value;
+  }
+  
+  public String getName() {
+    if (this.name == null)
+      return ""; 
+    return this.name;
+  }
+  
+  public void setName(String value) {
+    this.name = value;
+  }
+  
+  public boolean isShowAsIcon() {
+    if (this.showAsIcon == null)
+      return false; 
+    return this.showAsIcon;
+  }
+  
+  public void setShowAsIcon(Boolean value) {
+    this.showAsIcon = value;
+  }
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+  
+  public Integer getImgW() {
+    return this.imgW;
+  }
+  
+  public void setImgW(Integer value) {
+    this.imgW = value;
+  }
+  
+  public Integer getImgH() {
+    return this.imgH;
+  }
+  
+  public void setImgH(Integer value) {
+    this.imgH = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOleObjectEmbed.java

@@ -0,0 +1,33 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OleObjectEmbed", propOrder = {"extLst"})
+public class CTOleObjectEmbed {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "followColorScheme")
+  protected STOleObjectFollowColorScheme followColorScheme;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public STOleObjectFollowColorScheme getFollowColorScheme() {
+    if (this.followColorScheme == null)
+      return STOleObjectFollowColorScheme.NONE; 
+    return this.followColorScheme;
+  }
+  
+  public void setFollowColorScheme(STOleObjectFollowColorScheme value) {
+    this.followColorScheme = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOleObjectLink.java

@@ -0,0 +1,33 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OleObjectLink", propOrder = {"extLst"})
+public class CTOleObjectLink {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "updateAutomatic")
+  protected Boolean updateAutomatic;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isUpdateAutomatic() {
+    if (this.updateAutomatic == null)
+      return false; 
+    return this.updateAutomatic;
+  }
+  
+  public void setUpdateAutomatic(Boolean value) {
+    this.updateAutomatic = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOptionalBlackTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OptionalBlackTransition")
+public class CTOptionalBlackTransition {
+  @XmlAttribute(name = "thruBlk")
+  protected Boolean thruBlk;
+  
+  public boolean isThruBlk() {
+    if (this.thruBlk == null)
+      return false; 
+    return this.thruBlk;
+  }
+  
+  public void setThruBlk(Boolean value) {
+    this.thruBlk = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOrientationTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OrientationTransition")
+public class CTOrientationTransition {
+  @XmlAttribute(name = "dir")
+  protected STDirection dir;
+  
+  public STDirection getDir() {
+    if (this.dir == null)
+      return STDirection.HORZ; 
+    return this.dir;
+  }
+  
+  public void setDir(STDirection value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOutlineViewProperties.java

@@ -0,0 +1,41 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OutlineViewProperties", propOrder = {"cViewPr", "sldLst", "extLst"})
+public class CTOutlineViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonViewProperties cViewPr;
+  
+  protected CTOutlineViewSlideList sldLst;
+  
+  protected CTExtensionList extLst;
+  
+  public CTCommonViewProperties getCViewPr() {
+    return this.cViewPr;
+  }
+  
+  public void setCViewPr(CTCommonViewProperties value) {
+    this.cViewPr = value;
+  }
+  
+  public CTOutlineViewSlideList getSldLst() {
+    return this.sldLst;
+  }
+  
+  public void setSldLst(CTOutlineViewSlideList value) {
+    this.sldLst = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOutlineViewSlideEntry.java

@@ -0,0 +1,34 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OutlineViewSlideEntry")
+public class CTOutlineViewSlideEntry {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  @XmlAttribute(name = "collapse")
+  protected Boolean collapse;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+  
+  public boolean isCollapse() {
+    if (this.collapse == null)
+      return false; 
+    return this.collapse;
+  }
+  
+  public void setCollapse(Boolean value) {
+    this.collapse = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTOutlineViewSlideList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_OutlineViewSlideList", propOrder = {"sld"})
+public class CTOutlineViewSlideList {
+  protected List<CTOutlineViewSlideEntry> sld;
+  
+  public List<CTOutlineViewSlideEntry> getSld() {
+    if (this.sld == null)
+      this.sld = new ArrayList<CTOutlineViewSlideEntry>(); 
+    return this.sld;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTPhotoAlbum.java

@@ -0,0 +1,75 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_PhotoAlbum", propOrder = {"extLst"})
+public class CTPhotoAlbum {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "bw")
+  protected Boolean bw;
+  
+  @XmlAttribute(name = "showCaptions")
+  protected Boolean showCaptions;
+  
+  @XmlAttribute(name = "layout")
+  @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
+  protected String layout;
+  
+  @XmlAttribute(name = "frame")
+  protected STPhotoAlbumFrameShape frame;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isBw() {
+    if (this.bw == null)
+      return false; 
+    return this.bw;
+  }
+  
+  public void setBw(Boolean value) {
+    this.bw = value;
+  }
+  
+  public boolean isShowCaptions() {
+    if (this.showCaptions == null)
+      return false; 
+    return this.showCaptions;
+  }
+  
+  public void setShowCaptions(Boolean value) {
+    this.showCaptions = value;
+  }
+  
+  public String getLayout() {
+    if (this.layout == null)
+      return "fitToSlide"; 
+    return this.layout;
+  }
+  
+  public void setLayout(String value) {
+    this.layout = value;
+  }
+  
+  public STPhotoAlbumFrameShape getFrame() {
+    if (this.frame == null)
+      return STPhotoAlbumFrameShape.FRAME_STYLE_1; 
+    return this.frame;
+  }
+  
+  public void setFrame(STPhotoAlbumFrameShape value) {
+    this.frame = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTPlaceholder.java

@@ -0,0 +1,87 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Placeholder", propOrder = {"extLst"})
+public class CTPlaceholder {
+  protected CTExtensionListModify extLst;
+  
+  @XmlAttribute(name = "type")
+  protected STPlaceholderType type;
+  
+  @XmlAttribute(name = "orient")
+  protected STDirection orient;
+  
+  @XmlAttribute(name = "sz")
+  protected STPlaceholderSize sz;
+  
+  @XmlAttribute(name = "idx")
+  @XmlSchemaType(name = "unsignedInt")
+  protected Long idx;
+  
+  @XmlAttribute(name = "hasCustomPrompt")
+  protected Boolean hasCustomPrompt;
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+  
+  public STPlaceholderType getType() {
+    if (this.type == null)
+      return STPlaceholderType.OBJ; 
+    return this.type;
+  }
+  
+  public void setType(STPlaceholderType value) {
+    this.type = value;
+  }
+  
+  public STDirection getOrient() {
+    if (this.orient == null)
+      return STDirection.HORZ; 
+    return this.orient;
+  }
+  
+  public void setOrient(STDirection value) {
+    this.orient = value;
+  }
+  
+  public STPlaceholderSize getSz() {
+    if (this.sz == null)
+      return STPlaceholderSize.FULL; 
+    return this.sz;
+  }
+  
+  public void setSz(STPlaceholderSize value) {
+    this.sz = value;
+  }
+  
+  public long getIdx() {
+    if (this.idx == null)
+      return 0L; 
+    return this.idx;
+  }
+  
+  public void setIdx(Long value) {
+    this.idx = value;
+  }
+  
+  public boolean isHasCustomPrompt() {
+    if (this.hasCustomPrompt == null)
+      return false; 
+    return this.hasCustomPrompt;
+  }
+  
+  public void setHasCustomPrompt(Boolean value) {
+    this.hasCustomPrompt = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTPrintProperties.java

@@ -0,0 +1,85 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_PrintProperties", propOrder = {"extLst"})
+public class CTPrintProperties {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "prnWhat")
+  protected STPrintWhat prnWhat;
+  
+  @XmlAttribute(name = "clrMode")
+  protected STPrintColorMode clrMode;
+  
+  @XmlAttribute(name = "hiddenSlides")
+  protected Boolean hiddenSlides;
+  
+  @XmlAttribute(name = "scaleToFitPaper")
+  protected Boolean scaleToFitPaper;
+  
+  @XmlAttribute(name = "frameSlides")
+  protected Boolean frameSlides;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public STPrintWhat getPrnWhat() {
+    if (this.prnWhat == null)
+      return STPrintWhat.SLIDES; 
+    return this.prnWhat;
+  }
+  
+  public void setPrnWhat(STPrintWhat value) {
+    this.prnWhat = value;
+  }
+  
+  public STPrintColorMode getClrMode() {
+    if (this.clrMode == null)
+      return STPrintColorMode.CLR; 
+    return this.clrMode;
+  }
+  
+  public void setClrMode(STPrintColorMode value) {
+    this.clrMode = value;
+  }
+  
+  public boolean isHiddenSlides() {
+    if (this.hiddenSlides == null)
+      return false; 
+    return this.hiddenSlides;
+  }
+  
+  public void setHiddenSlides(Boolean value) {
+    this.hiddenSlides = value;
+  }
+  
+  public boolean isScaleToFitPaper() {
+    if (this.scaleToFitPaper == null)
+      return false; 
+    return this.scaleToFitPaper;
+  }
+  
+  public void setScaleToFitPaper(Boolean value) {
+    this.scaleToFitPaper = value;
+  }
+  
+  public boolean isFrameSlides() {
+    if (this.frameSlides == null)
+      return false; 
+    return this.frameSlides;
+  }
+  
+  public void setFrameSlides(Boolean value) {
+    this.frameSlides = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTRel.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_Rel")
+public class CTRel {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTShowInfoBrowse.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ShowInfoBrowse")
+public class CTShowInfoBrowse {
+  @XmlAttribute(name = "showScrollbar")
+  protected Boolean showScrollbar;
+  
+  public boolean isShowScrollbar() {
+    if (this.showScrollbar == null)
+      return true; 
+    return this.showScrollbar;
+  }
+  
+  public void setShowScrollbar(Boolean value) {
+    this.showScrollbar = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTShowInfoKiosk.java

@@ -0,0 +1,25 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ShowInfoKiosk")
+public class CTShowInfoKiosk {
+  @XmlAttribute(name = "restart")
+  @XmlSchemaType(name = "unsignedInt")
+  protected Long restart;
+  
+  public long getRestart() {
+    if (this.restart == null)
+      return 300000L; 
+    return this.restart;
+  }
+  
+  public void setRestart(Long value) {
+    this.restart = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTShowProperties.java

@@ -0,0 +1,143 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTColor;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_ShowProperties", propOrder = {"present", "browse", "kiosk", "sldAll", "sldRg", "custShow", "penClr", "extLst"})
+public class CTShowProperties {
+  protected CTEmpty present;
+  
+  protected CTShowInfoBrowse browse;
+  
+  protected CTShowInfoKiosk kiosk;
+  
+  protected CTEmpty sldAll;
+  
+  protected CTIndexRange sldRg;
+  
+  protected CTCustomShowId custShow;
+  
+  protected CTColor penClr;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "loop")
+  protected Boolean loop;
+  
+  @XmlAttribute(name = "showNarration")
+  protected Boolean showNarration;
+  
+  @XmlAttribute(name = "showAnimation")
+  protected Boolean showAnimation;
+  
+  @XmlAttribute(name = "useTimings")
+  protected Boolean useTimings;
+  
+  public CTEmpty getPresent() {
+    return this.present;
+  }
+  
+  public void setPresent(CTEmpty value) {
+    this.present = value;
+  }
+  
+  public CTShowInfoBrowse getBrowse() {
+    return this.browse;
+  }
+  
+  public void setBrowse(CTShowInfoBrowse value) {
+    this.browse = value;
+  }
+  
+  public CTShowInfoKiosk getKiosk() {
+    return this.kiosk;
+  }
+  
+  public void setKiosk(CTShowInfoKiosk value) {
+    this.kiosk = value;
+  }
+  
+  public CTEmpty getSldAll() {
+    return this.sldAll;
+  }
+  
+  public void setSldAll(CTEmpty value) {
+    this.sldAll = value;
+  }
+  
+  public CTIndexRange getSldRg() {
+    return this.sldRg;
+  }
+  
+  public void setSldRg(CTIndexRange value) {
+    this.sldRg = value;
+  }
+  
+  public CTCustomShowId getCustShow() {
+    return this.custShow;
+  }
+  
+  public void setCustShow(CTCustomShowId value) {
+    this.custShow = value;
+  }
+  
+  public CTColor getPenClr() {
+    return this.penClr;
+  }
+  
+  public void setPenClr(CTColor value) {
+    this.penClr = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isLoop() {
+    if (this.loop == null)
+      return false; 
+    return this.loop;
+  }
+  
+  public void setLoop(Boolean value) {
+    this.loop = value;
+  }
+  
+  public boolean isShowNarration() {
+    if (this.showNarration == null)
+      return false; 
+    return this.showNarration;
+  }
+  
+  public void setShowNarration(Boolean value) {
+    this.showNarration = value;
+  }
+  
+  public boolean isShowAnimation() {
+    if (this.showAnimation == null)
+      return true; 
+    return this.showAnimation;
+  }
+  
+  public void setShowAnimation(Boolean value) {
+    this.showAnimation = value;
+  }
+  
+  public boolean isUseTimings() {
+    if (this.useTimings == null)
+      return true; 
+    return this.useTimings;
+  }
+  
+  public void setUseTimings(Boolean value) {
+    this.useTimings = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSideDirectionTransition.java

@@ -0,0 +1,23 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SideDirectionTransition")
+public class CTSideDirectionTransition {
+  @XmlAttribute(name = "dir")
+  protected STTransitionSideDirectionType dir;
+  
+  public STTransitionSideDirectionType getDir() {
+    if (this.dir == null)
+      return STTransitionSideDirectionType.L; 
+    return this.dir;
+  }
+  
+  public void setDir(STTransitionSideDirectionType value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideMasterTextStyles.java

@@ -0,0 +1,50 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTTextListStyle;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideMasterTextStyles", propOrder = {"titleStyle", "bodyStyle", "otherStyle", "extLst"})
+public class CTSlideMasterTextStyles {
+  protected CTTextListStyle titleStyle;
+  
+  protected CTTextListStyle bodyStyle;
+  
+  protected CTTextListStyle otherStyle;
+  
+  protected CTExtensionList extLst;
+  
+  public CTTextListStyle getTitleStyle() {
+    return this.titleStyle;
+  }
+  
+  public void setTitleStyle(CTTextListStyle value) {
+    this.titleStyle = value;
+  }
+  
+  public CTTextListStyle getBodyStyle() {
+    return this.bodyStyle;
+  }
+  
+  public void setBodyStyle(CTTextListStyle value) {
+    this.bodyStyle = value;
+  }
+  
+  public CTTextListStyle getOtherStyle() {
+    return this.otherStyle;
+  }
+  
+  public void setOtherStyle(CTTextListStyle value) {
+    this.otherStyle = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideRelationshipList.java

@@ -0,0 +1,19 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideRelationshipList", propOrder = {"sld"})
+public class CTSlideRelationshipList {
+  protected List<CTSlideRelationshipListEntry> sld;
+  
+  public List<CTSlideRelationshipListEntry> getSld() {
+    if (this.sld == null)
+      this.sld = new ArrayList<CTSlideRelationshipListEntry>(); 
+    return this.sld;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideRelationshipListEntry.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideRelationshipListEntry")
+public class CTSlideRelationshipListEntry {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideSorterViewProperties.java

@@ -0,0 +1,45 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideSorterViewProperties", propOrder = {"cViewPr", "extLst"})
+public class CTSlideSorterViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonViewProperties cViewPr;
+  
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "showFormatting")
+  protected Boolean showFormatting;
+  
+  public CTCommonViewProperties getCViewPr() {
+    return this.cViewPr;
+  }
+  
+  public void setCViewPr(CTCommonViewProperties value) {
+    this.cViewPr = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public boolean isShowFormatting() {
+    if (this.showFormatting == null)
+      return true; 
+    return this.showFormatting;
+  }
+  
+  public void setShowFormatting(Boolean value) {
+    this.showFormatting = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideSyncProperties.java

@@ -0,0 +1,57 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideSyncProperties", propOrder = {"extLst"})
+public class CTSlideSyncProperties {
+  protected CTExtensionList extLst;
+  
+  @XmlAttribute(name = "serverSldId", required = true)
+  protected String serverSldId;
+  
+  @XmlAttribute(name = "serverSldModifiedTime", required = true)
+  @XmlSchemaType(name = "dateTime")
+  protected XMLGregorianCalendar serverSldModifiedTime;
+  
+  @XmlAttribute(name = "clientInsertedTime", required = true)
+  @XmlSchemaType(name = "dateTime")
+  protected XMLGregorianCalendar clientInsertedTime;
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+  
+  public String getServerSldId() {
+    return this.serverSldId;
+  }
+  
+  public void setServerSldId(String value) {
+    this.serverSldId = value;
+  }
+  
+  public XMLGregorianCalendar getServerSldModifiedTime() {
+    return this.serverSldModifiedTime;
+  }
+  
+  public void setServerSldModifiedTime(XMLGregorianCalendar value) {
+    this.serverSldModifiedTime = value;
+  }
+  
+  public XMLGregorianCalendar getClientInsertedTime() {
+    return this.clientInsertedTime;
+  }
+  
+  public void setClientInsertedTime(XMLGregorianCalendar value) {
+    this.clientInsertedTime = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideTiming.java

@@ -0,0 +1,39 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideTiming", propOrder = {"tnLst", "bldLst", "extLst"})
+public class CTSlideTiming {
+  protected CTTimeNodeList tnLst;
+  
+  protected CTBuildList bldLst;
+  
+  protected CTExtensionListModify extLst;
+  
+  public CTTimeNodeList getTnLst() {
+    return this.tnLst;
+  }
+  
+  public void setTnLst(CTTimeNodeList value) {
+    this.tnLst = value;
+  }
+  
+  public CTBuildList getBldLst() {
+    return this.bldLst;
+  }
+  
+  public void setBldLst(CTBuildList value) {
+    this.bldLst = value;
+  }
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideTransition.java

@@ -0,0 +1,279 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideTransition", propOrder = {"blinds", "checker", "circle", "dissolve", "comb", "cover", "cut", "diamond", "fade", "newsflash", "plus", "pull", "push", "random", "randomBar", "split", "strips", "wedge", "wheel", "wipe", "zoom", "sndAc", "extLst"})
+public class CTSlideTransition {
+  protected CTOrientationTransition blinds;
+  
+  protected CTOrientationTransition checker;
+  
+  protected CTEmpty circle;
+  
+  protected CTEmpty dissolve;
+  
+  protected CTOrientationTransition comb;
+  
+  protected CTEightDirectionTransition cover;
+  
+  protected CTOptionalBlackTransition cut;
+  
+  protected CTEmpty diamond;
+  
+  protected CTOptionalBlackTransition fade;
+  
+  protected CTEmpty newsflash;
+  
+  protected CTEmpty plus;
+  
+  protected CTEightDirectionTransition pull;
+  
+  protected CTSideDirectionTransition push;
+  
+  protected CTEmpty random;
+  
+  protected CTOrientationTransition randomBar;
+  
+  protected CTSplitTransition split;
+  
+  protected CTCornerDirectionTransition strips;
+  
+  protected CTEmpty wedge;
+  
+  protected CTWheelTransition wheel;
+  
+  protected CTSideDirectionTransition wipe;
+  
+  protected CTInOutTransition zoom;
+  
+  protected CTTransitionSoundAction sndAc;
+  
+  protected CTExtensionListModify extLst;
+  
+  @XmlAttribute(name = "spd")
+  protected STTransitionSpeed spd;
+  
+  @XmlAttribute(name = "advClick")
+  protected Boolean advClick;
+  
+  @XmlAttribute(name = "advTm")
+  @XmlSchemaType(name = "unsignedInt")
+  protected Long advTm;
+  
+  public CTOrientationTransition getBlinds() {
+    return this.blinds;
+  }
+  
+  public void setBlinds(CTOrientationTransition value) {
+    this.blinds = value;
+  }
+  
+  public CTOrientationTransition getChecker() {
+    return this.checker;
+  }
+  
+  public void setChecker(CTOrientationTransition value) {
+    this.checker = value;
+  }
+  
+  public CTEmpty getCircle() {
+    return this.circle;
+  }
+  
+  public void setCircle(CTEmpty value) {
+    this.circle = value;
+  }
+  
+  public CTEmpty getDissolve() {
+    return this.dissolve;
+  }
+  
+  public void setDissolve(CTEmpty value) {
+    this.dissolve = value;
+  }
+  
+  public CTOrientationTransition getComb() {
+    return this.comb;
+  }
+  
+  public void setComb(CTOrientationTransition value) {
+    this.comb = value;
+  }
+  
+  public CTEightDirectionTransition getCover() {
+    return this.cover;
+  }
+  
+  public void setCover(CTEightDirectionTransition value) {
+    this.cover = value;
+  }
+  
+  public CTOptionalBlackTransition getCut() {
+    return this.cut;
+  }
+  
+  public void setCut(CTOptionalBlackTransition value) {
+    this.cut = value;
+  }
+  
+  public CTEmpty getDiamond() {
+    return this.diamond;
+  }
+  
+  public void setDiamond(CTEmpty value) {
+    this.diamond = value;
+  }
+  
+  public CTOptionalBlackTransition getFade() {
+    return this.fade;
+  }
+  
+  public void setFade(CTOptionalBlackTransition value) {
+    this.fade = value;
+  }
+  
+  public CTEmpty getNewsflash() {
+    return this.newsflash;
+  }
+  
+  public void setNewsflash(CTEmpty value) {
+    this.newsflash = value;
+  }
+  
+  public CTEmpty getPlus() {
+    return this.plus;
+  }
+  
+  public void setPlus(CTEmpty value) {
+    this.plus = value;
+  }
+  
+  public CTEightDirectionTransition getPull() {
+    return this.pull;
+  }
+  
+  public void setPull(CTEightDirectionTransition value) {
+    this.pull = value;
+  }
+  
+  public CTSideDirectionTransition getPush() {
+    return this.push;
+  }
+  
+  public void setPush(CTSideDirectionTransition value) {
+    this.push = value;
+  }
+  
+  public CTEmpty getRandom() {
+    return this.random;
+  }
+  
+  public void setRandom(CTEmpty value) {
+    this.random = value;
+  }
+  
+  public CTOrientationTransition getRandomBar() {
+    return this.randomBar;
+  }
+  
+  public void setRandomBar(CTOrientationTransition value) {
+    this.randomBar = value;
+  }
+  
+  public CTSplitTransition getSplit() {
+    return this.split;
+  }
+  
+  public void setSplit(CTSplitTransition value) {
+    this.split = value;
+  }
+  
+  public CTCornerDirectionTransition getStrips() {
+    return this.strips;
+  }
+  
+  public void setStrips(CTCornerDirectionTransition value) {
+    this.strips = value;
+  }
+  
+  public CTEmpty getWedge() {
+    return this.wedge;
+  }
+  
+  public void setWedge(CTEmpty value) {
+    this.wedge = value;
+  }
+  
+  public CTWheelTransition getWheel() {
+    return this.wheel;
+  }
+  
+  public void setWheel(CTWheelTransition value) {
+    this.wheel = value;
+  }
+  
+  public CTSideDirectionTransition getWipe() {
+    return this.wipe;
+  }
+  
+  public void setWipe(CTSideDirectionTransition value) {
+    this.wipe = value;
+  }
+  
+  public CTInOutTransition getZoom() {
+    return this.zoom;
+  }
+  
+  public void setZoom(CTInOutTransition value) {
+    this.zoom = value;
+  }
+  
+  public CTTransitionSoundAction getSndAc() {
+    return this.sndAc;
+  }
+  
+  public void setSndAc(CTTransitionSoundAction value) {
+    this.sndAc = value;
+  }
+  
+  public CTExtensionListModify getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionListModify value) {
+    this.extLst = value;
+  }
+  
+  public STTransitionSpeed getSpd() {
+    if (this.spd == null)
+      return STTransitionSpeed.FAST; 
+    return this.spd;
+  }
+  
+  public void setSpd(STTransitionSpeed value) {
+    this.spd = value;
+  }
+  
+  public boolean isAdvClick() {
+    if (this.advClick == null)
+      return true; 
+    return this.advClick;
+  }
+  
+  public void setAdvClick(Boolean value) {
+    this.advClick = value;
+  }
+  
+  public Long getAdvTm() {
+    return this.advTm;
+  }
+  
+  public void setAdvTm(Long value) {
+    this.advTm = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSlideViewProperties.java

@@ -0,0 +1,31 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SlideViewProperties", propOrder = {"cSldViewPr", "extLst"})
+public class CTSlideViewProperties {
+  @XmlElement(required = true)
+  protected CTCommonSlideViewProperties cSldViewPr;
+  
+  protected CTExtensionList extLst;
+  
+  public CTCommonSlideViewProperties getCSldViewPr() {
+    return this.cSldViewPr;
+  }
+  
+  public void setCSldViewPr(CTCommonSlideViewProperties value) {
+    this.cSldViewPr = value;
+  }
+  
+  public CTExtensionList getExtLst() {
+    return this.extLst;
+  }
+  
+  public void setExtLst(CTExtensionList value) {
+    this.extLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSmartTags.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SmartTags")
+public class CTSmartTags {
+  @XmlAttribute(name = "id", namespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships", required = true)
+  protected String id;
+  
+  public String getId() {
+    return this.id;
+  }
+  
+  public void setId(String value) {
+    this.id = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTSplitTransition.java

@@ -0,0 +1,36 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_SplitTransition")
+public class CTSplitTransition {
+  @XmlAttribute(name = "orient")
+  protected STDirection orient;
+  
+  @XmlAttribute(name = "dir")
+  protected STTransitionInOutDirectionType dir;
+  
+  public STDirection getOrient() {
+    if (this.orient == null)
+      return STDirection.HORZ; 
+    return this.orient;
+  }
+  
+  public void setOrient(STDirection value) {
+    this.orient = value;
+  }
+  
+  public STTransitionInOutDirectionType getDir() {
+    if (this.dir == null)
+      return STTransitionInOutDirectionType.OUT; 
+    return this.dir;
+  }
+  
+  public void setDir(STTransitionInOutDirectionType value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTStringTag.java

@@ -0,0 +1,32 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_StringTag")
+public class CTStringTag {
+  @XmlAttribute(name = "name")
+  protected String name;
+  
+  @XmlAttribute(name = "val")
+  protected String val;
+  
+  public String getName() {
+    return this.name;
+  }
+  
+  public void setName(String value) {
+    this.name = value;
+  }
+  
+  public String getVal() {
+    return this.val;
+  }
+  
+  public void setVal(String value) {
+    this.val = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimVariant.java

@@ -0,0 +1,60 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTColor;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimVariant", propOrder = {"boolVal", "intVal", "fltVal", "strVal", "clrVal"})
+public class CTTLAnimVariant {
+  protected CTTLAnimVariantBooleanVal boolVal;
+  
+  protected CTTLAnimVariantIntegerVal intVal;
+  
+  protected CTTLAnimVariantFloatVal fltVal;
+  
+  protected CTTLAnimVariantStringVal strVal;
+  
+  protected CTColor clrVal;
+  
+  public CTTLAnimVariantBooleanVal getBoolVal() {
+    return this.boolVal;
+  }
+  
+  public void setBoolVal(CTTLAnimVariantBooleanVal value) {
+    this.boolVal = value;
+  }
+  
+  public CTTLAnimVariantIntegerVal getIntVal() {
+    return this.intVal;
+  }
+  
+  public void setIntVal(CTTLAnimVariantIntegerVal value) {
+    this.intVal = value;
+  }
+  
+  public CTTLAnimVariantFloatVal getFltVal() {
+    return this.fltVal;
+  }
+  
+  public void setFltVal(CTTLAnimVariantFloatVal value) {
+    this.fltVal = value;
+  }
+  
+  public CTTLAnimVariantStringVal getStrVal() {
+    return this.strVal;
+  }
+  
+  public void setStrVal(CTTLAnimVariantStringVal value) {
+    this.strVal = value;
+  }
+  
+  public CTColor getClrVal() {
+    return this.clrVal;
+  }
+  
+  public void setClrVal(CTColor value) {
+    this.clrVal = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimVariantBooleanVal.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimVariantBooleanVal")
+public class CTTLAnimVariantBooleanVal {
+  @XmlAttribute(name = "val", required = true)
+  protected boolean val;
+  
+  public boolean isVal() {
+    return this.val;
+  }
+  
+  public void setVal(boolean value) {
+    this.val = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimVariantFloatVal.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimVariantFloatVal")
+public class CTTLAnimVariantFloatVal {
+  @XmlAttribute(name = "val", required = true)
+  protected float val;
+  
+  public float getVal() {
+    return this.val;
+  }
+  
+  public void setVal(float value) {
+    this.val = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimVariantIntegerVal.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimVariantIntegerVal")
+public class CTTLAnimVariantIntegerVal {
+  @XmlAttribute(name = "val", required = true)
+  protected int val;
+  
+  public int getVal() {
+    return this.val;
+  }
+  
+  public void setVal(int value) {
+    this.val = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimVariantStringVal.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimVariantStringVal")
+public class CTTLAnimVariantStringVal {
+  @XmlAttribute(name = "val", required = true)
+  protected String val;
+  
+  public String getVal() {
+    return this.val;
+  }
+  
+  public void setVal(String value) {
+    this.val = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateBehavior.java

@@ -0,0 +1,87 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateBehavior", propOrder = {"cBhvr", "tavLst"})
+public class CTTLAnimateBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  protected CTTLTimeAnimateValueList tavLst;
+  
+  @XmlAttribute(name = "by")
+  protected String by;
+  
+  @XmlAttribute(name = "from")
+  protected String from;
+  
+  @XmlAttribute(name = "to")
+  protected String to;
+  
+  @XmlAttribute(name = "calcmode")
+  protected STTLAnimateBehaviorCalcMode calcmode;
+  
+  @XmlAttribute(name = "valueType")
+  protected STTLAnimateBehaviorValueType valueType;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public CTTLTimeAnimateValueList getTavLst() {
+    return this.tavLst;
+  }
+  
+  public void setTavLst(CTTLTimeAnimateValueList value) {
+    this.tavLst = value;
+  }
+  
+  public String getBy() {
+    return this.by;
+  }
+  
+  public void setBy(String value) {
+    this.by = value;
+  }
+  
+  public String getFrom() {
+    return this.from;
+  }
+  
+  public void setFrom(String value) {
+    this.from = value;
+  }
+  
+  public String getTo() {
+    return this.to;
+  }
+  
+  public void setTo(String value) {
+    this.to = value;
+  }
+  
+  public STTLAnimateBehaviorCalcMode getCalcmode() {
+    return this.calcmode;
+  }
+  
+  public void setCalcmode(STTLAnimateBehaviorCalcMode value) {
+    this.calcmode = value;
+  }
+  
+  public STTLAnimateBehaviorValueType getValueType() {
+    return this.valueType;
+  }
+  
+  public void setValueType(STTLAnimateBehaviorValueType value) {
+    this.valueType = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateColorBehavior.java

@@ -0,0 +1,75 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+import org.docx4j.dml.CTColor;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateColorBehavior", propOrder = {"cBhvr", "by", "from", "to"})
+public class CTTLAnimateColorBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  protected CTTLByAnimateColorTransform by;
+  
+  protected CTColor from;
+  
+  protected CTColor to;
+  
+  @XmlAttribute(name = "clrSpc")
+  protected STTLAnimateColorSpace clrSpc;
+  
+  @XmlAttribute(name = "dir")
+  protected STTLAnimateColorDirection dir;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public CTTLByAnimateColorTransform getBy() {
+    return this.by;
+  }
+  
+  public void setBy(CTTLByAnimateColorTransform value) {
+    this.by = value;
+  }
+  
+  public CTColor getFrom() {
+    return this.from;
+  }
+  
+  public void setFrom(CTColor value) {
+    this.from = value;
+  }
+  
+  public CTColor getTo() {
+    return this.to;
+  }
+  
+  public void setTo(CTColor value) {
+    this.to = value;
+  }
+  
+  public STTLAnimateColorSpace getClrSpc() {
+    return this.clrSpc;
+  }
+  
+  public void setClrSpc(STTLAnimateColorSpace value) {
+    this.clrSpc = value;
+  }
+  
+  public STTLAnimateColorDirection getDir() {
+    return this.dir;
+  }
+  
+  public void setDir(STTLAnimateColorDirection value) {
+    this.dir = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateEffectBehavior.java

@@ -0,0 +1,65 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateEffectBehavior", propOrder = {"cBhvr", "progress"})
+public class CTTLAnimateEffectBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  protected CTTLAnimVariant progress;
+  
+  @XmlAttribute(name = "transition")
+  protected STTLAnimateEffectTransition transition;
+  
+  @XmlAttribute(name = "filter")
+  protected String filter;
+  
+  @XmlAttribute(name = "prLst")
+  protected String prLst;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public CTTLAnimVariant getProgress() {
+    return this.progress;
+  }
+  
+  public void setProgress(CTTLAnimVariant value) {
+    this.progress = value;
+  }
+  
+  public STTLAnimateEffectTransition getTransition() {
+    return this.transition;
+  }
+  
+  public void setTransition(STTLAnimateEffectTransition value) {
+    this.transition = value;
+  }
+  
+  public String getFilter() {
+    return this.filter;
+  }
+  
+  public void setFilter(String value) {
+    this.filter = value;
+  }
+  
+  public String getPrLst() {
+    return this.prLst;
+  }
+  
+  public void setPrLst(String value) {
+    this.prLst = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateMotionBehavior.java

@@ -0,0 +1,117 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateMotionBehavior", propOrder = {"cBhvr", "by", "from", "to", "rCtr"})
+public class CTTLAnimateMotionBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  protected CTTLPoint by;
+  
+  protected CTTLPoint from;
+  
+  protected CTTLPoint to;
+  
+  protected CTTLPoint rCtr;
+  
+  @XmlAttribute(name = "origin")
+  protected STTLAnimateMotionBehaviorOrigin origin;
+  
+  @XmlAttribute(name = "path")
+  protected String path;
+  
+  @XmlAttribute(name = "pathEditMode")
+  protected STTLAnimateMotionPathEditMode pathEditMode;
+  
+  @XmlAttribute(name = "rAng")
+  protected Integer rAng;
+  
+  @XmlAttribute(name = "ptsTypes")
+  protected String ptsTypes;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public CTTLPoint getBy() {
+    return this.by;
+  }
+  
+  public void setBy(CTTLPoint value) {
+    this.by = value;
+  }
+  
+  public CTTLPoint getFrom() {
+    return this.from;
+  }
+  
+  public void setFrom(CTTLPoint value) {
+    this.from = value;
+  }
+  
+  public CTTLPoint getTo() {
+    return this.to;
+  }
+  
+  public void setTo(CTTLPoint value) {
+    this.to = value;
+  }
+  
+  public CTTLPoint getRCtr() {
+    return this.rCtr;
+  }
+  
+  public void setRCtr(CTTLPoint value) {
+    this.rCtr = value;
+  }
+  
+  public STTLAnimateMotionBehaviorOrigin getOrigin() {
+    return this.origin;
+  }
+  
+  public void setOrigin(STTLAnimateMotionBehaviorOrigin value) {
+    this.origin = value;
+  }
+  
+  public String getPath() {
+    return this.path;
+  }
+  
+  public void setPath(String value) {
+    this.path = value;
+  }
+  
+  public STTLAnimateMotionPathEditMode getPathEditMode() {
+    return this.pathEditMode;
+  }
+  
+  public void setPathEditMode(STTLAnimateMotionPathEditMode value) {
+    this.pathEditMode = value;
+  }
+  
+  public Integer getRAng() {
+    return this.rAng;
+  }
+  
+  public void setRAng(Integer value) {
+    this.rAng = value;
+  }
+  
+  public String getPtsTypes() {
+    return this.ptsTypes;
+  }
+  
+  public void setPtsTypes(String value) {
+    this.ptsTypes = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateRotationBehavior.java

@@ -0,0 +1,55 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateRotationBehavior", propOrder = {"cBhvr"})
+public class CTTLAnimateRotationBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  @XmlAttribute(name = "by")
+  protected Integer by;
+  
+  @XmlAttribute(name = "from")
+  protected Integer from;
+  
+  @XmlAttribute(name = "to")
+  protected Integer to;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public Integer getBy() {
+    return this.by;
+  }
+  
+  public void setBy(Integer value) {
+    this.by = value;
+  }
+  
+  public Integer getFrom() {
+    return this.from;
+  }
+  
+  public void setFrom(Integer value) {
+    this.from = value;
+  }
+  
+  public Integer getTo() {
+    return this.to;
+  }
+  
+  public void setTo(Integer value) {
+    this.to = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLAnimateScaleBehavior.java

@@ -0,0 +1,63 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLAnimateScaleBehavior", propOrder = {"cBhvr", "by", "from", "to"})
+public class CTTLAnimateScaleBehavior {
+  @XmlElement(required = true)
+  protected CTTLCommonBehaviorData cBhvr;
+  
+  protected CTTLPoint by;
+  
+  protected CTTLPoint from;
+  
+  protected CTTLPoint to;
+  
+  @XmlAttribute(name = "zoomContents")
+  protected Boolean zoomContents;
+  
+  public CTTLCommonBehaviorData getCBhvr() {
+    return this.cBhvr;
+  }
+  
+  public void setCBhvr(CTTLCommonBehaviorData value) {
+    this.cBhvr = value;
+  }
+  
+  public CTTLPoint getBy() {
+    return this.by;
+  }
+  
+  public void setBy(CTTLPoint value) {
+    this.by = value;
+  }
+  
+  public CTTLPoint getFrom() {
+    return this.from;
+  }
+  
+  public void setFrom(CTTLPoint value) {
+    this.from = value;
+  }
+  
+  public CTTLPoint getTo() {
+    return this.to;
+  }
+  
+  public void setTo(CTTLPoint value) {
+    this.to = value;
+  }
+  
+  public Boolean isZoomContents() {
+    return this.zoomContents;
+  }
+  
+  public void setZoomContents(Boolean value) {
+    this.zoomContents = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLBehaviorAttributeNameList.java

@@ -0,0 +1,21 @@
+package org.pptx4j.pml;
+
+import java.util.ArrayList;
+import java.util.List;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLBehaviorAttributeNameList", propOrder = {"attrName"})
+public class CTTLBehaviorAttributeNameList {
+  @XmlElement(required = true)
+  protected List<String> attrName;
+  
+  public List<String> getAttrName() {
+    if (this.attrName == null)
+      this.attrName = new ArrayList<String>(); 
+    return this.attrName;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLBuildDiagram.java

@@ -0,0 +1,63 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLBuildDiagram")
+public class CTTLBuildDiagram {
+  @XmlAttribute(name = "bld")
+  protected STTLDiagramBuildType bld;
+  
+  @XmlAttribute(name = "spid", required = true)
+  @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
+  protected String spid;
+  
+  @XmlAttribute(name = "grpId", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long grpId;
+  
+  @XmlAttribute(name = "uiExpand")
+  protected Boolean uiExpand;
+  
+  public STTLDiagramBuildType getBld() {
+    if (this.bld == null)
+      return STTLDiagramBuildType.WHOLE; 
+    return this.bld;
+  }
+  
+  public void setBld(STTLDiagramBuildType value) {
+    this.bld = value;
+  }
+  
+  public String getSpid() {
+    return this.spid;
+  }
+  
+  public void setSpid(String value) {
+    this.spid = value;
+  }
+  
+  public long getGrpId() {
+    return this.grpId;
+  }
+  
+  public void setGrpId(long value) {
+    this.grpId = value;
+  }
+  
+  public boolean isUiExpand() {
+    if (this.uiExpand == null)
+      return false; 
+    return this.uiExpand;
+  }
+  
+  public void setUiExpand(Boolean value) {
+    this.uiExpand = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLBuildParagraph.java

@@ -0,0 +1,139 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlSchemaType;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
+import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLBuildParagraph", propOrder = {"tmplLst"})
+public class CTTLBuildParagraph {
+  protected CTTLTemplateList tmplLst;
+  
+  @XmlAttribute(name = "build")
+  protected STTLParaBuildType build;
+  
+  @XmlAttribute(name = "bldLvl")
+  @XmlSchemaType(name = "unsignedInt")
+  protected Long bldLvl;
+  
+  @XmlAttribute(name = "animBg")
+  protected Boolean animBg;
+  
+  @XmlAttribute(name = "autoUpdateAnimBg")
+  protected Boolean autoUpdateAnimBg;
+  
+  @XmlAttribute(name = "rev")
+  protected Boolean rev;
+  
+  @XmlAttribute(name = "advAuto")
+  protected String advAuto;
+  
+  @XmlAttribute(name = "spid", required = true)
+  @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
+  protected String spid;
+  
+  @XmlAttribute(name = "grpId", required = true)
+  @XmlSchemaType(name = "unsignedInt")
+  protected long grpId;
+  
+  @XmlAttribute(name = "uiExpand")
+  protected Boolean uiExpand;
+  
+  public CTTLTemplateList getTmplLst() {
+    return this.tmplLst;
+  }
+  
+  public void setTmplLst(CTTLTemplateList value) {
+    this.tmplLst = value;
+  }
+  
+  public STTLParaBuildType getBuild() {
+    if (this.build == null)
+      return STTLParaBuildType.WHOLE; 
+    return this.build;
+  }
+  
+  public void setBuild(STTLParaBuildType value) {
+    this.build = value;
+  }
+  
+  public long getBldLvl() {
+    if (this.bldLvl == null)
+      return 1L; 
+    return this.bldLvl;
+  }
+  
+  public void setBldLvl(Long value) {
+    this.bldLvl = value;
+  }
+  
+  public boolean isAnimBg() {
+    if (this.animBg == null)
+      return false; 
+    return this.animBg;
+  }
+  
+  public void setAnimBg(Boolean value) {
+    this.animBg = value;
+  }
+  
+  public boolean isAutoUpdateAnimBg() {
+    if (this.autoUpdateAnimBg == null)
+      return true; 
+    return this.autoUpdateAnimBg;
+  }
+  
+  public void setAutoUpdateAnimBg(Boolean value) {
+    this.autoUpdateAnimBg = value;
+  }
+  
+  public boolean isRev() {
+    if (this.rev == null)
+      return false; 
+    return this.rev;
+  }
+  
+  public void setRev(Boolean value) {
+    this.rev = value;
+  }
+  
+  public String getAdvAuto() {
+    if (this.advAuto == null)
+      return "indefinite"; 
+    return this.advAuto;
+  }
+  
+  public void setAdvAuto(String value) {
+    this.advAuto = value;
+  }
+  
+  public String getSpid() {
+    return this.spid;
+  }
+  
+  public void setSpid(String value) {
+    this.spid = value;
+  }
+  
+  public long getGrpId() {
+    return this.grpId;
+  }
+  
+  public void setGrpId(long value) {
+    this.grpId = value;
+  }
+  
+  public boolean isUiExpand() {
+    if (this.uiExpand == null)
+      return false; 
+    return this.uiExpand;
+  }
+  
+  public void setUiExpand(Boolean value) {
+    this.uiExpand = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLByAnimateColorTransform.java

@@ -0,0 +1,29 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLByAnimateColorTransform", propOrder = {"rgb", "hsl"})
+public class CTTLByAnimateColorTransform {
+  protected CTTLByRgbColorTransform rgb;
+  
+  protected CTTLByHslColorTransform hsl;
+  
+  public CTTLByRgbColorTransform getRgb() {
+    return this.rgb;
+  }
+  
+  public void setRgb(CTTLByRgbColorTransform value) {
+    this.rgb = value;
+  }
+  
+  public CTTLByHslColorTransform getHsl() {
+    return this.hsl;
+  }
+  
+  public void setHsl(CTTLByHslColorTransform value) {
+    this.hsl = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLByHslColorTransform.java

@@ -0,0 +1,43 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLByHslColorTransform")
+public class CTTLByHslColorTransform {
+  @XmlAttribute(name = "h", required = true)
+  protected int h;
+  
+  @XmlAttribute(name = "s", required = true)
+  protected int s;
+  
+  @XmlAttribute(name = "l", required = true)
+  protected int l;
+  
+  public int getH() {
+    return this.h;
+  }
+  
+  public void setH(int value) {
+    this.h = value;
+  }
+  
+  public int getS() {
+    return this.s;
+  }
+  
+  public void setS(int value) {
+    this.s = value;
+  }
+  
+  public int getL() {
+    return this.l;
+  }
+  
+  public void setL(int value) {
+    this.l = value;
+  }
+}

rus/WEB-INF/lib/docx4j-3.2.1_src/org/pptx4j/pml/CTTLByRgbColorTransform.java

@@ -0,0 +1,43 @@
+package org.pptx4j.pml;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlType;
+
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "CT_TLByRgbColorTransform")
+public class CTTLByRgbColorTransform {
+  @XmlAttribute(name = "r", required = true)
+  protected int r;
+  
+  @XmlAttribute(name = "g", required = true)
+  protected int g;
+  
+  @XmlAttribute(name = "b", required = true)
+  protected int b;
+  
+  public int getR() {
+    return this.r;
+  }
+  
+  public void setR(int value) {
+    this.r = value;
+  }
+  
+  public int getG() {
+    return this.g;
+  }
+  
+  public void setG(int value) {
+    this.g = value;
+  }
+  
+  public int getB() {
+    return this.b;
+  }
+  
+  public void setB(int value) {
+    this.b = value;
+  }
+}