public ITATDocument()
 {
     _ITATDocumentID = Guid.NewGuid();
     _documentName = string.Empty;
     _defaultDocument = false;
     _workflowEnabled = true;
     _clause = new ITATClause();
     _clause.Name = XMLNames._E_Document;
     _header = new ITATDocumentHeader();
     _footer = new ITATDocumentFooter();           
     
 }
        private bool FormChanged(ITATClause clause)
        {
            if (clause.Name != txtName.Text)
            {
                //TODO: rename the appropriate tree node that was changed
                return true;
            }
            if (clause.ChildNumberingScheme != (Business.ChildNumberingSchemeType)Enum.Parse(typeof(Business.ChildNumberingSchemeType), ddlChildNumberingScheme.SelectedValue))
                return true;
            if ((clause.IndentFirstParagraph ?? false) != chkIndentFirstParagraph.Checked)
                return true;
            if ((clause.IndentSubsequentParagraphs ?? false) != chkIndentSubsequentParagraphs.Checked)
                return true;
            if ((clause.HangingIndent ?? false) != chkHangingIndent.Checked)
                return true;
            if ((clause.BreakParagraphs ?? false) != chkBreakParagraphs.Checked)
                return true;
            if ((clause.PageBreakBefore ?? false) != chkPageBreakBefore.Checked)
                return true;

            //in the next 3 "if" blocks, ignore the case where one string is null and the other is empty			
            if (_template.MatchTerm(clause.DependsOnTermID, clause.DependsOnTermName, ddlConditionalTerm.SelectedValue))
                return true;
            if (clause.DependsOnOperator != ddlConditionalOperator.SelectedValue)
                if (!(string.IsNullOrEmpty(clause.DependsOnOperator) && string.IsNullOrEmpty(ddlConditionalOperator.SelectedValue)))   //ignore the case where one string is null and the other is empty
                    return true;
            if (clause.DependsOnValue != ddlConditionalValue.SelectedValue)
                if (!(string.IsNullOrEmpty(clause.DependsOnValue) && string.IsNullOrEmpty(ddlConditionalValue.SelectedValue)))   //ignore the case where one string is null and the other is empty
                    return true;

            return false;
        }
        public ITATDocument(XmlDocument xmlTemplateDoc, XmlNode node, Template template, bool isNewDocStructure)
        {
            if (isNewDocStructure)
            {
                _ITATDocumentID = new Guid(Utility.XMLHelper.GetAttributeString(node, XMLNames._A_ID));
                _documentName = Utility.XMLHelper.GetAttributeString(node, XMLNames._A_Name);
                _defaultDocument = Utility.XMLHelper.GetAttributeBool(node, XMLNames._A_Document_DefaultDocument);
                _workflowEnabled = Utility.XMLHelper.GetAttributeBool(node, XMLNames._A_Document_WorkflowEnabled);
                _generatedDocumentID = Utility.XMLHelper.GetAttributeString(node, XMLNames._A_GeneratedDocumentID);
            }
            else
            {
                _ITATDocumentID = Guid.NewGuid();
                _documentName = Utility.XMLHelper.GetAttributeString(node.SelectSingleNode(XMLNames._E_Body), XMLNames._A_Name);
                _defaultDocument = true;
                _workflowEnabled = true;
                _generatedDocumentID = Utility.XMLHelper.GetAttributeString(xmlTemplateDoc.DocumentElement, XMLNames._A_GeneratedDocument); ;
            }


            XmlNode nodeHeader = node.SelectSingleNode(XMLNames._E_Header);
            _header = new ITATDocumentHeader(nodeHeader);

            XmlNode nodeFooter = node.SelectSingleNode(XMLNames._E_Footer);
            _footer = new ITATDocumentFooter(nodeFooter);

            XmlNode nodeBody = node.SelectSingleNode(XMLNames._E_Body);
            _clause = new ITATClause();
            _clause.Name = Utility.XMLHelper.GetAttributeString(nodeBody, XMLNames._A_Name);
            _clause.ChildNumberingScheme = ChildNumberingSchemeHelper.GetSchemeType(Utility.XMLHelper.GetAttributeString(nodeBody, XMLNames._A_ChildNumberingScheme));
            _clause.Create(nodeBody);
        }
        private void LoadClauseProperties(ITATClause clause, bool rootNode)
        {
            txtName.Text = clause.Name;
            ddlChildNumberingScheme.SelectedValue = clause.ChildNumberingScheme.ToString("D");

            if (rootNode)
            {
                lblName.Visible = false;
                txtName.Visible = false;
                chkIndentFirstParagraph.Visible = false;
                chkIndentSubsequentParagraphs.Visible = false;
                chkHangingIndent.Visible = false;
                chkBreakParagraphs.Visible = false;
                chkPageBreakBefore.Visible = false;
                ddlConditionalTerm.Visible = false;
                spnDependsOn.Visible = false;
                fldDependsOn.Visible = false;


            }
            else
            {
                chkIndentFirstParagraph.Checked = (clause.IndentFirstParagraph ?? false);
                chkIndentSubsequentParagraphs.Checked = (clause.IndentSubsequentParagraphs ?? false);
                chkHangingIndent.Checked = (clause.HangingIndent ?? false);
                chkBreakParagraphs.Checked = (clause.BreakParagraphs ?? false);
                chkPageBreakBefore.Checked = (clause.PageBreakBefore ?? false);
                string dependsOnTermName = _template.FindTermName(clause.DependsOnTermID, clause.DependsOnTermName);
                FormatDependentClauseSection(dependsOnTermName, clause.DependsOnOperator, clause.DependsOnValue);

                txtName.Visible = true;
                lblName.Visible = true;
                chkIndentFirstParagraph.Visible = true;
                chkIndentSubsequentParagraphs.Visible = true;
                chkHangingIndent.Visible = true;
                chkBreakParagraphs.Visible = true;
                chkPageBreakBefore.Visible = true;
                ddlConditionalTerm.Visible = true;
                spnDependsOn.Visible = true;
                fldDependsOn.Visible = true;
            }

        }
 protected void btnAddClause_OnCommand(object sender, CommandEventArgs e)
 {
     ITATClause parent = _template.GetITATDocument(_ITATDocumentID).FindClause(_clausePath, treClauses.PathSeparator);
     ITATClause newClause = new ITATClause();
     newClause.Name = "New Clause";
     newClause.ChildNumberingScheme = ChildNumberingSchemeType.None;
     newClause.Text = Helper.DefaultEditorHtml(edt);
     parent.Children.Add(newClause);
     LoadClauseTree();   //refresh the clause tree to pick up the new clause
     SelectTreeNode(string.Format("{0}{2}{1}", _clausePath, newClause.Name, treClauses.PathSeparator));
     IsChanged = true;
 }
        private void AddTreeNode(TreeNode parent, ITATClause clause)
        {
            TreeNode newNode;
            if (parent == null)
            {
                newNode = new TreeNode(clause.Name, clause.Name);
                treClauses.Nodes.Add(newNode);
            }
            else
            {
                newNode = new TreeNode(clause.Name, clause.Name);
                parent.ChildNodes.Add(newNode);
            }
            //newNode.NavigateUrl = string.Format("javascript:OnTreeNodeClick('{0}')", clause.Name);

            foreach (ITATClause childClause in clause.Children)
                AddTreeNode(newNode, childClause);
        }
 private void LoadClauseText(ITATClause clause)
 {
     edt.Visible = true;
     edt.Html = Business.Term.SubstituteTermIDs(_template, clause.Text);
 }
		public static void ReplaceEmbeddedTermNames(Template template, ITATClause child, List<string> sErrors)
		{
			if (!string.IsNullOrEmpty(child.DependsOnTermName))
			{
				try
				{
					child.DependsOnTermID = template.FindTerm(child.DependsOnTermName).ID;
				}
				catch (Exception)
				{
					sErrors.Add(string.Format("Unable to find Clause Dependent term '{0}'", child.DependsOnTermName));
				}
			}

			for (int i = 0; i < child._children.Count; i++)
			{
				if (!string.IsNullOrEmpty(child._children[i].DependsOnTermName))
				{
					try
					{
						child._children[i].DependsOnTermID = template.FindTerm(child._children[i].DependsOnTermName).ID;
					}
					catch (Exception)
					{
						sErrors.Add(string.Format("Unable to find Clause Dependent term '{0}'", child._children[i].DependsOnTermName));
					}
				}
			}
		}
		private void SubstituteComplexLists(Template template)
		{
			int sampleListItemsOnPreview = 2;

			//First, substitute a child clause for each item in each DISTINCT complex list in this clause			
			string text = Term.SubstituteTermIDs(template, HttpUtility.HtmlDecode(_text));
			//NOTE: (RR 2-11-2010) -- added filter to only select complex lists where Runtime.Enabled==true.
			List<ComplexList> complexLists = FindComplexLists(template, text).FindAll(cl => cl.Runtime.Enabled == true);
			foreach (ComplexList complexList in complexLists)
			{
				string pattern = string.Format(XMLNames._M_TermImageFindPattern, complexList.Name);
				bool inTable = IsInTable(text, complexList.Name);
				if (!string.IsNullOrEmpty(complexList.Header))
				{
					string headerText = (template.IsManagedItem ? complexList.Header : complexList.StandardHeader);
					Term.SubstituteBasicTerms(template, ref headerText);
					Term.SubstituteSpecialTerms(ref headerText, template);
					if (ContainsPrintableCharacters())
					{
						text = string.Concat(text, HttpUtility.HtmlDecode(headerText));
					}
					else
					{
						text = HttpUtility.HtmlDecode(headerText);
					}
				}

				//when doing the preview (i.e. template is NOT a managed item), add sample listitems to the complex list
				if (template.IsManagedItem)
				{
					int index = 0;
					for (int i = 0; i < complexList.Items.Count; i++)
					{
						if (complexList.Items[i].Selected ?? false)
						{
							if (inTable)
							{
								string itemDisplayValue = complexList.ItemDisplayValue(complexList.Items[i]);
								text = text.Replace(pattern, string.Format("{0}{1}", itemDisplayValue, pattern));
							}
							else
							{
								ITATClause childClause = new ITATClause();
								childClause.HangingIndent = this.HangingIndent;
								childClause.IndentFirstParagraph = this.IndentFirstParagraph;
								childClause.IndentSubsequentParagraphs = this.IndentSubsequentParagraphs;
								childClause.BreakParagraphs = this.BreakParagraphs;
								childClause.PageBreakBefore = false;
								childClause.Text = complexList.ItemDisplayValue(complexList.Items[i]);
								if (this.ChildNumberingScheme == ChildNumberingSchemeType.None)
									childClause.SuppressSpacingBefore = true;
								_children.Insert(index, childClause);
								index++;
							}
						}
					}
				}
				else
				{
					int index = 0;
					for (int i = 0; i < sampleListItemsOnPreview; i++)
					{
						ComplexListItem newItem = new ComplexListItem();
						for (int j = 0; j < complexList.Fields.Count; j++)
						{
							ComplexListField field = complexList.Fields[j];
                            ComplexListItemValue complexListItemValue = new ComplexListItemValue(field.ID, string.Format(@"<span style=""font-weight:bold; text-decoration:underline;"">{3}{0} #{1} | {2}{4}</span>", complexList.Name, i + 1, field.Name, (char)0xab, (char)0xbb), complexList, field.FilterTerm, true);
							newItem.ItemValues.Add(complexListItemValue);
						}
						if (inTable)
						{
							text = text.Replace(pattern, string.Format("{0}{1}", complexList.ItemDisplayValue(newItem), pattern));
						}
						else
						{
							ITATClause childClause = new ITATClause();
							childClause.HangingIndent = this.HangingIndent;
							childClause.IndentFirstParagraph = this.IndentFirstParagraph;
							childClause.IndentSubsequentParagraphs = this.IndentSubsequentParagraphs;
							childClause.BreakParagraphs = this.BreakParagraphs;
							childClause.PageBreakBefore = false;
							childClause.Text = complexList.ItemDisplayValue(newItem);
							_children.Insert(index, childClause);
							index++;
						}
					}
				}

				//Delete the Complex List Term placeholder from _text
				string sOutput = text.Replace(pattern, string.Empty);
				_text = HttpUtility.HtmlEncode(sOutput);
			}
		}
		public static void SubstituteTermNames(Template template, ITATClause child)
		{
			child.Text = Term.SubstituteTermNames(template, child.Text);
			for (int i = 0; i < child._children.Count; i++)
			{
				child._children[i].Text = Term.SubstituteTermNames(template, child._children[i].Text);
			}
		}
		public void Build(XmlDocument xmlDoc, XmlNode parentNode, ITATClause parentClause, bool bValidate)
		{
			foreach (ITATClause childClause in parentClause._children)
			{
				if (bValidate)
				{
					Utility.XMLHelper.ValidateString("ITATClause text", childClause._text);
				}

				XmlNode elementChildClause = xmlDoc.CreateNode(XmlNodeType.Element, XMLNames._E_Clause, XMLNames._M_NameSpaceURI);
				BuildNode(xmlDoc, elementChildClause, childClause, bValidate);
				Build(xmlDoc, elementChildClause, childClause, bValidate);
				parentNode.AppendChild(elementChildClause);
			}
		}
		public void BuildNode(XmlDocument xmlDoc, XmlNode node, ITATClause clause, bool bValidate)
		{
			if (bValidate)
			{
				if (string.IsNullOrEmpty(clause._text))
					throw new XmlException("Required ITATClause text not supplied");
			}
			Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_Name, clause._name);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_IndentFirstParagraph, clause._indentFirstParagraph);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_IndentSubsequentParagraphs, clause._indentSubsequentParagraphs);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_HangingIndent, clause._hangingIndent);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_BreakParagraphs, clause._breakParagraphs);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_PageBreakBefore, clause._pageBreakBefore);
			Utility.XMLHelper.AddAttributeBool(xmlDoc, node, XMLNames._A_SuppressSpacingBefore, clause._suppressSpacingBefore);
			Term.StoreID(xmlDoc, node, XMLNames._A_DependsOnTermName, clause._dependsOnTermName, XMLNames._A_DependsOnTermID, clause._dependsOnTermID);

			Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_DependsOnOperator, clause._dependsOnOperator);
			Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_DependsOnValue, clause._dependsOnValue);
			Utility.XMLHelper.AddAttributeString(xmlDoc, node, XMLNames._A_ChildNumberingScheme, ChildNumberingSchemeHelper.GetSchemeText(clause._childNumberingScheme));
			Utility.XMLHelper.AddText(xmlDoc, node, clause._text);
		}
		private bool ParseDOM(XmlNode parentNode, ITATClause parentClause)
		{
			foreach (XmlNode childNode in parentNode.ChildNodes)
			{
				if (!Utility.XMLHelper.IsTextNode(childNode))
				{
					ITATClause childClause = new ITATClause();
					childClause.CreateNode(childNode, childClause);
					childClause._parent = parentClause;
					parentClause._children.Add(childClause);
				}
			}
			return true;
		}
		private bool CreateNode(XmlNode clauseNode, ITATClause clause)
		{
			clause._name = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_Name);
			clause._indentFirstParagraph = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_IndentFirstParagraph);
			clause._indentSubsequentParagraphs = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_IndentSubsequentParagraphs);
			clause._hangingIndent = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_HangingIndent);
			clause._breakParagraphs = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_BreakParagraphs);
			clause._pageBreakBefore = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_PageBreakBefore);
			clause._suppressSpacingBefore = Utility.XMLHelper.GetAttributeBool(clauseNode, XMLNames._A_SuppressSpacingBefore);

			clause._dependsOnTermName = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnTermName);
			clause._dependsOnTermID = Term.CreateID(clauseNode, XMLNames._A_DependsOnTermID);

			clause._dependsOnOperator = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnOperator);
			clause._dependsOnValue = Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_DependsOnValue);

			clause._childNumberingScheme = ChildNumberingSchemeHelper.GetSchemeType(Utility.XMLHelper.GetAttributeString(clauseNode, XMLNames._A_ChildNumberingScheme));
			clause._text = Utility.XMLHelper.GetText(clauseNode);

			return ParseDOM(clauseNode, clause);
		}