コード例 #1
0
ファイル: JDFSpanBase.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * version fixing routine for JDF
        ///	 *
        ///	 * uses heuristics to modify this element and its children to be compatible with a given version in general, it will
        ///	 * be able to move from low to high versions but potentially fail when attempting to move from higher to lower
        ///	 * versions
        ///	 *  </summary>
        ///	 * <param name="version"> : version that the resulting element should correspond to </param>
        ///	 * <returns> true if successful </returns>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            bool bRet = true;

            if (version != null)
            {
                if (version.getValue() >= EnumVersion.Version_1_2.getValue())
                {
                    if (hasAttribute(AttributeName.PRIORITY))
                    {
                        if (getPriority() == EnumPriority.Required)
                        {
                            setSettingsPolicy(EnumSettingsPolicy.MustHonor);
                        }
                        else
                        {
                            setSettingsPolicy(EnumSettingsPolicy.BestEffort);
                        }
                        removeAttribute(AttributeName.PRIORITY);
                    }
                }
                else
                {
                    if (getSettingsPolicy(true) == EnumSettingsPolicy.BestEffort)
                    {
                        setPriority(EnumPriority.Required);
                    }
                    else
                    {
                        setPriority(EnumPriority.Suggested);
                    }
                }
            }
            return(base.fixVersion(version) && bRet);
        }
コード例 #2
0
ファイル: JDFLayout.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * version fixing routine
        ///	 *
        ///	 * uses heuristics to modify this element and its children to be compatible
        ///	 * with a given version in general, it will be able to move from low to high
        ///	 * versions but potentially fail when attempting to move from higher to
        ///	 * lower versions
        ///	 *  </summary>
        ///	 * <param name="version">
        ///	 *            : version that the resulting element should correspond to </param>
        ///	 * <returns> true if successful </returns>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            bool bRet = true;

            if (isResourceRoot() && version != null)
            {
                bool newLayout = isNewLayout(this);
                if (version.getValue() >= EnumVersion.Version_1_3.getValue() && !newLayout)
                {
                    bRet = toNewLayout();
                }
                else if (version.getValue() < EnumVersion.Version_1_3.getValue() && newLayout)
                {
                    bRet = fromNewLayout();
                }
            }
            return(base.fixVersion(version) && bRet);
        }
コード例 #3
0
ファイル: JDFTool.cs プロジェクト: cip4/JDFLibNet
 public override bool fixVersion(EnumVersion version)
 {
     if (version != null && version.getValue() >= EnumVersion.Version_1_3.getValue())
     {
         if (hasAttribute(AttributeName.TOOLID) && !hasAttribute(AttributeName.PRODUCTID))
         {
             setProductID(getToolID());
         }
         removeAttribute(AttributeName.TOOLID, null);
     }
     else if (version != null && version.getValue() < EnumVersion.Version_1_3.getValue())
     {
         if (hasAttribute(AttributeName.PRODUCTID) && !hasAttribute(AttributeName.TOOLID))
         {
             setToolID(getProductID());
         }
     }
     return(base.fixVersion(version));
 }
コード例 #4
0
 ///
 ///	 <summary> * version fixing routine for JDF
 ///	 *
 ///	 * uses heuristics to modify this element and its children to be compatible
 ///	 * with a given version in general, it will be able to move from low to high
 ///	 * versions but potentially fail when attempting to move from higher to
 ///	 * lower versions
 ///	 *  </summary>
 ///	 * <param name="version">
 ///	 *            : version that the resulting element should correspond to </param>
 ///	 * <returns> true if successful </returns>
 ///
 public override bool fixVersion(EnumVersion version)
 {
     if (version.getValue() >= EnumVersion.Version_1_3.getValue())
     {
         appendAnchor(null);
     }
     else
     {
         removeAttribute(AttributeName.ID);
     }
     return(base.fixVersion(version));
 }
コード例 #5
0
ファイル: JDFAudit.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * init
        ///	 *  </summary>
        ///	 * <returns> boolean </returns>
        ///
        public override bool init()
        {
            EnumVersion auditVersion = getVersion(true);

            setAttributeNameTimeStamp(AttributeName.TIMESTAMP, null);
            if (auditVersion == null || auditVersion.getValue() >= EnumVersion.Version_1_2.getValue())
            {
                setAgentName(m_strAgentName);
                setAgentVersion(m_strAgentVersion);
            }
            if (m_strAuthor != null)
            {
                setAuthor(m_strAuthor);
            }

            if (auditVersion == null || auditVersion.getValue() >= EnumVersion.Version_1_3.getValue())
            {
                appendAnchor(null);
            }
            return(base.init());
        }
コード例 #6
0
ファイル: JDFComment.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * init this comment by adding agentname, agentversion and id
        ///	 *  </summary>
        ///	 * <returns> boolean </returns>
        ///
        public override bool init()
        {
            EnumVersion v = getVersion(true);

            if (v.getValue() >= EnumVersion.Version_1_3.getValue() && LocalName.Equals(ElementName.COMMENT))
            {
                appendAnchor(null);
                setAgentName(JDFAudit.getStaticAgentName());
                setAgentVersion(JDFAudit.getStaticAgentVersion());
            }
            return(base.init());
        }
コード例 #7
0
        ///
        ///	 <summary> * fixes an ApprovalSuccess by moving the appropriate elements in and out of
        ///	 * ApprovalDetails elements
        ///	 *  </summary>
        ///	 * <seealso cref= org.cip4.jdflib.resource.JDFResource#fixVersion(org.cip4.jdflib.core.JDFElement.EnumVersion) </seealso>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            bool bRet = true;

            if (version != null)
            {
                // create ApprovalDetails
                if (version.getValue() >= EnumVersion.Version_1_3.getValue())
                {
                    if (hasChildElement(ElementName.CONTACT, null) || hasChildElement(ElementName.FILESPEC, null))
                    {
                        JDFApprovalDetails ad = appendApprovalDetails();
                        ad.setApprovalState(EnumApprovalState.Approved);
                        ad.moveElement(getContact(), null);
                        ad.moveElement(getFileSpec(), null);
                    }
                }
                else
                { // remove ApprovalDetails
                    for (int i = 0; i < 99999; i++)
                    {
                        JDFApprovalDetails ad = getApprovalDetails(i);
                        int iAccept           = 0;
                        if (ad == null)
                        {
                            if (iAccept == 0)
                            {
                                setResStatus(EnumResStatus.Rejected, false);
                            }
                            break; // none left
                        }

                        if (ad.getApprovalState() == EnumApprovalState.Rejected)
                        {
                            bRet = false;
                            ad.deleteNode();
                            continue; // semantics of reject are not available in
                            // 1.2 and below ignore
                        }
                        iAccept++;
                        moveElement(ad.getContact(), null);
                        moveElement(ad.getFileSpec(), null);
                        ad.deleteNode();
                    }
                }
            }
            return(base.fixVersion(version) && bRet);
        }
コード例 #8
0
        ///
        ///	 <summary> * version fixing routine for JDF
        ///	 *
        ///	 * uses heuristics to modify this element and its children to be compatible with a given version in general, it will
        ///	 * be able to move from low to high versions but potentially fail when attempting to move from higher to lower
        ///	 * versions
        ///	 *  </summary>
        ///	 * <param name="version"> version that the resulting element should correspond to </param>
        ///	 * <returns> true if successful </returns>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            bool bRet = true;

            if (version != null)
            {
                setVersion(version);
                setMaxVersion(version);
                if (version.getValue() < EnumVersion.Version_1_3.getValue())
                {
                    inlineRefElements(null, null, true);
                }
            }

            return(base.fixVersion(version) && bRet);
        }
コード例 #9
0
        ///
        ///	 <summary> * version fixing routine for JDF
        ///	 *
        ///	 * uses heuristics to modify this element and its children to be compatible
        ///	 * with a given version in general, it will be able to move from low to high
        ///	 * versions but potentially fail when attempting to move from higher to
        ///	 * lower versions
        ///	 *  </summary>
        ///	 * <param name="version">
        ///	 *            : version that the resulting element should correspond to </param>
        ///	 * <returns> true if successful </returns>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            bool bRet = true;

            if (version != null)
            {
                if (version.getValue() >= EnumVersion.Version_1_3.getValue())
                {
                    if (hasAttribute(AttributeName.SOURCESHEET))
                    {
                        string sourceSheet = getSourceSheet();

                        JDFRefElement layoutRef = (JDFRefElement)getElement_KElement("LayoutRef", null, 0);
                        if (layoutRef != null)
                        {
                            JDFLayout lo = (JDFLayout)layoutRef.getLinkRoot(layoutRef.getrRef());
                            if (lo != null)
                            {
                                lo.fixVersion(version);
                            }

                            layoutRef.setPartMap(new JDFAttributeMap(AttributeName.SHEETNAME, sourceSheet));
                            lo = (JDFLayout)layoutRef.getTarget();
                            layoutRef.setPartMap(lo.getPartMap());
                        }
                        removeAttribute(AttributeName.SOURCESHEET);
                    }
                }
                else
                {
                    JDFLayout layout = getLayout();
                    if (layout != null)
                    {
                        string sourcesheet = layout.getSheetName();
                        setSourceSheet(sourcesheet);
                        JDFRefElement layoutRef = (JDFRefElement)getElement_KElement("LayoutRef", null, 0);
                        // JDF 1.2 layout should be unpartitioned
                        if (layoutRef != null)
                        {
                            // JDF 1.2 layout should be unpartitioned
                            layoutRef.removeChild(ElementName.PART, null, 0);
                        }
                    }
                }
            }
            return(base.fixVersion(version) && bRet);
        }
コード例 #10
0
ファイル: JDFLayout.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * heuristics to check which version an element of a Layout is in: 1.3 or
        ///	 * 1.2
        ///	 *
        ///	 * Note that this routine is static since it must be used on all sheets,
        ///	 * surfaces etc.
        ///	 *  </summary>
        ///	 * <param name="sheet">
        ///	 *            the Sheet, Surface, Signature or Layout to check </param>
        ///	 * <returns> true if this is a new, i.e. partitioned Layout
        ///	 *  </returns>
        ///
        public static bool isNewLayout(JDFResource sheet)
        {
            // not one of Layout, Signature, Sheet or Surface
            if (!(sheet is JDFLayout))
            {
                return(false);
            }

            // either Signature, Sheet or Surface --> old
            if (!sheet.LocalName.Equals(ElementName.LAYOUT))
            {
                return(false);
            }

            // it's a layout the only allowed (old) element is a signature , if it
            // exists --> old
            if (sheet.getElement_KElement(ElementName.SIGNATURE, null, 0) != null)
            {
                return(false);
            }
            // it is a layout and it has no subelements and it is partitioned -->
            // new
            JDFResource resourceRoot = sheet.getResourceRoot();

            if (resourceRoot.hasAttribute(AttributeName.PARTIDKEYS))
            {
                return(true);
            }
            // it is a non partitioned layout and it has palacedobjects --> new
            if (resourceRoot.hasChildElement(ElementName.CONTENTOBJECT, null) || resourceRoot.hasChildElement(ElementName.MARKOBJECT, null))
            {
                return(true);
            }

            // now I'm ready to punt - no partition and no subelements --> assume
            // that version tags are correct
            EnumVersion v = sheet.getVersion(true);

            // no version, we are 1.3 --> assume 1.3
            if (v == null)
            {
                return(true);
            }

            return(v.getValue() >= EnumVersion.Version_1_3.getValue());
        }
コード例 #11
0
ファイル: JDFComment.cs プロジェクト: cip4/JDFLibNet
 ///
 ///	 <summary> * version fixing routine for JDF
 ///	 *
 ///	 * uses heuristics to modify this element and its children to be compatible with a given version<br>
 ///	 * in general, it will be able to move from low to high versions but potentially fail when attempting to move from
 ///	 * higher to lower versions
 ///	 *  </summary>
 ///	 * <param name="version"> version that the resulting element should correspond to </param>
 ///	 * <returns> true if successful </returns>
 ///
 public override bool fixVersion(EnumVersion version)
 {
     if (version != null)
     {
         if (version.getValue() >= EnumVersion.Version_1_3.getValue() && LocalName.Equals(ElementName.COMMENT))
         {
             appendAnchor(null);
         }
         else
         {
             removeAttribute(AttributeName.ID);
             removeAttribute(AttributeName.AGENTNAME);
             removeAttribute(AttributeName.AGENTVERSION);
             removeAttribute(AttributeName.AUTHOR);
             removeAttribute(AttributeName.TIMESTAMP);
         }
     }
     return(base.fixVersion(version));
 }
コード例 #12
0
ファイル: JDFAudit.cs プロジェクト: cip4/JDFLibNet
        ///
        ///	 <summary> * version fixing routine for JDF
        ///	 *
        ///	 * uses heuristics to modify this element and its children to be compatible with a given version in general, it will
        ///	 * be able to move from low to high versions but potentially fail when attempting to move from higher to lower
        ///	 * versions
        ///	 *  </summary>
        ///	 * <param name="version"> : version that the resulting element should correspond to </param>
        ///	 * <returns> true if successful </returns>
        ///
        public override bool fixVersion(EnumVersion version)
        {
            if (version != null)
            {
                int @value = version.getValue();
                if (@value >= EnumVersion.Version_1_3.getValue())
                {
                    appendAnchor(null);
                }
                else
                {
                    removeAttribute(AttributeName.ID);
                    // TODO fix agentname and agentversion
                }
                string author = getAuthor();
                if (@value <= EnumVersion.Version_1_1.getValue())
                {
                    string tmp = getAgentName();
                    bool   b   = false;
                    if (tmp.Length != 0)
                    {
                        author += "_|_" + tmp;
                        b       = true;
                    }
                    tmp = getAgentVersion();
                    if (tmp.Length != 0)
                    {
                        if (!b)
                        {
                            author += "_|_ ";
                        }

                        author += "_|_" + tmp;
                        b       = true;
                    }
                    removeAttribute(AttributeName.AGENTNAME);
                    removeAttribute(AttributeName.AGENTVERSION);
                    if (b)
                    {
                        setAuthor(author);
                    }
                }
                else if (author.Length > 0) // version>=1.2 and has author
                {
                    VString tokens = new VString(StringUtil.tokenize(author, "_|_", false));
                    if (tokens.Count == 3)
                    { // it was previously fixed
                        string tmp = tokens.stringAt(0);
                        if (!tmp.Equals(JDFConstants.EMPTYSTRING) && !tmp.Equals(JDFConstants.BLANK))
                        {
                            setAuthor(tmp);
                        }
                        tmp = tokens.stringAt(1);
                        if (!tmp.Equals(JDFConstants.EMPTYSTRING) && !tmp.Equals(JDFConstants.BLANK))
                        {
                            setAgentName(tmp);
                        }
                        tmp = tokens.stringAt(2);
                        if (!tmp.Equals(JDFConstants.EMPTYSTRING) && !tmp.Equals(JDFConstants.BLANK))
                        {
                            setAgentVersion(tmp);
                        }
                    }
                }
            }
            return(base.fixVersion(version));
        }