public static void BackupFiles(Dvtk.Sessions.Session theSession, ArrayList theFilesToBackup)
{
foreach (string theFileToBackup in theFilesToBackup)
{
BackupFile(theSession, theFileToBackup);
}
}
// -------------------------------
// - Begin public methods region -
// -------------------------------
/// <summary>
/// Convert a HLI Attribute Set to a AttributeLayer Attribute Set.
/// </summary>
/// <param name="attributeSetIn">The HLI Attribute Set.</param>
/// <param name="attributeSetOut">The AttributeLayer Attribute Set.</param>
public static void ToAttributeSet(DvtkHighLevelInterface.Dicom.Other.AttributeSet attributeSetIn, Dvtk.Dicom.AttributeLayer.AttributeSet attributeSetOut)
{
for (int index = 0; index < attributeSetIn.Count; index++)
{
DvtkHighLevelInterface.Dicom.Other.Attribute hliAttribute = attributeSetIn[index];
Tag tag = new Tag(hliAttribute.GroupNumber, hliAttribute.ElementNumber);
if (hliAttribute.VR != DvtkData.Dimse.VR.SQ)
{
SingleAttribute singleAttribute = new SingleAttribute(tag, (VR)Enum.Parse(typeof(VR), hliAttribute.VR.ToString(), true), attributeSetOut);
}
else
{
SequenceAttribute sequenceAttribute = new SequenceAttribute(tag, attributeSetOut);
for (int sequenceItemIndex = 1; sequenceItemIndex <= hliAttribute.ItemCount; sequenceItemIndex++)
{
DvtkHighLevelInterface.Dicom.Other.SequenceItem hliSequenceItem = hliAttribute.GetItem(sequenceItemIndex);
SequenceItem sequenceItem = new SequenceItem(sequenceAttribute);
ToAttributeSet(hliSequenceItem, sequenceItem);
}
}
}
}
public static ArrayList GetAllNamesForSession(Dvtk.Sessions.Session theSession)
{
ArrayList theResultsFiles = new ArrayList();
DirectoryInfo theDirectoryInfo;
FileInfo[] theFilesInfo;
theDirectoryInfo = new DirectoryInfo (theSession.ResultsRootDirectory);
if (theDirectoryInfo.Exists)
{
theFilesInfo = theDirectoryInfo.GetFiles ("*.xml");
foreach (FileInfo theFileInfo in theFilesInfo)
{
string theResultsFileName = theFileInfo.Name;
if (IsValid(theResultsFileName))
{
theResultsFiles.Add(theResultsFileName);
}
}
}
return theResultsFiles;
}
public SelectTransferSyntaxesForm(Dvtk.Sessions.EmulatorSession session)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this._session = session;
ts_list = new ArrayList();
ts_list.Add (DvtkData.Dul.TransferSyntax.Implicit_VR_Little_Endian);
ts_list.Add (DvtkData.Dul.TransferSyntax.Explicit_VR_Big_Endian);
ts_list.Add (DvtkData.Dul.TransferSyntax.Explicit_VR_Little_Endian);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Baseline_Process_1);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Extended_Hierarchical_16_And_18);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Extended_Hierarchical_17_And_19);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Extended_Process_2_And_4);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Extended_Process_3_And_5);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Full_Progression_Hierarchical_24_And_26);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Full_Progression_Hierarchical_25_And_27);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Full_Progression_Non_Hierarchical_10_And_12);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Full_Progression_Non_Hierarchical_11_And_13);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Lossless_Hierarchical_28);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Lossless_Hierarchical_29);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Lossless_Non_Hierarchical_14);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Lossless_Non_Hierarchical_15);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Lossless_Non_Hierarchical_1st_Order_Prediction);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_LS_Lossless_Image_Compression);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_LS_Lossy_Image_Compression);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_2000_IC_Lossless_Only);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_2000_IC);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Spectral_Selection_Hierarchical_20_And_22);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Spectral_Selection_Hierarchical_21_And_23);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Spectral_Selection_Non_Hierarchical_6_And_8);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_Spectral_Selection_Non_Hierarchical_7_And_9);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_2000_Multicomponent_lossless2);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPEG_2000_Multicomponent2);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPIP_Referenced);
ts_list.Add (DvtkData.Dul.TransferSyntax.JPIP_Referenced_Deflate);
ts_list.Add (DvtkData.Dul.TransferSyntax.MPEG2_Main_Profile_Level);
ts_list.Add (DvtkData.Dul.TransferSyntax.RFC_2557_Mime_Encapsulation);
ts_list.Add (DvtkData.Dul.TransferSyntax.RLE_Lossless);
ts_list.Add (DvtkData.Dul.TransferSyntax.Deflated_Explicit_VR_Little_Endian);
foreach (DvtkData.Dul.TransferSyntax ts in ts_list)
{
TreeNode node = this.TreeViewSTS.Nodes.Add (ts.ToString());
// Set the item to 'checked' if the transfer syntax is supported by the emulator
if (this._session.SupportedTransferSyntaxSettings.SupportedTransferSyntaxes.Contains (ts))
{
node.Checked = true;
}
}
}
public PrintEmulatorStatusForm(Dvtk.Sessions.EmulatorSession emulator_session)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.session = emulator_session;
this.TextBoxManufacturer.Text = this.session.Printer.Manufacturer;
this.TextBoxModelName.Text = this.session.Printer.ManufacturerModelName;
this.TextBoxPrinterName.Text = this.session.Printer.PrinterName;
this.TextBoxSerialNumber.Text = this.session.Printer.DeviceSerialNumber;
this.TextBoxSoftwareVersions.Text = this.session.Printer.SoftwareVersions;
this.DateTimeCalibrationDate.Value = this.session.Printer.DateOfLastCalibration.Date;
this.DateTimeCalibrationTime.Value = this.session.Printer.TimeOfLastCalibration.ToLocalTime ();
// add the 3 possible Printer Status values
this.ComboBoxPrinterStatus.Items.Add("NORMAL");
this.ComboBoxPrinterStatus.Items.Add("WARNING");
this.ComboBoxPrinterStatus.Items.Add("ERROR");
string status = this.session.Printer.Status.ToString();
foreach (object o in this.ComboBoxPrinterStatus.Items)
{
if (o.ToString() == status) this.ComboBoxPrinterStatus.SelectedItem = o;
}
string statusInfo = this.session.Printer.StatusInfo.ToString();
foreach (string info_dt in this.session.Printer.StatusInfoDefinedTerms)
{
this.ComboBoxPrinterStatusInfo.Items.Add (info_dt);
}
foreach (object o in this.ComboBoxPrinterStatusInfo.Items)
{
if (o.ToString() == statusInfo) this.ComboBoxPrinterStatusInfo.SelectedItem = o;
}
}
private ArrayList GetFileNames(Dvtk.Sessions.Session session , string detailFile )
{
string resultFileName = System.IO.Path.GetFileNameWithoutExtension(detailFile);
ArrayList resultsFiles = new ArrayList();
DirectoryInfo directoryInfo;
FileInfo[] filesInfo;
directoryInfo = new DirectoryInfo (session.ResultsRootDirectory);
if (directoryInfo.Exists) {
filesInfo = directoryInfo.GetFiles(
resultFileName.Substring(0,resultFileName.Length - 3) + "*.xml");
foreach (FileInfo fileInfo in filesInfo){
resultsFiles.Add(fileInfo.Name);
}
}
return resultsFiles;
}
public BaseInformationModel(Dvtk.Dicom.InformationEntity.BaseInformationModel root)
{
_root = root;
}
public bool IsExecuting(Dvtk.Sessions.Session theSession)
{
ArrayList theExecutingSessions = GetExecutingSessions();
return(theExecutingSessions.Contains(theSession));
}
public DialogResult ShowDialog(IWin32Window theIWin32Window, Dvtk.Sessions.EmulatorSession theEmulatorSession)
{
_EmulatorSession = theEmulatorSession;
return(ShowDialog(theIWin32Window));
}
//
// - Constructors -
//
/// <summary>
/// Constructor.
/// </summary>
/// <param name="exceptionText">The exception text.</param>
/// <param name="receiveReturnCode">The receive return code indicating the reason for the exception.</param>
public DicomProtocolMessageReceiveException(String exceptionText, Dvtk.Sessions.ReceiveReturnCode receiveReturnCode)
: base(exceptionText)
{
this.receiveReturnCode = receiveReturnCode;
}
//
// ctor
//
internal CertificateHandling(
Dvtk.Sessions.ISecure secureSession)
{
this._securitySettings = secureSession.SecuritySettings;
this._password = this._securitySettings.TlsPassword;
this._fileName = this._securitySettings.CertificateFileName;
// Auto load certificate file using the session settings.
this.LoadCertificateFile(this._fileName, this._password);
}
public TreeNode GetSessionNode(Dvtk.Sessions.Session theSession)
{
TreeNode theSessionNodeToFind = null;
foreach (TreeNode theNode in _SessionTreeView.Nodes)
{
if (theNode.Tag is SessionTag)
{
SessionTag theSessionTag = (SessionTag)theNode.Tag;
if (theSessionTag._Session == theSession)
{
theSessionNodeToFind = theNode;
break;
}
}
}
return(theSessionNodeToFind);
}
private ArrayList GetVisibleScripts(Dvtk.Sessions.Session theSession)
{
ArrayList theVisibleScripts = new ArrayList();
Dvtk.Sessions.ScriptSession theScriptSession = null;
string theScriptRootDirectory = "";
DirectoryInfo theDirectoryInfo = null;
FileInfo[] theFilesInfo;
theScriptSession = (Dvtk.Sessions.ScriptSession) theSession;
theScriptRootDirectory = theScriptSession.DicomScriptRootDirectory;
theDirectoryInfo = new DirectoryInfo(theScriptRootDirectory);
if (theDirectoryInfo.Exists)
{
theFilesInfo = theDirectoryInfo.GetFiles();
foreach (FileInfo theFileInfo in theFilesInfo)
{
bool showScriptFile = false;
string theFileExtension = theFileInfo.Extension.ToLower();
if ((theFileExtension == ".ds") && (_MainForm._UserSettings.ShowDicomScripts))
{
showScriptFile = true;
}
else if ((theFileExtension == ".dss") && (_MainForm._UserSettings.ShowDicomSuperScripts))
{
showScriptFile = true;
}
else if ((theFileExtension == ".vbs") && (_MainForm._UserSettings.ShowVisualBasicScripts))
{
showScriptFile = true;
}
else
{
showScriptFile = false;
}
if (showScriptFile)
{
theVisibleScripts.Add(theFileInfo.Name);
}
}
}
return(theVisibleScripts);
}
public void UpdateSessionNodeTextMainNodeOnly(TreeNode theTreeNode, Dvtk.Sessions.Session theSession)
{
bool isSessionExecuting = _MainForm.IsExecuting(theSession);
bool isSessionExecutingInOtherSessionTreeView = (isSessionExecuting && (theSession != GetExecutingSession()));
theTreeNode.Text = System.IO.Path.GetFileName(theSession.SessionFileName);
if ( (theSession is Dvtk.Sessions.ScriptSession) ||
(theSession is Dvtk.Sessions.EmulatorSession)
)
{
if (isSessionExecutingInOtherSessionTreeView)
{
theTreeNode.Text+= " (disabled)";
}
}
if (theSession is Dvtk.Sessions.MediaSession)
{
// If this session is executing...
if (isSessionExecuting)
{
// If the executing session is executed by this session tree view...
if (theSession == GetExecutingSession())
{
theTreeNode.Text+= " (executing)";
}
// If the executing session is not executed by this session tree view...
else
{
theTreeNode.Text+= " (disabled)";
}
}
}
if (_Project.GetSessionChanged(theSession))
{
theTreeNode.Text+= " *";
}
}
/// <summary>
/// Update a Session node.
/// </summary>
/// <param name="theTreeNode">The tree node to update.</param>
/// <param name="theSession">The Session the node is representing.</param>
public void UpdateSessionNode(TreeNode theTreeNode, Dvtk.Sessions.Session theSession, ref bool isEmpty)
{
isEmpty = false;
UpdateSessionNodeTextMainNodeOnly(theTreeNode, theSession);
if (theSession is Dvtk.Sessions.ScriptSession)
{
UpdateScriptSessionNode(theTreeNode, theSession, ref isEmpty);
}
if (theSession is Dvtk.Sessions.MediaSession)
{
UpdateMediaSessionNode(theTreeNode, theSession);
}
if (theSession is Dvtk.Sessions.EmulatorSession)
{
UpdateEmulatorSessionNode(theTreeNode, theSession);
}
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="id">Actor Id.</param>
/// <param name="iheFramework">Ihe Framework container.</param>
public AdtPatientRegistrationActor(System.String id, Dvtk.IheActors.IheFramework.IheFramework iheFramework)
: base(new ActorName(ActorTypeEnum.AdtPatientRegistration, id), iheFramework)
{
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="id">Actor Id.</param>
/// <param name="iheFramework">Ihe Framework container.</param>
public PpsManagerActor(System.String id, Dvtk.IheActors.IheFramework.IheFramework iheFramework)
: base(new ActorName(ActorTypeEnum.PerformedProcedureStepManager, id), iheFramework)
{
}
public void UpdateEmulatorNode(TreeNode theEmulatorTreeNode, Dvtk.Sessions.Session theSession, ArrayList theResultsFiles, EmulatorTag.EmulatorType theEmulatorType, bool isExecuting)
{
// Set the text on this session tree node.
switch(theEmulatorType)
{
case EmulatorTag.EmulatorType.PRINT_SCP:
{
theEmulatorTreeNode.Text = "Print SCP Emulator";
}
break;
case EmulatorTag.EmulatorType.STORAGE_SCP:
{
theEmulatorTreeNode.Text = "Storage SCP Emulator";
}
break;
case EmulatorTag.EmulatorType.STORAGE_SCU:
{
theEmulatorTreeNode.Text = "Storage SCU Emulator";
}
break;
}
if (isExecuting)
{
theEmulatorTreeNode.Text += " (executing)";
}
// Set the tag for this session tree node.
EmulatorTag theEmulatorTag = new EmulatorTag(theSession, theEmulatorType);
theEmulatorTreeNode.Tag = theEmulatorTag;
// Remove the old tree nodes that may be present under this session tree node.
theEmulatorTreeNode.Nodes.Clear();
if (!isExecuting)
{
foreach (string theResultsFile in theResultsFiles)
{
TreeNode theTreeNode = new TreeNode();
theEmulatorTreeNode.Nodes.Add(theTreeNode);
UpdateResultsFileNode(theTreeNode, theSession, theResultsFile);
}
}
}
// ctor
internal CredentialHandling(
Dvtk.Sessions.ISecure secureSession)
{
this._securitySettings = secureSession.SecuritySettings;
this._password = this._securitySettings.TlsPassword;
this._fileName = this._securitySettings.CredentialsFileName;
// Auto load credential file using the session settings.
this.LoadCredentialFile(this._fileName, this._password);
}
/// <summary>
/// Update the emulator session node (update the supplied node and create sub-nodes if necessary).
///
/// Pre-condition:
/// - The supplied session is not executing.
/// - The supplied session is executing in another Session Tree View.
/// </summary>
/// <param name="theEmulatorSessionTreeNode">The tree node representing the Emulator Session.</param>
/// <param name="theSession">The session.</param>
public void UpdateEmulatorSessionNode(TreeNode theEmulatorSessionTreeNode, Dvtk.Sessions.Session theSession)
{
bool isSessionExecuting = _MainForm.IsExecuting(theSession);
bool isSessionExecutingInOtherSessionTreeView = (isSessionExecuting && (theSession != GetExecutingSession()));
// Set the tag for this session tree node.
EmulatorSessionTag theEmulatorSessionTag = new EmulatorSessionTag(theSession);
theEmulatorSessionTreeNode.Tag = theEmulatorSessionTag;
// Remove the old tree nodes that may be present under this session tree node.
theEmulatorSessionTreeNode.Nodes.Clear();
// If this session is executing...
if (isSessionExecutingInOtherSessionTreeView)
{
// Do nothing.
}
else if (!isSessionExecuting)
{
ArrayList theResultsFiles; // The result files belonging to this session.
// Get all result files from this session.
theResultsFiles = ResultsFile.GetVisibleNamesForSession(theSession);
// Add the Storage SCP emulator tree node.
TreeNode theStorageScpEmulatorTreeNode = new TreeNode();
theEmulatorSessionTreeNode.Nodes.Add(theStorageScpEmulatorTreeNode);
string theStorageScpBaseName = ResultsFile.GetBaseNameForEmulator(EmulatorTag.EmulatorType.STORAGE_SCP);
ArrayList theStorageScpEmulatorResultsFiles = ResultsFile.GetNamesForBaseName(theStorageScpBaseName, theResultsFiles);
theResultsFiles = ResultsFile.FilterOutResultsFileNames(theResultsFiles, theStorageScpEmulatorResultsFiles);
UpdateEmulatorNode(theStorageScpEmulatorTreeNode, theSession, theStorageScpEmulatorResultsFiles, EmulatorTag.EmulatorType.STORAGE_SCP, false);
// Add the Storage SCU emulator tree node.
TreeNode theStorageScuEmulatorTreeNode = new TreeNode();
theEmulatorSessionTreeNode.Nodes.Add(theStorageScuEmulatorTreeNode);
string theStorageScuBaseName = ResultsFile.GetBaseNameForEmulator(EmulatorTag.EmulatorType.STORAGE_SCU);
ArrayList theStorageScuEmulatorResultsFiles = ResultsFile.GetNamesForBaseName(theStorageScuBaseName, theResultsFiles);
theResultsFiles = ResultsFile.FilterOutResultsFileNames(theResultsFiles, theStorageScuEmulatorResultsFiles);
UpdateEmulatorNode(theStorageScuEmulatorTreeNode, theSession, theStorageScuEmulatorResultsFiles, EmulatorTag.EmulatorType.STORAGE_SCU, false);
// Add the Print SCP emulator tree node.
TreeNode thePrintScpEmulatorTreeNode = new TreeNode();
theEmulatorSessionTreeNode.Nodes.Add(thePrintScpEmulatorTreeNode);
string thePrintScpBaseName = ResultsFile.GetBaseNameForEmulator(EmulatorTag.EmulatorType.PRINT_SCP);
ArrayList thePrintScpEmulatorResultsFiles = ResultsFile.GetNamesForBaseName(thePrintScpBaseName, theResultsFiles);
theResultsFiles = ResultsFile.FilterOutResultsFileNames(theResultsFiles, thePrintScpEmulatorResultsFiles);
UpdateEmulatorNode(thePrintScpEmulatorTreeNode, theSession, thePrintScpEmulatorResultsFiles, EmulatorTag.EmulatorType.PRINT_SCP, false);
}
else
{
// Sanity check, pre-condition of this method is not fullfilled.
Debug.Assert(false);
}
}
public void Attach(Dvtk.IheActors.IheFramework.IheFramework iheFramework)
{
iheFramework.Attach(this);
}
public void UpdateMediaSessionNode(TreeNode theMediaSessionTreeNode, Dvtk.Sessions.Session theSession)
{
bool isSessionExecuting = _MainForm.IsExecuting(theSession);
// Set the tag for this session tree node.
MediaSessionTag theMediaSessionTag = new MediaSessionTag(theSession);
theMediaSessionTreeNode.Tag = theMediaSessionTag;
// Remove the old tree nodes that may be present under this session tree node.
theMediaSessionTreeNode.Nodes.Clear();
if (!isSessionExecuting)
{
ArrayList theResultsFileNames = ResultsFile.GetVisibleNamesForSession(theSession);
ArrayList theResultsFileBaseNames = ResultsFile.GetBaseNamesForResultsFiles(theResultsFileNames);
foreach(string theBaseName in theResultsFileBaseNames)
{
string theNodeText = "";
ArrayList theResultsFileNamesForBaseName = ResultsFile.GetNamesForBaseName(theBaseName, theResultsFileNames);
theResultsFileNames = ResultsFile.FilterOutResultsFileNames(theResultsFileNames, theResultsFileNamesForBaseName);
TreeNode theTreeNode = new TreeNode();
theMediaSessionTreeNode.Nodes.Add(theTreeNode);
if (theBaseName.ToLower().EndsWith("_DCM"))
{
theNodeText = theBaseName.Substring(0, theBaseName.Length - 4);
}
else
{
theNodeText = theBaseName;
}
UpdateResultsCollectionNode(theTreeNode, theNodeText, theSession, theResultsFileNamesForBaseName);
}
}
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="id">Actor Id.</param>
/// <param name="iheFramework">Ihe Framework container.</param>
public PrintComposerActor(System.String id, Dvtk.IheActors.IheFramework.IheFramework iheFramework)
: base(new ActorName(ActorTypeEnum.PrintComposer, id), iheFramework)
{
}
/// <summary>
/// Conversion Dvtk type => Wrappers type
/// </summary>
/// <param name="value">in</param>
/// <returns>out</returns>
private static Wrappers.StorageMode _Convert(Dvtk.Sessions.StorageMode value)
{
switch (value)
{
case Dvtk.Sessions.StorageMode.AsDataSet:
return Wrappers.StorageMode.StorageModeAsDataSet;
case Dvtk.Sessions.StorageMode.AsMedia:
return Wrappers.StorageMode.StorageModeAsMedia;
case Dvtk.Sessions.StorageMode.NoStorage:
return Wrappers.StorageMode.StorageModeNoStorage;
case Dvtk.Sessions.StorageMode.TemporaryPixelOnly:
return Wrappers.StorageMode.StorageModeTemporaryPixelOnly;
default:
// Unknown Dvtk.Sessions.StorageMode
throw new System.NotImplementedException();
}
}
/// <summary>
/// Activity logging handler
/// </summary>
/// <param name="sender"></param>
/// <param name="theArgs"></param>
private void OnActivityReportEvent(object sender, Dvtk.Events.ActivityReportEventArgs e)
{
string message;
switch(e.ReportLevel)
{
case Dvtk.Events.ReportLevel.Error:
message = "Error:" + e.Message + '\n';
break;
case Dvtk.Events.ReportLevel.Warning:
message = "Warning:" + e.Message + '\n';
break;
default:
message = e.Message + '\n';
break;
}
if (richTextBoxLog.InvokeRequired)
{
richTextBoxLog.Invoke(activityLoggingDelegate, new object[] {message});
}
else
{
richTextBoxLog.AppendText(e.Message + '\n');
}
}
/// <summary>
/// Set the Comparators needed to handle each message in the Transaction.
/// </summary>
/// <param name="comparatorCollection">Comparator collection to fill.</param>
public void SetComparators(Dvtk.Comparator.BaseComparatorCollection comparatorCollection)
{
if (_transaction is DicomTransaction)
{
System.String name = System.String.Empty;
DicomTransaction dicomTransaction = (DicomTransaction)_transaction;
switch(dicomTransaction.Direction)
{
case TransactionDirectionEnum.TransactionReceived:
name = System.String.Format("Received by {0}:{1} from {2}:{3}",
ActorTypes.Type(_toActorName.Type),
_toActorName.Id,
ActorTypes.Type(_fromActorName.Type),
_fromActorName.Id);
break;
case TransactionDirectionEnum.TransactionSent:
name = System.String.Format("Sent from {0}:{1} to {2}:{3}",
ActorTypes.Type(_toActorName.Type),
_toActorName.Id,
ActorTypes.Type(_fromActorName.Type),
_fromActorName.Id);
break;
default:
break;
}
for (int i = 0; i < dicomTransaction.DicomMessages.Count; i++)
{
DicomMessage dicomMessage = (DicomMessage)dicomTransaction.DicomMessages[i];
DvtkHighLevelInterface.Comparator.Comparator comparator = new DvtkHighLevelInterface.Comparator.Comparator(name);
Dvtk.Comparator.DicomComparator dicomComparator = comparator.InitializeDicomComparator(dicomMessage);
if (dicomComparator != null)
{
comparatorCollection.Add(dicomComparator);
}
}
}
else if (_transaction is Hl7Transaction)
{
System.String name = System.String.Empty;
Hl7Transaction hl7Transaction = (Hl7Transaction)_transaction;
switch(hl7Transaction.Direction)
{
case TransactionDirectionEnum.TransactionReceived:
name = System.String.Format("Received by {0}:{1} from {2}:{3}",
ActorTypes.Type(_toActorName.Type),
_toActorName.Id,
ActorTypes.Type(_fromActorName.Type),
_fromActorName.Id);
break;
case TransactionDirectionEnum.TransactionSent:
name = System.String.Format("Sent from {0}:{1} to {2}:{3}",
ActorTypes.Type(_toActorName.Type),
_toActorName.Id,
ActorTypes.Type(_fromActorName.Type),
_fromActorName.Id);
break;
default:
break;
}
Hl7Message hl7Message= hl7Transaction.Request;
DvtkHighLevelInterface.Comparator.Comparator comparator = new DvtkHighLevelInterface.Comparator.Comparator(name);
Dvtk.Comparator.Hl7Comparator hl7Comparator = comparator.InitializeHl7Comparator(hl7Message);
if (hl7Comparator != null)
{
comparatorCollection.Add(hl7Comparator);
}
}
}
/// <summary>
/// Occurs when a activity report is generated by the application.
/// </summary>
/// <remarks>
/// Users may register a callback to listen for this event.
/// </remarks>
protected static void ActivityReportEventHandler(object sender, Dvtk.Events.ActivityReportEventArgs e)
{
// format -15 equals left-alignment with a preferred width of 15 characters.
System.Console.WriteLine(
string.Format("{0,-15}: {1}", e.ReportLevel, e.Message));
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="id">Actor Id.</param>
/// <param name="iheFramework">Ihe Framework container.</param>
public ImageDisplayActor(System.String id, Dvtk.IheActors.IheFramework.IheFramework iheFramework)
: base(new ActorName(ActorTypeEnum.ImageDisplay, id), iheFramework)
{
}
public void SetSessionChanged(Dvtk.Sessions.Session theSession)
{
if (theSession == _SessionUsedForContentsOfTabSpecifySopClasses)
{
_SessionUsedForContentsOfTabSpecifySopClasses = null;
}
}
public void SetComparators(Dvtk.Comparator.BaseComparatorCollection comparatorCollection)
{
if (_transaction is DicomTransaction)
{
System.String name = System.String.Empty;
DicomTransaction dicomTransaction = (DicomTransaction)_transaction;
switch(dicomTransaction.Direction)
{
case TransactionDirectionEnum.TransactionReceived:
name = System.String.Format("Received by {0} from {1}", ActorNames.Name(_fromActorName), ActorNames.Name(_toActorName));
break;
case TransactionDirectionEnum.TransactionSent:
name = System.String.Format("Sent from {0} to {1}", ActorNames.Name(_fromActorName), ActorNames.Name(_toActorName));
break;
default:
break;
}
for (int i = 0; i < dicomTransaction.DicomMessages.Count; i++)
{
DicomMessage dicomMessage = (DicomMessage)dicomTransaction.DicomMessages[i];
DvtkHighLevelInterface.Comparator.Comparator comparator = new DvtkHighLevelInterface.Comparator.Comparator(name);
Dvtk.Comparator.DicomComparator dicomComparator = comparator.InitializeDicomComparator(dicomMessage);
if (dicomComparator != null)
{
comparatorCollection.Add(dicomComparator);
}
}
}
}
