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

com.microsoft.schemas.office.office.impl.CTShapeDefaultsImpl Maven / Gradle / Ivy

Go to download

XmlBeans generated from the Ecma supplied xsds (since POI 5.0.0, the 5th edition is used): https://www.ecma-international.org/publications/standards/Ecma-376.htm

There is a newer version: 5.2.5
Show newest version
/*
 * XML Type:  CT_ShapeDefaults
 * Namespace: urn:schemas-microsoft-com:office:office
 * Java type: com.microsoft.schemas.office.office.CTShapeDefaults
 *
 * Automatically generated - do not modify.
 */
package com.microsoft.schemas.office.office.impl;
/**
 * An XML CT_ShapeDefaults(@urn:schemas-microsoft-com:office:office).
 *
 * This is a complex type.
 */
public class CTShapeDefaultsImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl implements com.microsoft.schemas.office.office.CTShapeDefaults {
    private static final long serialVersionUID = 1L;
    
    public CTShapeDefaultsImpl(org.apache.xmlbeans.SchemaType sType) {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName FILL$0 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:vml", "fill");
    private static final javax.xml.namespace.QName STROKE$2 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:vml", "stroke");
    private static final javax.xml.namespace.QName TEXTBOX$4 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:vml", "textbox");
    private static final javax.xml.namespace.QName SHADOW$6 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:vml", "shadow");
    private static final javax.xml.namespace.QName SKEW$8 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "skew");
    private static final javax.xml.namespace.QName EXTRUSION$10 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "extrusion");
    private static final javax.xml.namespace.QName CALLOUT$12 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "callout");
    private static final javax.xml.namespace.QName LOCK$14 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "lock");
    private static final javax.xml.namespace.QName COLORMRU$16 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "colormru");
    private static final javax.xml.namespace.QName COLORMENU$18 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "colormenu");
    private static final javax.xml.namespace.QName EXT$20 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:vml", "ext");
    private static final javax.xml.namespace.QName SPIDMAX$22 = 
        new javax.xml.namespace.QName("", "spidmax");
    private static final javax.xml.namespace.QName STYLE$24 = 
        new javax.xml.namespace.QName("", "style");
    private static final javax.xml.namespace.QName FILL2$26 = 
        new javax.xml.namespace.QName("", "fill");
    private static final javax.xml.namespace.QName FILLCOLOR$28 = 
        new javax.xml.namespace.QName("", "fillcolor");
    private static final javax.xml.namespace.QName STROKE2$30 = 
        new javax.xml.namespace.QName("", "stroke");
    private static final javax.xml.namespace.QName STROKECOLOR$32 = 
        new javax.xml.namespace.QName("", "strokecolor");
    private static final javax.xml.namespace.QName ALLOWINCELL$34 = 
        new javax.xml.namespace.QName("urn:schemas-microsoft-com:office:office", "allowincell");
    
    
    /**
     * Gets the "fill" element
     */
    public com.microsoft.schemas.vml.CTFill getFill() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTFill target = null;
            target = (com.microsoft.schemas.vml.CTFill)get_store().find_element_user(FILL$0, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "fill" element
     */
    public boolean isSetFill() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(FILL$0) != 0;
        }
    }
    
    /**
     * Sets the "fill" element
     */
    public void setFill(com.microsoft.schemas.vml.CTFill fill) {
        generatedSetterHelperImpl(fill, FILL$0, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "fill" element
     */
    public com.microsoft.schemas.vml.CTFill addNewFill() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTFill target = null;
            target = (com.microsoft.schemas.vml.CTFill)get_store().add_element_user(FILL$0);
            return target;
        }
    }
    
    /**
     * Unsets the "fill" element
     */
    public void unsetFill() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(FILL$0, 0);
        }
    }
    
    /**
     * Gets the "stroke" element
     */
    public com.microsoft.schemas.vml.CTStroke getStroke() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTStroke target = null;
            target = (com.microsoft.schemas.vml.CTStroke)get_store().find_element_user(STROKE$2, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "stroke" element
     */
    public boolean isSetStroke() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(STROKE$2) != 0;
        }
    }
    
    /**
     * Sets the "stroke" element
     */
    public void setStroke(com.microsoft.schemas.vml.CTStroke stroke) {
        generatedSetterHelperImpl(stroke, STROKE$2, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "stroke" element
     */
    public com.microsoft.schemas.vml.CTStroke addNewStroke() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTStroke target = null;
            target = (com.microsoft.schemas.vml.CTStroke)get_store().add_element_user(STROKE$2);
            return target;
        }
    }
    
    /**
     * Unsets the "stroke" element
     */
    public void unsetStroke() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(STROKE$2, 0);
        }
    }
    
    /**
     * Gets the "textbox" element
     */
    public com.microsoft.schemas.vml.CTTextbox getTextbox() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTTextbox target = null;
            target = (com.microsoft.schemas.vml.CTTextbox)get_store().find_element_user(TEXTBOX$4, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "textbox" element
     */
    public boolean isSetTextbox() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(TEXTBOX$4) != 0;
        }
    }
    
    /**
     * Sets the "textbox" element
     */
    public void setTextbox(com.microsoft.schemas.vml.CTTextbox textbox) {
        generatedSetterHelperImpl(textbox, TEXTBOX$4, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "textbox" element
     */
    public com.microsoft.schemas.vml.CTTextbox addNewTextbox() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTTextbox target = null;
            target = (com.microsoft.schemas.vml.CTTextbox)get_store().add_element_user(TEXTBOX$4);
            return target;
        }
    }
    
    /**
     * Unsets the "textbox" element
     */
    public void unsetTextbox() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(TEXTBOX$4, 0);
        }
    }
    
    /**
     * Gets the "shadow" element
     */
    public com.microsoft.schemas.vml.CTShadow getShadow() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTShadow target = null;
            target = (com.microsoft.schemas.vml.CTShadow)get_store().find_element_user(SHADOW$6, 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$6) != 0;
        }
    }
    
    /**
     * Sets the "shadow" element
     */
    public void setShadow(com.microsoft.schemas.vml.CTShadow shadow) {
        generatedSetterHelperImpl(shadow, SHADOW$6, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "shadow" element
     */
    public com.microsoft.schemas.vml.CTShadow addNewShadow() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.CTShadow target = null;
            target = (com.microsoft.schemas.vml.CTShadow)get_store().add_element_user(SHADOW$6);
            return target;
        }
    }
    
    /**
     * Unsets the "shadow" element
     */
    public void unsetShadow() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SHADOW$6, 0);
        }
    }
    
    /**
     * Gets the "skew" element
     */
    public com.microsoft.schemas.office.office.CTSkew getSkew() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTSkew target = null;
            target = (com.microsoft.schemas.office.office.CTSkew)get_store().find_element_user(SKEW$8, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "skew" element
     */
    public boolean isSetSkew() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(SKEW$8) != 0;
        }
    }
    
    /**
     * Sets the "skew" element
     */
    public void setSkew(com.microsoft.schemas.office.office.CTSkew skew) {
        generatedSetterHelperImpl(skew, SKEW$8, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "skew" element
     */
    public com.microsoft.schemas.office.office.CTSkew addNewSkew() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTSkew target = null;
            target = (com.microsoft.schemas.office.office.CTSkew)get_store().add_element_user(SKEW$8);
            return target;
        }
    }
    
    /**
     * Unsets the "skew" element
     */
    public void unsetSkew() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(SKEW$8, 0);
        }
    }
    
    /**
     * Gets the "extrusion" element
     */
    public com.microsoft.schemas.office.office.CTExtrusion getExtrusion() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTExtrusion target = null;
            target = (com.microsoft.schemas.office.office.CTExtrusion)get_store().find_element_user(EXTRUSION$10, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "extrusion" element
     */
    public boolean isSetExtrusion() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(EXTRUSION$10) != 0;
        }
    }
    
    /**
     * Sets the "extrusion" element
     */
    public void setExtrusion(com.microsoft.schemas.office.office.CTExtrusion extrusion) {
        generatedSetterHelperImpl(extrusion, EXTRUSION$10, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "extrusion" element
     */
    public com.microsoft.schemas.office.office.CTExtrusion addNewExtrusion() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTExtrusion target = null;
            target = (com.microsoft.schemas.office.office.CTExtrusion)get_store().add_element_user(EXTRUSION$10);
            return target;
        }
    }
    
    /**
     * Unsets the "extrusion" element
     */
    public void unsetExtrusion() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(EXTRUSION$10, 0);
        }
    }
    
    /**
     * Gets the "callout" element
     */
    public com.microsoft.schemas.office.office.CTCallout getCallout() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTCallout target = null;
            target = (com.microsoft.schemas.office.office.CTCallout)get_store().find_element_user(CALLOUT$12, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "callout" element
     */
    public boolean isSetCallout() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(CALLOUT$12) != 0;
        }
    }
    
    /**
     * Sets the "callout" element
     */
    public void setCallout(com.microsoft.schemas.office.office.CTCallout callout) {
        generatedSetterHelperImpl(callout, CALLOUT$12, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "callout" element
     */
    public com.microsoft.schemas.office.office.CTCallout addNewCallout() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTCallout target = null;
            target = (com.microsoft.schemas.office.office.CTCallout)get_store().add_element_user(CALLOUT$12);
            return target;
        }
    }
    
    /**
     * Unsets the "callout" element
     */
    public void unsetCallout() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(CALLOUT$12, 0);
        }
    }
    
    /**
     * Gets the "lock" element
     */
    public com.microsoft.schemas.office.office.CTLock getLock() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTLock target = null;
            target = (com.microsoft.schemas.office.office.CTLock)get_store().find_element_user(LOCK$14, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "lock" element
     */
    public boolean isSetLock() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(LOCK$14) != 0;
        }
    }
    
    /**
     * Sets the "lock" element
     */
    public void setLock(com.microsoft.schemas.office.office.CTLock lock) {
        generatedSetterHelperImpl(lock, LOCK$14, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "lock" element
     */
    public com.microsoft.schemas.office.office.CTLock addNewLock() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTLock target = null;
            target = (com.microsoft.schemas.office.office.CTLock)get_store().add_element_user(LOCK$14);
            return target;
        }
    }
    
    /**
     * Unsets the "lock" element
     */
    public void unsetLock() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(LOCK$14, 0);
        }
    }
    
    /**
     * Gets the "colormru" element
     */
    public com.microsoft.schemas.office.office.CTColorMru getColormru() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTColorMru target = null;
            target = (com.microsoft.schemas.office.office.CTColorMru)get_store().find_element_user(COLORMRU$16, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "colormru" element
     */
    public boolean isSetColormru() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COLORMRU$16) != 0;
        }
    }
    
    /**
     * Sets the "colormru" element
     */
    public void setColormru(com.microsoft.schemas.office.office.CTColorMru colormru) {
        generatedSetterHelperImpl(colormru, COLORMRU$16, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "colormru" element
     */
    public com.microsoft.schemas.office.office.CTColorMru addNewColormru() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTColorMru target = null;
            target = (com.microsoft.schemas.office.office.CTColorMru)get_store().add_element_user(COLORMRU$16);
            return target;
        }
    }
    
    /**
     * Unsets the "colormru" element
     */
    public void unsetColormru() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COLORMRU$16, 0);
        }
    }
    
    /**
     * Gets the "colormenu" element
     */
    public com.microsoft.schemas.office.office.CTColorMenu getColormenu() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTColorMenu target = null;
            target = (com.microsoft.schemas.office.office.CTColorMenu)get_store().find_element_user(COLORMENU$18, 0);
            if (target == null) {
                return null;
            }
            return target;
        }
    }
    
    /**
     * True if has "colormenu" element
     */
    public boolean isSetColormenu() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(COLORMENU$18) != 0;
        }
    }
    
    /**
     * Sets the "colormenu" element
     */
    public void setColormenu(com.microsoft.schemas.office.office.CTColorMenu colormenu) {
        generatedSetterHelperImpl(colormenu, COLORMENU$18, 0, org.apache.xmlbeans.impl.values.XmlObjectBase.KIND_SETTERHELPER_SINGLETON);
    }
    
    /**
     * Appends and returns a new empty "colormenu" element
     */
    public com.microsoft.schemas.office.office.CTColorMenu addNewColormenu() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.office.office.CTColorMenu target = null;
            target = (com.microsoft.schemas.office.office.CTColorMenu)get_store().add_element_user(COLORMENU$18);
            return target;
        }
    }
    
    /**
     * Unsets the "colormenu" element
     */
    public void unsetColormenu() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(COLORMENU$18, 0);
        }
    }
    
    /**
     * Gets the "ext" attribute
     */
    public com.microsoft.schemas.vml.STExt.Enum getExt() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(EXT$20);
            if (target == null) {
                return null;
            }
            return (com.microsoft.schemas.vml.STExt.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "ext" attribute
     */
    public com.microsoft.schemas.vml.STExt xgetExt() {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.STExt target = null;
            target = (com.microsoft.schemas.vml.STExt)get_store().find_attribute_user(EXT$20);
            return target;
        }
    }
    
    /**
     * True if has "ext" attribute
     */
    public boolean isSetExt() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(EXT$20) != null;
        }
    }
    
    /**
     * Sets the "ext" attribute
     */
    public void setExt(com.microsoft.schemas.vml.STExt.Enum ext) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(EXT$20);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(EXT$20);
            }
            target.setEnumValue(ext);
        }
    }
    
    /**
     * Sets (as xml) the "ext" attribute
     */
    public void xsetExt(com.microsoft.schemas.vml.STExt ext) {
        synchronized (monitor())
        {
            check_orphaned();
            com.microsoft.schemas.vml.STExt target = null;
            target = (com.microsoft.schemas.vml.STExt)get_store().find_attribute_user(EXT$20);
            if (target == null) {
                target = (com.microsoft.schemas.vml.STExt)get_store().add_attribute_user(EXT$20);
            }
            target.set(ext);
        }
    }
    
    /**
     * Unsets the "ext" attribute
     */
    public void unsetExt() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(EXT$20);
        }
    }
    
    /**
     * Gets the "spidmax" attribute
     */
    public java.math.BigInteger getSpidmax() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SPIDMAX$22);
            if (target == null) {
                return null;
            }
            return target.getBigIntegerValue();
        }
    }
    
    /**
     * Gets (as xml) the "spidmax" attribute
     */
    public org.apache.xmlbeans.XmlInteger xgetSpidmax() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInteger target = null;
            target = (org.apache.xmlbeans.XmlInteger)get_store().find_attribute_user(SPIDMAX$22);
            return target;
        }
    }
    
    /**
     * True if has "spidmax" attribute
     */
    public boolean isSetSpidmax() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(SPIDMAX$22) != null;
        }
    }
    
    /**
     * Sets the "spidmax" attribute
     */
    public void setSpidmax(java.math.BigInteger spidmax) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(SPIDMAX$22);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(SPIDMAX$22);
            }
            target.setBigIntegerValue(spidmax);
        }
    }
    
    /**
     * Sets (as xml) the "spidmax" attribute
     */
    public void xsetSpidmax(org.apache.xmlbeans.XmlInteger spidmax) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlInteger target = null;
            target = (org.apache.xmlbeans.XmlInteger)get_store().find_attribute_user(SPIDMAX$22);
            if (target == null) {
                target = (org.apache.xmlbeans.XmlInteger)get_store().add_attribute_user(SPIDMAX$22);
            }
            target.set(spidmax);
        }
    }
    
    /**
     * Unsets the "spidmax" attribute
     */
    public void unsetSpidmax() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(SPIDMAX$22);
        }
    }
    
    /**
     * Gets the "style" attribute
     */
    public java.lang.String getStyle() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STYLE$24);
            if (target == null) {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "style" attribute
     */
    public org.apache.xmlbeans.XmlString xgetStyle() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(STYLE$24);
            return target;
        }
    }
    
    /**
     * True if has "style" attribute
     */
    public boolean isSetStyle() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(STYLE$24) != null;
        }
    }
    
    /**
     * Sets the "style" attribute
     */
    public void setStyle(java.lang.String style) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STYLE$24);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(STYLE$24);
            }
            target.setStringValue(style);
        }
    }
    
    /**
     * Sets (as xml) the "style" attribute
     */
    public void xsetStyle(org.apache.xmlbeans.XmlString style) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.XmlString target = null;
            target = (org.apache.xmlbeans.XmlString)get_store().find_attribute_user(STYLE$24);
            if (target == null) {
                target = (org.apache.xmlbeans.XmlString)get_store().add_attribute_user(STYLE$24);
            }
            target.set(style);
        }
    }
    
    /**
     * Unsets the "style" attribute
     */
    public void unsetStyle() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(STYLE$24);
        }
    }
    
    /**
     * Gets the "fill" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum getFill2() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FILL2$26);
            if (target == null) {
                return null;
            }
            return (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "fill" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse xgetFill2() {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(FILL2$26);
            return target;
        }
    }
    
    /**
     * True if has "fill" attribute
     */
    public boolean isSetFill2() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(FILL2$26) != null;
        }
    }
    
    /**
     * Sets the "fill" attribute
     */
    public void setFill2(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum fill2) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FILL2$26);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(FILL2$26);
            }
            target.setEnumValue(fill2);
        }
    }
    
    /**
     * Sets (as xml) the "fill" attribute
     */
    public void xsetFill2(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse fill2) {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(FILL2$26);
            if (target == null) {
                target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().add_attribute_user(FILL2$26);
            }
            target.set(fill2);
        }
    }
    
    /**
     * Unsets the "fill" attribute
     */
    public void unsetFill2() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(FILL2$26);
        }
    }
    
    /**
     * Gets the "fillcolor" attribute
     */
    public java.lang.String getFillcolor() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FILLCOLOR$28);
            if (target == null) {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "fillcolor" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType xgetFillcolor() {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().find_attribute_user(FILLCOLOR$28);
            return target;
        }
    }
    
    /**
     * True if has "fillcolor" attribute
     */
    public boolean isSetFillcolor() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(FILLCOLOR$28) != null;
        }
    }
    
    /**
     * Sets the "fillcolor" attribute
     */
    public void setFillcolor(java.lang.String fillcolor) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(FILLCOLOR$28);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(FILLCOLOR$28);
            }
            target.setStringValue(fillcolor);
        }
    }
    
    /**
     * Sets (as xml) the "fillcolor" attribute
     */
    public void xsetFillcolor(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType fillcolor) {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().find_attribute_user(FILLCOLOR$28);
            if (target == null) {
                target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().add_attribute_user(FILLCOLOR$28);
            }
            target.set(fillcolor);
        }
    }
    
    /**
     * Unsets the "fillcolor" attribute
     */
    public void unsetFillcolor() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(FILLCOLOR$28);
        }
    }
    
    /**
     * Gets the "stroke" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum getStroke2() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STROKE2$30);
            if (target == null) {
                return null;
            }
            return (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "stroke" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse xgetStroke2() {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(STROKE2$30);
            return target;
        }
    }
    
    /**
     * True if has "stroke" attribute
     */
    public boolean isSetStroke2() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(STROKE2$30) != null;
        }
    }
    
    /**
     * Sets the "stroke" attribute
     */
    public void setStroke2(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum stroke2) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STROKE2$30);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(STROKE2$30);
            }
            target.setEnumValue(stroke2);
        }
    }
    
    /**
     * Sets (as xml) the "stroke" attribute
     */
    public void xsetStroke2(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse stroke2) {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(STROKE2$30);
            if (target == null) {
                target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().add_attribute_user(STROKE2$30);
            }
            target.set(stroke2);
        }
    }
    
    /**
     * Unsets the "stroke" attribute
     */
    public void unsetStroke2() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(STROKE2$30);
        }
    }
    
    /**
     * Gets the "strokecolor" attribute
     */
    public java.lang.String getStrokecolor() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STROKECOLOR$32);
            if (target == null) {
                return null;
            }
            return target.getStringValue();
        }
    }
    
    /**
     * Gets (as xml) the "strokecolor" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType xgetStrokecolor() {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().find_attribute_user(STROKECOLOR$32);
            return target;
        }
    }
    
    /**
     * True if has "strokecolor" attribute
     */
    public boolean isSetStrokecolor() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(STROKECOLOR$32) != null;
        }
    }
    
    /**
     * Sets the "strokecolor" attribute
     */
    public void setStrokecolor(java.lang.String strokecolor) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(STROKECOLOR$32);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(STROKECOLOR$32);
            }
            target.setStringValue(strokecolor);
        }
    }
    
    /**
     * Sets (as xml) the "strokecolor" attribute
     */
    public void xsetStrokecolor(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType strokecolor) {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().find_attribute_user(STROKECOLOR$32);
            if (target == null) {
                target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STColorType)get_store().add_attribute_user(STROKECOLOR$32);
            }
            target.set(strokecolor);
        }
    }
    
    /**
     * Unsets the "strokecolor" attribute
     */
    public void unsetStrokecolor() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(STROKECOLOR$32);
        }
    }
    
    /**
     * Gets the "allowincell" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum getAllowincell() {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ALLOWINCELL$34);
            if (target == null) {
                return null;
            }
            return (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum)target.getEnumValue();
        }
    }
    
    /**
     * Gets (as xml) the "allowincell" attribute
     */
    public org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse xgetAllowincell() {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(ALLOWINCELL$34);
            return target;
        }
    }
    
    /**
     * True if has "allowincell" attribute
     */
    public boolean isSetAllowincell() {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().find_attribute_user(ALLOWINCELL$34) != null;
        }
    }
    
    /**
     * Sets the "allowincell" attribute
     */
    public void setAllowincell(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse.Enum allowincell) {
        synchronized (monitor())
        {
            check_orphaned();
            org.apache.xmlbeans.SimpleValue target = null;
            target = (org.apache.xmlbeans.SimpleValue)get_store().find_attribute_user(ALLOWINCELL$34);
            if (target == null) {
                target = (org.apache.xmlbeans.SimpleValue)get_store().add_attribute_user(ALLOWINCELL$34);
            }
            target.setEnumValue(allowincell);
        }
    }
    
    /**
     * Sets (as xml) the "allowincell" attribute
     */
    public void xsetAllowincell(org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse allowincell) {
        synchronized (monitor())
        {
            check_orphaned();
            org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse target = null;
            target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().find_attribute_user(ALLOWINCELL$34);
            if (target == null) {
                target = (org.openxmlformats.schemas.officeDocument.x2006.sharedTypes.STTrueFalse)get_store().add_attribute_user(ALLOWINCELL$34);
            }
            target.set(allowincell);
        }
    }
    
    /**
     * Unsets the "allowincell" attribute
     */
    public void unsetAllowincell() {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_attribute(ALLOWINCELL$34);
        }
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy