public override void Process(Configuration config)
{
var tables = GetTables(config);
// create a resource resolver that will scan all plugins
// TODO: we should only scan plugins that are tied to the specified PersistentStore, but there is currently no way to know this
IResourceResolver resolver = new ResourceResolver(
CollectionUtils.Map(Platform.PluginManager.Plugins, (PluginInfo pi) => pi.Assembly).ToArray());
// find all dbi resources
var rx = new Regex("dbi.xml$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
var dbiFiles = resolver.FindResources(rx);
foreach (var dbiFile in dbiFiles)
{
using (var stream = resolver.OpenResource(dbiFile))
{
var xmlDoc = new XmlDocument();
xmlDoc.Load(stream);
var indexElements = xmlDoc.SelectNodes("indexes/index");
if (indexElements == null)
continue;
foreach (XmlElement indexElement in indexElements)
{
ProcessIndex(indexElement, tables);
}
}
}
}
public TableView()
{
SuppressSelectionChangedEvent = false;
InitializeComponent();
// if we allow the framework to generate columns, there seems to be a bug with
// setting the minimum column width > 100 pixels
// therefore, turn off the auto-generate and create the columns ourselves
_dataGridView.AutoGenerateColumns = false;
_rowHeight = this.DataGridView.RowTemplate.Height;
this.DataGridView.RowPrePaint += SetCustomBackground;
this.DataGridView.RowPostPaint += DisplayCellSubRows;
this.DataGridView.RowPostPaint += OutlineCell;
this.DataGridView.RowPostPaint += SetLinkColor;
// System.Component.DesignMode does not work in control constructors
if (LicenseManager.UsageMode != LicenseUsageMode.Designtime)
{
// Use a DelayedEventPublisher to make fixes for bugs 386 and 8032 a little clearer. Previously used a Timer directly
// to delay the events
_delayedSelectionChangedPublisher = new DelayedEventPublisher((sender, args) => NotifySelectionChanged(), 50);
}
try
{
var resolver = new ResourceResolver(typeof (TableView), false);
using (var s = resolver.OpenResource("checkmark.png"))
{
_checkmarkBitmap = new Bitmap(s);
}
}
catch (Exception) {}
}
public ActionBuildingContext(string actionID, object actionTarget)
{
_actionID = actionID;
_actionTarget = actionTarget;
_resolver = new ActionResourceResolver(_actionTarget);
}
public static void TestConfigResourceToFile(string fileName)
{
ResourceResolver resolver = new ResourceResolver(typeof(SettingsMigrationTests).Assembly);
using (Stream resourceStream = resolver.OpenResource("TestPreviousConfiguration.config"))
{
StreamToFile(resourceStream, fileName);
resourceStream.Close();
}
}
/// <summary>
/// Translates the name of the specified property on the specified domain class.
/// </summary>
/// <param name="domainClass"></param>
/// <param name="propertyName"></param>
/// <returns></returns>
public static string Translate(Type domainClass, string propertyName)
{
IResourceResolver resolver = new ResourceResolver(domainClass.Assembly);
string key = domainClass.Name + propertyName;
string localized = resolver.LocalizeString(key);
if (localized == key)
localized = resolver.LocalizeString(propertyName);
return localized;
}
protected ImageExporter(string identifier, string description, string[] fileExtensions)
{
Platform.CheckForEmptyString(identifier, "identifier");
Platform.CheckForEmptyString(description, "description");
Platform.CheckForNullReference(fileExtensions, "fileExtension");
if (fileExtensions.Length == 0)
throw new ArgumentException("The exporter must have at least one associated file extension.");
IResourceResolver resolver = new ResourceResolver(this.GetType().Assembly);
_identifier = identifier;
_description = resolver.LocalizeString(description);
_fileExtensions = fileExtensions;
}
public override IActionSet GetExportedActions(string site, ClearCanvas.ImageViewer.InputManagement.IMouseInformation mouseInformation)
{
IResourceResolver resolver = new ResourceResolver(GetType(), true);
var @namespace = GetType().FullName;
var hideAction = new MenuAction(@namespace + ":toggle", new ActionPath(site + "/MenuSetMarkupColorForUser", resolver), ClickActionFlags.None, resolver);
hideAction.Label = "Set User Markup Color";
hideAction.Persistent = true;
hideAction.SetClickHandler(OpenAimMarkupColorOptions);
IActionSet actions = new ActionSet(new IAction[] { hideAction });
var other = base.GetExportedActions(site, mouseInformation);
if (other != null)
actions = actions.Union(other);
return actions;
}
public AlertNotificationForm(DesktopForm owner, string title)
{
InitializeComponent();
this.Text = title;
this.Owner = owner;
_maxOpacity = 1.0;
_minOpacity = 0.3;
var resolver = new ResourceResolver(typeof (AlertNotificationForm).Assembly);
using (var s = resolver.OpenResource("close.bmp"))
{
_closeButtonBitmap = new Bitmap(s);
}
owner.Move += OwnerFormMoved;
owner.Resize += OwnerFormResized;
}
private IActionSet CreateActions()
{
List<IAction> actions = new List<IAction>();
Type thisType = this.GetType();
IResourceResolver resolver = new ResourceResolver(thisType.Assembly);
foreach (ITableColumn tableColumn in this.Context.Columns)
{
string columnName = tableColumn.Name;
string escapedColumnName = SecurityElement.Escape(columnName);
string actionName = columnName.Replace("&", "").Replace("<", "_").Replace(">", "_").Replace("\"", "").Replace("'", "").Replace(' ', '_');
ButtonAction buttonAction = new ButtonAction(
string.Format("{0}:toggle_{1}", thisType.FullName, actionName),
new ActionPath(string.Format("{0}/{1}", TOGGLE_DROPDOWN_SITE, actionName),
resolver), ClickActionFlags.CheckAction, resolver);
buttonAction.Label = columnName;
buttonAction.Checked = !SearchSettings.Default.AimSearchHiddenColumns.Contains(escapedColumnName);
TableColumnBase<AIMSearchResult> column = (TableColumnBase<AIMSearchResult>) tableColumn;
buttonAction.SetClickHandler(delegate
{
bool wasChecked = buttonAction.Checked;
buttonAction.Checked = !wasChecked;
column.Visible = !wasChecked;
if (buttonAction.Checked)
{
while (SearchSettings.Default.AimSearchHiddenColumns.IndexOf(escapedColumnName) != -1)
SearchSettings.Default.AimSearchHiddenColumns.Remove(escapedColumnName);
}
else
{
SearchSettings.Default.AimSearchHiddenColumns.Add(escapedColumnName);
}
SearchSettings.Default.Save();
});
actions.Add(buttonAction);
}
return new ActionSet(actions);
}
public List<StoredDisplaySetCreationSetting> GetStoredSettings()
{
XmlDocument document = this.DisplaySetCreationSettingsXml;
if (document == null)
{
document = new XmlDocument();
Stream stream = new ResourceResolver(this.GetType(), false).OpenResource("DisplaySetCreationSettingsDefaults.xml");
document.Load(stream);
stream.Close();
}
XmlNodeList settingsNodes = document.SelectNodes("//display-set-creation-settings/setting");
if (settingsNodes== null || settingsNodes.Count == 0)
{
document = new XmlDocument();
Stream stream = new ResourceResolver(this.GetType(), false).OpenResource("DisplaySetCreationSettingsDefaults.xml");
document.Load(stream);
stream.Close();
settingsNodes = document.SelectNodes("//display-set-creation-settings/setting");
}
List<string> missingModalities = new List<string>(StandardModalities.Modalities);
List<StoredDisplaySetCreationSetting> storedDisplaySetSettings = new List<StoredDisplaySetCreationSetting>();
foreach (XmlElement settingsNode in settingsNodes)
{
XmlAttribute attribute = settingsNode.Attributes["modality"];
string modality = "";
if (attribute != null)
{
modality = attribute.Value ?? "";
missingModalities.Remove(modality);
}
if (!String.IsNullOrEmpty(modality))
{
XmlNodeList optionNodes = settingsNode.SelectNodes("options/option");
StoredDisplaySetCreationSetting setting = new StoredDisplaySetCreationSetting(modality);
SetOptions(setting, optionNodes);
storedDisplaySetSettings.Add(setting);
XmlNode presentationIntentNode = settingsNode.SelectSingleNode("presentation-intent");
if (presentationIntentNode != null)
{
attribute = presentationIntentNode.Attributes["show-grayscale-inverted"];
if (attribute != null)
setting.ShowGrayscaleInverted = (attribute.Value == "True");
}
}
}
foreach (string missingModality in missingModalities)
storedDisplaySetSettings.Add(new StoredDisplaySetCreationSetting(missingModality));
return storedDisplaySetSettings;
}
private void Initialize(bool reloadSettings)
{
lock (_syncLock)
{
if (Document != null && !reloadSettings)
return;
AnnotationLayoutStoreSettings.Default.Reload();
if (Document != null)
return;
try
{
XmlDocument document = new XmlDocument();
ResourceResolver resolver = new ResourceResolver(this.GetType().Assembly);
using (Stream stream = resolver.OpenResource("AnnotationLayoutStoreDefaults.xml"))
{
document.Load(stream);
Document = document;
}
}
catch (Exception e)
{
Platform.Log(LogLevel.Debug, e);
Clear();
}
}
}
/// <summary>
/// Translates the name of the specified domain class.
/// </summary>
/// <param name="domainClass"></param>
/// <returns></returns>
public static string Translate(Type domainClass)
{
IResourceResolver resolver = new ResourceResolver(domainClass.Assembly);
return resolver.LocalizeString(domainClass.Name);
}
public void Test()
{
List<IAnnotationItem> annotationItems = new List<IAnnotationItem>();
AnnotationLayoutStore.Instance.Clear();
IList<StoredAnnotationLayout> layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(0, layouts.Count);
AnnotationLayoutStore.Instance.Update(this.CreateLayout("testLayout1"));
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(1, layouts.Count);
layouts = new List<StoredAnnotationLayout>();
layouts.Clear();
layouts.Add(CreateLayout("testLayout1"));
layouts.Add(CreateLayout("testLayout2"));
layouts.Add(CreateLayout("testLayout3"));
layouts.Add(CreateLayout("testLayout4"));
AnnotationLayoutStore.Instance.Update(layouts);
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(4, layouts.Count);
ResourceResolver resolver = new ResourceResolver(this.GetType().Assembly);
using (Stream stream = resolver.OpenResource("AnnotationLayoutStoreDefaults.xml"))
{
AnnotationLayoutStoreSettings.Default.LayoutSettingsXml = new XmlDocument();
AnnotationLayoutStoreSettings.Default.LayoutSettingsXml.Load(stream);
}
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
int xmlLayoutCount = layouts.Count;
StoredAnnotationLayout layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT", annotationItems);
layout = CopyLayout(layout, "Dicom.OT.Copied");
AnnotationLayoutStore.Instance.Update(layout);
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(xmlLayoutCount + 1, layouts.Count);
layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT.Copied", annotationItems);
Assert.IsNotNull(layout);
AnnotationLayoutStore.Instance.RemoveLayout("Dicom.OT.Copied");
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(xmlLayoutCount, layouts.Count);
layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT.Copied", annotationItems);
Assert.IsNull(layout);
layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT", annotationItems);
Assert.IsNotNull(layout);
layouts = new List<StoredAnnotationLayout>();
layouts.Clear();
layouts.Add(CreateLayout("testLayout1"));
layouts.Add(CreateLayout("testLayout2"));
layouts.Add(CreateLayout("testLayout3"));
layouts.Add(CreateLayout("testLayout4"));
AnnotationLayoutStore.Instance.Update(layouts);
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(xmlLayoutCount + 4, layouts.Count);
AnnotationLayoutStore.Instance.RemoveLayout("testLayout1");
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(xmlLayoutCount + 3, layouts.Count);
AnnotationLayoutStore.Instance.RemoveLayout("testLayout2");
layouts = AnnotationLayoutStore.Instance.GetLayouts(annotationItems);
Assert.AreEqual(xmlLayoutCount + 2, layouts.Count);
layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT", annotationItems);
Assert.IsNotNull(layout);
layout = AnnotationLayoutStore.Instance.GetLayout("testLayout3", annotationItems);
Assert.AreEqual(1, layout.AnnotationBoxGroups.Count);
layout = AnnotationLayoutStore.Instance.GetLayout("Dicom.OT", annotationItems);
layout = CopyLayout(layout, "testLayout3");
AnnotationLayoutStore.Instance.Update(layout);
layout = AnnotationLayoutStore.Instance.GetLayout("testLayout3", annotationItems);
Assert.AreEqual(5, layout.AnnotationBoxGroups.Count);
}
protected void Initialize(string xmlResourceName)
{
using (Stream stream = new ResourceResolver(typeof(SopClassLegacyConfigurationElementCollection).Assembly).OpenResource(xmlResourceName))
{
XmlDocument document = new XmlDocument();
document.Load(stream);
foreach (XmlElement sopClass in document.SelectNodes("//sop-class"))
Add(sopClass.Attributes["uid"].InnerText, sopClass.Attributes["description"].InnerText);
stream.Close();
}
}
/// <summary>
/// Gets the display name for the specified worklist class, obtained either from
/// the <see cref="WorklistClassDisplayNameAttribute"/>, otherwise via the
/// <see cref="TerminologyTranslator"/> class.
/// </summary>
/// <param name="worklistClass"></param>
/// <returns></returns>
public static string GetDisplayName(Type worklistClass)
{
var a = AttributeUtils.GetAttribute<WorklistClassDisplayNameAttribute>(worklistClass, true);
if (a == null)
return TerminologyTranslator.Translate(worklistClass);
var resolver = new ResourceResolver(worklistClass, true);
return resolver.LocalizeString(a.DisplayName);
}
private void AddAssemblyIconToImage(Assembly pluginAssembly)
{
object[] pluginAttributes = pluginAssembly.GetCustomAttributes(typeof(PluginAttribute), false);
foreach (PluginAttribute pluginAttribute in pluginAttributes)
{
if (!string.IsNullOrEmpty(pluginAttribute.Icon))
{
try
{
IResourceResolver resolver = new ResourceResolver(pluginAssembly);
Bitmap icon = new Bitmap(resolver.OpenResource(pluginAttribute.Icon));
// Burn the icon into the background image
Graphics g = Graphics.FromImage(this.BackgroundImage);
int positionX = _nextIconPositionX;
int positionY = _nextIconPositionY;
g.DrawImage(icon, positionX, positionY, IconWidth, IconHeight);
// Burn the icon's name and version into the background image
string pluginName = pluginAttribute.Name;
string pluginVersion = string.Empty;
try
{
FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(pluginAssembly.Location);
pluginVersion = versionInfo.ProductVersion;
}
catch
{
}
Font font = new Font("Tahoma", 10F, GraphicsUnit.Pixel);
Brush brush = new SolidBrush(Color.FromArgb(50, 50, 50));
StringFormat format = new StringFormat();
format.Alignment = StringAlignment.Center;
Rectangle layoutRect = new Rectangle(positionX - IconPaddingX / 2, positionY + IconHeight, IconWidth + IconPaddingX, IconTextHeight);
g.DrawString(pluginName + "\n" + pluginVersion, font, brush, layoutRect, format);
font.Dispose();
brush.Dispose();
g.Dispose();
// Advance to the next icon position within the plugin rectangle
_nextIconPositionX += (IconWidth + IconPaddingX);
if (_nextIconPositionX + IconWidth + IconPaddingX / 2 > _pluginIconsRectangle.Right)
{
_nextIconPositionX = _pluginIconsRectangle.Left + IconPaddingX / 2;
_nextIconPositionY += IconPaddingY + IconHeight + IconTextHeight;
}
this.Invalidate();
}
catch
{
}
}
}
}
public void Test()
{
DicomFilteredAnnotationLayoutStore.Instance.Clear();
IList<DicomFilteredAnnotationLayout> layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(0, layouts.Count);
DicomFilteredAnnotationLayoutStore.Instance.Update(CreateLayout("testLayout1", "Dicom.MR", "MR"));
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(1, layouts.Count);
layouts = new List<DicomFilteredAnnotationLayout>();
layouts.Clear();
layouts.Add(CreateLayout("testLayout1", "Dicom.MR", "MR"));
layouts.Add(CreateLayout("testLayout2", "Dicom.MG", "MG"));
layouts.Add(CreateLayout("testLayout3", "Dicom.CT", "CT"));
layouts.Add(CreateLayout("testLayout4", "Dicom.PT", "PT"));
DicomFilteredAnnotationLayoutStore.Instance.Update(layouts);
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(4, layouts.Count);
ResourceResolver resolver = new ResourceResolver(this.GetType().Assembly);
using (Stream stream = resolver.OpenResource("DicomFilteredAnnotationLayoutStoreDefaults.xml"))
{
StreamReader reader = new StreamReader(stream);
DicomFilteredAnnotationLayoutStoreSettings.Default.FilteredLayoutSettingsXml = reader.ReadToEnd();
}
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml, layouts.Count);
DicomFilteredAnnotationLayout layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.MR");
layout = CopyLayout(layout, "Dicom.Filtered.RT");
layout.Filters[0] = new KeyValuePair<string,string>("Modality", "RT");
DicomFilteredAnnotationLayoutStore.Instance.Update(layout);
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml + 1, layouts.Count);
layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.RT");
Assert.IsNotNull(layout);
DicomFilteredAnnotationLayoutStore.Instance.RemoveFilteredLayout("Dicom.Filtered.RT");
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml, layouts.Count);
layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.RT");
Assert.IsNull(layout);
layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.MR");
Assert.IsNotNull(layout);
layouts = new List<DicomFilteredAnnotationLayout>();
layouts.Clear();
layouts.Add(CreateLayout("Dicom.Filtered.RT", "Dicom.RT", "RT"));
layouts.Add(CreateLayout("Dicom.Filtered.SC", "Dicom.SC", "SC"));
layouts.Add(CreateLayout("Dicom.Filtered.US", "Dicom.US", "US"));
layouts.Add(CreateLayout("Dicom.Filtered.ES", "Dicom.ES", "ES"));
DicomFilteredAnnotationLayoutStore.Instance.Update(layouts);
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml + 4, layouts.Count);
DicomFilteredAnnotationLayoutStore.Instance.RemoveFilteredLayout("Dicom.Filtered.RT");
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml + 3, layouts.Count);
DicomFilteredAnnotationLayoutStore.Instance.RemoveFilteredLayout("Dicom.Filtered.SC");
layouts = DicomFilteredAnnotationLayoutStore.Instance.FilteredLayouts;
Assert.AreEqual(_countLayoutsInDicomFilteredLayoutStoreXml + 2, layouts.Count);
layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.AllMatch");
Assert.IsNotNull(layout);
Assert.AreEqual(0, layout.Filters.Count);
layout = DicomFilteredAnnotationLayoutStore.Instance.GetFilteredLayout("Dicom.Filtered.MR");
Assert.AreEqual(1, layout.Filters.Count);
}
/// <summary>
/// Gets the category for the specified worklist class, as specified by
/// the <see cref="WorklistCategoryAttribute"/>, or null if not specified.
/// </summary>
/// <param name="worklistClass"></param>
/// <returns></returns>
public static string GetCategory(Type worklistClass)
{
var a = AttributeUtils.GetAttribute<WorklistCategoryAttribute>(worklistClass, true);
if (a == null)
return null;
var resolver = new ResourceResolver(worklistClass, true);
return resolver.LocalizeString(a.Category);
}
/// <summary>
/// Constructor.
/// </summary>
/// <remarks>
/// The resource is resolved using the calling assembly (from <see cref="System.Reflection.Assembly.GetCallingAssembly"/>).
/// </remarks>
/// <param name="resourceName">The resource name of the cursor.</param>
public CursorToken(string resourceName)
{
Platform.CheckForEmptyString(resourceName, "resourceName");
_resourceName = resourceName;
_resolver = new ApplicationThemeResourceResolver(Assembly.GetCallingAssembly());
}
/// <summary>
/// Gets the icon for the <see cref="ApplicationTheme"/>.
/// </summary>
/// <returns>A new <see cref="Stream"/> for the icon.</returns>
/// <seealso cref="Icon"/>
public Stream GetIcon()
{
if (string.IsNullOrEmpty(_providers[0].Icon))
return null;
var resourceResolver = new ResourceResolver(_providers[0].GetType(), false);
return resourceResolver.OpenResource(_providers[0].Icon);
}
private static PaletteColorLut CreateFromColorPaletteSopInstanceXml(string resourceName)
{
try
{
var resourceResolver = new ResourceResolver(Assembly.GetExecutingAssembly());
using (var xmlStream = resourceResolver.OpenResource(resourceName))
{
var xmlDocument = new XmlDocument();
xmlDocument.Load(xmlStream);
var docRootNode = CollectionUtils.FirstElement(xmlDocument.GetElementsByTagName("ClearCanvasColorPaletteDefinition")) as XmlElement;
if (docRootNode != null)
{
var instanceNode = CollectionUtils.FirstElement(docRootNode.GetElementsByTagName("Instance")) as XmlElement;
if (instanceNode != null)
{
var instanceXml = new InstanceXml(instanceNode, null);
return Create(instanceXml.Collection);
}
}
}
}
catch (Exception ex)
{
Platform.Log(LogLevel.Debug, ex, "Failed to load embedded standard color palette SOP from resource {0}", resourceName);
}
return null;
}
/// <summary>
/// Constructor
/// </summary>
protected Folder()
{
// establish default resource resolver on this assembly (not the assembly of the derived class)
_resourceResolver = new ResourceResolver(typeof(Folder).Assembly);
// Initialize folder Path
var pathAttrib = AttributeUtils.GetAttribute<FolderPathAttribute>(this.GetType());
if (pathAttrib != null)
{
_folderPath = new Path(pathAttrib.Path, _resourceResolver);
_startExpanded = pathAttrib.StartExpanded;
}
// Initialize tooltip
var attrib = AttributeUtils.GetAttribute<FolderDescriptionAttribute>(this.GetType());
if (attrib != null)
{
var resolver = new ResourceResolver(this.GetType(), true);
this.Tooltip = resolver.LocalizeString(attrib.Description);
}
}
protected override void InitializeDefault()
{
using (Stream stream = new ResourceResolver(typeof(SopClassLegacyConfigurationElementCollection).Assembly).OpenResource("TransferSyntaxes.xml"))
{
XmlDocument document = new XmlDocument();
document.Load(stream);
foreach (XmlElement transferSyntax in document.SelectNodes("//transfer-syntax"))
Add(transferSyntax.Attributes["uid"].InnerText, transferSyntax.Attributes["description"].InnerText);
}
}
private EnumerationInfo ReadSoftEnum(Type enumValueClass, Table table)
{
// look for an embedded resource that matches the enum class
string res = string.Format("{0}.enum.xml", enumValueClass.FullName);
IResourceResolver resolver = new ResourceResolver(enumValueClass.Assembly);
try
{
using (Stream xmlStream = resolver.OpenResource(res))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlStream);
int displayOrder = 1;
return new EnumerationInfo(enumValueClass.FullName, table.Name, false,
CollectionUtils.Map<XmlElement, EnumerationMemberInfo>(xmlDoc.GetElementsByTagName("enum-value"),
delegate(XmlElement enumValueElement)
{
XmlElement valueNode = CollectionUtils.FirstElement<XmlElement>(enumValueElement.GetElementsByTagName("value"));
XmlElement descNode = CollectionUtils.FirstElement<XmlElement>(enumValueElement.GetElementsByTagName("description"));
return new EnumerationMemberInfo(
enumValueElement.GetAttribute("code"),
valueNode != null ? valueNode.InnerText : null,
descNode != null ? descNode.InnerText : null,
displayOrder++,
false);
}));
}
}
catch (Exception)
{
// no embedded resource found - no values defined
return new EnumerationInfo(enumValueClass.FullName, table.Name, false, new List<EnumerationMemberInfo>());
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="systemCursor">The system cursor to show in the view.</param>
public CursorToken(SystemCursors systemCursor)
{
_resourceName = systemCursor.ToString();
_resolver = null;
}
private IActionSet GetContextMenuActionSet()
{
var aimUserGraphics = GetAimUserGraphics();
var actionsList = new List<IAction>();
const string path = "imageviewer-contextmenu/Visible AIM Users/";
var resolver = new ResourceResolver(GetType(), true);
foreach (var aimUser in aimUserGraphics.Keys)
{
if (aimUserGraphics.Count > 0)
{
var user = aimUser;
var action = new MenuAction(aimUser, new ActionPath(path + aimUser, resolver), ClickActionFlags.CheckAction, resolver);
action.Checked = aimUserGraphics[aimUser][0].Visible;
action.Enabled = true;
action.Persistent = false;
action.Label = aimUser;
actionsList.Add(action);
action.SetClickHandler(
delegate
{
var visible = !action.Checked;
_displayMarkupPerUser[user] = visible;
action.Checked = visible;
SelectedPresentationImage.Draw();
});
}
}
return new ActionSet(actionsList);
}
/// <summary>
/// Gets the description for the specified worklist class, as specified by
/// the <see cref="WorklistCategoryAttribute"/>, or null if not specified.
/// </summary>
/// <param name="worklistClass"></param>
/// <returns></returns>
public static string GetDescription(Type worklistClass)
{
var a = AttributeUtils.GetAttribute<WorklistClassDescriptionAttribute>(worklistClass, true);
if (a == null)
return null;
var resolver = new ResourceResolver(worklistClass, true);
return resolver.LocalizeString(a.Description);
}
/// <summary>
/// Translates the default value for a settings class given the raw value.
/// </summary>
/// <remarks>
/// If the specified raw value is the name of an embedded resource (embedded in the same
/// assembly as the specified settings class), the contents of the resource are returned.
/// Otherwise, the raw value is simply returned.
/// </remarks>
public static string TranslateDefaultValue(Type settingsClass, string rawValue)
{
// short circuit if nothing translatable
if (string.IsNullOrEmpty(rawValue))
return rawValue;
// does the raw value look like it could be an embedded resource?
if (Regex.IsMatch(rawValue, @"^([\w]+\.)+\w+$"))
{
try
{
// try to open the resource
IResourceResolver resolver = new ResourceResolver(settingsClass.Assembly);
using (var resourceStream = resolver.OpenResource(rawValue))
{
var r = new StreamReader(resourceStream);
return r.ReadToEnd();
}
}
catch (MissingManifestResourceException)
{
// guess it was not an embedded resource, so return the raw value
return rawValue;
}
}
return rawValue;
}
// [Test]
internal void ExportDefaultLayoutConfigurationData()
{
// this method exports the default layout in EnterpriseServer format
var configBodyData = new StringBuilder();
using (var configBodyDataWriter = new StringWriter(configBodyData))
{
var configBody = new XmlDocument();
{
var sbValue = new StringBuilder();
using (var writer = new StringWriter(sbValue))
{
var resourceResolver = new ResourceResolver(typeof (AnnotationLayoutStoreTests).Assembly);
var defaultLayout = new XmlDocument();
defaultLayout.Load(resourceResolver.OpenResource("AnnotationLayoutStoreDefaults.xml"));
defaultLayout.Save(writer);
}
var cdata = configBody.CreateCDataSection(sbValue.ToString());
var value = configBody.CreateElement("value");
value.AppendChild(cdata);
var setting = configBody.CreateElement("setting");
setting.SetAttribute("name", "LayoutSettingsXml");
setting.AppendChild(value);
var settings = configBody.CreateElement("settings");
settings.AppendChild(setting);
configBody.AppendChild(settings);
}
configBody.Save(configBodyDataWriter);
}
var configDocument = new XmlDocument();
var nameElement = configDocument.CreateElement("Name");
nameElement.InnerText = typeof (AnnotationLayoutStoreSettings).FullName ?? string.Empty;
var versionElement = configDocument.CreateElement("Version");
versionElement.InnerText = string.Format("{0:00000}.{1:00000}", ProductInformation.Version.Major, ProductInformation.Version.Minor);
var bodyElement = configDocument.CreateElement("Body");
bodyElement.InnerText = configBodyData.ToString();
var configItem = configDocument.CreateElement("item");
configItem.AppendChild(nameElement);
configItem.AppendChild(versionElement);
configItem.AppendChild(bodyElement);
var rootConfigurations = configDocument.CreateElement("Configurations");
rootConfigurations.SetAttribute("type", "array");
rootConfigurations.AppendChild(configItem);
configDocument.AppendChild(rootConfigurations);
configDocument.Save(string.Format("{0}.xml", typeof (AnnotationLayoutStoreSettings).FullName));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="resourceName">The resource name of the cursor.</param>
/// <param name="resourceAssembly">The assembly where the cursor resource resides.</param>
public CursorToken(string resourceName, Assembly resourceAssembly)
{
Platform.CheckForEmptyString(resourceName, "resourceName");
Platform.CheckForNullReference(resourceAssembly, "resourceAssembly");
_resourceName = resourceName;
_resolver = new ApplicationThemeResourceResolver(resourceAssembly);
}
