mcs/class/referencesource/System.Web.DataVisualization/Common/Utilities/ImageLoader.cs

   1 //-------------------------------------------------------------
   2 // <copyright company=’Microsoft Corporation’>
   3 //   Copyright © Microsoft Corporation. All Rights Reserved.
   4 // </copyright>
   5 //-------------------------------------------------------------
   6 // @owner=alexgor, deliant
   7 //=================================================================
   8 //  File:               ImageLoader.cs
   9 //
  10 //  Namespace:  System.Web.UI.WebControls[Windows.Forms].Charting.Utilities
  11 //
  12 //      Classes:        ImageLoader
  13 //
  14 //  Purpose:    ImageLoader utility class loads specified image and
  15 //              caches it in the memory for the future use.
  16 //
  17 //              Images can be loaded from different places including
  18 //              Files, URIs, WebRequests and Control Resources.
  19 //
  20 //      Reviewed:       AG - August 7, 2002
  21 //              AG - Microsoft 5, 2007
  22 //
  23 //===================================================================
  24
  25
  26 #region Used Namespaces
  27
  28 using System;
  29 using System.Drawing;
  30 using System.Collections;
  31 using System.ComponentModel;
  32 using System.ComponentModel.Design;
  33 using System.Reflection;
  34 using System.Net;
  35 using System.IO;
  36 using System.Security;
  37 using System.Resources;
  38
  39 #if Microsoft_CONTROL
  40         using System.Windows.Forms.DataVisualization.Charting;
  41 #else
  42         using System.Web;
  43     using System.Web.UI.DataVisualization.Charting;
  44 #endif
  45
  46 #endregion
  47
  48 #if Microsoft_CONTROL
  49         namespace System.Windows.Forms.DataVisualization.Charting.Utilities
  50 #else
  51         namespace System.Web.UI.DataVisualization.Charting.Utilities
  52 #endif
  53 {
  54         /// <summary>
  55     /// ImageLoader utility class loads and returns specified image
  56     /// form the File, URI, Web Request or Chart Resources.
  57     /// Loaded images are stored in the internal hashtable which
  58     /// allows to improve performance if image need to be used
  59     /// several times.
  60         /// </summary>
  61         internal class ImageLoader : IDisposable, IServiceProvider
  62         {
  63                 #region Fields
  64
  65                 // Image storage
  66                 private Hashtable                       _imageData = null;
  67
  68                 // Reference to the service container
  69                 private IServiceContainer       _serviceContainer = null;
  70
  71                 #endregion
  72
  73                 #region Constructors and Initialization
  74
  75                 /// <summary>
  76                 /// Default constructor is not accessible.
  77                 /// </summary>
  78                 private ImageLoader()
  79                 {
  80                 }
  81
  82                 /// <summary>
  83                 /// Default public constructor.
  84                 /// </summary>
  85                 /// <param name="container">Service container.</param>
  86                 public ImageLoader(IServiceContainer container)
  87                 {
  88                         if(container == null)
  89                         {
  90                                 throw(new ArgumentNullException(SR.ExceptionImageLoaderInvalidServiceContainer));
  91                         }
  92             _serviceContainer = container;
  93                 }
  94
  95                 /// <summary>
  96                 /// Returns Image Loader service object
  97                 /// </summary>
  98                 /// <param name="serviceType">Requested service type.</param>
  99                 /// <returns>Image Loader service object.</returns>
 100                 [EditorBrowsableAttribute(EditorBrowsableState.Never)]
 101                 object IServiceProvider.GetService(Type serviceType)
 102                 {
 103                         if(serviceType == typeof(ImageLoader))
 104                         {
 105                                 return this;
 106                         }
 107                         throw (new ArgumentException( SR.ExceptionImageLoaderUnsupportedType( serviceType.ToString())));
 108                 }
 109
 110                 /// <summary>
 111                 /// Dispose images in the hashtable
 112                 /// </summary>
 113                 public void Dispose()
 114                 {
 115             if (_imageData != null)
 116                         {
 117                 foreach (DictionaryEntry entry in _imageData)
 118                                 {
 119                     if (entry.Value is IDisposable)
 120                     {
 121                         ((IDisposable)entry.Value).Dispose();
 122                     }
 123                                 }
 124                 _imageData = null;
 125                                 GC.SuppressFinalize(this);
 126                         }
 127                 }
 128
 129                 #endregion
 130
 131                 #region Methods
 132
 133                 /// <summary>
 134                 /// Loads image from URL. Checks if image already loaded (cached).
 135                 /// </summary>
 136         /// <param name="imageURL">Image name (FileName, URL, Resource).</param>
 137                 /// <returns>Image object.</returns>
 138                 public System.Drawing.Image LoadImage(string imageURL)
 139                 {
 140                         return LoadImage(imageURL, true);
 141                 }
 142
 143                 /// <summary>
 144                 /// Loads image from URL. Checks if image already loaded (cached).
 145                 /// </summary>
 146                 /// <param name="imageURL">Image name (FileName, URL, Resource).</param>
 147                 /// <param name="saveImage">True if loaded image should be saved in cache.</param>
 148                 /// <returns>Image object</returns>
 149         public System.Drawing.Image LoadImage(string imageURL, bool saveImage)
 150                 {
 151             System.Drawing.Image image = null;
 152
 153                         // Check if image is defined in the chart image collection
 154             if (_serviceContainer != null)
 155                         {
 156                 Chart chart = (Chart)_serviceContainer.GetService(typeof(Chart));
 157                                 if(chart != null)
 158                                 {
 159                                         foreach(NamedImage namedImage in chart.Images)
 160                                         {
 161                                                 if(namedImage.Name == imageURL)
 162                                                 {
 163                                                         return namedImage.Image;
 164                                                 }
 165                                         }
 166                                 }
 167                         }
 168
 169                         // Create new hashtable
 170             if (_imageData == null)
 171                         {
 172                 _imageData = new Hashtable(StringComparer.OrdinalIgnoreCase);
 173                         }
 174
 175                         // First check if image with this name already loaded
 176             if (_imageData.Contains(imageURL))
 177                         {
 178                                 image = (System.Drawing.Image)_imageData[imageURL];
 179                         }
 180
 181 #if ! Microsoft_CONTROL
 182
 183                         // Try to load as relative URL using the Control object
 184                         if(image == null)
 185                         {
 186                 Chart control = (Chart)_serviceContainer.GetService(typeof(Chart));
 187                 if (control != null && control.Page != null)
 188                 {
 189                     if (!control.IsDesignMode())
 190                     {
 191                         image = LoadFromFile(control.Page.MapPath(imageURL));
 192                     }
 193                     else if (control.IsDesignMode() && !String.IsNullOrEmpty(control.webFormDocumentURL))
 194                     {
 195                         // Find current web page path and fileName
 196                         Uri pageUri = new Uri(control.webFormDocumentURL);
 197                         string path = pageUri.LocalPath;
 198                         string pageFile = pageUri.Segments[pageUri.Segments.Length-1];
 199
 200                         // Find full image fileName
 201                         string imageFileRelative = control.ResolveClientUrl(imageURL);
 202                         string imageFile = path.Replace(pageFile, imageFileRelative);
 203
 204                         // Load image
 205                         image = LoadFromFile(imageFile);
 206                     }
 207                 }
 208
 209                 else if ( HttpContext.Current != null )
 210                 {
 211                     image = LoadFromFile(HttpContext.Current.Request.MapPath(imageURL));
 212                 }
 213                         }
 214 #endif
 215
 216                         // Try to load image from resource
 217                         if(image == null)
 218                         {
 219                 try
 220                 {
 221
 222                     // Check if resource class type was specified
 223                     int columnIndex = imageURL.IndexOf("::", StringComparison.Ordinal);
 224                     if (columnIndex > 0)
 225                     {
 226                         string resourceRootName = imageURL.Substring(0, columnIndex);
 227                         string resourceName = imageURL.Substring(columnIndex + 2);
 228                         System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager(resourceRootName, Assembly.GetExecutingAssembly());
 229                         image = (System.Drawing.Image)(resourceManager.GetObject(resourceName));
 230                     }
 231 #if Microsoft_CONTROL
 232                     else if (Assembly.GetEntryAssembly() != null)
 233                     {
 234                         // Check if resource class type was specified
 235                         columnIndex = imageURL.IndexOf(':');
 236                         if (columnIndex > 0)
 237                         {
 238                             string resourceRootName = imageURL.Substring(0, columnIndex);
 239                             string resourceName = imageURL.Substring(columnIndex + 1);
 240                             System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager(resourceRootName, Assembly.GetEntryAssembly());
 241                             image = (Image)(resourceManager.GetObject(resourceName));
 242                         }
 243                         else
 244                         {
 245                             // Try to load resource from every type defined in entry assembly
 246                             Assembly entryAssembly = Assembly.GetEntryAssembly();
 247                             if (entryAssembly != null)
 248                             {
 249                                 foreach (Type type in entryAssembly.GetTypes())
 250                                 {
 251                                     System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager(type);
 252                                     try
 253                                     {
 254                                         image = (Image)(resourceManager.GetObject(imageURL));
 255                                     }
 256                                     catch (ArgumentNullException)
 257                                     {
 258                                     }
 259                                     catch (MissingManifestResourceException)
 260                                     {
 261                                     }
 262
 263                                     // Check if image was loaded
 264                                     if (image != null)
 265                                     {
 266                                         break;
 267                                     }
 268                                 }
 269                             }
 270                         }
 271                     }
 272 #endif
 273                 }
 274                 catch (MissingManifestResourceException)
 275                 {
 276                 }
 277                         }
 278
 279
 280                         // Try to load image using the Web Request
 281                         if(image == null)
 282                         {
 283                                 Uri     imageUri = null;
 284                                 try
 285                                 {
 286                                         // Try to create URI directly from image URL (will work in case of absolute URL)
 287                                         imageUri = new Uri(imageURL);
 288                                 }
 289                                 catch(UriFormatException)
 290                                 {}
 291
 292
 293                                 // Load image from file or web resource
 294                                 if(imageUri != null)
 295                                 {
 296                     try
 297                     {
 298                         WebRequest request = WebRequest.Create(imageUri);
 299                         image = System.Drawing.Image.FromStream(request.GetResponse().GetResponseStream());
 300                     }
 301                     catch (ArgumentException)
 302                     {
 303                     }
 304                     catch (NotSupportedException)
 305                     {
 306                     }
 307                     catch (SecurityException)
 308                     {
 309                     }
 310                                 }
 311             }
 312 #if Microsoft_CONTROL
 313             // absolute uri(without Server.MapPath)in web is not allowed. Loading from replative uri Server[Page].MapPath is done above.
 314             // Try to load as file
 315                         if(image == null)
 316                         {
 317
 318                 image = LoadFromFile(imageURL);
 319             }
 320 #endif
 321
 322             // Error loading image
 323                         if(image == null)
 324                         {
 325 #if ! Microsoft_CONTROL
 326                                 throw(new ArgumentException( SR.ExceptionImageLoaderIncorrectImageUrl( imageURL ) ) );
 327 #else
 328                                 throw(new ArgumentException( SR.ExceptionImageLoaderIncorrectImageLocation( imageURL ) ) );
 329 #endif
 330             }
 331
 332                         // Save new image in cache
 333                         if(saveImage)
 334                         {
 335                 _imageData[imageURL] = image;
 336                         }
 337
 338                         return image;
 339                 }
 340
 341                 /// <summary>
 342                 /// Helper function which loads image from file.
 343                 /// </summary>
 344                 /// <param name="fileName">File name.</param>
 345                 /// <returns>Loaded image or null.</returns>
 346         private System.Drawing.Image LoadFromFile(string fileName)
 347                 {
 348                         // Try to load image from file
 349                         try
 350                         {
 351                                 return System.Drawing.Image.FromFile(fileName);
 352                         }
 353                         catch(FileNotFoundException)
 354                         {
 355                                 return null;
 356                         }
 357                 }
 358
 359         /// <summary>
 360         /// Returns the image size taking the image DPI into consideration.
 361         /// </summary>
 362         /// <param name="name">Image name (FileName, URL, Resource).</param>
 363         /// <param name="graphics">Graphics used to calculate the image size.</param>
 364         /// <param name="size">Calculated size.</param>
 365         /// <returns>false if it fails to calculate the size, otherwise true.</returns>
 366         internal bool GetAdjustedImageSize(string name, Graphics graphics, ref SizeF size)
 367         {
 368             Image image = LoadImage(name);
 369
 370             if (image == null)
 371                 return false;
 372
 373             GetAdjustedImageSize(image, graphics, ref size);
 374
 375             return true;
 376         }
 377
 378         /// <summary>
 379         /// Returns the image size taking the image DPI into consideration.
 380         /// </summary>
 381         /// <param name="image">Image for whcih to calculate the size.</param>
 382         /// <param name="graphics">Graphics used to calculate the image size.</param>
 383         /// <param name="size">Calculated size.</param>
 384         internal static void GetAdjustedImageSize(Image image, Graphics graphics, ref SizeF size)
 385         {
 386             if (graphics != null)
 387             {
 388                 //this will work in case the image DPI is specified, otherwise the image DPI will be assumed to be same as the screen DPI
 389                 size.Width = image.Width * graphics.DpiX / image.HorizontalResolution;
 390                 size.Height = image.Height * graphics.DpiY / image.VerticalResolution;
 391             }
 392             else
 393             {
 394                 size.Width = image.Width;
 395                 size.Height = image.Height;
 396             }
 397         }
 398
 399         /// <summary>
 400         /// Checks if the image has the same DPI as the graphics object.
 401         /// </summary>
 402         /// <param name="image">Image to be checked.</param>
 403         /// <param name="graphics">Graphics object to be used.</param>
 404         /// <returns>true if they match, otherwise false.</returns>
 405         internal static bool DoDpisMatch(Image image, Graphics graphics)
 406         {
 407             return graphics.DpiX == image.HorizontalResolution && graphics.DpiY == image.VerticalResolution;
 408         }
 409
 410         internal static Image GetScaledImage(Image image, Graphics graphics)
 411         {
 412             Bitmap scaledImage = new Bitmap(image, new Size((int)(image.Width * graphics.DpiX / image.HorizontalResolution),
 413                 (int)(image.Height * graphics.DpiY / image.VerticalResolution)));
 414
 415             return scaledImage;
 416         }
 417
 418
 419                 #endregion
 420         }
 421 }