///
/// <summary> * fitsValue - checks whether <code>value</code> matches the given test
/// * lists
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="testlists">
/// * test lists the value has to match. In this State the test
/// * lists are ValueList AND ValueMod.<br>
/// * Choose one of two values: FitsValue_Allowed or
/// * FitsValue_Present. Defaults to Allowed.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlists or if
/// * AllowedValueList and AllowedValueMod are not specified </returns>
///
public override bool fitsValue(string @value, EnumFitsValue testlists)
{
bool testResult = true;
if (!fitsListType(@value))
{
testResult = false;
}
else
{
JDFIntegerRangeList rangelist = null;
try
{
rangelist = new JDFIntegerRangeList(@value);
}
catch (FormatException)
{
testResult = false;
}
if (testResult)
{
testResult = (fitsValueList(rangelist, testlists) && fitsValueMod(rangelist, testlists));
}
}
return(testResult);
}
public void testSetPages()
{
JDFIntegerRangeList integerRangeList = new JDFIntegerRangeList(new JDFIntegerRange(0, -1, 8));
rl.setPages(integerRangeList);
Assert.AreEqual(integerRangeList, rl.getPages());
Assert.AreEqual(8, rl.getNPage());
}
private void setupRunList(int type)
{
JDFIntegerRangeList pageRange = new JDFIntegerRangeList(new JDFIntegerRange(0, -1, 16));
rlIn.setPartUsage(EnumPartUsage.Sparse);
rlIn.setDescriptiveName("Explicitly partitioned by LayerIDs to enable layer selextion in the link");
JDFRunList rlAll = (JDFRunList)rlIn.addPartition(EnumPartIDKey.LayerIDs, "0");
rlAll.setFileURL("background.pdf");
rlAll.setPages(pageRange);
JDFRunList rlLanguage = (JDFRunList)rlIn.addPartition(EnumPartIDKey.LayerIDs, "1");
JDFRunList rlEn = (JDFRunList)rlLanguage.addPartition(EnumPartIDKey.PartVersion, "FR");
rlEn.setFileURL("francais.pdf");
rlEn.setPages(pageRange);
rlEn.setLogicalPage(16);
JDFRunList rlDe = (JDFRunList)rlLanguage.addPartition(EnumPartIDKey.PartVersion, "De");
rlDe.setFileURL("deutsch.pdf");
rlDe.setPages(pageRange);
rlDe.setLogicalPage(16);
if (type == 1)
{
JDFRunList rlCurrency = (JDFRunList)rlIn.addPartition(EnumPartIDKey.LayerIDs, "2");
JDFRunList rlEur = (JDFRunList)rlCurrency.addPartition(EnumPartIDKey.PartVersion, "Euro");
rlEur.setFileURL("€.pdf");
rlEur.setPages(pageRange);
rlEur.setLogicalPage(32);
JDFRunList rlCHF = (JDFRunList)rlCurrency.addPartition(EnumPartIDKey.PartVersion, "CHF");
rlCHF.setFileURL("Fränkli.pdf");
rlCHF.setPages(pageRange);
rlCHF.setLogicalPage(32);
}
else if (type == 2)
{
JDFRunList rlCurrency = (JDFRunList)rlIn.addPartition(EnumPartIDKey.LayerIDs, "2");
JDFRunList rlEur = (JDFRunList)rlCurrency.addPartition(EnumPartIDKey.PartVersion, "De");
rlEur.setFileURL("€.pdf");
rlEur.setPages(pageRange);
rlEur.setLogicalPage(32);
JDFRunList rlEur2 = (JDFRunList)rlCurrency.addPartition(EnumPartIDKey.PartVersion, "Fr");
rlEur2.setIdentical(rlEur);
JDFRunList rlCHF = (JDFRunList)rlCurrency.addPartition(EnumPartIDKey.PartVersion, "Ch");
rlCHF.setFileURL("Fränkli.pdf");
rlCHF.setPages(pageRange);
rlCHF.setLogicalPage(32);
JDFRunList rlCh = (JDFRunList)rlLanguage.addPartition(EnumPartIDKey.PartVersion, "Ch");
rlCh.setIdentical(rlDe);
}
}
///
/// <summary> * fitsValueList - checks whether <code>rangelist</code> matches the
/// * AllowedValueList/PresentValueList, specified for this State
/// * </summary>
/// * <param name="rangelist">
/// * range list to test </param>
/// * <param name="valuelist">
/// * switches between AllowedValueList and PresentValueList
/// * </param>
/// * <returns> boolean - true, if <code>rangelist</code> matches the valuelist
/// * or if AllowedValueList is not specified </returns>
///
private bool fitsValueList(JDFIntegerRangeList rangelist, EnumFitsValue valuelist)
{
JDFIntegerRangeList list = null;
if (valuelist.Equals(EnumFitsValue.Allowed))
{
list = getAllowedValueList();
}
else
{
list = getPresentValueList();
}
if (list == null)
{
return(true);
}
EnumListType listType = getListType();
if (listType.Equals(EnumListType.CompleteList))
{
return(fitsCompleteList(rangelist, list));
}
else if (listType.Equals(EnumListType.CompleteOrderedList))
{
return(fitsCompleteOrderedList(rangelist, list));
}
else if (listType.Equals(EnumListType.ContainedList))
{
return(fitsContainedList(rangelist, list));
}
int siz = rangelist.Count;
for (int i = 0; i < siz; i++)
{
JDFIntegerRange range = (JDFIntegerRange)rangelist[i];
// if range looks like"0~-1" but no xdef, then we assume that
// xdef=lastIntegerInList
int lastInList = ((JDFIntegerRange)list[list.Count - 1]).Right;
int leftInRange = range.Left;
int rightInRange = range.Right;
if (lastInList > 0 && ((rightInRange < 0 && Math.Abs(rightInRange) < lastInList) || (leftInRange < 0 && Math.Abs(leftInRange) < lastInList)))
{
range.setDef(lastInList);
}
if (!list.isPartOfRange(range))
{
return(false);
}
}
return(true);
}
///
/// <summary> * fitsValueMod - checks whether <code>rangelist</code> matches
/// * AllowedValueMod/PresentValueMod, specified for this State
/// * </summary>
/// * <param name="rangelist">
/// * range list to test </param>
/// * <param name="valuemod">
/// * switches between AllowedValueMod and PresentValueMod.
/// * </param>
/// * <returns> boolean - true, if <code>rangelist</code> matches the
/// * <code>valuemod</code> or if AllowedValueMod is not specified </returns>
///
private bool fitsValueMod(JDFIntegerRangeList rangelist, EnumFitsValue valuemod)
{
if (valuemod.Equals(EnumFitsValue.Allowed))
{
if (!hasAttribute(AttributeName.ALLOWEDVALUEMOD))
{
return(true);
}
}
else
{
if (!hasAttribute(AttributeName.ALLOWEDVALUEMOD) && !hasAttribute(AttributeName.PRESENTVALUEMOD))
{
return(true);
}
}
JDFXYPair mod;
if (valuemod.Equals(EnumFitsValue.Allowed))
{
mod = getAllowedValueMod();
}
else
{
mod = getPresentValueMod();
}
int divi = (int)(mod.X + 0.5); // X - the Modulo
int shift = (int)(mod.Y + 0.5); // Y - offset of the
// allowed/present value
if (divi == 0) // ValueMod can't be "0 x"
{
return(false);
}
JDFIntegerList v = rangelist.getIntegerList();
int[] vi = v.getIntArray();
int siz = vi.Length;
for (int i = 0; i < siz; i++)
{
if ((((vi[i] % divi) - shift) % divi) != 0)
{
return(false);
}
}
return(true);
}
public void testSetAllowedValueList()
{
JDFIntegerRangeList integerList = new JDFIntegerRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(integerList);
Assert.AreEqual(integerList, iState.getPresentValueList());
Assert.AreEqual(integerList, iState.getAllowedValueList());
JDFIntegerRangeList integerList2 = new JDFIntegerRangeList("1 2 3 7~77");
iState.setPresentValueList(integerList2);
Assert.AreEqual(integerList2, iState.getPresentValueList());
Assert.AreEqual(integerList, iState.getAllowedValueList());
}
public virtual void testContentData()
{
d = new JDFDoc("JDF");
n = d.getJDFRoot();
n.setType(EnumType.Approval);
JDFRunList rl = (JDFRunList)n.addResource(ElementName.RUNLIST, EnumUsage.Input);
pl = rl.appendPageList();
pl.makeRootResource("PageList", null, true);
cl = pl.appendContentList();
cl.makeRootResource("ContentList", null, true);
JDFContentData cd0 = cl.appendContentData();
cd0.setAttribute(AttributeName.CONTENTLISTINDEX, "1 2 3");
KElement book = cd0.appendElement("ContentMetaData");
book.setAttribute("ISBN", "0123456789");
JDFComment abstrakt = (JDFComment)book.appendElement("Comment");
abstrakt.setName("Abstract");
abstrakt.setText("Abstract of the book\nin english");
JDFEmployee editor = (JDFEmployee)book.appendElement(ElementName.EMPLOYEE);
editor.appendPerson().setFamilyName("authorName");
editor.setRoles(new VString("Editor", null));
book.setAttribute("Title", "book thing");
int p = 1;
for (int i = 1; i < 4; i++)
{
JDFContentData cd = cl.appendContentData();
cd.setAttribute("ID", "CD_" + i);
KElement chap = cd.appendElement("ContentMetaData");
chap.setAttribute("Title", "Chapter " + i);
JDFEmployee author = (JDFEmployee)chap.appendElement(ElementName.EMPLOYEE);
author.appendPerson().setFamilyName("authorName" + i);
author.setRoles(new VString("Author", null));
JDFPageData pd = pl.appendPageData();
JDFIntegerRangeList integerRangeList = new JDFIntegerRangeList();
integerRangeList.Append(p, p + i);
p += i + 1;
pd.setAttribute("PageIndex", integerRangeList.ToString());
JDFPageElement pe = pd.appendPageElement();
pe.setAttribute("ContentDataRefs", cd.getID());
}
pl.setXMLComment("Note that multiple page elements may but need not be specified\nit is also possible to reference only on pageEleemnt that spans the entire book");
d.write2File(sm_dirTestDataTemp + "ContentMetaData.jdf", 2, false);
}
public void testAddValue()
{
JDFIntegerRangeList integerList = new JDFIntegerRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(integerList);
iState.addValue("24", EnumFitsValue.Allowed);
Assert.AreEqual(integerList, iState.getAllowedValueList());
iState.addValue("45", EnumFitsValue.Allowed);
Assert.AreEqual(new JDFIntegerRangeList("1 ~ 45"), iState.getAllowedValueList());
iState.addValue("48", EnumFitsValue.Allowed);
Assert.AreEqual(new JDFIntegerRangeList("1 ~ 45 48"), iState.getAllowedValueList());
iState.addValue("49", EnumFitsValue.Present);
Assert.AreEqual(new JDFIntegerRangeList("49"), iState.getPresentValueList());
}
public virtual void testIntegerState()
{
JDFDoc d = new JDFDoc("IntegerState");
JDFIntegerState @is = (JDFIntegerState)d.getRoot();
JDFIntegerRangeList irl = new JDFIntegerRangeList("12~15");
@is.setAllowedValueList(irl);
@is.setListType(EnumListType.RangeList);
Assert.IsTrue(@is.fitsValue("12~15", EnumFitsValue.Allowed));
Assert.IsFalse(@is.fitsValue("19~33", EnumFitsValue.Allowed));
irl = new JDFIntegerRangeList("12~15 19~33");
@is.setAllowedValueList(irl);
Assert.IsTrue(@is.fitsValue("12~15", EnumFitsValue.Allowed));
Assert.IsTrue(@is.fitsValue("19~33", EnumFitsValue.Allowed));
}
///
/// <summary> * insert pageSet into PageSet.
/// * </summary>
/// * <param name="pageSet"> </param>
///
public virtual void insertPageSet(int pageSet)
{
JDFIntegerRangeList irl = getPageSet();
if (irl == null)
{
setPageSet(new JDFIntegerRangeList(new JDFIntegerRange(pageSet)));
}
else if (!irl.inRange(pageSet))
{
irl.Append(pageSet);
irl.normalize(true);
setPageSet(irl);
}
}
public void testFitsListType_IntegerState()
{
JDFIntegerRangeList list = new JDFIntegerRangeList();
list.Append(1);
list.Append(8);
list.Append(12);
// System.out.println(state.fitsCompleteList(value, list));
// System.out.println(state.fitsCompleteOrderedList(value, list));
// System.out.println(state.fitsContainedList(value, list));
// state.setListType(EnumListType.List);
// System.out.println(state.fitsListType(list.toString()));
// System.out.println(state.getListType());
}
///
/// <summary> * (20) get JDFIntegerRangeList attribute ElementPages </summary>
/// * <returns> JDFIntegerRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFIntegerRangeList </returns>
///
public virtual JDFIntegerRangeList getElementPages()
{
string strAttrName = "";
JDFIntegerRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.ELEMENTPAGES, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFIntegerRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * (20) get JDFIntegerRangeList attribute TypeOccurrenceNum </summary>
/// * <returns> JDFIntegerRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFIntegerRangeList </returns>
///
public virtual JDFIntegerRangeList getTypeOccurrenceNum()
{
string strAttrName = "";
JDFIntegerRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.TYPEOCCURRENCENUM, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFIntegerRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * (20) get JDFIntegerRangeList attribute ModuleIndex </summary>
/// * <returns> JDFIntegerRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFIntegerRangeList </returns>
///
public virtual JDFIntegerRangeList getModuleIndex()
{
string strAttrName = "";
JDFIntegerRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.MODULEINDEX, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFIntegerRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * (20) get JDFIntegerRangeList attribute FieldRange </summary>
/// * <returns> JDFIntegerRangeList the value of the attribute, null if a the
/// * attribute value is not a valid to create a JDFIntegerRangeList </returns>
///
public virtual JDFIntegerRangeList getFieldRange()
{
string strAttrName = "";
JDFIntegerRangeList nPlaceHolder = null;
strAttrName = getAttribute(AttributeName.FIELDRANGE, null, JDFConstants.EMPTYSTRING);
try
{
nPlaceHolder = new JDFIntegerRangeList(strAttrName);
}
catch (FormatException)
{
return(null);
}
return(nPlaceHolder);
}
///
/// <summary> * fitsContainedList - tests whether <code>value</code> matches the given
/// * testlist (ListType=ContainedList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlist </returns>
///
private bool fitsContainedList(JDFIntegerRangeList @value, JDFIntegerRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
for (int i = 0; i < v_size; i++)
{
for (int j = 0; j < l_size; j++)
{
if (@value[i].Equals(list[j]))
{
return(true);
}
}
}
return(false);
}
public void testIsValid()
{
JDFIntegerList integerList = new JDFIntegerList("1 2 3");
iState.setDefaultValue(integerList);
iState.setCurrentValue(integerList);
Assert.IsFalse(iState.isValid(EnumValidationLevel.Complete));
iState.setListType(EnumListType.List);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
JDFIntegerRangeList integerRList = new JDFIntegerRangeList("1 2 3 4 ~ 44");
iState.setAllowedValueList(integerRList);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
JDFIntegerRangeList integerList2 = new JDFIntegerRangeList("1 2 3 7~77");
iState.setPresentValueList(integerList2);
Assert.IsTrue(iState.isValid(EnumValidationLevel.Complete));
}
///
/// <summary> * fitsCompleteList - tests whether <code>value</code> matches the given
/// * testlist (ListType=CompleteList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlist </returns>
///
private bool fitsCompleteList(JDFIntegerRangeList @value, JDFIntegerRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
if (v_size != l_size)
{
return(false);
}
if ([email protected]())
{
return(false);
}
JDFIntegerRangeList valueList = new JDFIntegerRangeList(@value);
bool bFound;
for (int i = l_size - 1; i >= 0; i--)
{
bFound = false;
for (int j = valueList.Count - 1; j >= 0; j--)
{
if (list[i].Equals(valueList[j]))
{
valueList.erase(j);
bFound = true;
break;
}
}
if (!bFound)
{
return(false);
}
}
return(true);
}
///
/// <summary> * fitsCompleteOrderedList - tests whether <code>value</code> matches the
/// * given testlist (ListType=CompleteOrderedList)
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="list">
/// * testlist, either AllowedValueList or PresentValueList.
/// * </param>
/// * <returns> boolean - true, if <code>value</code> matches the testlist </returns>
///
private bool fitsCompleteOrderedList(JDFIntegerRangeList @value, JDFIntegerRangeList list)
{
int v_size = @value.Count;
int l_size = list.Count;
if (v_size != l_size)
{
return(false);
}
if ([email protected]())
{
return(false);
}
for (int i = 0; i < l_size; i++)
{
if (!list[i].Equals(@value[i]))
{
return(false);
}
}
return(true);
}
public virtual void testLayerRunList()
{
JDFElement.setLongID(false);
setUpDoc();
JDFIntegerRangeList pageRange = new JDFIntegerRangeList(new JDFIntegerRange(0, -1, 16));
rlIn.setDescriptiveName("Layers are just another partversion layer selection in the link is achieved using multiple partversions");
JDFRunList rlAll = (JDFRunList)rlIn.addPartition(EnumPartIDKey.PartVersion, "CMYK");
rlAll.setFileURL("background.pdf");
rlAll.setPages(pageRange);
JDFRunList rlEn = (JDFRunList)rlIn.addPartition(EnumPartIDKey.PartVersion, "FR");
rlEn.setFileURL("Francais.pdf");
rlEn.setPages(pageRange);
rlEn.setLogicalPage(16);
JDFRunList rlDe = (JDFRunList)rlIn.addPartition(EnumPartIDKey.PartVersion, "De");
rlDe.setFileURL("deutsch.pdf");
rlDe.setPages(pageRange);
rlDe.setLogicalPage(16);
setupLayout(false);
n.setPartStatus(new JDFAttributeMap(EnumPartIDKey.PartVersion, "De"), EnumNodeStatus.Completed, null);
JDFResourceLink rl = n.getLink(rlIn, null);
rl.setPartition(EnumPartIDKey.PartVersion, "CMYK De");
d.write2File(sm_dirTestDataTemp + "LayerList.jdf", 2, false);
rl.setPartition(EnumPartIDKey.PartVersion, "De");
rl.setDescriptiveName("Only DE, no bkg partversion is selected");
d.write2File(sm_dirTestDataTemp + "LayerList_BKG.jdf", 2, false);
}
//
// * // Element getter / setter
//
//
// * (non-Javadoc)
// *
// * @see
// * org.cip4.jdflib.resource.devicecapability.JDFAbstractState#addValue(java
// * .lang.String, org.cip4.jdflib.datatypes.JDFBaseDataTypes.EnumFitsValue)
//
public override void addValue(string @value, EnumFitsValue testlists)
{
if (fitsValue(@value, testlists))
{
return;
}
if (!StringUtil.isInteger(@value))
{
return;
}
int i = StringUtil.parseInt(@value, 0);
if (testlists == null || EnumFitsValue.Allowed.Equals(testlists))
{
JDFIntegerRangeList list = getAllowedValueList();
if (list == null)
{
list = new JDFIntegerRangeList();
}
list.Append(i);
list.normalize(true);
setAllowedValueList(list);
}
if (testlists == null || EnumFitsValue.Present.Equals(testlists))
{
JDFIntegerRangeList list = getPresentValueList();
if (list == null || !hasAttribute(AttributeName.PRESENTVALUELIST))
{
list = new JDFIntegerRangeList();
}
list.Append(i);
list.normalize(true);
setPresentValueList(list);
}
}
public void testFitsValue()
{
JDFParser p = new JDFParser();
string strNode = "<IntegerState Name=\"BitDepth\" DefaultValue=\"1\" AllowedValueList=\"1 8 12\"/>";
JDFDoc jdfDoc = p.parseString(strNode);
JDFIntegerState state = (JDFIntegerState)jdfDoc.getRoot();
JDFIntegerRangeList list = new JDFIntegerRangeList();
list.Append(new JDFIntegerRange(1, 12)); // 1~12
// list.append(12);
state.setListType(EnumListType.RangeList);
Assert.IsFalse(state.fitsValue(list.ToString(), EnumFitsValue.Allowed), "ListType=RangeList");
JDFIntegerRangeList list2 = new JDFIntegerRangeList();
list2.Append(new JDFIntegerRange(1, -2)); // 1~-2
JDFIntegerRangeList allowedVL = new JDFIntegerRangeList();
allowedVL.Append(new JDFIntegerRange(1, 32)); // 1~32
state.setAllowedValueList(allowedVL); // new AllowedVlaueList
Assert.IsTrue(state.fitsValue(list2.ToString(), EnumFitsValue.Allowed), "xDef is wrong");
list.erase(list.Count - 1); // erase "1~12"
list.Append(2);
list.Append(12);
list.Append(22);
state.setListType(EnumListType.List);
state.setAllowedValueMod(new JDFXYPair(10, 2));
Assert.IsTrue(state.fitsValue(list.ToString(), EnumFitsValue.Allowed), "ListType=List, ValueMod=" + state.getAllowedValueMod());
}
// ---------------------------------------------------------------------
// Methods for Attribute Docs
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute Docs </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setDocs(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.DOCS, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute ElementPages
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute ElementPages </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setElementPages(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.ELEMENTPAGES, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute Sets
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute Sets </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setSets(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.SETS, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute PageRefs
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute PageRefs </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setPageRefs(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.PAGEREFS, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute PageListIndex
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute PageListIndex </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setPageListIndex(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.PAGELISTINDEX, @value, null);
}
// ---------------------------------------------------------------------
// Methods for Attribute PageSet
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute PageSet </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setPageSet(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.PAGESET, @value, null);
}
///
/// <summary> * Set attribute Range as a IntegerRangeList
/// * </summary>
/// * <param name="JDFIntegerRangeList"> value - the value to set </param>
///
public virtual void setRange(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.RANGE, @value.ToString(), null);
}
// ************************************************************************
// * Attribute getter / setter
// * ************************************************************************
//
// ---------------------------------------------------------------------
// Methods for Attribute FieldRange
// ---------------------------------------------------------------------
///
/// <summary> * (36) set attribute FieldRange </summary>
/// * <param name="value">: the value to set the attribute to </param>
///
public virtual void setFieldRange(JDFIntegerRangeList @value)
{
setAttribute(AttributeName.FIELDRANGE, @value, null);
}
