public virtual void testEnumerationState()
{
JDFDoc d = new JDFDoc("EnumerationState");
JDFEnumerationState es = (JDFEnumerationState)d.getRoot();
VString v = new VString();
v.Add("foo");
v.Add("bar");
es.setAllowedValueList(v);
Assert.IsTrue(es.fitsValue("foo", EnumFitsValue.Allowed));
Assert.IsTrue(es.fitsValue("bar", EnumFitsValue.Allowed));
Assert.IsFalse(es.fitsValue("fnarf", EnumFitsValue.Allowed));
es.setListType(EnumListType.List);
Assert.IsTrue(es.fitsValue("foo", EnumFitsValue.Allowed));
Assert.IsTrue(es.fitsValue("foo bar", EnumFitsValue.Allowed));
Assert.IsTrue(es.fitsValue("foo bar foo", EnumFitsValue.Allowed));
Assert.IsFalse(es.fitsValue("foo bar fnarf", EnumFitsValue.Allowed));
es.setListType(EnumListType.CompleteList);
Assert.IsFalse(es.fitsValue("foo", EnumFitsValue.Allowed));
Assert.IsTrue(es.fitsValue("foo bar", EnumFitsValue.Allowed));
Assert.IsTrue(es.fitsValue("bar foo", EnumFitsValue.Allowed));
Assert.IsFalse(es.fitsValue("foo bar foo", EnumFitsValue.Allowed));
Assert.IsFalse(es.fitsValue("foo bar fnarf", EnumFitsValue.Allowed));
// TODO implement more list types
// es.setListType(EnumListType.OrderedList);
// Assert.IsFalse(es.fitsValue("foo", EnumFitsValue.Allowed));
// Assert.IsTrue(es.fitsValue("foo bar", EnumFitsValue.Allowed));
// Assert.IsFalse(es.fitsValue("bar foo", EnumFitsValue.Allowed));
// Assert.IsFalse(es.fitsValue("foo bar foo", EnumFitsValue.Allowed));
// Assert.IsFalse(es.fitsValue("foo bar fnarf", EnumFitsValue.Allowed));
}
public virtual void testTokenize()
{
string s = "1 2\n3 \n4 5";
VString v = new VString();
v.Add("1");
v.Add("2");
v.Add("3");
v.Add("4");
v.Add("5");
CollectionAssert.AreEqual(v, StringUtil.tokenize(s, " \n", false));
}
///
/// <summary> * This function first, gets all required attributes and then compare them with the attributes present and returns a
/// * Vector with the missing attributes
/// * </summary>
/// * <param name="nMax"> maximum size of the returned Vector
/// * </param>
/// * <returns> VString vector with the missing attribute names
/// *
/// * @default getMissingAttributes(9999999) </returns>
///
public override VString getMissingAttributes(int nMax)
{
VString v = base.getMissingAttributes(nMax);
if (nMax <= 0 || v.Count <= nMax)
{
if (!hasAttribute(AttributeName.MODULEINDEX) && !hasAttribute(AttributeName.MODULEID))
{
v.Add(AttributeName.MODULEID);
v.Add(AttributeName.MODULEINDEX);
}
}
return(v);
}
///
/// <summary> * add an element 's' to the Range attribute
/// * </summary>
/// * <param name="String"> s - the value to add </param>
///
public virtual void addRange(string s)
{
VString v = getRange();
v.Add(s);
setRange(v);
}
///
/// <summary> * </summary>
///
protected internal virtual JDFColorIntent initColorIntent(JDFNode node, int front, int back, string coatings)
{
JDFColorIntent ci = (JDFColorIntent)node.addResource(ElementName.COLORINTENT, EnumUsage.Input);
VElement vci = new VElement();
nCols[0] = front;
nCols[1] = back;
if (front != back && back != 0)
{
vci.Add(ci.addPartition(EnumPartIDKey.Side, EnumSide.Front));
vci.Add(ci.addPartition(EnumPartIDKey.Side, EnumSide.Back));
}
else
{
vci.Add(ci);
}
for (int i = 0; i < vci.Count; i++)
{
int colors = i == 0 ? front : back;
VString newCols = new VString();
for (int j = 0; j < colors; j++)
{
newCols.Add(cols[j]);
}
JDFColorIntent cip = (JDFColorIntent)vci[i];
cip.appendColorsUsed().setSeparations(newCols);
}
ci.setResStatus(EnumResStatus.Available, false);
ci.preferredToActual();
return(ci);
}
private void initMyArgs(string[] argv, string strSwitchParameter, string strArgumentParameter, string strRequiredParameter)
{
string[] argvLocal = argv;
if (argvLocal == null)
{
argvLocal = new string[0];
}
m_switchParameterString = strSwitchParameter;
m_argumentParameterString = strArgumentParameter;
m_requiredParameterString = strRequiredParameter;
m_argV = new VString(argvLocal);
m_onlyArgs = new VString();
// cut of the "-" from the options, but don't remove it from file names
for (int i = 0; i < argvLocal.Length; i++)
{
string tempString = argvLocal[i];
if (tempString.StartsWith("-"))
{
string whazzLeft = tempString.Substring(1);
while (whazzLeft.Length > 0)
{
string flag = whazzLeft.Substring(0, 1);
if (m_switchParameterString != null && m_switchParameterString.IndexOf(flag) >= 0)
{
m_flags.Add(flag);
whazzLeft = whazzLeft.Substring(1);
}
else if (m_argumentParameterString != null && m_argumentParameterString.IndexOf(flag) >= 0)
{
string wl2 = whazzLeft.Substring(1);
if (wl2.Length == 0 && argvLocal.Length > i + 1)
{
wl2 = argvLocal[i + 1];
i++;
}
m_Parameters.Add(flag, wl2);
whazzLeft = "";
}
else
{
// oops... don't know it; skip it
whazzLeft = whazzLeft.Substring(1);
if (!flag.Equals("-"))
{
Console.WriteLine("unknown flag:" + flag);
}
}
}
}
else
{
m_onlyArgs.Add(tempString);
}
}
}
///
/// <summary> * Gets the NamePath of this DevCap in form "
/// * <code>DevCapsName/SubelemName1/SubelemName2/...</code>"<br>
/// * If this DevCap is located in DevCapPool and not in a DevCaps, it
/// * describes the reusable resource. In this case DevCap root will have the
/// * attribute "Name" = value of DevCaps/@Name, but will have no info about
/// * <code>DevCaps/@Context</code> or <code>DevCaps/@LinkUsage</code>.
/// * <p>
/// * default: getNamePath(false)
/// * </summary>
/// * <param name="bRecurse">
/// * if true, returns "
/// * <code>DevCapsName/SubelemName1/SubelemName2/...</code>" </param>
/// * <returns> String - NamePath of this DevCap </returns>
///
public VString getNamePathVector()
{
string result = getDevCapsName();
EnumContext cont = getContext();
VString vResult = new VString();
if (cont.Equals(EnumContext.JMF) && (ParentNode is JDFMessageService) && result.Length > 4)
{
JDFMessageService serv = (JDFMessageService)ParentNode;
List <EnumFamily> vf = serv.getFamilies();
if (vf != null)
{
int size = vf.Count;
for (int i = 0; i < size; i++)
{
vResult.Add("JMF/" + vf[i].getName() + "/" + result.Substring(4));
}
}
if (EnumJMFRole.Sender.Equals(serv.getJMFRole()))
{
vResult.Add("JMF/Response/" + result.Substring(4));
}
}
else
{
if (cont.Equals(EnumContext.Link))
{
result = ElementName.JDF + "/" + ElementName.RESOURCELINKPOOL + "/" + result;
}
else if (cont.Equals(EnumContext.Resource))
{
string nam = result;
result = ElementName.JDF + "/" + ElementName.RESOURCEPOOL + "/" + result;
for (int i = 0; i < 6; i++)
{
vResult.Add(result);
result = result + "/" + nam;
}
}
vResult.Add(result);
}
return(vResult);
}
//
// * // FitsValue Methods
//
///
/// <summary> * fitsValue - tests, if the defined 'value' matches testlists, specified
/// * for this Evaluation
/// * </summary>
/// * <param name="String">
/// * value - value to test </param>
/// * <returns> boolean - true, if 'value' matches testlists or if testlists are
/// * not specified </returns>
///
public override bool fitsValue(string @value)
{
VString vs = new VString(@value, JDFConstants.BLANK);
int siz = vs.Count;
if (siz % 6 != 0)
{
return(false);
}
VString matrixList = new VString();
int i = 0;
StringBuilder sb = new StringBuilder(250);
sb.Append(vs[i]);
while ((i + 1) < siz)
{
do
{
sb.Append(JDFConstants.BLANK);
i++;
sb.Append(vs[i]);
} while ((i + 1) % 6 != 0);
matrixList.Add(sb.ToString());
if ((i + 1) < siz)
{
i++;
sb = new StringBuilder(250);
sb.Append(vs[i]);
}
}
if (!fitsListType(matrixList))
{
return(false);
}
for (int k = 0; k < matrixList.Count; k++)
{
string str = matrixList[k];
JDFMatrix matrix;
try
{
matrix = new JDFMatrix(str);
}
catch (FormatException)
{
return(false);
}
if ((fitsRotateMod(matrix) && fitsShift(matrix) && fitsTransforms(matrix) && fitsValueElem(matrix)) == false)
{
return(false);
}
}
return(true);
}
///
/// <summary> * get the keys as a Vector,
/// *
/// * @return </summary>
///
public virtual VString getKeys()
{
IEnumerator <string> it = getKeyIterator();
VString thisKeys = new VString();
while (it.MoveNext())
{
thisKeys.Add(it.Current);
}
return(thisKeys);
}
public virtual void testReduceMap()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap("a1", "v1");
VString keys = new VString();
keys.Add("a1");
m1.reduceMap(keys);
Assert.AreEqual(m1, m2);
}
protected internal virtual VString getMissingTerms(int iMin)
{
VElement v = getTermVector(null);
VString v2 = null;
if (v.Count < iMin)
{
v2 = new VString();
v2.Add("Term");
}
return(v2);
}
public virtual void testSetVString()
{
VString v = new VString();
v.Add("1");
v.Add("22");
v.Add("333");
v.Add("4444");
string s = StringUtil.setvString(v);
Assert.AreEqual("1 22 333 4444", s, "s");
s = StringUtil.setvString(v, "", "", "");
Assert.AreEqual("1223334444", s, "s");
s = StringUtil.setvString(v, null, null, null);
Assert.AreEqual("1223334444", s, "s");
string[] a = new string[v.Count];
a = v.ToArray();
s = StringUtil.setvString(a, " ", null, null);
Assert.AreEqual("1 22 333 4444", s, "s");
}
///
/// <summary> * GetRange
/// * </summary>
/// * <returns> Vector of strings in Range </returns>
///
private VString getRangeOfferRange(string elementName)
{
VString vL = new VString();
VElement v = getChildrenByTagName(elementName, null, null, true, true, 0);
for (int i = 0; i < v.Count; i++)
{
KElement e = v[i];
vL.Add(e.getText(0));
}
return(vL);
}
public virtual void testNameState()
{
JDFDoc d = new JDFDoc("NameState");
JDFNameState ns = (JDFNameState)d.getRoot();
VString nl = new VString();
nl.Add("anna~berta");
ns.setAllowedValueList(nl);
ns.setListType(EnumListType.RangeList);
Assert.IsTrue(ns.fitsValue("anna~berta", EnumFitsValue.Allowed));
Assert.IsFalse(ns.fitsValue("hans~otto", EnumFitsValue.Allowed));
nl.Add("anna~berta hans~otto");
ns.setAllowedValueList(nl);
Assert.IsTrue(ns.fitsValue("anna~berta", EnumFitsValue.Allowed));
Assert.IsTrue(ns.fitsValue("hans~otto", EnumFitsValue.Allowed));
ns.setAllowedValueList(null);
ns.setAllowedRegExp("*");
Assert.IsTrue(ns.fitsValue("hans~otto", EnumFitsValue.Allowed));
ns.setAllowedRegExp("[ab].*");
Assert.IsTrue(ns.fitsValue("al", EnumFitsValue.Allowed));
Assert.IsFalse(ns.fitsValue("cl", EnumFitsValue.Allowed));
}
public virtual void testTokenizeDelim()
{
string s = "http://aa/b?c";
VString v = new VString();
v.Add("http:");
v.Add("/");
v.Add("/");
v.Add("aa");
v.Add("/");
v.Add("b");
v.Add("?");
v.Add("c");
CollectionAssert.AreEqual(v, StringUtil.tokenize(s, "/?", true));
}
//
// * (non-Javadoc)
// *
// * @see
// * org.cip4.jdflib.core.JDFElement#getInvalidAttributes(org.cip4.jdflib.
// * core.KElement.EnumValidationLevel, boolean, int)
//
public override VString getInvalidAttributes(EnumValidationLevel level, bool bIgnorePrivate, int nMax)
{
VString vs = base.getInvalidAttributes(level, bIgnorePrivate, nMax);
if (nMax > 0 && vs.Count > nMax)
{
return(vs);
}
if (!EnumValidationLevel.RecursiveComplete.Equals(level) && !EnumValidationLevel.RecursiveIncomplete.Equals(level))
{
return(vs);
}
if (vs.Contains(AttributeName.DEVCAPREF))
{
return(vs);
}
if (hasAttribute(AttributeName.DEVCAPREF))
{
JDFDevCapPool devCapPool = getDevCapPool();
if (devCapPool == null)
{
vs.Add(AttributeName.DEVCAPREF);
return(vs);
}
VString idRefs = getDevCapRef();
for (int i = 0; i < idRefs.Count; i++)
{
JDFDevCap devCap = devCapPool.getDevCap(idRefs.stringAt(i));
if (devCap == null)
{
vs.Add(AttributeName.DEVCAPREF);
return(vs);
}
}
}
return(vs);
}
///
/// <summary> * set actual values to the preset defined in preferred
/// * </summary>
/// * <param name="String">
/// * key the key of the span resource to modify, if null do all </param>
/// * <returns> number of elements modified </returns>
///
public virtual int preferredToActual(string key)
{
int nDone = 0;
if (!isLeaf())
{
VElement leaves = getLeaves(false);
for (int i = 0; i < leaves.Count; i++)
{
JDFIntentResource ri = (JDFIntentResource)leaves[i];
nDone += ri.preferredToActual(key);
}
return(nDone);
}
VString vKeys = new VString();
if (KElement.isWildCard(key))
{
VElement v = getChildrenByTagName(null, null, new JDFAttributeMap(AttributeName.DATATYPE, (string)null), true, true, 0);
for (int i = 0; i < v.Count; i++)
{
vKeys.Add(v[i].Name);
}
}
else
{
vKeys.Add(key);
}
for (int i = 0; i < vKeys.Count; i++)
{
JDFSpanBase @base = (JDFSpanBase)getElement(vKeys[i], JDFConstants.EMPTYSTRING, 0);
if (@base.preferredToActual())
{
nDone++;
}
}
return(nDone);
}
///
/// <summary> * get the missing elements as a vector
/// * </summary>
/// * <param name="int"> nMax maximum value of missing elements to return
/// * </param>
/// * <returns> Vector vector with nMax missing elements
/// *
/// * default: getMissingElements(99999999) </returns>
///
public override VString getMissingElements(int nMax)
{
VString v = base.getMissingElements(nMax);
if (v.Count > nMax)
{
return(v);
}
if (getRasterFileLocation() == null)
{
v.Add("FileSpec[@ResourceUsage=\"RasterFileLocation\"]");
}
return(v);
}
public virtual void testProcessAllFiles()
{
JDFValidator checkJDF = new JDFValidator();
checkJDF.setPrint(false);
checkJDF.bQuiet = true;
checkJDF.level = EnumValidationLevel.Complete;
VString files = new VString();
files.Add(sm_dirTestData + "job.jdf");
checkJDF.allFiles = files;
XMLDoc schemaValidationResult = checkJDF.processAllFiles();
Assert.IsNotNull(schemaValidationResult.getRoot().getXPathElement("TestFile/SchemaValidationOutput"));
Assert.IsNotNull(schemaValidationResult.getRoot().getXPathElement("TestFile/CheckJDFOutput"));
}
public VString getNamePathVector()
{
VString vResult = new VString();
List <EnumFamily> families = getFamilies();
if (families != null)
{
int siz = families.Count;
for (int i = 0; i < siz; i++)
{
vResult.Add(families[i].getName());
}
}
return(vResult);
}
public void testFitsValue()
{
JDFParser p = new JDFParser();
string strNode = "<NameState Name=\"BitDepth\" DefaultValue=\"1\" AllowedValueList=\"a b c d\"/>";
JDFDoc jdfDoc = p.parseString(strNode);
JDFNameState state = (JDFNameState)jdfDoc.getRoot();
VString list = new VString("a b c", null);
state.setListType(EnumListType.RangeList);
Assert.IsFalse(state.fitsValue(list.ToString(), EnumFitsValue.Allowed), "ListType=RangeList");
VString list2 = new VString();
list2.Add("d"); // 1~-2
}
//
// * // FitsValue Methods
//
///
/// <summary> * fitsValue - checks whether <code>value</code> matches the Allowed test
/// * lists or Present test lists specified for this State
/// * </summary>
/// * <param name="value">
/// * value to test </param>
/// * <param name="testlists">
/// * the test lists the value has to match. In this State the test
/// * lists are RotateMod, Shift, Transforms and ValueElem.<br>
/// * Choose one of two values: FitsValue_Allowed or
/// * FitsValue_Present. (Defaults to Allowed)
/// * </param>
/// * <returns> boolean - true, if the value matches all test lists or if Allowed
/// * test lists are not specified </returns>
///
public override bool fitsValue(string @value, EnumFitsValue testlists)
{
VString vs = new VString(@value, JDFConstants.BLANK);
int siz = vs.Count;
if (siz % 6 != 0)
{
return(false);
}
List <JDFMatrix> matrixList = new List <JDFMatrix>();
for (int i = 0; i < siz; i += 6)
{
VString v = new VString();
v.Capacity = 6;
for (int j = 0; j < 6; j++)
{
v.Add(vs.stringAt(i + j));
}
try
{
JDFMatrix m = new JDFMatrix(StringUtil.setvString(vs, " ", null, null));
matrixList.Add(m);
}
catch (FormatException)
{
return(false);
}
}
if (fitsListType(matrixList))
{
for (int k = 0; k < matrixList.Count; k++)
{
JDFMatrix matrix = matrixList[k];
if (!fitsRotateMod(matrix, testlists) || !fitsShift(matrix, testlists) || !fitsTransforms(matrix, testlists) || !fitsValueElem(matrix, testlists))
{
return(false);
}
}
return(true);
}
return(false);
}
public virtual void testGetMinAvailability()
{
JDFDoc d = new JDFDoc(ElementName.MODULEPOOL);
JDFModulePool mp = (JDFModulePool)d.getRoot();
for (int i = 0; i < 4; i++)
{
JDFModuleCap mc = mp.appendModuleCap();
mc.setID("I" + i);
mc.setAvailability(EnumAvailability.getEnum(i));
}
VString s = new VString();
for (int i = 3; i >= 0; i--)
{
s.Add("I" + i);
Assert.AreEqual(EnumAvailability.getEnum(i), mp.getMinAvailability(s));
}
}
///
/// <summary> * GetResIds - returns a set of all IDs of the resources that are in this pool
/// * </summary>
/// * <returns> Vector - all IDs of the pool childs </returns>
///
public virtual VString getResIds()
{
VString setID = new VString();
VElement nl = getPoolChildren(null, null, null);
int l = nl.Count;
for (int i = 0; i < l; i++)
{
string s = ((JDFResource)nl[i]).getAttribute(AttributeName.ID);
if (s.Equals(JDFConstants.EMPTYSTRING))
{
continue;
}
setID.Add(s);
}
return(setID);
}
public virtual void testPreflightReport()
{
testPreflightProfile();
JDFPreflightReport prp = (JDFPreflightReport)n.appendMatchingResource(ElementName.PREFLIGHTREPORT, EnumProcessUsage.AnyOutput, null);
prp.refElement(preparms);
prp.refElement(inRun);
prp.refElement(prrp);
JDFAttributeMap prMap = new JDFAttributeMap();
VString groupBy = new VString();
prMap.put("CompressionTypes", "JPEG");
prMap.put("PageNumber", "2");
groupBy.Add("PageNumber");
JDFPRItem pi = prp.setPR(aPool.getAction(0), 2, prMap, groupBy);
Assert.IsNotNull(pi);
Assert.AreEqual(1, pi.getOccurrences());
prMap.put("CompressionTypes", "JPEG2000");
JDFPRItem pi2 = prp.setPR(aPool.getAction(0), 2, prMap, groupBy);
Assert.IsNotNull(pi2);
Assert.AreEqual(2, pi2.getOccurrences());
Assert.AreEqual(pi, pi2);
prMap.put("PageNumber", "3");
JDFPRItem pi3 = prp.setPR(aPool.getAction(0), 3, prMap, groupBy);
Assert.IsNotNull(pi3);
Assert.AreEqual(3, pi3.getOccurrences());
Assert.AreEqual(pi3, pi);
Assert.AreEqual(new JDFIntegerRangeList("2 ~ 3"), pi.getPageSet());
JDFPRItem pi4 = prp.setPR(aPool.getAction(1), 3, null, null);
Assert.AreEqual(1, pi4.getOccurrences());
Assert.AreNotEqual(pi, pi4);
Assert.AreEqual(new JDFIntegerRangeList("3"), pi4.getPageSet());
Assert.AreEqual(2, prp.numChildElements(ElementName.PRITEM, null));
n.getOwnerDocument_KElement().write2File(sm_dirTestDataTemp + "PreflightReport.jdf", 2, false);
}
///
/// <summary> * get list of missing elements
/// * </summary>
/// * <param name="nMax">
/// * maximum size of the returned vector </param>
///
public override VString getMissingElements(int nMax)
{
VString vs = getTheElementInfo().requiredElements();
vs = getMissingElementVector(vs, nMax);
VElement v2 = getChildElementVector_KElement(null, null, null, true, 0);
int n = 0;
for (int i = 0; i < v2.Count; i++)
{
if (v2[i] is JDFRefElement)
{
n++;
}
}
if (n == 0)
{
vs.Add("RefElement");
}
return(vs);
}
///
/// <summary> * isValid - validates the given String
/// * </summary>
/// * <param name="s"> the given string
/// * </param>
/// * <exception cref="FormatException"> - if the String has not a valid format </exception>
///
protected internal virtual void isValid(string s)
{
VString vs = new VString();
//StringTokenizer sToken = new StringTokenizer(s, "~");
SupportClass.Tokenizer sToken = new SupportClass.Tokenizer(s, "~");
while (sToken.HasMoreTokens())
{
string str = sToken.NextToken();
vs.Add(str.Trim());
}
Left = vs[0];
if (vs.Count == 2)
{
Right = vs[1];
}
else
{
Right = vs[0];
}
}
public void testFitsValue_MatrixState()
{
JDFDoc jdfDoc = new JDFDoc(ElementName.JDF);
JDFNode root = jdfDoc.getJDFRoot();
JDFMatrix matrix1 = new JDFMatrix("1 0 0 1 3.14 21631.3");
JDFMatrix matrix2 = new JDFMatrix("0 1 1 0 2 21000");
List <ValuedEnum> transforms = new List <ValuedEnum>();
transforms.Add(EnumOrientation.Rotate0);
transforms.Add(EnumOrientation.Rotate270);
transforms.Add(EnumOrientation.Flip0);
JDFRectangle shift = new JDFRectangle("2 4 20000 23000");
string value1 = "1 0 0 1 3.14 21631.3";
JDFMatrixState k = (JDFMatrixState)root.appendElement("MatrixState");
k.appendValue();
// k.setValueValueUsage(0, EnumFitsValue.Allowed);
k.setValueAllowedValue(0, matrix2);
k.appendValue();
// k.setValueValueUsage(1, EnumFitsValue.Present);
k.setValueAllowedValue(1, matrix1);
k.setAllowedTransforms(transforms);
k.setAllowedShift(shift);
k.setAllowedRotateMod(15);
EnumListType lt = EnumListType.UniqueList;
// JDFAbstractState.EnumListType lt = EnumListType.ListType.Unknown;
// JDFAbstractState.EnumListType lt = EnumListType.ListType.List;
k.setListType(lt);
// EnumListType listType = k.getListType();
Assert.IsTrue(k.fitsValue(value1, EnumFitsValue.Allowed), "Matrix OK");
string @value = "1 2 3 4 5 6 7 8 9 10 11 12 3 4 5 6 7 8";
VString vs = new VString(@value, JDFConstants.BLANK);
int siz = vs.Count;
Assert.AreEqual(0, siz % 6, "It is not a Matrix");
VString matrixList = new VString();
int i = 0;
StringBuilder sb = new StringBuilder(250);
sb.Append(vs[i]);
while ((i + 1) < siz)
{
do
{
sb.Append(JDFConstants.BLANK);
i++;
sb.Append(vs[i]);
} while ((i + 1) % 6 != 0);
matrixList.Add(sb.ToString());
if ((i + 1) < siz)
{
i++;
sb = new StringBuilder(250);
sb.Append(vs[i]);
}
}
for (int z = 0; z < matrixList.Count; z++)
{
JDFMatrix matrix3 = new JDFMatrix(matrixList.stringAt(z));
//matrix3.A;
}
}
///
/// * <param name="n"> </param>
/// * <param name="rlOut"> </param>
///
private void setupLayout(bool complex)
{
JDFLayout lo = (JDFLayout)n.appendMatchingResource("Layout", EnumProcessUsage.AnyInput, null);
JDFLayerList ll = lo.appendLayerList();
const string layerNames = "BackGround Language";
VString layers = new VString(layerNames, " ");
if (complex)
{
layers.Add("Currency");
}
for (int i = 0; i < layers.Count; i++)
{
ll.appendLayerDetails().setName(layers.stringAt(i));
}
JDFRunList rlOutDe = (JDFRunList)rlOut.addPartition(EnumPartIDKey.PartVersion, "De");
rlOutDe.setResStatus(EnumResStatus.Available, true);
JDFRunList rlOutEn = (JDFRunList)rlOut.addPartition(EnumPartIDKey.PartVersion, "Fr");
rlOutEn.setResStatus(EnumResStatus.Unavailable, true);
if (complex)
{
JDFRunList rlOutSwiss = (JDFRunList)rlOut.addPartition(EnumPartIDKey.PartVersion, "Ch");
rlOutSwiss.setResStatus(EnumResStatus.Unavailable, true);
}
for (int i = 0; i < 2; i++)
{
string sheetName = "Sheet" + i;
JDFLayout lSheet = (JDFLayout)lo.addPartition(EnumPartIDKey.SheetName, sheetName);
JDFRunList rlSheet = (JDFRunList)rlOutDe.addPartition(EnumPartIDKey.SheetName, sheetName);
for (int j = 0; j < 2; j++)
{
string side = j == 0 ? "Front" : "Back";
JDFLayout lSide = (JDFLayout)lSheet.addPartition(EnumPartIDKey.Side, side);
JDFRunList rlSide = (JDFRunList)rlSheet.addPartition(EnumPartIDKey.Side, side);
rlSide.setFileURL("file://out/De/" + sheetName + "_" + side + ".tif");
for (int k = 0; k < 4; k++)
{
JDFContentObject poBkg = lSide.appendContentObject();
int ord = i * 8 + j * 4 + k;
poBkg.setOrd(ord);
poBkg.setOrdID(ord);
JDFMatrix matrix = new JDFMatrix(1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
matrix.shift((k % 2) * 200, (k / 2) * 300);
poBkg.setCTM(matrix);
poBkg.setLayerID(0);
JDFContentObject poLang = lSide.appendContentObject();
poLang.setOrd(ord + 16);
poLang.setOrdID(ord);
poLang.setCTM(matrix);
poLang.setLayerID(1);
if (complex)
{
JDFContentObject pOCurr = lSide.appendContentObject();
pOCurr.setOrd(ord + 32);
pOCurr.setOrdID(ord);
pOCurr.setCTM(matrix);
pOCurr.setLayerID(2);
}
}
}
}
}
public virtual VString copyResource(JDFResource r, JDFResource.EnumSpawnStatus copyStatus, VJDFAttributeMap vParts, string spawnID)
{
VString ss = getResIds();
VString v = new VString();
// r is not yet here copy r
if (!ss.Contains(r.getID()))
{
JDFResource rNew = null;
// if spawning, fix stati and locks
if (copyStatus == JDFResource.EnumSpawnStatus.SpawnedRO)
{
// copy the complete resource as RO - no need to reduce
// partitions
r.appendSpawnIDs(spawnID);
rNew = (JDFResource)copyElement(r, null);
rNew.setLocked(true);
r.setSpawnStatus(copyStatus);
}
else if (copyStatus == JDFResource.EnumSpawnStatus.SpawnedRW)
{
if (vParts.Count == 0)
{ // just copy the whole thing - no parts specified
r.appendSpawnIDs(spawnID);
rNew = (JDFResource)copyElement(r, null);
r.setSpawnStatus(copyStatus);
}
else
{
rNew = (JDFResource)copyElement(r, null);
rNew.reducePartitions(vParts);
// reduce any unneeded leaves
// loop over all part maps to get best matching resource
for (int i = 0; i < vParts.Count; i++)
{
JDFResource pLeaf = r.getPartition(vParts[i], null);
JDFResource pNewLeaf = rNew.getPartition(vParts[i], null);
if (pLeaf != null)
{
pLeaf.setSpawnStatus(copyStatus);
pLeaf.appendSpawnIDs(spawnID);
}
if (pNewLeaf != null)
{
pNewLeaf.appendSpawnIDs(spawnID);
}
}
}
}
if (rNew != null)
{
v.Add(rNew.getID());
}
}
VString vs = r.getHRefs(null, false, true);
// add recursively copied resources
for (int i = 0; i < vs.Count; i++)
{
string id = vs[i];
// the referenced resource is in this pool - continue
if (ss.Contains(id))
{
continue;
}
// the referenced resource has already been merged in - continue
if (v.Contains(id))
{
continue;
}
JDFResource next = (JDFResource)getDocRoot().getTarget(id, AttributeName.ID);
if (next == null)
{
// 071101 RP added r is by definition in the original document
// which also contains the rrefs elements
next = (JDFResource)r.getDocRoot().getTarget(id, AttributeName.ID);
// and now all those interlinked resources
VString vv = copyResource(next, copyStatus, vParts, spawnID);
v.AddRange(vv);
}
}
return(v);
}
