private void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
try
{
var image = new Bitmap(ChartImageDisplayWidth, ChartImageDisplayHeight);
using (var graphics = Graphics.FromImage(image))
{
if (HWInfo.SensorTrends.ContainsKey(e.Src))
{
graphics.DrawLines(_scrollPen, HWInfo.SensorTrends[e.Src].Read(ChartImageDisplayWidth, ChartImageDisplayHeight));
}
graphics.DrawRectangle(_whitePen,
new Rectangle(0, 0, ChartImageDisplayWidth - 1, ChartImageDisplayHeight - 1));
graphics.DrawString(HWInfo.SensorTrends[e.Src].MaxV(), _drawFont, _whiteBrush, (float)1, (float)1);
graphics.DrawString(HWInfo.SensorTrends[e.Src].MinV(), _drawFont, _whiteBrush, (float)1, (float)ChartImageDisplayHeight - 17);
}
e.Callback(image);
}
catch
{
var image = new Bitmap(1, 1);
e.Callback(image);
}
}
/// <summary>
/// Set image of this image box by analyzing the src attribute.<br/>
/// Load the image from inline base64 encoded string.<br/>
/// Or from calling property/method on the bridge object that returns image or URL to image.<br/>
/// Or from file path<br/>
/// Or from URI.
/// </summary>
/// <remarks>
/// File path and URI image loading is executed async and after finishing calling <see cref="ImageLoadComplete"/>
/// on the main thread and not thread-pool.
/// </remarks>
/// <param name="src">the source of the image to load</param>
/// <param name="attributes">the collection of attributes on the element to use in event</param>
/// <returns>the image object (null if failed)</returns>
public void LoadImage(string src, Dictionary <string, string> attributes)
{
try
{
var args = new HtmlImageLoadEventArgs(src, attributes, OnHtmlImageLoadEventCallback);
_htmlContainer.RaiseHtmlImageLoadEvent(args);
_asyncCallback = !_htmlContainer.AvoidAsyncImagesLoading;
if (!args.Handled)
{
if (!string.IsNullOrEmpty(src))
{
if (src.StartsWith("data:image", StringComparison.CurrentCultureIgnoreCase))
{
SetFromInlineData(src);
}
else
{
SetImageFromPath(src);
}
}
else
{
ImageLoadComplete(false);
}
}
}
catch (Exception ex)
{
_htmlContainer.ReportError(HtmlRenderErrorType.Image, "Exception in handling image source", ex);
ImageLoadComplete(false);
}
}
private void htmlPanel_ImageLoad(object sender, HtmlImageLoadEventArgs e)
{
/**
* Codigo al iniciar el evento de cargar de imagen une la direccion relativa de
* la carga de imagen y la direccion fisica del capitulo, luego lo busca
* en el diccionario de imagenes y luego de obtener la imagen carga la imagen.
* Y la regreso al evento de carga de imagenes.
*/
string imageFilePath = GetFullPath(capitulo_actual.ContentFileName, e.Src);
EpubByteContentFile imageContent;
if (epub.Content.Images.TryGetValue(imageFilePath, out imageContent))
{
using (MemoryStream imageStream = new MemoryStream(imageContent.Content))
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = imageStream;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.EndInit();
bitmapImage.Freeze();
e.Callback(BitmapImage2Bitmap(bitmapImage));
}
e.Handled = true;
}
}
/// <summary>
///
/// </summary>
/// <param name="src"></param>
/// <param name="imageLoadEvent"></param>
protected void LoadImageFromFile(string src, HtmlImageLoadEventArgs imageLoadEvent)
{
try
{
Uri uri = new Uri(src);
//Try to load the file as Image from file
//Remove the scheme first
string srcWithoutScheme = src;
int i = srcWithoutScheme.IndexOf(':');
if (i > 0)
{
srcWithoutScheme = srcWithoutScheme.Substring(i + 1).TrimStart('/');
}
//If not absolute, add the current file path
if (!Path.IsPathRooted(srcWithoutScheme))
{
uri = new Uri(@"file:///" + this.FileInfo.FileDirectory + "/" + srcWithoutScheme);
}
//For SVG images: Convert to Bitmap
string extension = Path.GetExtension(src);
if (extension != null && extension.Equals(".svg", StringComparison.OrdinalIgnoreCase))
{
ConvertSvgToBitmap(SvgDocument.Open <SvgDocument>(uri.LocalPath), imageLoadEvent);
}
else
{
//Load uri, 8, 1
imageLoadEvent.Callback((Bitmap)Image.FromFile(uri.LocalPath, true));
}
}
catch { } //Not able to handle, refer back to orginal process
}
/// <summary>
/// On image load in renderer set the image by event async.
/// </summary>
public static void ImageLoad(HtmlImageLoadEventArgs e, bool pdfSharp)
{
var img = TryLoadResourceImage(e.Src);
XImage xImg = null;
if (img != null)
{
using (var ms = new MemoryStream())
{
img.Save(ms, img.RawFormat);
xImg = img != null?XImage.FromStream(ms) : null;
}
}
object imgObj;
if (pdfSharp)
{
imgObj = xImg;
}
else
{
imgObj = img;
}
if (!e.Handled && e.Attributes != null)
{
if (e.Attributes.ContainsKey("byevent"))
{
int delay;
if (Int32.TryParse(e.Attributes["byevent"], out delay))
{
e.Handled = true;
ThreadPool.QueueUserWorkItem(state =>
{
Thread.Sleep(delay);
e.Callback("https://fbcdn-sphotos-a-a.akamaihd.net/hphotos-ak-snc7/c0.44.403.403/p403x403/318890_10151195988833836_1081776452_n.jpg");
});
return;
}
else
{
e.Callback("http://sphotos-a.xx.fbcdn.net/hphotos-ash4/c22.0.403.403/p403x403/263440_10152243591765596_773620816_n.jpg");
return;
}
}
else if (e.Attributes.ContainsKey("byrect"))
{
var split = e.Attributes["byrect"].Split(',');
var rect = new Rectangle(Int32.Parse(split[0]), Int32.Parse(split[1]), Int32.Parse(split[2]), Int32.Parse(split[3]));
e.Callback(imgObj ?? TryLoadResourceImage("htmlicon"), rect.X, rect.Y, rect.Width, rect.Height);
return;
}
}
if (img != null)
{
e.Callback(imgObj);
}
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
protected virtual void OnImageLoad(HtmlImageLoadEventArgs e) {
var handler = ImageLoad;
if (handler != null)
handler(this, e);
if (!e.Handled)
YamuiThemeManager.GetHtmlImages(e);
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
private void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
if (ImageLoad != null)
{
ImageLoad(this, e);
}
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
protected virtual void OnImageLoad(HtmlImageLoadEventArgs e)
{
ImageLoad?.Invoke(this, e);
if (!e.Handled)
{
YamuiThemeManager.GetHtmlImages(e);
}
}
/// <summary>
///
/// </summary>
/// <param name="svgDocument"></param>
/// <param name="imageLoadEvent"></param>
protected Bitmap ConvertSvgToBitmap(SvgDocument svgDocument, HtmlImageLoadEventArgs imageLoadEvent)
{
Bitmap svgImage = new Bitmap((int)svgDocument.Width, (int)svgDocument.Height, PixelFormat.Format32bppArgb);
svgDocument.Draw(svgImage);
imageLoadEvent.Callback(svgImage);
imageLoadEvent.Handled = true;
return(svgImage);
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
protected virtual void OnImageLoad(HtmlImageLoadEventArgs e)
{
var handler = ImageLoad;
if (handler != null)
{
handler(this, e);
}
}
private void HtmlPanel_ImageLoad(object sender, HtmlImageLoadEventArgs e)
{
if (e.Src.StartsWith(".."))
{
var uri = new Uri(NewsUri);
var path = new Uri($"{uri.Scheme}://{e.Src.Replace("..", uri.Host)}");
e.Callback(path.AbsoluteUri);
}
}
/// <summary>
/// Feeds the images to the html renderer
/// </summary>
internal static void GetHtmlImages(HtmlImageLoadEventArgs e)
{
Image img = FindImage(e.Src);
if (img != null)
{
e.Callback(img);
e.Handled = true;
}
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
protected virtual void OnImageLoad(HtmlImageLoadEventArgs e)
{
YamuiThemeManager.OnHtmlImageLoad(e);
var handler = ImageLoad;
if (handler != null)
{
handler(this, e);
}
}
private void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
if (CheckAccess())
{
OnImageLoad(e);
}
else
{
Dispatcher.UIThread.InvokeAsync(() => OnImageLoad(e)).Wait();
}
}
/// <summary>
/// Raise the image load event with the given event args.
/// </summary>
/// <param name="args">the event args</param>
internal void RaiseHtmlImageLoadEvent(HtmlImageLoadEventArgs args)
{
try {
if (ImageLoad != null)
{
ImageLoad(this, args);
}
} catch (Exception ex) {
ReportError(HtmlRenderErrorType.Image, "Failed image load event", ex);
}
}
private void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
if (CheckAccess())
{
OnImageLoad(e);
}
else
{
Dispatcher.Invoke(new Action <HtmlImageLoadEventArgs>(OnImageLoad), e);
}
}
/// <summary>
/// Raise the image load event with the given event args.
/// </summary>
/// <param name="args">the event args</param>
internal void RaiseHtmlImageLoadEvent(HtmlImageLoadEventArgs args)
{
try
{
EventHandler <HtmlImageLoadEventArgs> handler = this.ImageLoad;
if (handler != null)
{
handler(this, args);
}
}
catch (Exception ex)
{
this.ReportError(HtmlRenderErrorType.Image, "Failed image load event", ex);
}
}
/// <summary>
/// Callback from ImageRequestorTask for when an image is retrieved.
/// </summary>
/// <param name="image">The image retrieved (may be null)</param>
/// <param name="parameter">The HtmlImageLoadEventArgs argument</param>
private void ImageRetrieved(Image image, object parameter)
{
HtmlImageLoadEventArgs args = parameter as HtmlImageLoadEventArgs;
if (args != null)
{
args.Callback(image);
Bounds = new Rectangle(Bounds.X, Bounds.Y, Control.Size.Width, Control.Size.Height + SpaceAfter);
// Now we have an image, we need to adjust the control height to accommodate the
// image size the label height will likely have changed.
_layout.Container.RaiseRelayout();
_layout.Container.Invalidate();
}
}
/// <summary>
/// Custom renderer for SVG images in the markdown as not supported natively.
/// @see https://htmlrenderer.codeplex.com/wikipage?title=Rendering%20SVG%20images
/// </summary>
/// <param name="sender"></param>
/// <param name="imageLoadEvent"></param>
protected void OnImageLoad(object sender, HtmlImageLoadEventArgs imageLoadEvent)
{
try
{
//Get some file information
string src = imageLoadEvent.Src;
Regex reg = new Regex("^(file|http|https)://.*");
if (!reg.IsMatch(src))
{
src = @"file:///" + Regex.Replace(src, @"\?.*", ""); //remove any params. like "?raw=1" from src
}
Uri uri = new Uri(src);
string extension = Path.GetExtension(src);
//Check if local file or web resource
switch (uri.Scheme.ToLowerInvariant())
{
case "file":
//In case of a local file -> Try to load it directly
imageLoadEvent.Handled = true; //Tell the event it was handled, so no error border is drawn
ThreadPool.QueueUserWorkItem(state => LoadImageFromFile(src, imageLoadEvent));
break;
case "http":
case "https":
//For web resources check extension and parameter, to fetch from e.g. "badge" creating sources
if ((extension != null && extension.Equals(".svg", StringComparison.OrdinalIgnoreCase)) ||
uri.ToString().Contains("svg="))
{
//In case of a web resource file -> Load async
using (WebClient webClient = new WebClient())
{
imageLoadEvent.Handled = true; //Tell the event it was handled, so no error border is drawn
webClient.DownloadDataCompleted += (downloadSender, downloadEvent) => { OnDownloadDataCompleted(downloadEvent, imageLoadEvent); };
webClient.DownloadDataAsync(uri);
}
}
break;
}
}
catch
{
}
}
protected override void OnImageLoad(HtmlImageLoadEventArgs e)
{
byte[] imageContent;
if (ChapterContent.Images.TryGetValue(e.Src, out imageContent))
{
using (MemoryStream imageStream = new MemoryStream(imageContent))
{
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = imageStream;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.EndInit();
bitmapImage.Freeze();
e.Callback(bitmapImage);
}
e.Handled = true;
}
base.OnImageLoad(e);
}
public static void OnImageLoad(object sender, HtmlImageLoadEventArgs args)
{
Console.WriteLine(directory + args.Src);
if (!_imageSurface.ContainsKey(args.Src))
{
var img_surface = SDL_image.IMG_Load(directory + args.Src);
if (img_surface.ShowSDLError("OnImageLoad: Unable to IMG_Load!"))
{
return;
}
_imageSurface[args.Src] = img_surface;
}
args.Handled = true;
//foreach (var kv in args.Attributes)
//Console.WriteLine("{0}: {1}", kv.Key, kv.Value);
args.Callback(_imageSurface[args.Src]);
}
/// <summary>
/// Set image of this image box by analyzing the src attribute.<br/>
/// Load the image from inline base64 encoded string.<br/>
/// Or from calling property/method on the bridge object that returns image or url to image.<br/>
/// Or from file path<br/>
/// Or from URI.
/// </summary>
/// <remarks>
/// File path and URI image loading is executed async and after finishing calling <see cref="ImageLoadComplete"/>
/// on the main thread and not threadpool.
/// </remarks>
/// <param name="htmlContainer">the container of the html to handle load image for</param>
/// <param name="src">the source of the image to load</param>
/// <param name="attributes">the collection of attributes on the element to use in event</param>
/// <returns>the image object (null if failed)</returns>
public void LoadImage(HtmlContainer htmlContainer, string src, Dictionary <string, string> attributes)
{
ArgChecker.AssertArgNotNull(htmlContainer, "htmlContainer");
_htmlContainer = htmlContainer;
try
{
var args = new HtmlImageLoadEventArgs(src, attributes, OnHtmlImageLoadEventCallback);
_htmlContainer.RaiseHtmlImageLoadEvent(args);
if (!args.Handled)
{
if (!string.IsNullOrEmpty(src))
{
if (src.StartsWith("data:image", StringComparison.CurrentCultureIgnoreCase))
{
_image = GetImageFromData(src);
if (_image == null)
{
_htmlContainer.ReportError(HtmlRenderErrorType.Image, "Failed extract image from inline data");
}
_releaseImageObject = true;
ImageLoadComplete(false);
}
else
{
SetImageFromPath(src);
}
}
else
{
ImageLoadComplete(false);
}
}
}
catch (Exception ex)
{
_htmlContainer.ReportError(HtmlRenderErrorType.Image, "Exception in handling image source", ex);
ImageLoadComplete(false);
}
}
/// <summary>
/// Feeds the images to the html renderer
/// </summary>
internal static void OnHtmlImageLoad(HtmlImageLoadEventArgs e)
{
// load image from user
if (OnHtmlImageNeeded != null)
{
OnHtmlImageNeeded(null, e);
if (e.Handled)
{
return;
}
}
// load image from yamui library
Image tryImg = (Image)Resources.Resources.ResourceManager.GetObject(e.Src);
if (tryImg == null)
{
return;
}
e.Handled = true;
e.Callback(tryImg);
}
/// <summary>
/// Custom renderer for SVG images in the markdown as not supported natively.
/// @see https://htmlrenderer.codeplex.com/wikipage?title=Rendering%20SVG%20images
/// </summary>
/// <param name="sender"></param>
/// <param name="imageLoadEvent"></param>
protected void OnImageLoad(object sender, HtmlImageLoadEventArgs imageLoadEvent)
{
try
{
//Get some file information
string src = imageLoadEvent.Src;
Uri uri = new Uri(src);
string extension = Path.GetExtension(src);
//Check if local file or web resource
switch (uri.Scheme.ToLowerInvariant())
{
case "file":
//In case of a local file -> Load directly
if (extension != null && extension.Equals(".svg", StringComparison.OrdinalIgnoreCase))
{
ConvertSvgToBitmap(SvgDocument.Open <SvgDocument>(uri.LocalPath), imageLoadEvent);
}
break;
case "http":
case "https":
//For web resources check extension and parameter, to fetch from e.g. "badge" creating sources
if ((extension != null && extension.Equals(".svg", StringComparison.OrdinalIgnoreCase)) ||
uri.ToString().Contains("svg="))
{
//In case of a web resource file -> Load async
using (WebClient webClient = new WebClient())
{
webClient.DownloadDataCompleted += (downloadSender, downloadEvent) => { OnDownloadDataCompleted(downloadEvent, imageLoadEvent); };
webClient.DownloadDataAsync(uri);
imageLoadEvent.Handled = true;
}
}
break;
}
} catch
{
}
}
/// <summary>
/// On image load in renderer set the image by event async.
/// </summary>
public static void ImageLoad(HtmlImageLoadEventArgs e)
{
var img = TryLoadResourceImage(e.Src);
if (!e.Handled && e.Attributes != null)
{
if (e.Attributes.ContainsKey("byevent"))
{
int delay;
if (Int32.TryParse(e.Attributes["byevent"], out delay))
{
e.Handled = true;
ThreadPool.QueueUserWorkItem(state =>
{
Thread.Sleep(delay);
e.Callback("https://fbcdn-sphotos-a-a.akamaihd.net/hphotos-ak-snc7/c0.44.403.403/p403x403/318890_10151195988833836_1081776452_n.jpg");
});
return;
}
else
{
e.Callback("http://sphotos-a.xx.fbcdn.net/hphotos-ash4/c22.0.403.403/p403x403/263440_10152243591765596_773620816_n.jpg");
return;
}
}
else if (e.Attributes.ContainsKey("byrect"))
{
var split = e.Attributes["byrect"].Split(',');
var rect = new Rect(Int32.Parse(split[0]), Int32.Parse(split[1]), Int32.Parse(split[2]), Int32.Parse(split[3]));
e.Callback(img ?? TryLoadResourceImage("htmlicon"), rect.X, rect.Y, rect.Width, rect.Height);
return;
}
}
if (img != null)
{
e.Callback(img);
}
}
/// <summary>
/// This callback is invoked when a remote image is requested. These are identified by image: prefixes on the img
/// tag source and are assumed to be http based. We request the image from the ImageRequestorTask in CIXClient and
/// provide a callback to be invoked when the image is retrieved.
/// </summary>
private void LabelOnImageLoad(object sender, HtmlImageLoadEventArgs htmlImageLoadEventArgs)
{
string realUrl = htmlImageLoadEventArgs.Src;
if (realUrl.StartsWith("image:", StringComparison.Ordinal))
{
realUrl = "http://" + realUrl.Substring(6);
Image image = CIX.ImageRequestorTask.NewRequest(realUrl, Control.MaximumSize.Width / 3, MaxHeight, ImageRetrieved, htmlImageLoadEventArgs);
if (image != null)
{
htmlImageLoadEventArgs.Callback(image);
}
}
else if (realUrl.StartsWith("images:", StringComparison.Ordinal))
{
realUrl = "https://" + realUrl.Substring(7);
Image image = CIX.ImageRequestorTask.NewRequest(realUrl, Control.MaximumSize.Width / 3, MaxHeight, ImageRetrieved, htmlImageLoadEventArgs);
if (image != null)
{
htmlImageLoadEventArgs.Callback(image);
}
}
}
/// <summary>
/// On image load in renderer set the image by event async.
/// </summary>
protected static void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
var img = TryLoadResourceImage(e.Src);
if (img != null)
{
e.Callback(img);
}
if (!e.Handled && e.Attributes != null)
{
if (e.Attributes.ContainsKey("byevent"))
{
int delay;
if (int.TryParse(e.Attributes["byevent"], out delay))
{
e.Handled = true;
System.Threading.ThreadPool.QueueUserWorkItem(state =>
{
System.Threading.Thread.Sleep(delay);
e.Callback("https://fbcdn-sphotos-a-a.akamaihd.net/hphotos-ak-snc7/c0.44.403.403/p403x403/318890_10151195988833836_1081776452_n.jpg");
});
}
else
{
e.Callback("http://sphotos-a.xx.fbcdn.net/hphotos-ash4/c22.0.403.403/p403x403/263440_10152243591765596_773620816_n.jpg");
}
}
else if (e.Attributes.ContainsKey("byrect"))
{
var split = e.Attributes["byrect"].Split(',');
var rect = new RectI(int.Parse(split[0]), int.Parse(split[1]), int.Parse(split[2]), int.Parse(split[3]));
e.Callback(Demo.HtmlRenderer.Resources.html32, rect);
}
}
}
/// <summary> /// Propagate the image load event from root container. /// </summary> protected virtual void OnImageLoad(HtmlImageLoadEventArgs e) => RaiseRouted(ImageLoadEvent, e);
private void OnImageLoad(object sender, HtmlImageLoadEventArgs e)
{
OnImageLoad(e);
}
/// <summary>
/// Set image of this image box by analyzing the src attribute.<br/>
/// Load the image from inline base64 encoded string.<br/>
/// Or from calling property/method on the bridge object that returns image or URL to image.<br/>
/// Or from file path<br/>
/// Or from URI.
/// </summary>
/// <remarks>
/// File path and URI image loading is executed async and after finishing calling <see cref="ImageLoadComplete"/>
/// on the main thread and not thread-pool.
/// </remarks>
/// <param name="src">the source of the image to load</param>
/// <param name="attributes">the collection of attributes on the element to use in event</param>
/// <returns>the image object (null if failed)</returns>
public void LoadImage(string src, Dictionary<string, string> attributes)
{
try
{
var args = new HtmlImageLoadEventArgs(src, attributes, OnHtmlImageLoadEventCallback);
_htmlContainer.RaiseHtmlImageLoadEvent(args);
_asyncCallback = !_htmlContainer.AvoidAsyncImagesLoading;
if (!args.Handled)
{
if (!string.IsNullOrEmpty(src))
{
if (src.StartsWith("data:image", StringComparison.CurrentCultureIgnoreCase))
{
SetFromInlineData(src);
}
else
{
SetImageFromPath(src);
}
}
else
{
ImageLoadComplete(false);
}
}
}
catch (Exception ex)
{
_htmlContainer.ReportError(HtmlRenderErrorType.Image, "Exception in handling image source", ex);
ImageLoadComplete(false);
}
}
/// <summary>
/// Propagate the image load event from root container.
/// </summary>
protected virtual void OnImageLoad(HtmlImageLoadEventArgs e)
{
RoutedEventArgs newEventArgs = new RoutedEvenArgs <HtmlImageLoadEventArgs>(ImageLoadEvent, this, e);
RaiseEvent(newEventArgs);
}
