/// <summary>
/// Writes child item XML to the provided writer.
/// </summary>
/// <param name="folderItem">Parent item.</param>
/// <param name="xmlWriter">XmlTextWriter to output to.</param>
private void WriteChildItems(QSetFolderItem folderItem, XmlTextWriter xmlWriter)
{
//write all folders
foreach (QSetItemBase childItem in folderItem.ChildItems)
{
if (childItem.GetType() == typeof(QSetFolderItem))
{
QSetFolderItem childFolderItem = (QSetFolderItem)childItem;
xmlWriter.WriteStartElement(QSetFolderItem.TypeName);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Name, childFolderItem.Name);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Guid, childFolderItem.ID.ToString());
WriteChildItems(childFolderItem, xmlWriter);
xmlWriter.WriteEndElement();
}
}
//write all machines
foreach (QSetItemBase childItem in folderItem.ChildItems)
{
if (childItem.GetType() == typeof(QSetMachineItem))
{
QSetMachineItem childMachineItem = (QSetMachineItem)childItem;
xmlWriter.WriteStartElement(QSetMachineItem.TypeName);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Name, childMachineItem.Name);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Guid, childMachineItem.ID.ToString());
WriteChildItems(childMachineItem, xmlWriter);
xmlWriter.WriteEndElement();
}
}
//write all queues
foreach (QSetItemBase childItem in folderItem.ChildItems)
{
QSetQueueItem childQueueItem = childItem as QSetQueueItem;
if (childQueueItem != null)
{
xmlWriter.WriteStartElement(QSetQueueItem.TypeName);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Name, childQueueItem.Name);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Guid, childQueueItem.ID.ToString());
if (childQueueItem.MessageViewerXslt != null && childQueueItem.MessageViewerXslt.Trim().Length > 0)
{
xmlWriter.WriteAttributeString(QSetXmlFileFormat.QueueElement.Attributes.MessageViewerXslt, childQueueItem.MessageViewerXslt.Trim());
}
xmlWriter.WriteEndElement();
}
}
//write all web services
foreach (QSetItemBase childItem in folderItem.ChildItems)
{
QSetWebServiceItem childWebServiceItem = childItem as QSetWebServiceItem;
if (childWebServiceItem != null)
{
xmlWriter.WriteStartElement(QSetWebServiceItem.TypeName);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Name, childWebServiceItem.Name);
xmlWriter.WriteAttributeString(QSetXmlFileFormat.ItemAttributes.Guid, childWebServiceItem.ID.ToString());
xmlWriter.WriteEndElement();
}
}
}
private void CountQueueMessages(QSetQueueItem queueItem)
{
//first of all, ensure we have a node to work with
QueueItemListViewItemPair itemPair = null;
if (_itemPairHashTable.ContainsKey(queueItem.ID))
itemPair = (QSetMonitorWorker.QueueItemListViewItemPair)_itemPairHashTable[queueItem.ID];
else
{
//TODO create icon
itemPair = new QueueItemListViewItemPair(queueItem, new ListViewItem(queueItem.Name, (int)Images.IconType.Queue));
for (int subItemCounter = 0; subItemCounter < _COLUMNS; subItemCounter ++)
itemPair.ListViewItem.SubItems.Add(string.Empty);
_itemPairHashTable.Add(itemPair.QSetQueueItem.ID, itemPair);
Action x = delegate { _monitorListView.Items.Add(itemPair.ListViewItem); };
_monitorListView.Invoke(x);
}
ManagementObject counter = null;
try
{
counter = new ManagementObject(String.Format("Win32_PerfRawdata_MSMQ_MSMQQueue.name='{0}'", itemPair.QSetQueueItem.Name));
counter.Get();
uint outgoingMessageCount = Convert.ToUInt32(counter.GetPropertyValue("MessagesInQueue"));
uint outgoingBytes = Convert.ToUInt32(counter.GetPropertyValue("BytesInQueue"));
Action herewegoagain = () =>
{
if (itemPair.ListViewItem.SubItems[(int)SubItemList.OutgoingMessageCount].Text != outgoingMessageCount.ToString()) //note: only do if necessary, to avoid flicker
itemPair.ListViewItem.SubItems[(int)SubItemList.OutgoingMessageCount].Text = outgoingMessageCount.ToString();
if (itemPair.ListViewItem.SubItems[(int)SubItemList.OutgoingBytes].Text != outgoingBytes.ToString()) //note: only do if necessary, to avoid flicker
itemPair.ListViewItem.SubItems[(int)SubItemList.OutgoingBytes].Text = outgoingBytes.ToString();
};
_monitorListView.Invoke(herewegoagain);
}
catch
{
//exception will occur when cannot get access to performance counters
}
finally
{
if (counter != null)
counter.Dispose();
}
}
/// <summary>
/// Constructs the pair.
/// </summary>
/// <param name="qsetQueueItem">QSetQueueItem of the pair.</param>
/// <param name="listViewItem">ListViewItem of the pair.</param>
public QueueItemListViewItemPair(QSetQueueItem qsetQueueItem, ListViewItem listViewItem)
{
_qsetQueueItem = qsetQueueItem;
_listViewItem = listViewItem;
}
/// <summary>
/// Constructs object, setting required properties.
/// </summary>
/// <param name="qsetMessageQueue">The queue set queue item which the message belongs to.</param>
/// <param name="process">Process associated with the event.</param>
/// <param name="message">Message being selected.</param>
public SelectedMessageChangedEventArgs (QSetQueueItem qsetQueueItem, System.Messaging.Message message)
: base()
{
_message = message;
_qsetQueueItem = qsetQueueItem;
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/> class that references the Message Queuing queue at the specified path.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="path">The location of the queue referenced by this <see cref="System.Messaging.MessageQueue"/>.</param>
public QSetMessageQueue(QSetQueueItem ownerItem, string path)
: base(path)
{
_ownerItem = ownerItem;
}
/// <summary>
/// Recursively creates all of the child items of a Q Set item.
/// </summary>
/// <param name="parentItem">Parent item.</param>
/// <param name="parentNodeIterator">XPathNodeIterator positioned at the parent item. </param>
private static void CreateChildItems(QSetFolderItem parentItem, XPathNodeIterator parentNodeIterator)
{
//iterate through all child items
XPathNodeIterator childNodeIterator = parentNodeIterator.Current.Select("*");
while (childNodeIterator.MoveNext())
{
//get the item details
string itemName = childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Name, "");
Guid itemGuid = Guid.Empty;
if (childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Guid, "") != string.Empty)
itemGuid = new Guid(childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Guid, ""));
//create a new item of the required type, specifying the guid if available
QSetItemBase newItem = null;
if (childNodeIterator.Current.Name == QSetFolderItem.TypeName)
{
//create folder
if (itemGuid == Guid.Empty)
newItem = new QSetFolderItem(itemName);
else
newItem = new QSetFolderItem(itemGuid, itemName);
}
else if (childNodeIterator.Current.Name == QSetMachineItem.TypeName)
{
//create machine
if (itemGuid == Guid.Empty)
newItem = new QSetMachineItem(itemName);
else
newItem = new QSetMachineItem(itemGuid, itemName);
}
else if (childNodeIterator.Current.Name == QSetQueueItem.TypeName)
{
//create queue
if (itemGuid == Guid.Empty)
newItem = new QSetQueueItem(itemName);
else
newItem = new QSetQueueItem(itemGuid, itemName);
if (childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.QueueElement.Attributes.MessageViewerXslt, "") != string.Empty)
((QSetQueueItem)newItem).MessageViewerXslt = childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.QueueElement.Attributes.MessageViewerXslt, "");
}
else if (childNodeIterator.Current.Name == QSetWebServiceItem.TypeName)
{
//web service item
if (itemGuid == Guid.Empty)
newItem = new QSetWebServiceItem(itemName);
else
newItem = new QSetWebServiceItem(itemGuid, itemName);
}
//apply finaly settings and actions to new item
if (newItem != null)
{
//finish type specific setup
if (newItem is QSetFolderItem)
{
//create child items
CreateChildItems((QSetFolderItem)newItem, childNodeIterator);
}
//final setup common to all item types
parentItem.ChildItems.Add(newItem);
newItem.IsDirty = false;
}
}
}
public NewMessageForm(Licensing.License license, QueueTaskManager queueTaskManager, System.Messaging.Message[] messages, QSetQueueItem sourceQueueItem)
{
Initialize(license, queueTaskManager, null, messages, sourceQueueItem);
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/>MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="path">The location of the queue referenced by this <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="sharedModeDenyReceive">true to grant exclusive read access to the first application that accesses the queue; otherwise, false.</param>
public QSetMessageQueue(QSetQueueItem ownerItem, string path, bool sharedModeDenyReceive)
: base(path, sharedModeDenyReceive)
{
_ownerItem = ownerItem;
}
private void Initialize(Licensing.License license, QueueTaskManager queueTaskManager, QSetQueueItem initialRecipient, System.Messaging.Message[] messages, QSetQueueItem sourceQueueItem)
{
_license = license;
InitializeComponent();
if (messages != null && messages.Length > 0)
_mode = Mode.ExistingMessage;
else
_mode = Mode.NewMessage;
_queueTaskManager = queueTaskManager;
_sourceQueueItem = sourceQueueItem;
base.Closing += new CancelEventHandler(NewMessageForm_Closing);
numberOfCopiesComboBoxItem.ToolTipText = "Select the number of copies to send to each recipient queue.";
numberOfCopiesComboBoxItem.ComboBox.SelectedIndex = 0;
numberOfCopiesComboBoxItem.ComboBox.KeyPress += new KeyPressEventHandler(ComboBox_KeyPress);
numberOfCopiesComboBoxItem.ComboBox.MaxLength = 4;
_messageViewer = new MessageViewer(license);
_messageViewer.Dock = DockStyle.Fill;
_messageViewerHostPanel.Controls.Add(_messageViewer);
recipientsListView.Items.Clear();
messagesListView.Items.Clear();
if (_mode == Mode.NewMessage)
{
FormatterComboItem[] formatterItems = new FormatterComboItem[3];
formatterItems[0] = new FormatterComboItem(_FORMATTER_ACTIVEX, MessageFormatterType.ActiveX);
formatterItems[1] = new FormatterComboItem(_FORMATTER_BINARY, MessageFormatterType.Binary);
formatterItems[2] = new FormatterComboItem(_FORMATTER_XML, MessageFormatterType.Xml);
formatterComboBoxItem.ComboBox.DisplayMember = "Name";
formatterComboBoxItem.ComboBox.ValueMember = "FormatterType";
formatterComboBoxItem.ComboBox.DataSource = formatterItems;
formatterComboBoxItem.ComboBox.SelectedIndex = 2;
formatterComboBoxItem.ComboBox.DropDownStyle = ComboBoxStyle.DropDownList;
foreach (MenuItemBase item in optionsPriorityMenuItem.Items)
item.Checked = false;
priorityNormalMenuItem.Checked = true;
ConfigureMessagePriorityMenuItems();
SelectMessagePriorityMenuItem(System.Messaging.MessagePriority.Normal);
}
else
{
if (messages.Length == 1)
existingMessagesLabel.Text = "Message:";
else
existingMessagesLabel.Text = "Messages:";
foreach (System.Messaging.Message message in messages)
{
ListViewItem item = new ListViewItem(message.Label, (int)Resources.Images.IconType.Message);
item.Tag = message;
messagesListView.Items.Add(item);
}
messagesListView.Items[0].Selected = true;
}
//TODO when multiple messages are supplied leave all the options blank so that the existing message properties take effect
// but let the options be selectable so they can be overridde. When a single message is passed into the form all
// of the options can be defaulted to that messages options
sendAndKeepOpenButtonItem.Visible = _mode == Mode.NewMessage;
formatterComboBoxItem.Visible = _mode == Mode.NewMessage;
optionsDropDownMenuItem.Visible = _mode == Mode.NewMessage;
labelLabel.Visible = _mode == Mode.NewMessage;
labelTextBox.Visible = _mode == Mode.NewMessage;
newMessagePanel.Visible = _mode == Mode.NewMessage;
existingMessagePanel.Visible = _mode == Mode.ExistingMessage;
ConfigureControls();
SetupToolTips();
if (initialRecipient != null)
AddQueueItemToRecipientsList(initialRecipient);
}
private void AddQueueItemToRecipientsList(QSetQueueItem queueItem)
{
ListViewItem recipientItem = new ListViewItem(queueItem.Name, (int)Resources.Images.IconType.Queue);
recipientItem.Tag = queueItem;
recipientsListView.Items.Add(recipientItem);
}
/// <summary>
/// Constructs the event arguments.
/// </summary>
/// <param name="fromQueueItem">Queue where messages were dragged from.</param>
/// <param name="toQueueItem">Queue where messages were dragged to.</param>
/// <param name="messages">Messages which were dragged.</param>
public MessagesDragDropEventArgs(QSetQueueItem fromQueueItem, QSetQueueItem toQueueItem, Message[] messages)
{
_fromQueueItem = fromQueueItem;
_toQueueItem = toQueueItem;
_messages = messages;
}
/// <summary>
/// Loads anew MessageBrowser, and displays in the main document window.
/// </summary>
/// <param name="qsetQueueItem">QSetQueueItem to display.</param>
/// <returns>The added DockControl hosting the MessageBrowser if successful, else false.</returns>
private DockControl LoadNewMessageBrowser(QSetQueueItem qsetQueueItem)
{
DockControl newDockControl = null;
//set up a new message browser, and create adock for it
MessageBrowser messageBrowser = new MessageBrowser();
messageBrowser.UserSettings = _primaryObjects.UserSettings;
_primaryControls.MessageBrowserCollection.Add(qsetQueueItem.ID.ToString(), messageBrowser);
newDockControl = new TabbedDocument(_primaryControls.DocumentContainer.Manager, messageBrowser, qsetQueueItem.Name);
newDockControl.Open();
messageBrowser.ImageList = _primaryControls.Images.Icon16ImageList;
//pass the qsetitem to the message browser to load the queue
try
{
messageBrowser.QSetQueueItem = qsetQueueItem;
newDockControl.Activate();
}
catch (Exception exc)
{
_primaryObjects.ProcessVisualizer.SeizeCursor(Cursors.Arrow);
MessageBox.Show(exc.Message, Locale.ApplicationName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
_primaryObjects.ProcessVisualizer.ReleaseCursor();
newDockControl.Close();
newDockControl = null;
}
return newDockControl;
}
/// <summary>
/// Opens a new queue in the environment for browsing.
/// </summary>
/// <param name="queueName">QSetQueueItem which contains the queue to be opened.</param>
public void OpenQueue(QSetQueueItem qsetQueueItem)
{
if (!IsItemOpen(qsetQueueItem))
LoadNewMessageBrowser(qsetQueueItem);
else
BringDocumentToFront(qsetQueueItem);
if (qsetQueueItem.ParentItem == null && _primaryControls.QSetExplorer.QSet != null)
AddActiveQueueToQSet();
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/> class. After the default constructor initializes the new instance, you must set the instance's Path property before you can use the instance.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
public QSetMessageQueue(QSetQueueItem ownerItem)
: base ()
{
_ownerItem = ownerItem;
}
public NewMessageForm(Licensing.License license, QueueTaskManager queueTaskManager, QSetQueueItem initialRecipient)
{
Initialize(license, queueTaskManager, initialRecipient, null, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/> class that references the Message Queuing queue at the specified path.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="path">The location of the queue referenced by this <see cref="System.Messaging.MessageQueue"/>.</param>
public QSetMessageQueue(QSetQueueItem ownerItem, string path)
: base(path)
{
_ownerItem = ownerItem;
}
/// <summary>
/// Constructs the object.
/// </summary>
/// <param name="ownerQueueItem">Queue which the messages belong to.</param>
/// <param name="messages">Messages which are being dragged.</param>
public MessageDragContainer(QSetQueueItem ownerQueueItem, Message[] messages)
{
_ownerQueueItem = ownerQueueItem;
_messages = messages;
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/> class. After the default constructor initializes the new instance, you must set the instance's Path property before you can use the instance.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
public QSetMessageQueue(QSetQueueItem ownerItem)
: base()
{
_ownerItem = ownerItem;
}
/// <summary>
/// Displays the new message form to send a message.
/// </summary>
/// <param name="queue">Initial queue to show in the recipients list.</param>
public void SendNewMessage(QSetQueueItem queue)
{
NewMessageForm form = new NewMessageForm(_primaryObjects.License, this, queue);
form.SmallImageList = _primaryControls.Images.Icon16ImageList;
form.Show();
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Messaging.MessageQueue"/>MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.
/// </summary>
/// <param name="ownerItem">QSetQueueItem which owns the <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="path">The location of the queue referenced by this <see cref="System.Messaging.MessageQueue"/>.</param>
/// <param name="sharedModeDenyReceive">true to grant exclusive read access to the first application that accesses the queue; otherwise, false.</param>
public QSetMessageQueue(QSetQueueItem ownerItem, string path, bool sharedModeDenyReceive)
: base(path, sharedModeDenyReceive)
{
_ownerItem = ownerItem;
}
/// <summary>
/// Pugres the queue contents from the QSetQueueItem.
/// </summary>
/// <param name="queueItem">Item which contains the quue to be purged.</param>
public void PurgeQueue(QSetQueueItem queueItem)
{
QSetMessageQueue queue = queueItem.QSetMessageQueue;
string confirmationMessage = string.Format(Locale.UserMessages.ConfirmQueuePurge, string.Format(@"{0}\{1}", queue.MachineName, queue.QueueName));
if (WindowsForms.MessageBox.Show(_primaryForms.EnvironmentForm, confirmationMessage, Locale.ApplicationName, WindowsForms.MessageBoxButtons.YesNoCancel, WindowsForms.MessageBoxIcon.Question, WindowsForms.MessageBoxDefaultButton.Button3) == WindowsForms.DialogResult.Yes)
{
VisualizableProcess process = new VisualizableProcess(Locale.UserMessages.PurgingQueue, false);
try
{
_primaryObjects.ProcessVisualizer.ProcessStarting(process);
queue.Purge();
}
catch (Exception exc)
{
WindowsForms.MessageBox.Show(_primaryForms.EnvironmentForm, string.Format(Locale.UserMessages.UnableToPurgeQueue, exc.Message), Locale.ApplicationName, WindowsForms.MessageBoxButtons.OK, WindowsForms.MessageBoxIcon.Exclamation);
}
finally
{
_primaryObjects.ProcessVisualizer.ProcessCompleted(process);
}
}
}
/// <summary>
/// Constructs the object.
/// </summary>
public MessageBrowser()
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
_qSetQueueItem = null;
base.Disposed += new EventHandler(MessageBrowser_Disposed);
}
/// <summary>
/// Copies or moves messages from one queue to another.
/// </summary>
/// <param name="fromQueueItem">Source queue.</param>
/// <param name="toQueueItem">Destination queue.</param>
/// <param name="messages">Messages to move or copy.</param>
/// <param name="deleteSourceMessagesOnComplete">Set to true to move the messages, false to copy the messages.</param>
public void CopyMessages(QSetQueueItem fromQueueItem, QSetQueueItem toQueueItem, Message[] messages, bool deleteSourceMessagesOnComplete)
{
try
{
//validate license
if (_primaryObjects.License.ValidateFeatureUse(Licensing.Feature.DragAndDropMessage))
{
if (fromQueueItem.QSetMessageQueue.CanRead)
{
if (toQueueItem.QSetMessageQueue.CanWrite)
{
//attempt to get message browsers for the queues
MessageBrowser fromMessageBrowser = null;
MessageBrowser toMessageBrowser = null;
foreach (MessageBrowser messageBrowser in _primaryControls.MessageBrowserCollection)
{
if (messageBrowser.QSetQueueItem == fromQueueItem)
fromMessageBrowser = messageBrowser;
else if (messageBrowser.QSetQueueItem == toQueueItem)
toMessageBrowser = messageBrowser;
if (toMessageBrowser != null && (fromMessageBrowser != null || !deleteSourceMessagesOnComplete))
break;
}
//move/copy the messages
foreach (Message message in messages)
{
SendMessage((MessageQueue)toQueueItem.QSetMessageQueue, fromQueueItem.QSetMessageQueue.PeekById(message.Id));
//SendMessage((MessageQueue)toQueueItem.QSetMessageQueue, DuplicateMessage(fromQueueItem.QSetMessageQueue, message.Id));
if (deleteSourceMessagesOnComplete)
fromQueueItem.QSetMessageQueue.ReceiveById(message.Id);
}
//update the message browsers
if (toMessageBrowser != null)
toMessageBrowser.Refresh();
if (fromMessageBrowser != null && deleteSourceMessagesOnComplete && toMessageBrowser != fromMessageBrowser)
fromMessageBrowser.Refresh();
}
else
{
//TODO use locale
WindowsForms.MessageBox.Show(
_primaryForms.EnvironmentForm,
"Insufficient permissions to write to the target queue.",
Locale.ApplicationName,
System.Windows.Forms.MessageBoxButtons.OK,
System.Windows.Forms.MessageBoxIcon.Information);
}
}
else
{
//TODO use locale
WindowsForms.MessageBox.Show(
_primaryForms.EnvironmentForm,
"Insufficient permissions to read from queue.",
Locale.ApplicationName,
System.Windows.Forms.MessageBoxButtons.OK,
System.Windows.Forms.MessageBoxIcon.Information);
}
}
}
catch (Exception exc)
{
//TODO use locale and have a message that can distinguish between move and copy
WindowsForms.MessageBox.Show(
_primaryForms.EnvironmentForm,
string.Format("Encountered an error during move.\n\n{0}", exc.Message),
Locale.ApplicationName,
System.Windows.Forms.MessageBoxButtons.OK,
System.Windows.Forms.MessageBoxIcon.Information);
}
}
/// <summary>
/// Displays a new message.
/// </summary>
/// <param name="qsetMessageQueue">Queue that the message belongs to.</param>
/// <param name="message">Message to display.</param>
public void DisplayMessage(QSetQueueItem qsetQueueItem, System.Messaging.Message message)
{
//set the memeber level message reference
_message = message;
//check if an xslt is assigned to the queue
if (qsetQueueItem.MessageViewerXslt != null && qsetQueueItem.MessageViewerXslt.Length > 0)
{
//is this xslt already loaded?
if (_currentXsltPath != qsetQueueItem.MessageViewerXslt)
{
//load the new xslt
StreamReader sr = null;
try
{
sr = new StreamReader(new FileStream(qsetQueueItem.MessageViewerXslt, FileMode.Open, FileAccess.Read, FileShare.ReadWrite));
_transfomer = new Transformer(sr.ReadToEnd());
_currentXsltPath = qsetQueueItem.MessageViewerXslt;
}
catch
{
_currentXsltPath = null;
_transfomer = null;
}
finally
{
if (sr != null)
sr.Close();
}
}
}
else
{
_currentXsltPath = null;
_transfomer = null;
}
//now display the message
DoDisplayMessage();
ConfigureButtons();
}
/// <summary>
/// Recursively creates all of the child items of a Q Set item.
/// </summary>
/// <param name="parentItem">Parent item.</param>
/// <param name="parentNodeIterator">XPathNodeIterator positioned at the parent item. </param>
private static void CreateChildItems(QSetFolderItem parentItem, XPathNodeIterator parentNodeIterator)
{
//iterate through all child items
XPathNodeIterator childNodeIterator = parentNodeIterator.Current.Select("*");
while (childNodeIterator.MoveNext())
{
//get the item details
string itemName = childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Name, "");
Guid itemGuid = Guid.Empty;
if (childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Guid, "") != string.Empty)
{
itemGuid = new Guid(childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.ItemAttributes.Guid, ""));
}
//create a new item of the required type, specifying the guid if available
QSetItemBase newItem = null;
if (childNodeIterator.Current.Name == QSetFolderItem.TypeName)
{
//create folder
if (itemGuid == Guid.Empty)
{
newItem = new QSetFolderItem(itemName);
}
else
{
newItem = new QSetFolderItem(itemGuid, itemName);
}
}
else if (childNodeIterator.Current.Name == QSetMachineItem.TypeName)
{
//create machine
if (itemGuid == Guid.Empty)
{
newItem = new QSetMachineItem(itemName);
}
else
{
newItem = new QSetMachineItem(itemGuid, itemName);
}
}
else if (childNodeIterator.Current.Name == QSetQueueItem.TypeName)
{
//create queue
if (itemGuid == Guid.Empty)
{
newItem = new QSetQueueItem(itemName);
}
else
{
newItem = new QSetQueueItem(itemGuid, itemName);
}
if (childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.QueueElement.Attributes.MessageViewerXslt, "") != string.Empty)
{
((QSetQueueItem)newItem).MessageViewerXslt = childNodeIterator.Current.GetAttribute(QSetXmlFileFormat.QueueElement.Attributes.MessageViewerXslt, "");
}
}
else if (childNodeIterator.Current.Name == QSetWebServiceItem.TypeName)
{
//web service item
if (itemGuid == Guid.Empty)
{
newItem = new QSetWebServiceItem(itemName);
}
else
{
newItem = new QSetWebServiceItem(itemGuid, itemName);
}
}
//apply finaly settings and actions to new item
if (newItem != null)
{
//finish type specific setup
if (newItem is QSetFolderItem)
{
//create child items
CreateChildItems((QSetFolderItem)newItem, childNodeIterator);
}
//final setup common to all item types
parentItem.ChildItems.Add(newItem);
newItem.IsDirty = false;
}
}
}
