Package org.openxmlformats.schemas.officeDocument.x2006.math

Interface CTOMath

All Superinterfaces:
XmlObject, XmlTokenSource
public interface CTOMath extends XmlObject
An XML CT_OMath(@http://schemas.openxmlformats.org/officeDocument/2006/math). This is a complex type.

  • Field Details

  • Method Details

    • getAccList

      List<CTAcc> getAccList()
      Gets a List of "acc" elements

    • getAccArray

      CTAcc[] getAccArray()
      Gets array of all "acc" elements

    • getAccArray

      CTAcc getAccArray(int i)
      Gets ith "acc" element

    • sizeOfAccArray

      int sizeOfAccArray()
      Returns number of "acc" element

    • setAccArray

      void setAccArray(CTAcc[] accArray)
      Sets array of all "acc" element

    • setAccArray

      void setAccArray(int i, CTAcc acc)
      Sets ith "acc" element

    • insertNewAcc

      CTAcc insertNewAcc(int i)
      Inserts and returns a new empty value (as xml) as the ith "acc" element

    • addNewAcc

      CTAcc addNewAcc()
      Appends and returns a new empty value (as xml) as the last "acc" element

    • removeAcc

      void removeAcc(int i)
      Removes the ith "acc" element

    • getBarList

      List<CTBar> getBarList()
      Gets a List of "bar" elements

    • getBarArray

      CTBar[] getBarArray()
      Gets array of all "bar" elements

    • getBarArray

      CTBar getBarArray(int i)
      Gets ith "bar" element

    • sizeOfBarArray

      int sizeOfBarArray()
      Returns number of "bar" element

    • setBarArray

      void setBarArray(CTBar[] barArray)
      Sets array of all "bar" element

    • setBarArray

      void setBarArray(int i, CTBar bar)
      Sets ith "bar" element

    • insertNewBar

      CTBar insertNewBar(int i)
      Inserts and returns a new empty value (as xml) as the ith "bar" element

    • addNewBar

      CTBar addNewBar()
      Appends and returns a new empty value (as xml) as the last "bar" element

    • removeBar

      void removeBar(int i)
      Removes the ith "bar" element

    • getBoxList

      List<CTBox> getBoxList()
      Gets a List of "box" elements

    • getBoxArray

      CTBox[] getBoxArray()
      Gets array of all "box" elements

    • getBoxArray

      CTBox getBoxArray(int i)
      Gets ith "box" element

    • sizeOfBoxArray

      int sizeOfBoxArray()
      Returns number of "box" element

    • setBoxArray

      void setBoxArray(CTBox[] boxArray)
      Sets array of all "box" element

    • setBoxArray

      void setBoxArray(int i, CTBox box)
      Sets ith "box" element

    • insertNewBox

      CTBox insertNewBox(int i)
      Inserts and returns a new empty value (as xml) as the ith "box" element

    • addNewBox

      CTBox addNewBox()
      Appends and returns a new empty value (as xml) as the last "box" element

    • removeBox

      void removeBox(int i)
      Removes the ith "box" element

    • getBorderBoxList

      List<CTBorderBox> getBorderBoxList()
      Gets a List of "borderBox" elements

    • getBorderBoxArray

      CTBorderBox[] getBorderBoxArray()
      Gets array of all "borderBox" elements

    • getBorderBoxArray

      CTBorderBox getBorderBoxArray(int i)
      Gets ith "borderBox" element

    • sizeOfBorderBoxArray

      int sizeOfBorderBoxArray()
      Returns number of "borderBox" element

    • setBorderBoxArray

      void setBorderBoxArray(CTBorderBox[] borderBoxArray)
      Sets array of all "borderBox" element

    • setBorderBoxArray

      void setBorderBoxArray(int i, CTBorderBox borderBox)
      Sets ith "borderBox" element

    • insertNewBorderBox

      CTBorderBox insertNewBorderBox(int i)
      Inserts and returns a new empty value (as xml) as the ith "borderBox" element

    • addNewBorderBox

      CTBorderBox addNewBorderBox()
      Appends and returns a new empty value (as xml) as the last "borderBox" element

    • removeBorderBox

      void removeBorderBox(int i)
      Removes the ith "borderBox" element

    • getDList

      List<CTD> getDList()
      Gets a List of "d" elements

    • getDArray

      CTD[] getDArray()
      Gets array of all "d" elements

    • getDArray

      CTD getDArray(int i)
      Gets ith "d" element

    • sizeOfDArray

      int sizeOfDArray()
      Returns number of "d" element

    • setDArray

      void setDArray(CTD[] dArray)
      Sets array of all "d" element

    • setDArray

      void setDArray(int i, CTD d)
      Sets ith "d" element

    • insertNewD

      CTD insertNewD(int i)
      Inserts and returns a new empty value (as xml) as the ith "d" element

    • addNewD

      CTD addNewD()
      Appends and returns a new empty value (as xml) as the last "d" element

    • removeD

      void removeD(int i)
      Removes the ith "d" element

    • getEqArrList

      List<CTEqArr> getEqArrList()
      Gets a List of "eqArr" elements

    • getEqArrArray

      CTEqArr[] getEqArrArray()
      Gets array of all "eqArr" elements

    • getEqArrArray

      CTEqArr getEqArrArray(int i)
      Gets ith "eqArr" element

    • sizeOfEqArrArray

      int sizeOfEqArrArray()
      Returns number of "eqArr" element

    • setEqArrArray

      void setEqArrArray(CTEqArr[] eqArrArray)
      Sets array of all "eqArr" element

    • setEqArrArray

      void setEqArrArray(int i, CTEqArr eqArr)
      Sets ith "eqArr" element

    • insertNewEqArr

      CTEqArr insertNewEqArr(int i)
      Inserts and returns a new empty value (as xml) as the ith "eqArr" element

    • addNewEqArr

      CTEqArr addNewEqArr()
      Appends and returns a new empty value (as xml) as the last "eqArr" element

    • removeEqArr

      void removeEqArr(int i)
      Removes the ith "eqArr" element

    • getFList

      List<CTF> getFList()
      Gets a List of "f" elements

    • getFArray

      CTF[] getFArray()
      Gets array of all "f" elements

    • getFArray

      CTF getFArray(int i)
      Gets ith "f" element

    • sizeOfFArray

      int sizeOfFArray()
      Returns number of "f" element

    • setFArray

      void setFArray(CTF[] fArray)
      Sets array of all "f" element

    • setFArray

      void setFArray(int i, CTF f)
      Sets ith "f" element

    • insertNewF

      CTF insertNewF(int i)
      Inserts and returns a new empty value (as xml) as the ith "f" element

    • addNewF

      CTF addNewF()
      Appends and returns a new empty value (as xml) as the last "f" element

    • removeF

      void removeF(int i)
      Removes the ith "f" element

    • getFuncList

      List<CTFunc> getFuncList()
      Gets a List of "func" elements

    • getFuncArray

      CTFunc[] getFuncArray()
      Gets array of all "func" elements

    • getFuncArray

      CTFunc getFuncArray(int i)
      Gets ith "func" element

    • sizeOfFuncArray

      int sizeOfFuncArray()
      Returns number of "func" element

    • setFuncArray

      void setFuncArray(CTFunc[] funcArray)
      Sets array of all "func" element

    • setFuncArray

      void setFuncArray(int i, CTFunc func)
      Sets ith "func" element

    • insertNewFunc

      CTFunc insertNewFunc(int i)
      Inserts and returns a new empty value (as xml) as the ith "func" element

    • addNewFunc

      CTFunc addNewFunc()
      Appends and returns a new empty value (as xml) as the last "func" element

    • removeFunc

      void removeFunc(int i)
      Removes the ith "func" element

    • getGroupChrList

      List<CTGroupChr> getGroupChrList()
      Gets a List of "groupChr" elements

    • getGroupChrArray

      CTGroupChr[] getGroupChrArray()
      Gets array of all "groupChr" elements

    • getGroupChrArray

      CTGroupChr getGroupChrArray(int i)
      Gets ith "groupChr" element

    • sizeOfGroupChrArray

      int sizeOfGroupChrArray()
      Returns number of "groupChr" element

    • setGroupChrArray

      void setGroupChrArray(CTGroupChr[] groupChrArray)
      Sets array of all "groupChr" element

    • setGroupChrArray

      void setGroupChrArray(int i, CTGroupChr groupChr)
      Sets ith "groupChr" element

    • insertNewGroupChr

      CTGroupChr insertNewGroupChr(int i)
      Inserts and returns a new empty value (as xml) as the ith "groupChr" element

    • addNewGroupChr

      CTGroupChr addNewGroupChr()
      Appends and returns a new empty value (as xml) as the last "groupChr" element

    • removeGroupChr

      void removeGroupChr(int i)
      Removes the ith "groupChr" element

    • getLimLowList

      List<CTLimLow> getLimLowList()
      Gets a List of "limLow" elements

    • getLimLowArray

      CTLimLow[] getLimLowArray()
      Gets array of all "limLow" elements

    • getLimLowArray

      CTLimLow getLimLowArray(int i)
      Gets ith "limLow" element

    • sizeOfLimLowArray

      int sizeOfLimLowArray()
      Returns number of "limLow" element

    • setLimLowArray

      void setLimLowArray(CTLimLow[] limLowArray)
      Sets array of all "limLow" element

    • setLimLowArray

      void setLimLowArray(int i, CTLimLow limLow)
      Sets ith "limLow" element

    • insertNewLimLow

      CTLimLow insertNewLimLow(int i)
      Inserts and returns a new empty value (as xml) as the ith "limLow" element

    • addNewLimLow

      CTLimLow addNewLimLow()
      Appends and returns a new empty value (as xml) as the last "limLow" element

    • removeLimLow

      void removeLimLow(int i)
      Removes the ith "limLow" element

    • getLimUppList

      List<CTLimUpp> getLimUppList()
      Gets a List of "limUpp" elements

    • getLimUppArray

      CTLimUpp[] getLimUppArray()
      Gets array of all "limUpp" elements

    • getLimUppArray

      CTLimUpp getLimUppArray(int i)
      Gets ith "limUpp" element

    • sizeOfLimUppArray

      int sizeOfLimUppArray()
      Returns number of "limUpp" element

    • setLimUppArray

      void setLimUppArray(CTLimUpp[] limUppArray)
      Sets array of all "limUpp" element

    • setLimUppArray

      void setLimUppArray(int i, CTLimUpp limUpp)
      Sets ith "limUpp" element

    • insertNewLimUpp

      CTLimUpp insertNewLimUpp(int i)
      Inserts and returns a new empty value (as xml) as the ith "limUpp" element

    • addNewLimUpp

      CTLimUpp addNewLimUpp()
      Appends and returns a new empty value (as xml) as the last "limUpp" element

    • removeLimUpp

      void removeLimUpp(int i)
      Removes the ith "limUpp" element

    • getMList

      List<CTM> getMList()
      Gets a List of "m" elements

    • getMArray

      CTM[] getMArray()
      Gets array of all "m" elements

    • getMArray

      CTM getMArray(int i)
      Gets ith "m" element

    • sizeOfMArray

      int sizeOfMArray()
      Returns number of "m" element

    • setMArray

      void setMArray(CTM[] mArray)
      Sets array of all "m" element

    • setMArray

      void setMArray(int i, CTM m)
      Sets ith "m" element

    • insertNewM

      CTM insertNewM(int i)
      Inserts and returns a new empty value (as xml) as the ith "m" element

    • addNewM

      CTM addNewM()
      Appends and returns a new empty value (as xml) as the last "m" element

    • removeM

      void removeM(int i)
      Removes the ith "m" element

    • getNaryList

      List<CTNary> getNaryList()
      Gets a List of "nary" elements

    • getNaryArray

      CTNary[] getNaryArray()
      Gets array of all "nary" elements

    • getNaryArray

      CTNary getNaryArray(int i)
      Gets ith "nary" element

    • sizeOfNaryArray

      int sizeOfNaryArray()
      Returns number of "nary" element

    • setNaryArray

      void setNaryArray(CTNary[] naryArray)
      Sets array of all "nary" element

    • setNaryArray

      void setNaryArray(int i, CTNary nary)
      Sets ith "nary" element

    • insertNewNary

      CTNary insertNewNary(int i)
      Inserts and returns a new empty value (as xml) as the ith "nary" element

    • addNewNary

      CTNary addNewNary()
      Appends and returns a new empty value (as xml) as the last "nary" element

    • removeNary

      void removeNary(int i)
      Removes the ith "nary" element

    • getPhantList

      List<CTPhant> getPhantList()
      Gets a List of "phant" elements

    • getPhantArray

      CTPhant[] getPhantArray()
      Gets array of all "phant" elements

    • getPhantArray

      CTPhant getPhantArray(int i)
      Gets ith "phant" element

    • sizeOfPhantArray

      int sizeOfPhantArray()
      Returns number of "phant" element

    • setPhantArray

      void setPhantArray(CTPhant[] phantArray)
      Sets array of all "phant" element

    • setPhantArray

      void setPhantArray(int i, CTPhant phant)
      Sets ith "phant" element

    • insertNewPhant

      CTPhant insertNewPhant(int i)
      Inserts and returns a new empty value (as xml) as the ith "phant" element

    • addNewPhant

      CTPhant addNewPhant()
      Appends and returns a new empty value (as xml) as the last "phant" element

    • removePhant

      void removePhant(int i)
      Removes the ith "phant" element

    • getRadList

      List<CTRad> getRadList()
      Gets a List of "rad" elements

    • getRadArray

      CTRad[] getRadArray()
      Gets array of all "rad" elements

    • getRadArray

      CTRad getRadArray(int i)
      Gets ith "rad" element

    • sizeOfRadArray

      int sizeOfRadArray()
      Returns number of "rad" element

    • setRadArray

      void setRadArray(CTRad[] radArray)
      Sets array of all "rad" element

    • setRadArray

      void setRadArray(int i, CTRad rad)
      Sets ith "rad" element

    • insertNewRad

      CTRad insertNewRad(int i)
      Inserts and returns a new empty value (as xml) as the ith "rad" element

    • addNewRad

      CTRad addNewRad()
      Appends and returns a new empty value (as xml) as the last "rad" element

    • removeRad

      void removeRad(int i)
      Removes the ith "rad" element

    • getSPreList

      List<CTSPre> getSPreList()
      Gets a List of "sPre" elements

    • getSPreArray

      CTSPre[] getSPreArray()
      Gets array of all "sPre" elements

    • getSPreArray

      CTSPre getSPreArray(int i)
      Gets ith "sPre" element

    • sizeOfSPreArray

      int sizeOfSPreArray()
      Returns number of "sPre" element

    • setSPreArray

      void setSPreArray(CTSPre[] sPreArray)
      Sets array of all "sPre" element

    • setSPreArray

      void setSPreArray(int i, CTSPre sPre)
      Sets ith "sPre" element

    • insertNewSPre

      CTSPre insertNewSPre(int i)
      Inserts and returns a new empty value (as xml) as the ith "sPre" element

    • addNewSPre

      CTSPre addNewSPre()
      Appends and returns a new empty value (as xml) as the last "sPre" element

    • removeSPre

      void removeSPre(int i)
      Removes the ith "sPre" element

    • getSSubList

      List<CTSSub> getSSubList()
      Gets a List of "sSub" elements

    • getSSubArray

      CTSSub[] getSSubArray()
      Gets array of all "sSub" elements

    • getSSubArray

      CTSSub getSSubArray(int i)
      Gets ith "sSub" element

    • sizeOfSSubArray

      int sizeOfSSubArray()
      Returns number of "sSub" element

    • setSSubArray

      void setSSubArray(CTSSub[] sSubArray)
      Sets array of all "sSub" element

    • setSSubArray

      void setSSubArray(int i, CTSSub sSub)
      Sets ith "sSub" element

    • insertNewSSub

      CTSSub insertNewSSub(int i)
      Inserts and returns a new empty value (as xml) as the ith "sSub" element

    • addNewSSub

      CTSSub addNewSSub()
      Appends and returns a new empty value (as xml) as the last "sSub" element

    • removeSSub

      void removeSSub(int i)
      Removes the ith "sSub" element

    • getSSubSupList

      List<CTSSubSup> getSSubSupList()
      Gets a List of "sSubSup" elements

    • getSSubSupArray

      CTSSubSup[] getSSubSupArray()
      Gets array of all "sSubSup" elements

    • getSSubSupArray

      CTSSubSup getSSubSupArray(int i)
      Gets ith "sSubSup" element

    • sizeOfSSubSupArray

      int sizeOfSSubSupArray()
      Returns number of "sSubSup" element

    • setSSubSupArray

      void setSSubSupArray(CTSSubSup[] sSubSupArray)
      Sets array of all "sSubSup" element

    • setSSubSupArray

      void setSSubSupArray(int i, CTSSubSup sSubSup)
      Sets ith "sSubSup" element

    • insertNewSSubSup

      CTSSubSup insertNewSSubSup(int i)
      Inserts and returns a new empty value (as xml) as the ith "sSubSup" element

    • addNewSSubSup

      CTSSubSup addNewSSubSup()
      Appends and returns a new empty value (as xml) as the last "sSubSup" element

    • removeSSubSup

      void removeSSubSup(int i)
      Removes the ith "sSubSup" element

    • getSSupList

      List<CTSSup> getSSupList()
      Gets a List of "sSup" elements

    • getSSupArray

      CTSSup[] getSSupArray()
      Gets array of all "sSup" elements

    • getSSupArray

      CTSSup getSSupArray(int i)
      Gets ith "sSup" element

    • sizeOfSSupArray

      int sizeOfSSupArray()
      Returns number of "sSup" element

    • setSSupArray

      void setSSupArray(CTSSup[] sSupArray)
      Sets array of all "sSup" element

    • setSSupArray

      void setSSupArray(int i, CTSSup sSup)
      Sets ith "sSup" element

    • insertNewSSup

      CTSSup insertNewSSup(int i)
      Inserts and returns a new empty value (as xml) as the ith "sSup" element

    • addNewSSup

      CTSSup addNewSSup()
      Appends and returns a new empty value (as xml) as the last "sSup" element

    • removeSSup

      void removeSSup(int i)
      Removes the ith "sSup" element

    • getRList

      List<CTR> getRList()
      Gets a List of "r" elements

    • getRArray

      CTR[] getRArray()
      Gets array of all "r" elements

    • getRArray

      CTR getRArray(int i)
      Gets ith "r" element

    • sizeOfRArray

      int sizeOfRArray()
      Returns number of "r" element

    • setRArray

      void setRArray(CTR[] rArray)
      Sets array of all "r" element

    • setRArray

      void setRArray(int i, CTR r)
      Sets ith "r" element

    • insertNewR

      CTR insertNewR(int i)
      Inserts and returns a new empty value (as xml) as the ith "r" element

    • addNewR

      CTR addNewR()
      Appends and returns a new empty value (as xml) as the last "r" element

    • removeR

      void removeR(int i)
      Removes the ith "r" element

    • getCustomXmlList

      List<CTCustomXmlRun> getCustomXmlList()
      Gets a List of "customXml" elements

    • getCustomXmlArray

      CTCustomXmlRun[] getCustomXmlArray()
      Gets array of all "customXml" elements

    • getCustomXmlArray

      CTCustomXmlRun getCustomXmlArray(int i)
      Gets ith "customXml" element

    • sizeOfCustomXmlArray

      int sizeOfCustomXmlArray()
      Returns number of "customXml" element

    • setCustomXmlArray

      void setCustomXmlArray(CTCustomXmlRun[] customXmlArray)
      Sets array of all "customXml" element

    • setCustomXmlArray

      void setCustomXmlArray(int i, CTCustomXmlRun customXml)
      Sets ith "customXml" element

    • insertNewCustomXml

      CTCustomXmlRun insertNewCustomXml(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXml" element

    • addNewCustomXml

      CTCustomXmlRun addNewCustomXml()
      Appends and returns a new empty value (as xml) as the last "customXml" element

    • removeCustomXml

      void removeCustomXml(int i)
      Removes the ith "customXml" element

    • getFldSimpleList

      List<CTSimpleField> getFldSimpleList()
      Gets a List of "fldSimple" elements

    • getFldSimpleArray

      CTSimpleField[] getFldSimpleArray()
      Gets array of all "fldSimple" elements

    • getFldSimpleArray

      CTSimpleField getFldSimpleArray(int i)
      Gets ith "fldSimple" element

    • sizeOfFldSimpleArray

      int sizeOfFldSimpleArray()
      Returns number of "fldSimple" element

    • setFldSimpleArray

      void setFldSimpleArray(CTSimpleField[] fldSimpleArray)
      Sets array of all "fldSimple" element

    • setFldSimpleArray

      void setFldSimpleArray(int i, CTSimpleField fldSimple)
      Sets ith "fldSimple" element

    • insertNewFldSimple

      CTSimpleField insertNewFldSimple(int i)
      Inserts and returns a new empty value (as xml) as the ith "fldSimple" element

    • addNewFldSimple

      CTSimpleField addNewFldSimple()
      Appends and returns a new empty value (as xml) as the last "fldSimple" element

    • removeFldSimple

      void removeFldSimple(int i)
      Removes the ith "fldSimple" element

    • getHyperlinkList

      List<CTHyperlink> getHyperlinkList()
      Gets a List of "hyperlink" elements

    • getHyperlinkArray

      CTHyperlink[] getHyperlinkArray()
      Gets array of all "hyperlink" elements

    • getHyperlinkArray

      CTHyperlink getHyperlinkArray(int i)
      Gets ith "hyperlink" element

    • sizeOfHyperlinkArray

      int sizeOfHyperlinkArray()
      Returns number of "hyperlink" element

    • setHyperlinkArray

      void setHyperlinkArray(CTHyperlink[] hyperlinkArray)
      Sets array of all "hyperlink" element

    • setHyperlinkArray

      void setHyperlinkArray(int i, CTHyperlink hyperlink)
      Sets ith "hyperlink" element

    • insertNewHyperlink

      CTHyperlink insertNewHyperlink(int i)
      Inserts and returns a new empty value (as xml) as the ith "hyperlink" element

    • addNewHyperlink

      CTHyperlink addNewHyperlink()
      Appends and returns a new empty value (as xml) as the last "hyperlink" element

    • removeHyperlink

      void removeHyperlink(int i)
      Removes the ith "hyperlink" element

    • getSmartTagList

      List<CTSmartTagRun> getSmartTagList()
      Gets a List of "smartTag" elements

    • getSmartTagArray

      CTSmartTagRun[] getSmartTagArray()
      Gets array of all "smartTag" elements

    • getSmartTagArray

      CTSmartTagRun getSmartTagArray(int i)
      Gets ith "smartTag" element

    • sizeOfSmartTagArray

      int sizeOfSmartTagArray()
      Returns number of "smartTag" element

    • setSmartTagArray

      void setSmartTagArray(CTSmartTagRun[] smartTagArray)
      Sets array of all "smartTag" element

    • setSmartTagArray

      void setSmartTagArray(int i, CTSmartTagRun smartTag)
      Sets ith "smartTag" element

    • insertNewSmartTag

      CTSmartTagRun insertNewSmartTag(int i)
      Inserts and returns a new empty value (as xml) as the ith "smartTag" element

    • addNewSmartTag

      CTSmartTagRun addNewSmartTag()
      Appends and returns a new empty value (as xml) as the last "smartTag" element

    • removeSmartTag

      void removeSmartTag(int i)
      Removes the ith "smartTag" element

    • getSdtList

      List<CTSdtRun> getSdtList()
      Gets a List of "sdt" elements

    • getSdtArray

      CTSdtRun[] getSdtArray()
      Gets array of all "sdt" elements

    • getSdtArray

      CTSdtRun getSdtArray(int i)
      Gets ith "sdt" element

    • sizeOfSdtArray

      int sizeOfSdtArray()
      Returns number of "sdt" element

    • setSdtArray

      void setSdtArray(CTSdtRun[] sdtArray)
      Sets array of all "sdt" element

    • setSdtArray

      void setSdtArray(int i, CTSdtRun sdt)
      Sets ith "sdt" element

    • insertNewSdt

      CTSdtRun insertNewSdt(int i)
      Inserts and returns a new empty value (as xml) as the ith "sdt" element

    • addNewSdt

      CTSdtRun addNewSdt()
      Appends and returns a new empty value (as xml) as the last "sdt" element

    • removeSdt

      void removeSdt(int i)
      Removes the ith "sdt" element

    • getProofErrList

      List<CTProofErr> getProofErrList()
      Gets a List of "proofErr" elements

    • getProofErrArray

      CTProofErr[] getProofErrArray()
      Gets array of all "proofErr" elements

    • getProofErrArray

      CTProofErr getProofErrArray(int i)
      Gets ith "proofErr" element

    • sizeOfProofErrArray

      int sizeOfProofErrArray()
      Returns number of "proofErr" element

    • setProofErrArray

      void setProofErrArray(CTProofErr[] proofErrArray)
      Sets array of all "proofErr" element

    • setProofErrArray

      void setProofErrArray(int i, CTProofErr proofErr)
      Sets ith "proofErr" element

    • insertNewProofErr

      CTProofErr insertNewProofErr(int i)
      Inserts and returns a new empty value (as xml) as the ith "proofErr" element

    • addNewProofErr

      CTProofErr addNewProofErr()
      Appends and returns a new empty value (as xml) as the last "proofErr" element

    • removeProofErr

      void removeProofErr(int i)
      Removes the ith "proofErr" element

    • getPermStartList

      List<CTPermStart> getPermStartList()
      Gets a List of "permStart" elements

    • getPermStartArray

      CTPermStart[] getPermStartArray()
      Gets array of all "permStart" elements

    • getPermStartArray

      CTPermStart getPermStartArray(int i)
      Gets ith "permStart" element

    • sizeOfPermStartArray

      int sizeOfPermStartArray()
      Returns number of "permStart" element

    • setPermStartArray

      void setPermStartArray(CTPermStart[] permStartArray)
      Sets array of all "permStart" element

    • setPermStartArray

      void setPermStartArray(int i, CTPermStart permStart)
      Sets ith "permStart" element

    • insertNewPermStart

      CTPermStart insertNewPermStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "permStart" element

    • addNewPermStart

      CTPermStart addNewPermStart()
      Appends and returns a new empty value (as xml) as the last "permStart" element

    • removePermStart

      void removePermStart(int i)
      Removes the ith "permStart" element

    • getPermEndList

      List<CTPerm> getPermEndList()
      Gets a List of "permEnd" elements

    • getPermEndArray

      CTPerm[] getPermEndArray()
      Gets array of all "permEnd" elements

    • getPermEndArray

      CTPerm getPermEndArray(int i)
      Gets ith "permEnd" element

    • sizeOfPermEndArray

      int sizeOfPermEndArray()
      Returns number of "permEnd" element

    • setPermEndArray

      void setPermEndArray(CTPerm[] permEndArray)
      Sets array of all "permEnd" element

    • setPermEndArray

      void setPermEndArray(int i, CTPerm permEnd)
      Sets ith "permEnd" element

    • insertNewPermEnd

      CTPerm insertNewPermEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "permEnd" element

    • addNewPermEnd

      CTPerm addNewPermEnd()
      Appends and returns a new empty value (as xml) as the last "permEnd" element

    • removePermEnd

      void removePermEnd(int i)
      Removes the ith "permEnd" element

    • getBookmarkStartList

      List<CTBookmark> getBookmarkStartList()
      Gets a List of "bookmarkStart" elements

    • getBookmarkStartArray

      CTBookmark[] getBookmarkStartArray()
      Gets array of all "bookmarkStart" elements

    • getBookmarkStartArray

      CTBookmark getBookmarkStartArray(int i)
      Gets ith "bookmarkStart" element

    • sizeOfBookmarkStartArray

      int sizeOfBookmarkStartArray()
      Returns number of "bookmarkStart" element

    • setBookmarkStartArray

      void setBookmarkStartArray(CTBookmark[] bookmarkStartArray)
      Sets array of all "bookmarkStart" element

    • setBookmarkStartArray

      void setBookmarkStartArray(int i, CTBookmark bookmarkStart)
      Sets ith "bookmarkStart" element

    • insertNewBookmarkStart

      CTBookmark insertNewBookmarkStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "bookmarkStart" element

    • addNewBookmarkStart

      CTBookmark addNewBookmarkStart()
      Appends and returns a new empty value (as xml) as the last "bookmarkStart" element

    • removeBookmarkStart

      void removeBookmarkStart(int i)
      Removes the ith "bookmarkStart" element

    • getBookmarkEndList

      List<CTMarkupRange> getBookmarkEndList()
      Gets a List of "bookmarkEnd" elements

    • getBookmarkEndArray

      CTMarkupRange[] getBookmarkEndArray()
      Gets array of all "bookmarkEnd" elements

    • getBookmarkEndArray

      CTMarkupRange getBookmarkEndArray(int i)
      Gets ith "bookmarkEnd" element

    • sizeOfBookmarkEndArray

      int sizeOfBookmarkEndArray()
      Returns number of "bookmarkEnd" element

    • setBookmarkEndArray

      void setBookmarkEndArray(CTMarkupRange[] bookmarkEndArray)
      Sets array of all "bookmarkEnd" element

    • setBookmarkEndArray

      void setBookmarkEndArray(int i, CTMarkupRange bookmarkEnd)
      Sets ith "bookmarkEnd" element

    • insertNewBookmarkEnd

      CTMarkupRange insertNewBookmarkEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "bookmarkEnd" element

    • addNewBookmarkEnd

      CTMarkupRange addNewBookmarkEnd()
      Appends and returns a new empty value (as xml) as the last "bookmarkEnd" element

    • removeBookmarkEnd

      void removeBookmarkEnd(int i)
      Removes the ith "bookmarkEnd" element

    • getMoveFromRangeStartList

      List<CTMoveBookmark> getMoveFromRangeStartList()
      Gets a List of "moveFromRangeStart" elements

    • getMoveFromRangeStartArray

      CTMoveBookmark[] getMoveFromRangeStartArray()
      Gets array of all "moveFromRangeStart" elements

    • getMoveFromRangeStartArray

      CTMoveBookmark getMoveFromRangeStartArray(int i)
      Gets ith "moveFromRangeStart" element

    • sizeOfMoveFromRangeStartArray

      int sizeOfMoveFromRangeStartArray()
      Returns number of "moveFromRangeStart" element

    • setMoveFromRangeStartArray

      void setMoveFromRangeStartArray(CTMoveBookmark[] moveFromRangeStartArray)
      Sets array of all "moveFromRangeStart" element

    • setMoveFromRangeStartArray

      void setMoveFromRangeStartArray(int i, CTMoveBookmark moveFromRangeStart)
      Sets ith "moveFromRangeStart" element

    • insertNewMoveFromRangeStart

      CTMoveBookmark insertNewMoveFromRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveFromRangeStart" element

    • addNewMoveFromRangeStart

      CTMoveBookmark addNewMoveFromRangeStart()
      Appends and returns a new empty value (as xml) as the last "moveFromRangeStart" element

    • removeMoveFromRangeStart

      void removeMoveFromRangeStart(int i)
      Removes the ith "moveFromRangeStart" element

    • getMoveFromRangeEndList

      List<CTMarkupRange> getMoveFromRangeEndList()
      Gets a List of "moveFromRangeEnd" elements

    • getMoveFromRangeEndArray

      CTMarkupRange[] getMoveFromRangeEndArray()
      Gets array of all "moveFromRangeEnd" elements

    • getMoveFromRangeEndArray

      CTMarkupRange getMoveFromRangeEndArray(int i)
      Gets ith "moveFromRangeEnd" element

    • sizeOfMoveFromRangeEndArray

      int sizeOfMoveFromRangeEndArray()
      Returns number of "moveFromRangeEnd" element

    • setMoveFromRangeEndArray

      void setMoveFromRangeEndArray(CTMarkupRange[] moveFromRangeEndArray)
      Sets array of all "moveFromRangeEnd" element

    • setMoveFromRangeEndArray

      void setMoveFromRangeEndArray(int i, CTMarkupRange moveFromRangeEnd)
      Sets ith "moveFromRangeEnd" element

    • insertNewMoveFromRangeEnd

      CTMarkupRange insertNewMoveFromRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveFromRangeEnd" element

    • addNewMoveFromRangeEnd

      CTMarkupRange addNewMoveFromRangeEnd()
      Appends and returns a new empty value (as xml) as the last "moveFromRangeEnd" element

    • removeMoveFromRangeEnd

      void removeMoveFromRangeEnd(int i)
      Removes the ith "moveFromRangeEnd" element

    • getMoveToRangeStartList

      List<CTMoveBookmark> getMoveToRangeStartList()
      Gets a List of "moveToRangeStart" elements

    • getMoveToRangeStartArray

      CTMoveBookmark[] getMoveToRangeStartArray()
      Gets array of all "moveToRangeStart" elements

    • getMoveToRangeStartArray

      CTMoveBookmark getMoveToRangeStartArray(int i)
      Gets ith "moveToRangeStart" element

    • sizeOfMoveToRangeStartArray

      int sizeOfMoveToRangeStartArray()
      Returns number of "moveToRangeStart" element

    • setMoveToRangeStartArray

      void setMoveToRangeStartArray(CTMoveBookmark[] moveToRangeStartArray)
      Sets array of all "moveToRangeStart" element

    • setMoveToRangeStartArray

      void setMoveToRangeStartArray(int i, CTMoveBookmark moveToRangeStart)
      Sets ith "moveToRangeStart" element

    • insertNewMoveToRangeStart

      CTMoveBookmark insertNewMoveToRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveToRangeStart" element

    • addNewMoveToRangeStart

      CTMoveBookmark addNewMoveToRangeStart()
      Appends and returns a new empty value (as xml) as the last "moveToRangeStart" element

    • removeMoveToRangeStart

      void removeMoveToRangeStart(int i)
      Removes the ith "moveToRangeStart" element

    • getMoveToRangeEndList

      List<CTMarkupRange> getMoveToRangeEndList()
      Gets a List of "moveToRangeEnd" elements

    • getMoveToRangeEndArray

      CTMarkupRange[] getMoveToRangeEndArray()
      Gets array of all "moveToRangeEnd" elements

    • getMoveToRangeEndArray

      CTMarkupRange getMoveToRangeEndArray(int i)
      Gets ith "moveToRangeEnd" element

    • sizeOfMoveToRangeEndArray

      int sizeOfMoveToRangeEndArray()
      Returns number of "moveToRangeEnd" element

    • setMoveToRangeEndArray

      void setMoveToRangeEndArray(CTMarkupRange[] moveToRangeEndArray)
      Sets array of all "moveToRangeEnd" element

    • setMoveToRangeEndArray

      void setMoveToRangeEndArray(int i, CTMarkupRange moveToRangeEnd)
      Sets ith "moveToRangeEnd" element

    • insertNewMoveToRangeEnd

      CTMarkupRange insertNewMoveToRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveToRangeEnd" element

    • addNewMoveToRangeEnd

      CTMarkupRange addNewMoveToRangeEnd()
      Appends and returns a new empty value (as xml) as the last "moveToRangeEnd" element

    • removeMoveToRangeEnd

      void removeMoveToRangeEnd(int i)
      Removes the ith "moveToRangeEnd" element

    • getCommentRangeStartList

      List<CTMarkupRange> getCommentRangeStartList()
      Gets a List of "commentRangeStart" elements

    • getCommentRangeStartArray

      CTMarkupRange[] getCommentRangeStartArray()
      Gets array of all "commentRangeStart" elements

    • getCommentRangeStartArray

      CTMarkupRange getCommentRangeStartArray(int i)
      Gets ith "commentRangeStart" element

    • sizeOfCommentRangeStartArray

      int sizeOfCommentRangeStartArray()
      Returns number of "commentRangeStart" element

    • setCommentRangeStartArray

      void setCommentRangeStartArray(CTMarkupRange[] commentRangeStartArray)
      Sets array of all "commentRangeStart" element

    • setCommentRangeStartArray

      void setCommentRangeStartArray(int i, CTMarkupRange commentRangeStart)
      Sets ith "commentRangeStart" element

    • insertNewCommentRangeStart

      CTMarkupRange insertNewCommentRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "commentRangeStart" element

    • addNewCommentRangeStart

      CTMarkupRange addNewCommentRangeStart()
      Appends and returns a new empty value (as xml) as the last "commentRangeStart" element

    • removeCommentRangeStart

      void removeCommentRangeStart(int i)
      Removes the ith "commentRangeStart" element

    • getCommentRangeEndList

      List<CTMarkupRange> getCommentRangeEndList()
      Gets a List of "commentRangeEnd" elements

    • getCommentRangeEndArray

      CTMarkupRange[] getCommentRangeEndArray()
      Gets array of all "commentRangeEnd" elements

    • getCommentRangeEndArray

      CTMarkupRange getCommentRangeEndArray(int i)
      Gets ith "commentRangeEnd" element

    • sizeOfCommentRangeEndArray

      int sizeOfCommentRangeEndArray()
      Returns number of "commentRangeEnd" element

    • setCommentRangeEndArray

      void setCommentRangeEndArray(CTMarkupRange[] commentRangeEndArray)
      Sets array of all "commentRangeEnd" element

    • setCommentRangeEndArray

      void setCommentRangeEndArray(int i, CTMarkupRange commentRangeEnd)
      Sets ith "commentRangeEnd" element

    • insertNewCommentRangeEnd

      CTMarkupRange insertNewCommentRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "commentRangeEnd" element

    • addNewCommentRangeEnd

      CTMarkupRange addNewCommentRangeEnd()
      Appends and returns a new empty value (as xml) as the last "commentRangeEnd" element

    • removeCommentRangeEnd

      void removeCommentRangeEnd(int i)
      Removes the ith "commentRangeEnd" element

    • getCustomXmlInsRangeStartList

      List<CTTrackChange> getCustomXmlInsRangeStartList()
      Gets a List of "customXmlInsRangeStart" elements

    • getCustomXmlInsRangeStartArray

      CTTrackChange[] getCustomXmlInsRangeStartArray()
      Gets array of all "customXmlInsRangeStart" elements

    • getCustomXmlInsRangeStartArray

      CTTrackChange getCustomXmlInsRangeStartArray(int i)
      Gets ith "customXmlInsRangeStart" element

    • sizeOfCustomXmlInsRangeStartArray

      int sizeOfCustomXmlInsRangeStartArray()
      Returns number of "customXmlInsRangeStart" element

    • setCustomXmlInsRangeStartArray

      void setCustomXmlInsRangeStartArray(CTTrackChange[] customXmlInsRangeStartArray)
      Sets array of all "customXmlInsRangeStart" element

    • setCustomXmlInsRangeStartArray

      void setCustomXmlInsRangeStartArray(int i, CTTrackChange customXmlInsRangeStart)
      Sets ith "customXmlInsRangeStart" element

    • insertNewCustomXmlInsRangeStart

      CTTrackChange insertNewCustomXmlInsRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlInsRangeStart" element

    • addNewCustomXmlInsRangeStart

      CTTrackChange addNewCustomXmlInsRangeStart()
      Appends and returns a new empty value (as xml) as the last "customXmlInsRangeStart" element

    • removeCustomXmlInsRangeStart

      void removeCustomXmlInsRangeStart(int i)
      Removes the ith "customXmlInsRangeStart" element

    • getCustomXmlInsRangeEndList

      List<CTMarkup> getCustomXmlInsRangeEndList()
      Gets a List of "customXmlInsRangeEnd" elements

    • getCustomXmlInsRangeEndArray

      CTMarkup[] getCustomXmlInsRangeEndArray()
      Gets array of all "customXmlInsRangeEnd" elements

    • getCustomXmlInsRangeEndArray

      CTMarkup getCustomXmlInsRangeEndArray(int i)
      Gets ith "customXmlInsRangeEnd" element

    • sizeOfCustomXmlInsRangeEndArray

      int sizeOfCustomXmlInsRangeEndArray()
      Returns number of "customXmlInsRangeEnd" element

    • setCustomXmlInsRangeEndArray

      void setCustomXmlInsRangeEndArray(CTMarkup[] customXmlInsRangeEndArray)
      Sets array of all "customXmlInsRangeEnd" element

    • setCustomXmlInsRangeEndArray

      void setCustomXmlInsRangeEndArray(int i, CTMarkup customXmlInsRangeEnd)
      Sets ith "customXmlInsRangeEnd" element

    • insertNewCustomXmlInsRangeEnd

      CTMarkup insertNewCustomXmlInsRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlInsRangeEnd" element

    • addNewCustomXmlInsRangeEnd

      CTMarkup addNewCustomXmlInsRangeEnd()
      Appends and returns a new empty value (as xml) as the last "customXmlInsRangeEnd" element

    • removeCustomXmlInsRangeEnd

      void removeCustomXmlInsRangeEnd(int i)
      Removes the ith "customXmlInsRangeEnd" element

    • getCustomXmlDelRangeStartList

      List<CTTrackChange> getCustomXmlDelRangeStartList()
      Gets a List of "customXmlDelRangeStart" elements

    • getCustomXmlDelRangeStartArray

      CTTrackChange[] getCustomXmlDelRangeStartArray()
      Gets array of all "customXmlDelRangeStart" elements

    • getCustomXmlDelRangeStartArray

      CTTrackChange getCustomXmlDelRangeStartArray(int i)
      Gets ith "customXmlDelRangeStart" element

    • sizeOfCustomXmlDelRangeStartArray

      int sizeOfCustomXmlDelRangeStartArray()
      Returns number of "customXmlDelRangeStart" element

    • setCustomXmlDelRangeStartArray

      void setCustomXmlDelRangeStartArray(CTTrackChange[] customXmlDelRangeStartArray)
      Sets array of all "customXmlDelRangeStart" element

    • setCustomXmlDelRangeStartArray

      void setCustomXmlDelRangeStartArray(int i, CTTrackChange customXmlDelRangeStart)
      Sets ith "customXmlDelRangeStart" element

    • insertNewCustomXmlDelRangeStart

      CTTrackChange insertNewCustomXmlDelRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlDelRangeStart" element

    • addNewCustomXmlDelRangeStart

      CTTrackChange addNewCustomXmlDelRangeStart()
      Appends and returns a new empty value (as xml) as the last "customXmlDelRangeStart" element

    • removeCustomXmlDelRangeStart

      void removeCustomXmlDelRangeStart(int i)
      Removes the ith "customXmlDelRangeStart" element

    • getCustomXmlDelRangeEndList

      List<CTMarkup> getCustomXmlDelRangeEndList()
      Gets a List of "customXmlDelRangeEnd" elements

    • getCustomXmlDelRangeEndArray

      CTMarkup[] getCustomXmlDelRangeEndArray()
      Gets array of all "customXmlDelRangeEnd" elements

    • getCustomXmlDelRangeEndArray

      CTMarkup getCustomXmlDelRangeEndArray(int i)
      Gets ith "customXmlDelRangeEnd" element

    • sizeOfCustomXmlDelRangeEndArray

      int sizeOfCustomXmlDelRangeEndArray()
      Returns number of "customXmlDelRangeEnd" element

    • setCustomXmlDelRangeEndArray

      void setCustomXmlDelRangeEndArray(CTMarkup[] customXmlDelRangeEndArray)
      Sets array of all "customXmlDelRangeEnd" element

    • setCustomXmlDelRangeEndArray

      void setCustomXmlDelRangeEndArray(int i, CTMarkup customXmlDelRangeEnd)
      Sets ith "customXmlDelRangeEnd" element

    • insertNewCustomXmlDelRangeEnd

      CTMarkup insertNewCustomXmlDelRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlDelRangeEnd" element

    • addNewCustomXmlDelRangeEnd

      CTMarkup addNewCustomXmlDelRangeEnd()
      Appends and returns a new empty value (as xml) as the last "customXmlDelRangeEnd" element

    • removeCustomXmlDelRangeEnd

      void removeCustomXmlDelRangeEnd(int i)
      Removes the ith "customXmlDelRangeEnd" element

    • getCustomXmlMoveFromRangeStartList

      List<CTTrackChange> getCustomXmlMoveFromRangeStartList()
      Gets a List of "customXmlMoveFromRangeStart" elements

    • getCustomXmlMoveFromRangeStartArray

      CTTrackChange[] getCustomXmlMoveFromRangeStartArray()
      Gets array of all "customXmlMoveFromRangeStart" elements

    • getCustomXmlMoveFromRangeStartArray

      CTTrackChange getCustomXmlMoveFromRangeStartArray(int i)
      Gets ith "customXmlMoveFromRangeStart" element

    • sizeOfCustomXmlMoveFromRangeStartArray

      int sizeOfCustomXmlMoveFromRangeStartArray()
      Returns number of "customXmlMoveFromRangeStart" element

    • setCustomXmlMoveFromRangeStartArray

      void setCustomXmlMoveFromRangeStartArray(CTTrackChange[] customXmlMoveFromRangeStartArray)
      Sets array of all "customXmlMoveFromRangeStart" element

    • setCustomXmlMoveFromRangeStartArray

      void setCustomXmlMoveFromRangeStartArray(int i, CTTrackChange customXmlMoveFromRangeStart)
      Sets ith "customXmlMoveFromRangeStart" element

    • insertNewCustomXmlMoveFromRangeStart

      CTTrackChange insertNewCustomXmlMoveFromRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlMoveFromRangeStart" element

    • addNewCustomXmlMoveFromRangeStart

      CTTrackChange addNewCustomXmlMoveFromRangeStart()
      Appends and returns a new empty value (as xml) as the last "customXmlMoveFromRangeStart" element

    • removeCustomXmlMoveFromRangeStart

      void removeCustomXmlMoveFromRangeStart(int i)
      Removes the ith "customXmlMoveFromRangeStart" element

    • getCustomXmlMoveFromRangeEndList

      List<CTMarkup> getCustomXmlMoveFromRangeEndList()
      Gets a List of "customXmlMoveFromRangeEnd" elements

    • getCustomXmlMoveFromRangeEndArray

      CTMarkup[] getCustomXmlMoveFromRangeEndArray()
      Gets array of all "customXmlMoveFromRangeEnd" elements

    • getCustomXmlMoveFromRangeEndArray

      CTMarkup getCustomXmlMoveFromRangeEndArray(int i)
      Gets ith "customXmlMoveFromRangeEnd" element

    • sizeOfCustomXmlMoveFromRangeEndArray

      int sizeOfCustomXmlMoveFromRangeEndArray()
      Returns number of "customXmlMoveFromRangeEnd" element

    • setCustomXmlMoveFromRangeEndArray

      void setCustomXmlMoveFromRangeEndArray(CTMarkup[] customXmlMoveFromRangeEndArray)
      Sets array of all "customXmlMoveFromRangeEnd" element

    • setCustomXmlMoveFromRangeEndArray

      void setCustomXmlMoveFromRangeEndArray(int i, CTMarkup customXmlMoveFromRangeEnd)
      Sets ith "customXmlMoveFromRangeEnd" element

    • insertNewCustomXmlMoveFromRangeEnd

      CTMarkup insertNewCustomXmlMoveFromRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlMoveFromRangeEnd" element

    • addNewCustomXmlMoveFromRangeEnd

      CTMarkup addNewCustomXmlMoveFromRangeEnd()
      Appends and returns a new empty value (as xml) as the last "customXmlMoveFromRangeEnd" element

    • removeCustomXmlMoveFromRangeEnd

      void removeCustomXmlMoveFromRangeEnd(int i)
      Removes the ith "customXmlMoveFromRangeEnd" element

    • getCustomXmlMoveToRangeStartList

      List<CTTrackChange> getCustomXmlMoveToRangeStartList()
      Gets a List of "customXmlMoveToRangeStart" elements

    • getCustomXmlMoveToRangeStartArray

      CTTrackChange[] getCustomXmlMoveToRangeStartArray()
      Gets array of all "customXmlMoveToRangeStart" elements

    • getCustomXmlMoveToRangeStartArray

      CTTrackChange getCustomXmlMoveToRangeStartArray(int i)
      Gets ith "customXmlMoveToRangeStart" element

    • sizeOfCustomXmlMoveToRangeStartArray

      int sizeOfCustomXmlMoveToRangeStartArray()
      Returns number of "customXmlMoveToRangeStart" element

    • setCustomXmlMoveToRangeStartArray

      void setCustomXmlMoveToRangeStartArray(CTTrackChange[] customXmlMoveToRangeStartArray)
      Sets array of all "customXmlMoveToRangeStart" element

    • setCustomXmlMoveToRangeStartArray

      void setCustomXmlMoveToRangeStartArray(int i, CTTrackChange customXmlMoveToRangeStart)
      Sets ith "customXmlMoveToRangeStart" element

    • insertNewCustomXmlMoveToRangeStart

      CTTrackChange insertNewCustomXmlMoveToRangeStart(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlMoveToRangeStart" element

    • addNewCustomXmlMoveToRangeStart

      CTTrackChange addNewCustomXmlMoveToRangeStart()
      Appends and returns a new empty value (as xml) as the last "customXmlMoveToRangeStart" element

    • removeCustomXmlMoveToRangeStart

      void removeCustomXmlMoveToRangeStart(int i)
      Removes the ith "customXmlMoveToRangeStart" element

    • getCustomXmlMoveToRangeEndList

      List<CTMarkup> getCustomXmlMoveToRangeEndList()
      Gets a List of "customXmlMoveToRangeEnd" elements

    • getCustomXmlMoveToRangeEndArray

      CTMarkup[] getCustomXmlMoveToRangeEndArray()
      Gets array of all "customXmlMoveToRangeEnd" elements

    • getCustomXmlMoveToRangeEndArray

      CTMarkup getCustomXmlMoveToRangeEndArray(int i)
      Gets ith "customXmlMoveToRangeEnd" element

    • sizeOfCustomXmlMoveToRangeEndArray

      int sizeOfCustomXmlMoveToRangeEndArray()
      Returns number of "customXmlMoveToRangeEnd" element

    • setCustomXmlMoveToRangeEndArray

      void setCustomXmlMoveToRangeEndArray(CTMarkup[] customXmlMoveToRangeEndArray)
      Sets array of all "customXmlMoveToRangeEnd" element

    • setCustomXmlMoveToRangeEndArray

      void setCustomXmlMoveToRangeEndArray(int i, CTMarkup customXmlMoveToRangeEnd)
      Sets ith "customXmlMoveToRangeEnd" element

    • insertNewCustomXmlMoveToRangeEnd

      CTMarkup insertNewCustomXmlMoveToRangeEnd(int i)
      Inserts and returns a new empty value (as xml) as the ith "customXmlMoveToRangeEnd" element

    • addNewCustomXmlMoveToRangeEnd

      CTMarkup addNewCustomXmlMoveToRangeEnd()
      Appends and returns a new empty value (as xml) as the last "customXmlMoveToRangeEnd" element

    • removeCustomXmlMoveToRangeEnd

      void removeCustomXmlMoveToRangeEnd(int i)
      Removes the ith "customXmlMoveToRangeEnd" element

    • getInsList

      List<CTRunTrackChange> getInsList()
      Gets a List of "ins" elements

    • getInsArray

      CTRunTrackChange[] getInsArray()
      Gets array of all "ins" elements

    • getInsArray

      CTRunTrackChange getInsArray(int i)
      Gets ith "ins" element

    • sizeOfInsArray

      int sizeOfInsArray()
      Returns number of "ins" element

    • setInsArray

      void setInsArray(CTRunTrackChange[] insArray)
      Sets array of all "ins" element

    • setInsArray

      void setInsArray(int i, CTRunTrackChange ins)
      Sets ith "ins" element

    • insertNewIns

      CTRunTrackChange insertNewIns(int i)
      Inserts and returns a new empty value (as xml) as the ith "ins" element

    • addNewIns

      CTRunTrackChange addNewIns()
      Appends and returns a new empty value (as xml) as the last "ins" element

    • removeIns

      void removeIns(int i)
      Removes the ith "ins" element

    • getDelList

      List<CTRunTrackChange> getDelList()
      Gets a List of "del" elements

    • getDelArray

      CTRunTrackChange[] getDelArray()
      Gets array of all "del" elements

    • getDelArray

      CTRunTrackChange getDelArray(int i)
      Gets ith "del" element

    • sizeOfDelArray

      int sizeOfDelArray()
      Returns number of "del" element

    • setDelArray

      void setDelArray(CTRunTrackChange[] delArray)
      Sets array of all "del" element

    • setDelArray

      void setDelArray(int i, CTRunTrackChange del)
      Sets ith "del" element

    • insertNewDel

      CTRunTrackChange insertNewDel(int i)
      Inserts and returns a new empty value (as xml) as the ith "del" element

    • addNewDel

      CTRunTrackChange addNewDel()
      Appends and returns a new empty value (as xml) as the last "del" element

    • removeDel

      void removeDel(int i)
      Removes the ith "del" element

    • getMoveFromList

      List<CTRunTrackChange> getMoveFromList()
      Gets a List of "moveFrom" elements

    • getMoveFromArray

      CTRunTrackChange[] getMoveFromArray()
      Gets array of all "moveFrom" elements

    • getMoveFromArray

      CTRunTrackChange getMoveFromArray(int i)
      Gets ith "moveFrom" element

    • sizeOfMoveFromArray

      int sizeOfMoveFromArray()
      Returns number of "moveFrom" element

    • setMoveFromArray

      void setMoveFromArray(CTRunTrackChange[] moveFromArray)
      Sets array of all "moveFrom" element

    • setMoveFromArray

      void setMoveFromArray(int i, CTRunTrackChange moveFrom)
      Sets ith "moveFrom" element

    • insertNewMoveFrom

      CTRunTrackChange insertNewMoveFrom(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveFrom" element

    • addNewMoveFrom

      CTRunTrackChange addNewMoveFrom()
      Appends and returns a new empty value (as xml) as the last "moveFrom" element

    • removeMoveFrom

      void removeMoveFrom(int i)
      Removes the ith "moveFrom" element

    • getMoveToList

      List<CTRunTrackChange> getMoveToList()
      Gets a List of "moveTo" elements

    • getMoveToArray

      CTRunTrackChange[] getMoveToArray()
      Gets array of all "moveTo" elements

    • getMoveToArray

      CTRunTrackChange getMoveToArray(int i)
      Gets ith "moveTo" element

    • sizeOfMoveToArray

      int sizeOfMoveToArray()
      Returns number of "moveTo" element

    • setMoveToArray

      void setMoveToArray(CTRunTrackChange[] moveToArray)
      Sets array of all "moveTo" element

    • setMoveToArray

      void setMoveToArray(int i, CTRunTrackChange moveTo)
      Sets ith "moveTo" element

    • insertNewMoveTo

      CTRunTrackChange insertNewMoveTo(int i)
      Inserts and returns a new empty value (as xml) as the ith "moveTo" element

    • addNewMoveTo

      CTRunTrackChange addNewMoveTo()
      Appends and returns a new empty value (as xml) as the last "moveTo" element

    • removeMoveTo

      void removeMoveTo(int i)
      Removes the ith "moveTo" element

    • getOMathParaList

      List<CTOMathPara> getOMathParaList()
      Gets a List of "oMathPara" elements

    • getOMathParaArray

      CTOMathPara[] getOMathParaArray()
      Gets array of all "oMathPara" elements

    • getOMathParaArray

      CTOMathPara getOMathParaArray(int i)
      Gets ith "oMathPara" element

    • sizeOfOMathParaArray

      int sizeOfOMathParaArray()
      Returns number of "oMathPara" element

    • setOMathParaArray

      void setOMathParaArray(CTOMathPara[] oMathParaArray)
      Sets array of all "oMathPara" element

    • setOMathParaArray

      void setOMathParaArray(int i, CTOMathPara oMathPara)
      Sets ith "oMathPara" element

    • insertNewOMathPara

      CTOMathPara insertNewOMathPara(int i)
      Inserts and returns a new empty value (as xml) as the ith "oMathPara" element

    • addNewOMathPara

      CTOMathPara addNewOMathPara()
      Appends and returns a new empty value (as xml) as the last "oMathPara" element

    • removeOMathPara

      void removeOMathPara(int i)
      Removes the ith "oMathPara" element

    • getOMathList

      List<CTOMath> getOMathList()
      Gets a List of "oMath" elements

    • getOMathArray

      CTOMath[] getOMathArray()
      Gets array of all "oMath" elements

    • getOMathArray

      CTOMath getOMathArray(int i)
      Gets ith "oMath" element

    • sizeOfOMathArray

      int sizeOfOMathArray()
      Returns number of "oMath" element

    • setOMathArray

      void setOMathArray(CTOMath[] oMathArray)
      Sets array of all "oMath" element

    • setOMathArray

      void setOMathArray(int i, CTOMath oMath)
      Sets ith "oMath" element

    • insertNewOMath

      CTOMath insertNewOMath(int i)
      Inserts and returns a new empty value (as xml) as the ith "oMath" element

    • addNewOMath

      CTOMath addNewOMath()
      Appends and returns a new empty value (as xml) as the last "oMath" element

    • removeOMath

      void removeOMath(int i)
      Removes the ith "oMath" element