public interface IEptXmlParserEvents

Public Interface IEptXmlParserEvents

using System;
using System.Text;
using System.Windows.Forms;
using ContentStudio.Document;
using ContentStudio.Document.EPT;

namespace TestCSServer
{
    public partial class Form1 : Form
    {
        private const int ConnectionId = 52;
        private const string App_Title = "CS Test application";

        private const int EptDocumentIdToWorkWith = 1556;

        public Form1()
        {
            InitializeComponent();

            //config the remoting
            try
            {
                ChannelConfigurator config = new ChannelConfigurator(ChannelConfigurator.TransportProtocol.IPC);
                config.Configure();
            }
            catch (Exception ex)
            {
                MessageBox.Show(String.Concat(ex.Message, "\r\n", ex.GetType().ToString()), 
                                App_Title,
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error); 
            }
        }


        #region Helpers
        private void DisplayError(Exception theException)
        {
            if (theException != null)
            {
                string message = String.Concat(theException.Message, Environment.NewLine, theException.GetType().ToString());
                MessageBox.Show(message, App_Title, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        private static int OpenSession()
        {
            ContentStudio.Security.SessionManager session = new ContentStudio.Security.SessionManager();
            return session.OpenSession(ConnectionId);

        }
        #endregion


        private void btnEptEvents_Click(object sender, EventArgs e)
        {
            Exception theException = null;
            try
            {
                int session = OpenSession();
                textBox1.Text = "";
                CSDocumentInformation dinf = new CSDocumentInformation(ConnectionId, 
                                                                       session,
                                                                       EptDocumentIdToWorkWith,
                                                                       CSDocumentInformation.ContentToLoad.DraftOrApproved);

                EPTXmlEditableParser ept = new EPTXmlEditableParser(dinf.Content);
                //add event handlers
                ept.EptFieldAdded += new EptFieldAddedEventHandler(ept_EptFieldAdded);
                ept.EptFieldRemoved += new EptFieldRemovedEventHandler(ept_EptFieldRemoved);
                ept.EptFieldValueChanging += new EptFieldValueChangingEventHandler(ept_EptFieldValueChanging);
                ept.EptFieldValueChanged += new EptFieldValueChangedEventHandler(ept_EptFieldValueChanged);
                //Add a field, this triggers the EptFieldAdded event.
                ept.Add("theNewField", "The value");
                //Change the value to an empty string, this triggers the 
                //EptFieldValueChanging event. The event handler will 
                //cancel the event if the value is empty
                ept["theNewField"] = String.Empty;
                //Change the value to something that is allowed, this triggers
                //the EptFieldValueChanging followed by the PropertyChanged event.
                ept["theNewField"] = "The new value";
                //Remove the field, this triggers the EptFieldRemoved event.
                ept.Remove("theNewField");
            }
            catch (System.Net.Sockets.SocketException socka)
            {
                theException = socka;
            }
            catch (ContentStudio.CSException cex)
            {
                theException = cex;
            }
            catch (ArgumentException ax)
            {
                theException = ax;
            }
            finally
            {
                DisplayError(theException);
            }
        }

        void ept_EptFieldValueChanged(object sender, EptXmlParserEventArgs e)
        {
            textBox1.Text += String.Format("Event EptFieldValueChanged: FieldName:{0}\r\n", e.FieldName);
        }

        void ept_EptFieldValueChanging(object sender, EptXmlParserOnBeforeEventArgs e)
        {
            textBox1.Text += String.Format("Event EptFieldValueChanging: FieldName:{0}\r\n\tOldValue:\r\n{1}\r\n\tNewValue:\r\n{2}\r\n", 
                                            e.FieldName,
                                            e.CurrentFieldValue,
                                            e.NewFieldValue);
            if (String.IsNullOrEmpty(e.NewFieldValue))
            {
                e.Cancel = true;
                textBox1.Text += "\t The value is empty, the update operation has been canceled!\r\n";
            }
        }

        void ept_EptFieldRemoved(object sender, EptXmlParserEventArgs e)
        {
            textBox1.Text += String.Format("Event FieldRemoved: FieldName:{0}\r\n", e.FieldName);
        }

        void ept_EptFieldAdded(object sender, EptXmlParserEventArgs e)
        {
            textBox1.Text += String.Format("Event FieldAdded: FieldName:{0}\r\n", e.FieldName);
        }
    }
}