public static MailMessage AddAttachments(this MailMessage mail, List<string> attachments, IResourceResolver resourceResolver)
 {
     if (mail != null && attachments != null && attachments.Any())
     {
         if (resourceResolver == null)
         {
             throw new Exception("ResourceResolver not set");
         }
         attachments.ForEach(a =>
         {
             MailAttachment att = resourceResolver.GetMailAttachment(a);
             if (att != null)
             {
                 MemoryStream ms = new MemoryStream(att.Content);
                 if (att.MediaType.Clear() != null)
                 {
                     mail.Attachments.Add(new Attachment(ms, att.Name, att.MediaType));
                 }
                 else
                 {
                     mail.Attachments.Add(new Attachment(ms, att.Name));
                 }
             }
         });
     }
     return mail;
 }

 public static MailMessage AddHtmlView(this MailMessage mail, string htmlBody, List<string> resources, IResourceResolver resourceResolver)
 {
     if (mail != null && htmlBody.Clear() != null && resources != null && resources.Any())
     {
         if (resourceResolver == null)
         {
             throw new Exception("ResourceResolver not set");
         }
         AlternateView av = AlternateView.CreateAlternateViewFromString(htmlBody, null, MediaTypeNames.Text.Html);
         resources.ForEach(r =>
         {
             HtmlResource hr = resourceResolver.GetHtmlResource(r);
             if (hr != null)
             {
                 MemoryStream ms = new MemoryStream(hr.Content);
                 LinkedResource lr;
                 if (hr.MediaType.Clear() != null)
                 {
                     lr = new LinkedResource(ms, hr.MediaType.Clear());
                 }
                 else
                 {
                     lr = new LinkedResource(ms);
                 }
                 lr.ContentId = hr.ContentId;
                 av.LinkedResources.Add(lr);
             }
             mail.AlternateViews.Add(av);
         });
     }
     return mail;
 }

        protected override IView CreateView(VirtualPath pathToView, IResourceResolver resolver)
        {
            var resource = resolver.GetResource(pathToView);
            if (resource == null || !resource.IsFile) {
                return null;
            }

            return new NustacheView(this, pathToView, resource, resolver);
        }

		/// <summary>
		/// Instantiates an active template from an embedded resource.
		/// </summary>
		/// <param name="resource"></param>
		/// <param name="resolver"></param>
		/// <returns></returns>
		public static ActiveTemplate FromEmbeddedResource(string resource, IResourceResolver resolver)
		{
			using (var stream = resolver.OpenResource(resource))
			{
				using (var reader = new StreamReader(stream))
				{
					return new ActiveTemplate(reader);
				}
			}
		}

 public DotLiquidView(VirtualPath path, IResource resource, IResourceResolver resolver)
 {
     _path = path;
     _resolver = resolver;
     using (var stream = resource.Open())
     using (var reader = new StreamReader(stream)) {
         string tpl = reader.ReadToEnd();
         _template = Template.Parse(tpl);
     }
 }

		/// <summary>
		/// Constructor.
		/// </summary>
		/// <param name="identifier">The unique identifier of the <see cref="AnnotationItem"/>.</param>
		/// <param name="displayName">The <see cref="AnnotationItem"/>'s display name.</param>
		/// <param name="label">The <see cref="AnnotationItem"/>'s label.</param>
		/// <param name="resourceResolver">The object that will resolve the display name and label parameters as the keys representing localized strings.</param>
		protected AnnotationItem(string identifier, string displayName, string label, IResourceResolver resourceResolver)
		{
			Platform.CheckForEmptyString(identifier, "identifier");
			Platform.CheckForEmptyString(displayName, "displayName");

			_standardResourceResolver = resourceResolver ?? new ResourceResolver(GetType(), false);
			_identifier = identifier;
			_displayName = displayName;
			_label = label ?? "";
		}

 public NustacheView(NustacheViewEngine engine, VirtualPath path, IResource resource, IResourceResolver resolver)
 {
     _engine = engine;
     _path = path;
     _resolver = resolver;
     using (var stream = resource.Open())
     using (var reader = new StreamReader(stream)) {
         Template = new Template();
         Template.Load(reader);
     }
 }

		/// <summary>
		/// Constructor.
		/// </summary>
		/// <param name="name">The name of the page.</param>
		/// <param name="component">The <see cref="IApplicationComponent"/> to be hosted in this page.</param>
		/// <param name="title">The text to display on the title bar.</param>
		/// <param name="iconSet">The icon to display on the title bar.</param>
		/// <param name="fallbackResolver">Resource resolver to fall back on in case the default failed to find resources.</param>
		public StackTabPage(string name, 
			IApplicationComponent component, 
			string title, 
			IconSet iconSet,
			IResourceResolver fallbackResolver)
			: base(name, component)
		{
			_title = title;
			_iconSet = iconSet;
			_resourceResolver = new ApplicationThemeResourceResolver(typeof(StackTabPage).Assembly, fallbackResolver);
		}

 public ServerSerializationContextProvider(IUriResolver uriResolver, IResourceResolver resourceResolver, NancyContext nancyContext)
 {
     if (uriResolver == null)
         throw new ArgumentNullException("uriResolver");
     if (resourceResolver == null)
         throw new ArgumentNullException("resourceResolver");
     if (nancyContext == null)
         throw new ArgumentNullException("nancyContext");
     this.uriResolver = uriResolver;
     this.resourceResolver = resourceResolver;
     this.nancyContext = nancyContext;
 }

		private IAction CreateAction(TransferSyntax syntax, IResourceResolver resolver)
		{
		    var action = new ClickAction(syntax.UidString,
		                                 new ActionPath("dicomstudybrowser-contextmenu/Change Transfer Syntax/" + syntax.ToString(), resolver),
		                                 ClickActionFlags.None, resolver) {Enabled = Enabled};

		    this.EnabledChanged += (sender, args) => action.Enabled = Enabled;

            action.SetClickHandler(() => ChangeToSyntax(syntax));
			action.Label = syntax.ToString();
			return action;
		}

		public override Image CreateIcon(IconSize iconSize, IResourceResolver resourceResolver)
		{
			var bitmap = new Bitmap(_dimensions.Width, _dimensions.Height);
			using(var g = System.Drawing.Graphics.FromImage(bitmap))
			{
				g.FillRectangle(Brushes.White, 0, 0, _dimensions.Width - 1, _dimensions.Height - 1);
				g.DrawRectangle(Pens.DarkGray, 0, 0, _dimensions.Width - 1, _dimensions.Height - 1);
				g.FillRectangle(GetBrush(), 1, 1,
					Math.Min((int)(_dimensions.Width*_percent/100), _dimensions.Width - 2),
					_dimensions.Height - 2);
			}
			return bitmap;
		}

		/// <summary>
		/// Creates an icon using the specified icon resource and resource resolver.
		/// </summary>
		/// <param name="iconSize">The size of the desired icon.</param>
		/// <param name="resourceResolver">The resource resolver with which to resolve the requested icon resource.</param>
		/// <returns>An <see cref="Image"/> constructed from the requested resource.</returns>
		/// <exception cref="ArgumentNullException">Thrown if <paramref name="resourceResolver"/> is null.</exception>
		/// <exception cref="ArgumentException">Thrown if <paramref name="resourceResolver"/> was unable to resolve the requested icon resource.</exception>
		public override Image CreateIcon(IconSize iconSize, IResourceResolver resourceResolver)
		{
			var iconBase = base.CreateIcon(iconSize, resourceResolver);
			var iconOverlay = GetOverlayIcon(iconSize);
			if (iconOverlay != null)
			{
				using (var g = Graphics.FromImage(iconBase))
				{
					g.DrawImageUnscaledAndClipped(iconOverlay, new Rectangle(Point.Empty, iconBase.Size));
				}
				iconOverlay.Dispose();
			}
			return iconBase;
		}

        public IView GetView(VirtualPath pathToView, IResourceResolver resolver)
        {
            if (_settings.Debug)
            {
                return CreateView(pathToView, resolver);
            }

            IView result = null;
            string key = pathToView.Path;
            if (!_cache.TryGetValue(key, out result)) {
                result = CreateView(pathToView, resolver);
                _cache[key] = result;
            }
            return result;
        }

		/// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="actionID">The logical action ID.</param>
        /// <param name="path">The action path.</param>
        /// <param name="resourceResolver">A resource resolver that will be used to resolve icons associated with this action.</param>
        protected Action(string actionID, ActionPath path, IResourceResolver resourceResolver)
        {
            _actionID = actionID;
            _path = path;
            _resourceResolver = resourceResolver;

            // smart defaults
            _enabled = true;
            _visible = true;
			_available = true;

			_persistent = false;

            FormerActionIDs = new List<string>();
        }

		private AbstractAction(string id, string path, IResourceResolver resourceResolver)
		{
			Platform.CheckForEmptyString(id, "id");
			Platform.CheckForEmptyString(path, "path");

			_resourceResolver = resourceResolver;
			_actionId = id;
            _formerActionIds = new List<string>();
			_path = new ActionPath(path, resourceResolver);
			_groupHint = new GroupHint(string.Empty);
			_label = string.Empty;
			_tooltip = string.Empty;
			_iconSet = null;
			_available = true;
			_permissible = false;
		}

 public EmailService(EmailServiceParams serviceParams, IResourceResolver resourceResolver)
 {
     if (serviceParams.FromAddress.Clear() == null)
     {
         throw new Exception("From address cannot be null or empty");
     }
     if (serviceParams.SmtpAddress.Clear() == null || serviceParams.SmtpPort == 0)
     {
         throw new Exception("Invalid SMTP server configuration");
     }
     ServiceParams = serviceParams;
     From = ExtensionsLocal.GetMailAddress(serviceParams.FromAddress, serviceParams.FromDisplayName);
     Sender = ExtensionsLocal.GetMailAddress(serviceParams.SenderAddress, serviceParams.SenderDisplayName) ?? From;
     UseAuthentication = false;
     ResourceResolver = resourceResolver;
 }

		/// <summary>
		/// Constructor that allows specifying which of Add, Edit, and Delete actions should appear.
		/// </summary>
		/// <param name="add"></param>
		/// <param name="edit"></param>
		/// <param name="delete"></param>
		/// <param name="fallBackResolver"></param>
		public CrudActionModel(bool add, bool edit, bool delete, IResourceResolver fallBackResolver)
			: base(new ApplicationThemeResourceResolver(typeof(CrudActionModel).Assembly, fallBackResolver))
		{
			if (add)
			{
				this.AddAction(AddKey, SR.TitleAdd, IconAddResource);
			}
			if (edit)
			{
				this.AddAction(EditKey, SR.TitleEdit, IconEditResource);
			}
			if (delete)
			{
				this.AddAction(DeleteKey, SR.TitleDelete, IconDeleteResource);
			}
		}

 public ServerSerializationContextProvider(ITypeResolver typeMapper,
                                           IUriResolver uriResolver,
                                           IResourceResolver resourceResolver,
                                           IContainer container)
 {
     if (typeMapper == null)
         throw new ArgumentNullException(nameof(typeMapper));
     if (uriResolver == null)
         throw new ArgumentNullException(nameof(uriResolver));
     if (resourceResolver == null)
         throw new ArgumentNullException(nameof(resourceResolver));
     if (container == null)
         throw new ArgumentNullException(nameof(container));
     this.typeMapper = typeMapper;
     this.uriResolver = uriResolver;
     this.resourceResolver = resourceResolver;
     this.container = container;
 }

		public override Image CreateIcon(IconSize iconSize, IResourceResolver resourceResolver)
		{
			//TODO: make unsafe. Not enabling unsafe code just for this, though.
			var bitmap = (Bitmap) base.CreateIcon(iconSize, resourceResolver);
			for (int x = 0; x < bitmap.Width; ++x)
			{
				for (int y = 0; y < bitmap.Height; ++y)
				{
					var pixel = bitmap.GetPixel(x, y);
					int gray = (int) (pixel.R*0.3f + pixel.G*0.59F + pixel.B*0.11f);
					if (gray > 255)
						gray = 255;

					bitmap.SetPixel(x, y, Color.FromArgb(pixel.A, gray, gray, gray));
				}
			}
			return bitmap;
		}

		/// <summary>
		/// Constructs a controller that uses the 32-bit colour ARGB bitmap specified by the resource name and resource resolver.
		/// </summary>
		/// <param name="resourceName">The partially or fully qualified name of the resource to access.</param>
		/// <param name="resourceResolver">A resource resolver for the resource.</param>
		public FlashOverlayController(string resourceName, IResourceResolver resourceResolver) : this()
		{
			using (Bitmap bitmap = new Bitmap(resourceResolver.OpenResource(resourceName)))
			{
				BitmapData data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
				try
				{
					int length = data.Stride*data.Height;
					_pixelData = new byte[length];
					_rows = data.Height;
					_columns = data.Width;
					Marshal.Copy(data.Scan0, _pixelData, 0, length);
				}
				finally
				{
					bitmap.UnlockBits(data);
				}
			}
		}