All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.openxmlformats.schemas.wordprocessingml.x2006.main.impl.CTRPrImpl Maven / Gradle / Ivy

Go to download

XmlBeans generated from the Ecma supplied xsds: http://www.ecma-international.org/publications/files/ECMA-ST/Office%20Open%20XML%20Part%204%20(DOCX).zip

There is a newer version: 1.4
Show newest version
/*
 * XML Type:  CT_RPr
 * Namespace: http://schemas.openxmlformats.org/wordprocessingml/2006/main
 * Java type: org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr
 *
 * Automatically generated - do not modify.
 */
package org.openxmlformats.schemas.wordprocessingml.x2006.main.impl;
/**
 * An XML CT_RPr(@http://schemas.openxmlformats.org/wordprocessingml/2006/main).
 *
 * This is a complex type.
 */
public class CTRPrImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr
{
    
    public CTRPrImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName RSTYLE$0 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "rStyle");
    private static final javax.xml.namespace.QName RFONTS$2 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "rFonts");
    private static final javax.xml.namespace.QName B$4 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "b");
    private static final javax.xml.namespace.QName BCS$6 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "bCs");
    private static final javax.xml.namespace.QName I$8 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "i");
    private static final javax.xml.namespace.QName ICS$10 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "iCs");
    private static final javax.xml.namespace.QName CAPS$12 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "caps");
    private static final javax.xml.namespace.QName SMALLCAPS$14 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "smallCaps");
    private static final javax.xml.namespace.QName STRIKE$16 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "strike");
    private static final javax.xml.namespace.QName DSTRIKE$18 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "dstrike");
    private static final javax.xml.namespace.QName OUTLINE$20 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "outline");
    private static final javax.xml.namespace.QName SHADOW$22 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "shadow");
    private static final javax.xml.namespace.QName EMBOSS$24 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "emboss");
    private static final javax.xml.namespace.QName IMPRINT$26 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "imprint");
    private static final javax.xml.namespace.QName NOPROOF$28 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "noProof");
    private static final javax.xml.namespace.QName SNAPTOGRID$30 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "snapToGrid");
    private static final javax.xml.namespace.QName VANISH$32 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "vanish");
    private static final javax.xml.namespace.QName WEBHIDDEN$34 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "webHidden");
    private static final javax.xml.namespace.QName COLOR$36 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "color");
    private static final javax.xml.namespace.QName SPACING$38 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "spacing");
    private static final javax.xml.namespace.QName W$40 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "w");
    private static final javax.xml.namespace.QName KERN$42 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "kern");
    private static final javax.xml.namespace.QName POSITION$44 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "position");
    private static final javax.xml.namespace.QName SZ$46 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "sz");
    private static final javax.xml.namespace.QName SZCS$48 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "szCs");
    private static final javax.xml.namespace.QName HIGHLIGHT$50 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "highlight");
    private static final javax.xml.namespace.QName U$52 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "u");
    private static final javax.xml.namespace.QName EFFECT$54 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "effect");
    private static final javax.xml.namespace.QName BDR$56 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "bdr");
    private static final javax.xml.namespace.QName SHD$58 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "shd");
    private static final javax.xml.namespace.QName FITTEXT$60 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "fitText");
    private static final javax.xml.namespace.QName VERTALIGN$62 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "vertAlign");
    private static final javax.xml.namespace.QName RTL$64 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "rtl");
    private static final javax.xml.namespace.QName CS$66 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "cs");
    private static final javax.xml.namespace.QName EM$68 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "em");
    private static final javax.xml.namespace.QName LANG$70 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "lang");
    private static final javax.xml.namespace.QName EASTASIANLAYOUT$72 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "eastAsianLayout");
    private static final javax.xml.namespace.QName SPECVANISH$74 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "specVanish");
    private static final javax.xml.namespace.QName OMATH$76 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "oMath");
    private static final javax.xml.namespace.QName RPRCHANGE$78 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "rPrChange");
    
    
    /**
     * Gets the "rStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString getRStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString)get_store().find_element_user(RSTYLE$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "rStyle" element
     */
    public boolean isSetRStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RSTYLE$0) != 0;
        }
    }
    
    /**
     * Sets the "rStyle" element
     */
    public void setRStyle(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString rStyle)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString)get_store().find_element_user(RSTYLE$0, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString)get_store().add_element_user(RSTYLE$0);
            }
            target.set(rStyle);
        }
    }
    
    /**
     * Appends and returns a new empty "rStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString addNewRStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString)get_store().add_element_user(RSTYLE$0);
            return target;
        }
    }
    
    /**
     * Unsets the "rStyle" element
     */
    public void unsetRStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RSTYLE$0, 0);
        }
    }
    
    /**
     * Gets the "rFonts" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts getRFonts()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts)get_store().find_element_user(RFONTS$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "rFonts" element
     */
    public boolean isSetRFonts()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RFONTS$2) != 0;
        }
    }
    
    /**
     * Sets the "rFonts" element
     */
    public void setRFonts(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts rFonts)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts)get_store().find_element_user(RFONTS$2, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts)get_store().add_element_user(RFONTS$2);
            }
            target.set(rFonts);
        }
    }
    
    /**
     * Appends and returns a new empty "rFonts" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts addNewRFonts()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts)get_store().add_element_user(RFONTS$2);
            return target;
        }
    }
    
    /**
     * Unsets the "rFonts" element
     */
    public void unsetRFonts()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RFONTS$2, 0);
        }
    }
    
    /**
     * Gets the "b" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(B$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "b" element
     */
    public boolean isSetB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(B$4) != 0;
        }
    }
    
    /**
     * Sets the "b" element
     */
    public void setB(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff b)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(B$4, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(B$4);
            }
            target.set(b);
        }
    }
    
    /**
     * Appends and returns a new empty "b" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(B$4);
            return target;
        }
    }
    
    /**
     * Unsets the "b" element
     */
    public void unsetB()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(B$4, 0);
        }
    }
    
    /**
     * Gets the "bCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getBCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(BCS$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "bCs" element
     */
    public boolean isSetBCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BCS$6) != 0;
        }
    }
    
    /**
     * Sets the "bCs" element
     */
    public void setBCs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff bCs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(BCS$6, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(BCS$6);
            }
            target.set(bCs);
        }
    }
    
    /**
     * Appends and returns a new empty "bCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewBCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(BCS$6);
            return target;
        }
    }
    
    /**
     * Unsets the "bCs" element
     */
    public void unsetBCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BCS$6, 0);
        }
    }
    
    /**
     * Gets the "i" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getI()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(I$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "i" element
     */
    public boolean isSetI()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(I$8) != 0;
        }
    }
    
    /**
     * Sets the "i" element
     */
    public void setI(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff iValue)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(I$8, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(I$8);
            }
            target.set(iValue);
        }
    }
    
    /**
     * Appends and returns a new empty "i" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewI()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(I$8);
            return target;
        }
    }
    
    /**
     * Unsets the "i" element
     */
    public void unsetI()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(I$8, 0);
        }
    }
    
    /**
     * Gets the "iCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getICs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ICS$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "iCs" element
     */
    public boolean isSetICs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ICS$10) != 0;
        }
    }
    
    /**
     * Sets the "iCs" element
     */
    public void setICs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff iCs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(ICS$10, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ICS$10);
            }
            target.set(iCs);
        }
    }
    
    /**
     * Appends and returns a new empty "iCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewICs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ICS$10);
            return target;
        }
    }
    
    /**
     * Unsets the "iCs" element
     */
    public void unsetICs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ICS$10, 0);
        }
    }
    
    /**
     * Gets the "caps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CAPS$12, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "caps" element
     */
    public boolean isSetCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CAPS$12) != 0;
        }
    }
    
    /**
     * Sets the "caps" element
     */
    public void setCaps(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff caps)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CAPS$12, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CAPS$12);
            }
            target.set(caps);
        }
    }
    
    /**
     * Appends and returns a new empty "caps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CAPS$12);
            return target;
        }
    }
    
    /**
     * Unsets the "caps" element
     */
    public void unsetCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CAPS$12, 0);
        }
    }
    
    /**
     * Gets the "smallCaps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SMALLCAPS$14, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "smallCaps" element
     */
    public boolean isSetSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SMALLCAPS$14) != 0;
        }
    }
    
    /**
     * Sets the "smallCaps" element
     */
    public void setSmallCaps(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff smallCaps)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SMALLCAPS$14, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SMALLCAPS$14);
            }
            target.set(smallCaps);
        }
    }
    
    /**
     * Appends and returns a new empty "smallCaps" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SMALLCAPS$14);
            return target;
        }
    }
    
    /**
     * Unsets the "smallCaps" element
     */
    public void unsetSmallCaps()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SMALLCAPS$14, 0);
        }
    }
    
    /**
     * Gets the "strike" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getStrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(STRIKE$16, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "strike" element
     */
    public boolean isSetStrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STRIKE$16) != 0;
        }
    }
    
    /**
     * Sets the "strike" element
     */
    public void setStrike(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff strike)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(STRIKE$16, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(STRIKE$16);
            }
            target.set(strike);
        }
    }
    
    /**
     * Appends and returns a new empty "strike" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewStrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(STRIKE$16);
            return target;
        }
    }
    
    /**
     * Unsets the "strike" element
     */
    public void unsetStrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STRIKE$16, 0);
        }
    }
    
    /**
     * Gets the "dstrike" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getDstrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DSTRIKE$18, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "dstrike" element
     */
    public boolean isSetDstrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DSTRIKE$18) != 0;
        }
    }
    
    /**
     * Sets the "dstrike" element
     */
    public void setDstrike(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff dstrike)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(DSTRIKE$18, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DSTRIKE$18);
            }
            target.set(dstrike);
        }
    }
    
    /**
     * Appends and returns a new empty "dstrike" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewDstrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(DSTRIKE$18);
            return target;
        }
    }
    
    /**
     * Unsets the "dstrike" element
     */
    public void unsetDstrike()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DSTRIKE$18, 0);
        }
    }
    
    /**
     * Gets the "outline" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getOutline()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(OUTLINE$20, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "outline" element
     */
    public boolean isSetOutline()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OUTLINE$20) != 0;
        }
    }
    
    /**
     * Sets the "outline" element
     */
    public void setOutline(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff outline)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(OUTLINE$20, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(OUTLINE$20);
            }
            target.set(outline);
        }
    }
    
    /**
     * Appends and returns a new empty "outline" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewOutline()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(OUTLINE$20);
            return target;
        }
    }
    
    /**
     * Unsets the "outline" element
     */
    public void unsetOutline()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OUTLINE$20, 0);
        }
    }
    
    /**
     * Gets the "shadow" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getShadow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHADOW$22, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "shadow" element
     */
    public boolean isSetShadow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SHADOW$22) != 0;
        }
    }
    
    /**
     * Sets the "shadow" element
     */
    public void setShadow(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff shadow)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SHADOW$22, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHADOW$22);
            }
            target.set(shadow);
        }
    }
    
    /**
     * Appends and returns a new empty "shadow" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewShadow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SHADOW$22);
            return target;
        }
    }
    
    /**
     * Unsets the "shadow" element
     */
    public void unsetShadow()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHADOW$22, 0);
        }
    }
    
    /**
     * Gets the "emboss" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getEmboss()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(EMBOSS$24, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "emboss" element
     */
    public boolean isSetEmboss()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EMBOSS$24) != 0;
        }
    }
    
    /**
     * Sets the "emboss" element
     */
    public void setEmboss(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff emboss)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(EMBOSS$24, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(EMBOSS$24);
            }
            target.set(emboss);
        }
    }
    
    /**
     * Appends and returns a new empty "emboss" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewEmboss()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(EMBOSS$24);
            return target;
        }
    }
    
    /**
     * Unsets the "emboss" element
     */
    public void unsetEmboss()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EMBOSS$24, 0);
        }
    }
    
    /**
     * Gets the "imprint" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getImprint()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(IMPRINT$26, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "imprint" element
     */
    public boolean isSetImprint()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(IMPRINT$26) != 0;
        }
    }
    
    /**
     * Sets the "imprint" element
     */
    public void setImprint(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff imprint)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(IMPRINT$26, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(IMPRINT$26);
            }
            target.set(imprint);
        }
    }
    
    /**
     * Appends and returns a new empty "imprint" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewImprint()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(IMPRINT$26);
            return target;
        }
    }
    
    /**
     * Unsets the "imprint" element
     */
    public void unsetImprint()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(IMPRINT$26, 0);
        }
    }
    
    /**
     * Gets the "noProof" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getNoProof()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOPROOF$28, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "noProof" element
     */
    public boolean isSetNoProof()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NOPROOF$28) != 0;
        }
    }
    
    /**
     * Sets the "noProof" element
     */
    public void setNoProof(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff noProof)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(NOPROOF$28, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOPROOF$28);
            }
            target.set(noProof);
        }
    }
    
    /**
     * Appends and returns a new empty "noProof" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewNoProof()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(NOPROOF$28);
            return target;
        }
    }
    
    /**
     * Unsets the "noProof" element
     */
    public void unsetNoProof()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NOPROOF$28, 0);
        }
    }
    
    /**
     * Gets the "snapToGrid" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSnapToGrid()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SNAPTOGRID$30, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "snapToGrid" element
     */
    public boolean isSetSnapToGrid()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SNAPTOGRID$30) != 0;
        }
    }
    
    /**
     * Sets the "snapToGrid" element
     */
    public void setSnapToGrid(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff snapToGrid)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SNAPTOGRID$30, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SNAPTOGRID$30);
            }
            target.set(snapToGrid);
        }
    }
    
    /**
     * Appends and returns a new empty "snapToGrid" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSnapToGrid()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SNAPTOGRID$30);
            return target;
        }
    }
    
    /**
     * Unsets the "snapToGrid" element
     */
    public void unsetSnapToGrid()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SNAPTOGRID$30, 0);
        }
    }
    
    /**
     * Gets the "vanish" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(VANISH$32, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "vanish" element
     */
    public boolean isSetVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(VANISH$32) != 0;
        }
    }
    
    /**
     * Sets the "vanish" element
     */
    public void setVanish(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff vanish)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(VANISH$32, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(VANISH$32);
            }
            target.set(vanish);
        }
    }
    
    /**
     * Appends and returns a new empty "vanish" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(VANISH$32);
            return target;
        }
    }
    
    /**
     * Unsets the "vanish" element
     */
    public void unsetVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(VANISH$32, 0);
        }
    }
    
    /**
     * Gets the "webHidden" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWebHidden()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WEBHIDDEN$34, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "webHidden" element
     */
    public boolean isSetWebHidden()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WEBHIDDEN$34) != 0;
        }
    }
    
    /**
     * Sets the "webHidden" element
     */
    public void setWebHidden(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff webHidden)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(WEBHIDDEN$34, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WEBHIDDEN$34);
            }
            target.set(webHidden);
        }
    }
    
    /**
     * Appends and returns a new empty "webHidden" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWebHidden()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WEBHIDDEN$34);
            return target;
        }
    }
    
    /**
     * Unsets the "webHidden" element
     */
    public void unsetWebHidden()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WEBHIDDEN$34, 0);
        }
    }
    
    /**
     * Gets the "color" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor getColor()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor)get_store().find_element_user(COLOR$36, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "color" element
     */
    public boolean isSetColor()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COLOR$36) != 0;
        }
    }
    
    /**
     * Sets the "color" element
     */
    public void setColor(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor color)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor)get_store().find_element_user(COLOR$36, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor)get_store().add_element_user(COLOR$36);
            }
            target.set(color);
        }
    }
    
    /**
     * Appends and returns a new empty "color" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor addNewColor()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTColor)get_store().add_element_user(COLOR$36);
            return target;
        }
    }
    
    /**
     * Unsets the "color" element
     */
    public void unsetColor()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COLOR$36, 0);
        }
    }
    
    /**
     * Gets the "spacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure getSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure)get_store().find_element_user(SPACING$38, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "spacing" element
     */
    public boolean isSetSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPACING$38) != 0;
        }
    }
    
    /**
     * Sets the "spacing" element
     */
    public void setSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure spacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure)get_store().find_element_user(SPACING$38, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure)get_store().add_element_user(SPACING$38);
            }
            target.set(spacing);
        }
    }
    
    /**
     * Appends and returns a new empty "spacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure addNewSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedTwipsMeasure)get_store().add_element_user(SPACING$38);
            return target;
        }
    }
    
    /**
     * Unsets the "spacing" element
     */
    public void unsetSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPACING$38, 0);
        }
    }
    
    /**
     * Gets the "w" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale getW()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale)get_store().find_element_user(W$40, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "w" element
     */
    public boolean isSetW()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(W$40) != 0;
        }
    }
    
    /**
     * Sets the "w" element
     */
    public void setW(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale w)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale)get_store().find_element_user(W$40, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale)get_store().add_element_user(W$40);
            }
            target.set(w);
        }
    }
    
    /**
     * Appends and returns a new empty "w" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale addNewW()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextScale)get_store().add_element_user(W$40);
            return target;
        }
    }
    
    /**
     * Unsets the "w" element
     */
    public void unsetW()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(W$40, 0);
        }
    }
    
    /**
     * Gets the "kern" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure getKern()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(KERN$42, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "kern" element
     */
    public boolean isSetKern()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KERN$42) != 0;
        }
    }
    
    /**
     * Sets the "kern" element
     */
    public void setKern(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure kern)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(KERN$42, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(KERN$42);
            }
            target.set(kern);
        }
    }
    
    /**
     * Appends and returns a new empty "kern" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure addNewKern()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(KERN$42);
            return target;
        }
    }
    
    /**
     * Unsets the "kern" element
     */
    public void unsetKern()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KERN$42, 0);
        }
    }
    
    /**
     * Gets the "position" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure getPosition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure)get_store().find_element_user(POSITION$44, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "position" element
     */
    public boolean isSetPosition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(POSITION$44) != 0;
        }
    }
    
    /**
     * Sets the "position" element
     */
    public void setPosition(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure position)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure)get_store().find_element_user(POSITION$44, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure)get_store().add_element_user(POSITION$44);
            }
            target.set(position);
        }
    }
    
    /**
     * Appends and returns a new empty "position" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure addNewPosition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSignedHpsMeasure)get_store().add_element_user(POSITION$44);
            return target;
        }
    }
    
    /**
     * Unsets the "position" element
     */
    public void unsetPosition()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(POSITION$44, 0);
        }
    }
    
    /**
     * Gets the "sz" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure getSz()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(SZ$46, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "sz" element
     */
    public boolean isSetSz()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SZ$46) != 0;
        }
    }
    
    /**
     * Sets the "sz" element
     */
    public void setSz(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure sz)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(SZ$46, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(SZ$46);
            }
            target.set(sz);
        }
    }
    
    /**
     * Appends and returns a new empty "sz" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure addNewSz()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(SZ$46);
            return target;
        }
    }
    
    /**
     * Unsets the "sz" element
     */
    public void unsetSz()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SZ$46, 0);
        }
    }
    
    /**
     * Gets the "szCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure getSzCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(SZCS$48, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "szCs" element
     */
    public boolean isSetSzCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SZCS$48) != 0;
        }
    }
    
    /**
     * Sets the "szCs" element
     */
    public void setSzCs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure szCs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().find_element_user(SZCS$48, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(SZCS$48);
            }
            target.set(szCs);
        }
    }
    
    /**
     * Appends and returns a new empty "szCs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure addNewSzCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHpsMeasure)get_store().add_element_user(SZCS$48);
            return target;
        }
    }
    
    /**
     * Unsets the "szCs" element
     */
    public void unsetSzCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SZCS$48, 0);
        }
    }
    
    /**
     * Gets the "highlight" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight getHighlight()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight)get_store().find_element_user(HIGHLIGHT$50, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "highlight" element
     */
    public boolean isSetHighlight()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(HIGHLIGHT$50) != 0;
        }
    }
    
    /**
     * Sets the "highlight" element
     */
    public void setHighlight(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight highlight)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight)get_store().find_element_user(HIGHLIGHT$50, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight)get_store().add_element_user(HIGHLIGHT$50);
            }
            target.set(highlight);
        }
    }
    
    /**
     * Appends and returns a new empty "highlight" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight addNewHighlight()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTHighlight)get_store().add_element_user(HIGHLIGHT$50);
            return target;
        }
    }
    
    /**
     * Unsets the "highlight" element
     */
    public void unsetHighlight()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(HIGHLIGHT$50, 0);
        }
    }
    
    /**
     * Gets the "u" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline getU()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline)get_store().find_element_user(U$52, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "u" element
     */
    public boolean isSetU()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(U$52) != 0;
        }
    }
    
    /**
     * Sets the "u" element
     */
    public void setU(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline u)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline)get_store().find_element_user(U$52, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline)get_store().add_element_user(U$52);
            }
            target.set(u);
        }
    }
    
    /**
     * Appends and returns a new empty "u" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline addNewU()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTUnderline)get_store().add_element_user(U$52);
            return target;
        }
    }
    
    /**
     * Unsets the "u" element
     */
    public void unsetU()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(U$52, 0);
        }
    }
    
    /**
     * Gets the "effect" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect getEffect()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect)get_store().find_element_user(EFFECT$54, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "effect" element
     */
    public boolean isSetEffect()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EFFECT$54) != 0;
        }
    }
    
    /**
     * Sets the "effect" element
     */
    public void setEffect(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect effect)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect)get_store().find_element_user(EFFECT$54, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect)get_store().add_element_user(EFFECT$54);
            }
            target.set(effect);
        }
    }
    
    /**
     * Appends and returns a new empty "effect" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect addNewEffect()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextEffect)get_store().add_element_user(EFFECT$54);
            return target;
        }
    }
    
    /**
     * Unsets the "effect" element
     */
    public void unsetEffect()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EFFECT$54, 0);
        }
    }
    
    /**
     * Gets the "bdr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder getBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder)get_store().find_element_user(BDR$56, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "bdr" element
     */
    public boolean isSetBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BDR$56) != 0;
        }
    }
    
    /**
     * Sets the "bdr" element
     */
    public void setBdr(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder bdr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder)get_store().find_element_user(BDR$56, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder)get_store().add_element_user(BDR$56);
            }
            target.set(bdr);
        }
    }
    
    /**
     * Appends and returns a new empty "bdr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder addNewBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTBorder)get_store().add_element_user(BDR$56);
            return target;
        }
    }
    
    /**
     * Unsets the "bdr" element
     */
    public void unsetBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BDR$56, 0);
        }
    }
    
    /**
     * Gets the "shd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd getShd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd)get_store().find_element_user(SHD$58, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "shd" element
     */
    public boolean isSetShd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SHD$58) != 0;
        }
    }
    
    /**
     * Sets the "shd" element
     */
    public void setShd(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd shd)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd)get_store().find_element_user(SHD$58, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd)get_store().add_element_user(SHD$58);
            }
            target.set(shd);
        }
    }
    
    /**
     * Appends and returns a new empty "shd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd addNewShd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd)get_store().add_element_user(SHD$58);
            return target;
        }
    }
    
    /**
     * Unsets the "shd" element
     */
    public void unsetShd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHD$58, 0);
        }
    }
    
    /**
     * Gets the "fitText" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText getFitText()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText)get_store().find_element_user(FITTEXT$60, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "fitText" element
     */
    public boolean isSetFitText()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FITTEXT$60) != 0;
        }
    }
    
    /**
     * Sets the "fitText" element
     */
    public void setFitText(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText fitText)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText)get_store().find_element_user(FITTEXT$60, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText)get_store().add_element_user(FITTEXT$60);
            }
            target.set(fitText);
        }
    }
    
    /**
     * Appends and returns a new empty "fitText" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText addNewFitText()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFitText)get_store().add_element_user(FITTEXT$60);
            return target;
        }
    }
    
    /**
     * Unsets the "fitText" element
     */
    public void unsetFitText()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FITTEXT$60, 0);
        }
    }
    
    /**
     * Gets the "vertAlign" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun getVertAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun)get_store().find_element_user(VERTALIGN$62, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "vertAlign" element
     */
    public boolean isSetVertAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(VERTALIGN$62) != 0;
        }
    }
    
    /**
     * Sets the "vertAlign" element
     */
    public void setVertAlign(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun vertAlign)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun)get_store().find_element_user(VERTALIGN$62, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun)get_store().add_element_user(VERTALIGN$62);
            }
            target.set(vertAlign);
        }
    }
    
    /**
     * Appends and returns a new empty "vertAlign" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun addNewVertAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTVerticalAlignRun)get_store().add_element_user(VERTALIGN$62);
            return target;
        }
    }
    
    /**
     * Unsets the "vertAlign" element
     */
    public void unsetVertAlign()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(VERTALIGN$62, 0);
        }
    }
    
    /**
     * Gets the "rtl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getRtl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(RTL$64, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "rtl" element
     */
    public boolean isSetRtl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RTL$64) != 0;
        }
    }
    
    /**
     * Sets the "rtl" element
     */
    public void setRtl(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff rtl)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(RTL$64, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(RTL$64);
            }
            target.set(rtl);
        }
    }
    
    /**
     * Appends and returns a new empty "rtl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewRtl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(RTL$64);
            return target;
        }
    }
    
    /**
     * Unsets the "rtl" element
     */
    public void unsetRtl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RTL$64, 0);
        }
    }
    
    /**
     * Gets the "cs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CS$66, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "cs" element
     */
    public boolean isSetCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CS$66) != 0;
        }
    }
    
    /**
     * Sets the "cs" element
     */
    public void setCs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff cs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(CS$66, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CS$66);
            }
            target.set(cs);
        }
    }
    
    /**
     * Appends and returns a new empty "cs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CS$66);
            return target;
        }
    }
    
    /**
     * Unsets the "cs" element
     */
    public void unsetCs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CS$66, 0);
        }
    }
    
    /**
     * Gets the "em" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm getEm()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm)get_store().find_element_user(EM$68, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "em" element
     */
    public boolean isSetEm()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EM$68) != 0;
        }
    }
    
    /**
     * Sets the "em" element
     */
    public void setEm(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm em)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm)get_store().find_element_user(EM$68, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm)get_store().add_element_user(EM$68);
            }
            target.set(em);
        }
    }
    
    /**
     * Appends and returns a new empty "em" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm addNewEm()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEm)get_store().add_element_user(EM$68);
            return target;
        }
    }
    
    /**
     * Unsets the "em" element
     */
    public void unsetEm()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EM$68, 0);
        }
    }
    
    /**
     * Gets the "lang" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage getLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage)get_store().find_element_user(LANG$70, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "lang" element
     */
    public boolean isSetLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LANG$70) != 0;
        }
    }
    
    /**
     * Sets the "lang" element
     */
    public void setLang(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage lang)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage)get_store().find_element_user(LANG$70, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage)get_store().add_element_user(LANG$70);
            }
            target.set(lang);
        }
    }
    
    /**
     * Appends and returns a new empty "lang" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage addNewLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLanguage)get_store().add_element_user(LANG$70);
            return target;
        }
    }
    
    /**
     * Unsets the "lang" element
     */
    public void unsetLang()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LANG$70, 0);
        }
    }
    
    /**
     * Gets the "eastAsianLayout" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout getEastAsianLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout)get_store().find_element_user(EASTASIANLAYOUT$72, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "eastAsianLayout" element
     */
    public boolean isSetEastAsianLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EASTASIANLAYOUT$72) != 0;
        }
    }
    
    /**
     * Sets the "eastAsianLayout" element
     */
    public void setEastAsianLayout(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout eastAsianLayout)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout)get_store().find_element_user(EASTASIANLAYOUT$72, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout)get_store().add_element_user(EASTASIANLAYOUT$72);
            }
            target.set(eastAsianLayout);
        }
    }
    
    /**
     * Appends and returns a new empty "eastAsianLayout" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout addNewEastAsianLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTEastAsianLayout)get_store().add_element_user(EASTASIANLAYOUT$72);
            return target;
        }
    }
    
    /**
     * Unsets the "eastAsianLayout" element
     */
    public void unsetEastAsianLayout()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EASTASIANLAYOUT$72, 0);
        }
    }
    
    /**
     * Gets the "specVanish" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSpecVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPECVANISH$74, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "specVanish" element
     */
    public boolean isSetSpecVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SPECVANISH$74) != 0;
        }
    }
    
    /**
     * Sets the "specVanish" element
     */
    public void setSpecVanish(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff specVanish)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(SPECVANISH$74, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPECVANISH$74);
            }
            target.set(specVanish);
        }
    }
    
    /**
     * Appends and returns a new empty "specVanish" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSpecVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SPECVANISH$74);
            return target;
        }
    }
    
    /**
     * Unsets the "specVanish" element
     */
    public void unsetSpecVanish()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPECVANISH$74, 0);
        }
    }
    
    /**
     * Gets the "oMath" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getOMath()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(OMATH$76, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "oMath" element
     */
    public boolean isSetOMath()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OMATH$76) != 0;
        }
    }
    
    /**
     * Sets the "oMath" element
     */
    public void setOMath(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff oMath)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().find_element_user(OMATH$76, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(OMATH$76);
            }
            target.set(oMath);
        }
    }
    
    /**
     * Appends and returns a new empty "oMath" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewOMath()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(OMATH$76);
            return target;
        }
    }
    
    /**
     * Unsets the "oMath" element
     */
    public void unsetOMath()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OMATH$76, 0);
        }
    }
    
    /**
     * Gets the "rPrChange" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange getRPrChange()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange)get_store().find_element_user(RPRCHANGE$78, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "rPrChange" element
     */
    public boolean isSetRPrChange()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RPRCHANGE$78) != 0;
        }
    }
    
    /**
     * Sets the "rPrChange" element
     */
    public void setRPrChange(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange rPrChange)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange)get_store().find_element_user(RPRCHANGE$78, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange)get_store().add_element_user(RPRCHANGE$78);
            }
            target.set(rPrChange);
        }
    }
    
    /**
     * Appends and returns a new empty "rPrChange" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange addNewRPrChange()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPrChange)get_store().add_element_user(RPRCHANGE$78);
            return target;
        }
    }
    
    /**
     * Unsets the "rPrChange" element
     */
    public void unsetRPrChange()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RPRCHANGE$78, 0);
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy