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

org.openxmlformats.schemas.wordprocessingml.x2006.main.impl.CTPPrBaseImpl 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_PPrBase
 * Namespace: http://schemas.openxmlformats.org/wordprocessingml/2006/main
 * Java type: org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPrBase
 *
 * Automatically generated - do not modify.
 */
package org.openxmlformats.schemas.wordprocessingml.x2006.main.impl;
/**
 * An XML CT_PPrBase(@http://schemas.openxmlformats.org/wordprocessingml/2006/main).
 *
 * This is a complex type.
 */
public class CTPPrBaseImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPrBase
{
    
    public CTPPrBaseImpl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName PSTYLE$0 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "pStyle");
    private static final javax.xml.namespace.QName KEEPNEXT$2 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "keepNext");
    private static final javax.xml.namespace.QName KEEPLINES$4 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "keepLines");
    private static final javax.xml.namespace.QName PAGEBREAKBEFORE$6 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "pageBreakBefore");
    private static final javax.xml.namespace.QName FRAMEPR$8 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "framePr");
    private static final javax.xml.namespace.QName WIDOWCONTROL$10 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "widowControl");
    private static final javax.xml.namespace.QName NUMPR$12 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "numPr");
    private static final javax.xml.namespace.QName SUPPRESSLINENUMBERS$14 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressLineNumbers");
    private static final javax.xml.namespace.QName PBDR$16 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "pBdr");
    private static final javax.xml.namespace.QName SHD$18 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "shd");
    private static final javax.xml.namespace.QName TABS$20 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "tabs");
    private static final javax.xml.namespace.QName SUPPRESSAUTOHYPHENS$22 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressAutoHyphens");
    private static final javax.xml.namespace.QName KINSOKU$24 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "kinsoku");
    private static final javax.xml.namespace.QName WORDWRAP$26 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "wordWrap");
    private static final javax.xml.namespace.QName OVERFLOWPUNCT$28 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "overflowPunct");
    private static final javax.xml.namespace.QName TOPLINEPUNCT$30 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "topLinePunct");
    private static final javax.xml.namespace.QName AUTOSPACEDE$32 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "autoSpaceDE");
    private static final javax.xml.namespace.QName AUTOSPACEDN$34 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "autoSpaceDN");
    private static final javax.xml.namespace.QName BIDI$36 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "bidi");
    private static final javax.xml.namespace.QName ADJUSTRIGHTIND$38 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "adjustRightInd");
    private static final javax.xml.namespace.QName SNAPTOGRID$40 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "snapToGrid");
    private static final javax.xml.namespace.QName SPACING$42 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "spacing");
    private static final javax.xml.namespace.QName IND$44 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "ind");
    private static final javax.xml.namespace.QName CONTEXTUALSPACING$46 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "contextualSpacing");
    private static final javax.xml.namespace.QName MIRRORINDENTS$48 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "mirrorIndents");
    private static final javax.xml.namespace.QName SUPPRESSOVERLAP$50 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "suppressOverlap");
    private static final javax.xml.namespace.QName JC$52 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "jc");
    private static final javax.xml.namespace.QName TEXTDIRECTION$54 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "textDirection");
    private static final javax.xml.namespace.QName TEXTALIGNMENT$56 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "textAlignment");
    private static final javax.xml.namespace.QName TEXTBOXTIGHTWRAP$58 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "textboxTightWrap");
    private static final javax.xml.namespace.QName OUTLINELVL$60 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "outlineLvl");
    private static final javax.xml.namespace.QName DIVID$62 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "divId");
    private static final javax.xml.namespace.QName CNFSTYLE$64 = 
        new javax.xml.namespace.QName("http://schemas.openxmlformats.org/wordprocessingml/2006/main", "cnfStyle");
    
    
    /**
     * Gets the "pStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString getPStyle()
    {
        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(PSTYLE$0, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "pStyle" element
     */
    public boolean isSetPStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PSTYLE$0) != 0;
        }
    }
    
    /**
     * Sets the "pStyle" element
     */
    public void setPStyle(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString pStyle)
    {
        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(PSTYLE$0, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString)get_store().add_element_user(PSTYLE$0);
            }
            target.set(pStyle);
        }
    }
    
    /**
     * Appends and returns a new empty "pStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTString addNewPStyle()
    {
        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(PSTYLE$0);
            return target;
        }
    }
    
    /**
     * Unsets the "pStyle" element
     */
    public void unsetPStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PSTYLE$0, 0);
        }
    }
    
    /**
     * Gets the "keepNext" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getKeepNext()
    {
        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(KEEPNEXT$2, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "keepNext" element
     */
    public boolean isSetKeepNext()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KEEPNEXT$2) != 0;
        }
    }
    
    /**
     * Sets the "keepNext" element
     */
    public void setKeepNext(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff keepNext)
    {
        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(KEEPNEXT$2, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(KEEPNEXT$2);
            }
            target.set(keepNext);
        }
    }
    
    /**
     * Appends and returns a new empty "keepNext" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewKeepNext()
    {
        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(KEEPNEXT$2);
            return target;
        }
    }
    
    /**
     * Unsets the "keepNext" element
     */
    public void unsetKeepNext()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KEEPNEXT$2, 0);
        }
    }
    
    /**
     * Gets the "keepLines" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getKeepLines()
    {
        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(KEEPLINES$4, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "keepLines" element
     */
    public boolean isSetKeepLines()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KEEPLINES$4) != 0;
        }
    }
    
    /**
     * Sets the "keepLines" element
     */
    public void setKeepLines(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff keepLines)
    {
        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(KEEPLINES$4, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(KEEPLINES$4);
            }
            target.set(keepLines);
        }
    }
    
    /**
     * Appends and returns a new empty "keepLines" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewKeepLines()
    {
        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(KEEPLINES$4);
            return target;
        }
    }
    
    /**
     * Unsets the "keepLines" element
     */
    public void unsetKeepLines()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KEEPLINES$4, 0);
        }
    }
    
    /**
     * Gets the "pageBreakBefore" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getPageBreakBefore()
    {
        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(PAGEBREAKBEFORE$6, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "pageBreakBefore" element
     */
    public boolean isSetPageBreakBefore()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PAGEBREAKBEFORE$6) != 0;
        }
    }
    
    /**
     * Sets the "pageBreakBefore" element
     */
    public void setPageBreakBefore(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff pageBreakBefore)
    {
        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(PAGEBREAKBEFORE$6, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(PAGEBREAKBEFORE$6);
            }
            target.set(pageBreakBefore);
        }
    }
    
    /**
     * Appends and returns a new empty "pageBreakBefore" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewPageBreakBefore()
    {
        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(PAGEBREAKBEFORE$6);
            return target;
        }
    }
    
    /**
     * Unsets the "pageBreakBefore" element
     */
    public void unsetPageBreakBefore()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PAGEBREAKBEFORE$6, 0);
        }
    }
    
    /**
     * Gets the "framePr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr getFramePr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr)get_store().find_element_user(FRAMEPR$8, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "framePr" element
     */
    public boolean isSetFramePr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FRAMEPR$8) != 0;
        }
    }
    
    /**
     * Sets the "framePr" element
     */
    public void setFramePr(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr framePr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr)get_store().find_element_user(FRAMEPR$8, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr)get_store().add_element_user(FRAMEPR$8);
            }
            target.set(framePr);
        }
    }
    
    /**
     * Appends and returns a new empty "framePr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr addNewFramePr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFramePr)get_store().add_element_user(FRAMEPR$8);
            return target;
        }
    }
    
    /**
     * Unsets the "framePr" element
     */
    public void unsetFramePr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FRAMEPR$8, 0);
        }
    }
    
    /**
     * Gets the "widowControl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWidowControl()
    {
        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(WIDOWCONTROL$10, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "widowControl" element
     */
    public boolean isSetWidowControl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WIDOWCONTROL$10) != 0;
        }
    }
    
    /**
     * Sets the "widowControl" element
     */
    public void setWidowControl(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff widowControl)
    {
        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(WIDOWCONTROL$10, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WIDOWCONTROL$10);
            }
            target.set(widowControl);
        }
    }
    
    /**
     * Appends and returns a new empty "widowControl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWidowControl()
    {
        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(WIDOWCONTROL$10);
            return target;
        }
    }
    
    /**
     * Unsets the "widowControl" element
     */
    public void unsetWidowControl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WIDOWCONTROL$10, 0);
        }
    }
    
    /**
     * Gets the "numPr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr getNumPr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr)get_store().find_element_user(NUMPR$12, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "numPr" element
     */
    public boolean isSetNumPr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(NUMPR$12) != 0;
        }
    }
    
    /**
     * Sets the "numPr" element
     */
    public void setNumPr(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr numPr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr)get_store().find_element_user(NUMPR$12, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr)get_store().add_element_user(NUMPR$12);
            }
            target.set(numPr);
        }
    }
    
    /**
     * Appends and returns a new empty "numPr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr addNewNumPr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr)get_store().add_element_user(NUMPR$12);
            return target;
        }
    }
    
    /**
     * Unsets the "numPr" element
     */
    public void unsetNumPr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(NUMPR$12, 0);
        }
    }
    
    /**
     * Gets the "suppressLineNumbers" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressLineNumbers()
    {
        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(SUPPRESSLINENUMBERS$14, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressLineNumbers" element
     */
    public boolean isSetSuppressLineNumbers()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSLINENUMBERS$14) != 0;
        }
    }
    
    /**
     * Sets the "suppressLineNumbers" element
     */
    public void setSuppressLineNumbers(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressLineNumbers)
    {
        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(SUPPRESSLINENUMBERS$14, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSLINENUMBERS$14);
            }
            target.set(suppressLineNumbers);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressLineNumbers" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressLineNumbers()
    {
        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(SUPPRESSLINENUMBERS$14);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressLineNumbers" element
     */
    public void unsetSuppressLineNumbers()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSLINENUMBERS$14, 0);
        }
    }
    
    /**
     * Gets the "pBdr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr getPBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr)get_store().find_element_user(PBDR$16, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "pBdr" element
     */
    public boolean isSetPBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PBDR$16) != 0;
        }
    }
    
    /**
     * Sets the "pBdr" element
     */
    public void setPBdr(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr pBdr)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr)get_store().find_element_user(PBDR$16, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr)get_store().add_element_user(PBDR$16);
            }
            target.set(pBdr);
        }
    }
    
    /**
     * Appends and returns a new empty "pBdr" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr addNewPBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPBdr)get_store().add_element_user(PBDR$16);
            return target;
        }
    }
    
    /**
     * Unsets the "pBdr" element
     */
    public void unsetPBdr()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PBDR$16, 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$18, 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$18) != 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$18, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTShd)get_store().add_element_user(SHD$18);
            }
            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$18);
            return target;
        }
    }
    
    /**
     * Unsets the "shd" element
     */
    public void unsetShd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHD$18, 0);
        }
    }
    
    /**
     * Gets the "tabs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs getTabs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs)get_store().find_element_user(TABS$20, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "tabs" element
     */
    public boolean isSetTabs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TABS$20) != 0;
        }
    }
    
    /**
     * Sets the "tabs" element
     */
    public void setTabs(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs tabs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs)get_store().find_element_user(TABS$20, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs)get_store().add_element_user(TABS$20);
            }
            target.set(tabs);
        }
    }
    
    /**
     * Appends and returns a new empty "tabs" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs addNewTabs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTabs)get_store().add_element_user(TABS$20);
            return target;
        }
    }
    
    /**
     * Unsets the "tabs" element
     */
    public void unsetTabs()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TABS$20, 0);
        }
    }
    
    /**
     * Gets the "suppressAutoHyphens" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressAutoHyphens()
    {
        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(SUPPRESSAUTOHYPHENS$22, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressAutoHyphens" element
     */
    public boolean isSetSuppressAutoHyphens()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSAUTOHYPHENS$22) != 0;
        }
    }
    
    /**
     * Sets the "suppressAutoHyphens" element
     */
    public void setSuppressAutoHyphens(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressAutoHyphens)
    {
        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(SUPPRESSAUTOHYPHENS$22, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSAUTOHYPHENS$22);
            }
            target.set(suppressAutoHyphens);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressAutoHyphens" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressAutoHyphens()
    {
        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(SUPPRESSAUTOHYPHENS$22);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressAutoHyphens" element
     */
    public void unsetSuppressAutoHyphens()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSAUTOHYPHENS$22, 0);
        }
    }
    
    /**
     * Gets the "kinsoku" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getKinsoku()
    {
        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(KINSOKU$24, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "kinsoku" element
     */
    public boolean isSetKinsoku()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(KINSOKU$24) != 0;
        }
    }
    
    /**
     * Sets the "kinsoku" element
     */
    public void setKinsoku(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff kinsoku)
    {
        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(KINSOKU$24, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(KINSOKU$24);
            }
            target.set(kinsoku);
        }
    }
    
    /**
     * Appends and returns a new empty "kinsoku" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewKinsoku()
    {
        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(KINSOKU$24);
            return target;
        }
    }
    
    /**
     * Unsets the "kinsoku" element
     */
    public void unsetKinsoku()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(KINSOKU$24, 0);
        }
    }
    
    /**
     * Gets the "wordWrap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getWordWrap()
    {
        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(WORDWRAP$26, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "wordWrap" element
     */
    public boolean isSetWordWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(WORDWRAP$26) != 0;
        }
    }
    
    /**
     * Sets the "wordWrap" element
     */
    public void setWordWrap(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff wordWrap)
    {
        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(WORDWRAP$26, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(WORDWRAP$26);
            }
            target.set(wordWrap);
        }
    }
    
    /**
     * Appends and returns a new empty "wordWrap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewWordWrap()
    {
        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(WORDWRAP$26);
            return target;
        }
    }
    
    /**
     * Unsets the "wordWrap" element
     */
    public void unsetWordWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(WORDWRAP$26, 0);
        }
    }
    
    /**
     * Gets the "overflowPunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getOverflowPunct()
    {
        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(OVERFLOWPUNCT$28, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "overflowPunct" element
     */
    public boolean isSetOverflowPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OVERFLOWPUNCT$28) != 0;
        }
    }
    
    /**
     * Sets the "overflowPunct" element
     */
    public void setOverflowPunct(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff overflowPunct)
    {
        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(OVERFLOWPUNCT$28, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(OVERFLOWPUNCT$28);
            }
            target.set(overflowPunct);
        }
    }
    
    /**
     * Appends and returns a new empty "overflowPunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewOverflowPunct()
    {
        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(OVERFLOWPUNCT$28);
            return target;
        }
    }
    
    /**
     * Unsets the "overflowPunct" element
     */
    public void unsetOverflowPunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OVERFLOWPUNCT$28, 0);
        }
    }
    
    /**
     * Gets the "topLinePunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getTopLinePunct()
    {
        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(TOPLINEPUNCT$30, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "topLinePunct" element
     */
    public boolean isSetTopLinePunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TOPLINEPUNCT$30) != 0;
        }
    }
    
    /**
     * Sets the "topLinePunct" element
     */
    public void setTopLinePunct(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff topLinePunct)
    {
        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(TOPLINEPUNCT$30, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(TOPLINEPUNCT$30);
            }
            target.set(topLinePunct);
        }
    }
    
    /**
     * Appends and returns a new empty "topLinePunct" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewTopLinePunct()
    {
        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(TOPLINEPUNCT$30);
            return target;
        }
    }
    
    /**
     * Unsets the "topLinePunct" element
     */
    public void unsetTopLinePunct()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TOPLINEPUNCT$30, 0);
        }
    }
    
    /**
     * Gets the "autoSpaceDE" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAutoSpaceDE()
    {
        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(AUTOSPACEDE$32, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "autoSpaceDE" element
     */
    public boolean isSetAutoSpaceDE()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(AUTOSPACEDE$32) != 0;
        }
    }
    
    /**
     * Sets the "autoSpaceDE" element
     */
    public void setAutoSpaceDE(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff autoSpaceDE)
    {
        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(AUTOSPACEDE$32, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOSPACEDE$32);
            }
            target.set(autoSpaceDE);
        }
    }
    
    /**
     * Appends and returns a new empty "autoSpaceDE" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAutoSpaceDE()
    {
        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(AUTOSPACEDE$32);
            return target;
        }
    }
    
    /**
     * Unsets the "autoSpaceDE" element
     */
    public void unsetAutoSpaceDE()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(AUTOSPACEDE$32, 0);
        }
    }
    
    /**
     * Gets the "autoSpaceDN" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAutoSpaceDN()
    {
        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(AUTOSPACEDN$34, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "autoSpaceDN" element
     */
    public boolean isSetAutoSpaceDN()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(AUTOSPACEDN$34) != 0;
        }
    }
    
    /**
     * Sets the "autoSpaceDN" element
     */
    public void setAutoSpaceDN(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff autoSpaceDN)
    {
        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(AUTOSPACEDN$34, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(AUTOSPACEDN$34);
            }
            target.set(autoSpaceDN);
        }
    }
    
    /**
     * Appends and returns a new empty "autoSpaceDN" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAutoSpaceDN()
    {
        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(AUTOSPACEDN$34);
            return target;
        }
    }
    
    /**
     * Unsets the "autoSpaceDN" element
     */
    public void unsetAutoSpaceDN()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(AUTOSPACEDN$34, 0);
        }
    }
    
    /**
     * Gets the "bidi" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getBidi()
    {
        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(BIDI$36, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "bidi" element
     */
    public boolean isSetBidi()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(BIDI$36) != 0;
        }
    }
    
    /**
     * Sets the "bidi" element
     */
    public void setBidi(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff bidi)
    {
        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(BIDI$36, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(BIDI$36);
            }
            target.set(bidi);
        }
    }
    
    /**
     * Appends and returns a new empty "bidi" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewBidi()
    {
        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(BIDI$36);
            return target;
        }
    }
    
    /**
     * Unsets the "bidi" element
     */
    public void unsetBidi()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(BIDI$36, 0);
        }
    }
    
    /**
     * Gets the "adjustRightInd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getAdjustRightInd()
    {
        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(ADJUSTRIGHTIND$38, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "adjustRightInd" element
     */
    public boolean isSetAdjustRightInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(ADJUSTRIGHTIND$38) != 0;
        }
    }
    
    /**
     * Sets the "adjustRightInd" element
     */
    public void setAdjustRightInd(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff adjustRightInd)
    {
        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(ADJUSTRIGHTIND$38, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(ADJUSTRIGHTIND$38);
            }
            target.set(adjustRightInd);
        }
    }
    
    /**
     * Appends and returns a new empty "adjustRightInd" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewAdjustRightInd()
    {
        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(ADJUSTRIGHTIND$38);
            return target;
        }
    }
    
    /**
     * Unsets the "adjustRightInd" element
     */
    public void unsetAdjustRightInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(ADJUSTRIGHTIND$38, 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$40, 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$40) != 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$40, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SNAPTOGRID$40);
            }
            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$40);
            return target;
        }
    }
    
    /**
     * Unsets the "snapToGrid" element
     */
    public void unsetSnapToGrid()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SNAPTOGRID$40, 0);
        }
    }
    
    /**
     * Gets the "spacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing getSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing)get_store().find_element_user(SPACING$42, 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$42) != 0;
        }
    }
    
    /**
     * Sets the "spacing" element
     */
    public void setSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing spacing)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing)get_store().find_element_user(SPACING$42, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing)get_store().add_element_user(SPACING$42);
            }
            target.set(spacing);
        }
    }
    
    /**
     * Appends and returns a new empty "spacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing addNewSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSpacing)get_store().add_element_user(SPACING$42);
            return target;
        }
    }
    
    /**
     * Unsets the "spacing" element
     */
    public void unsetSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SPACING$42, 0);
        }
    }
    
    /**
     * Gets the "ind" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd getInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd)get_store().find_element_user(IND$44, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "ind" element
     */
    public boolean isSetInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(IND$44) != 0;
        }
    }
    
    /**
     * Sets the "ind" element
     */
    public void setInd(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd ind)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd)get_store().find_element_user(IND$44, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd)get_store().add_element_user(IND$44);
            }
            target.set(ind);
        }
    }
    
    /**
     * Appends and returns a new empty "ind" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd addNewInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTInd)get_store().add_element_user(IND$44);
            return target;
        }
    }
    
    /**
     * Unsets the "ind" element
     */
    public void unsetInd()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(IND$44, 0);
        }
    }
    
    /**
     * Gets the "contextualSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getContextualSpacing()
    {
        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(CONTEXTUALSPACING$46, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "contextualSpacing" element
     */
    public boolean isSetContextualSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CONTEXTUALSPACING$46) != 0;
        }
    }
    
    /**
     * Sets the "contextualSpacing" element
     */
    public void setContextualSpacing(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff contextualSpacing)
    {
        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(CONTEXTUALSPACING$46, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(CONTEXTUALSPACING$46);
            }
            target.set(contextualSpacing);
        }
    }
    
    /**
     * Appends and returns a new empty "contextualSpacing" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewContextualSpacing()
    {
        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(CONTEXTUALSPACING$46);
            return target;
        }
    }
    
    /**
     * Unsets the "contextualSpacing" element
     */
    public void unsetContextualSpacing()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CONTEXTUALSPACING$46, 0);
        }
    }
    
    /**
     * Gets the "mirrorIndents" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getMirrorIndents()
    {
        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(MIRRORINDENTS$48, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "mirrorIndents" element
     */
    public boolean isSetMirrorIndents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(MIRRORINDENTS$48) != 0;
        }
    }
    
    /**
     * Sets the "mirrorIndents" element
     */
    public void setMirrorIndents(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff mirrorIndents)
    {
        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(MIRRORINDENTS$48, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(MIRRORINDENTS$48);
            }
            target.set(mirrorIndents);
        }
    }
    
    /**
     * Appends and returns a new empty "mirrorIndents" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewMirrorIndents()
    {
        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(MIRRORINDENTS$48);
            return target;
        }
    }
    
    /**
     * Unsets the "mirrorIndents" element
     */
    public void unsetMirrorIndents()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(MIRRORINDENTS$48, 0);
        }
    }
    
    /**
     * Gets the "suppressOverlap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff getSuppressOverlap()
    {
        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(SUPPRESSOVERLAP$50, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "suppressOverlap" element
     */
    public boolean isSetSuppressOverlap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SUPPRESSOVERLAP$50) != 0;
        }
    }
    
    /**
     * Sets the "suppressOverlap" element
     */
    public void setSuppressOverlap(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff suppressOverlap)
    {
        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(SUPPRESSOVERLAP$50, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff)get_store().add_element_user(SUPPRESSOVERLAP$50);
            }
            target.set(suppressOverlap);
        }
    }
    
    /**
     * Appends and returns a new empty "suppressOverlap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTOnOff addNewSuppressOverlap()
    {
        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(SUPPRESSOVERLAP$50);
            return target;
        }
    }
    
    /**
     * Unsets the "suppressOverlap" element
     */
    public void unsetSuppressOverlap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SUPPRESSOVERLAP$50, 0);
        }
    }
    
    /**
     * Gets the "jc" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc getJc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc)get_store().find_element_user(JC$52, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "jc" element
     */
    public boolean isSetJc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(JC$52) != 0;
        }
    }
    
    /**
     * Sets the "jc" element
     */
    public void setJc(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc jc)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc)get_store().find_element_user(JC$52, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc)get_store().add_element_user(JC$52);
            }
            target.set(jc);
        }
    }
    
    /**
     * Appends and returns a new empty "jc" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc addNewJc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTJc)get_store().add_element_user(JC$52);
            return target;
        }
    }
    
    /**
     * Unsets the "jc" element
     */
    public void unsetJc()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(JC$52, 0);
        }
    }
    
    /**
     * Gets the "textDirection" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection getTextDirection()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection)get_store().find_element_user(TEXTDIRECTION$54, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "textDirection" element
     */
    public boolean isSetTextDirection()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TEXTDIRECTION$54) != 0;
        }
    }
    
    /**
     * Sets the "textDirection" element
     */
    public void setTextDirection(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection textDirection)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection)get_store().find_element_user(TEXTDIRECTION$54, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection)get_store().add_element_user(TEXTDIRECTION$54);
            }
            target.set(textDirection);
        }
    }
    
    /**
     * Appends and returns a new empty "textDirection" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection addNewTextDirection()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextDirection)get_store().add_element_user(TEXTDIRECTION$54);
            return target;
        }
    }
    
    /**
     * Unsets the "textDirection" element
     */
    public void unsetTextDirection()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TEXTDIRECTION$54, 0);
        }
    }
    
    /**
     * Gets the "textAlignment" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment getTextAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment)get_store().find_element_user(TEXTALIGNMENT$56, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "textAlignment" element
     */
    public boolean isSetTextAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TEXTALIGNMENT$56) != 0;
        }
    }
    
    /**
     * Sets the "textAlignment" element
     */
    public void setTextAlignment(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment textAlignment)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment)get_store().find_element_user(TEXTALIGNMENT$56, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment)get_store().add_element_user(TEXTALIGNMENT$56);
            }
            target.set(textAlignment);
        }
    }
    
    /**
     * Appends and returns a new empty "textAlignment" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment addNewTextAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextAlignment)get_store().add_element_user(TEXTALIGNMENT$56);
            return target;
        }
    }
    
    /**
     * Unsets the "textAlignment" element
     */
    public void unsetTextAlignment()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TEXTALIGNMENT$56, 0);
        }
    }
    
    /**
     * Gets the "textboxTightWrap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap getTextboxTightWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap)get_store().find_element_user(TEXTBOXTIGHTWRAP$58, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "textboxTightWrap" element
     */
    public boolean isSetTextboxTightWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TEXTBOXTIGHTWRAP$58) != 0;
        }
    }
    
    /**
     * Sets the "textboxTightWrap" element
     */
    public void setTextboxTightWrap(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap textboxTightWrap)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap)get_store().find_element_user(TEXTBOXTIGHTWRAP$58, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap)get_store().add_element_user(TEXTBOXTIGHTWRAP$58);
            }
            target.set(textboxTightWrap);
        }
    }
    
    /**
     * Appends and returns a new empty "textboxTightWrap" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap addNewTextboxTightWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTextboxTightWrap)get_store().add_element_user(TEXTBOXTIGHTWRAP$58);
            return target;
        }
    }
    
    /**
     * Unsets the "textboxTightWrap" element
     */
    public void unsetTextboxTightWrap()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TEXTBOXTIGHTWRAP$58, 0);
        }
    }
    
    /**
     * Gets the "outlineLvl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber getOutlineLvl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().find_element_user(OUTLINELVL$60, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "outlineLvl" element
     */
    public boolean isSetOutlineLvl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(OUTLINELVL$60) != 0;
        }
    }
    
    /**
     * Sets the "outlineLvl" element
     */
    public void setOutlineLvl(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber outlineLvl)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().find_element_user(OUTLINELVL$60, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().add_element_user(OUTLINELVL$60);
            }
            target.set(outlineLvl);
        }
    }
    
    /**
     * Appends and returns a new empty "outlineLvl" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber addNewOutlineLvl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().add_element_user(OUTLINELVL$60);
            return target;
        }
    }
    
    /**
     * Unsets the "outlineLvl" element
     */
    public void unsetOutlineLvl()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(OUTLINELVL$60, 0);
        }
    }
    
    /**
     * Gets the "divId" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber getDivId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().find_element_user(DIVID$62, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "divId" element
     */
    public boolean isSetDivId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(DIVID$62) != 0;
        }
    }
    
    /**
     * Sets the "divId" element
     */
    public void setDivId(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber divId)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().find_element_user(DIVID$62, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().add_element_user(DIVID$62);
            }
            target.set(divId);
        }
    }
    
    /**
     * Appends and returns a new empty "divId" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber addNewDivId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTDecimalNumber)get_store().add_element_user(DIVID$62);
            return target;
        }
    }
    
    /**
     * Unsets the "divId" element
     */
    public void unsetDivId()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(DIVID$62, 0);
        }
    }
    
    /**
     * Gets the "cnfStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf getCnfStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf)get_store().find_element_user(CNFSTYLE$64, 0);
            if (target == null)
            {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "cnfStyle" element
     */
    public boolean isSetCnfStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CNFSTYLE$64) != 0;
        }
    }
    
    /**
     * Sets the "cnfStyle" element
     */
    public void setCnfStyle(org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf cnfStyle)
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf)get_store().find_element_user(CNFSTYLE$64, 0);
            if (target == null)
            {
                target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf)get_store().add_element_user(CNFSTYLE$64);
            }
            target.set(cnfStyle);
        }
    }
    
    /**
     * Appends and returns a new empty "cnfStyle" element
     */
    public org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf addNewCnfStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf target = null;
            target = (org.openxmlformats.schemas.wordprocessingml.x2006.main.CTCnf)get_store().add_element_user(CNFSTYLE$64);
            return target;
        }
    }
    
    /**
     * Unsets the "cnfStyle" element
     */
    public void unsetCnfStyle()
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CNFSTYLE$64, 0);
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy