public static ImageLayout FromXml(XmlElement element)
{
var imageRec = ImageRec.FromXml(element);
if (imageRec == null)
{
return(null);
}
string str;
List <int> monitors = new List <int>();
str = element.GetAttribute("Monitors");
if (!string.IsNullOrEmpty(str))
{
foreach (var monStr in str.Split(','))
{
int monitor;
if (int.TryParse(monStr.Trim(), out monitor))
{
monitors.Add(monitor);
}
}
}
if (monitors.Count == 0)
{
monitors.Add(0);
}
return(new ImageLayout(imageRec, monitors.ToArray()));
}
public static string SaveImage(ImageRec img, Database db)
{
try
{
var image = img.Image;
if (image == null)
{
return(null);
}
var fmt = img.ImageFormat ?? ImageFormat.Png;
var fileName = string.Concat(Guid.NewGuid().ToString(), ImageFormatDesc.ImageFormatToExtension(fmt));
var cachePathName = Path.Combine(GetCacheDir(true), fileName);
image.Save(cachePathName, fmt);
if (db.SelectInt("select count(*) from img_cache where location = @loc", "@loc", img.Location) == 0)
{
db.Insert("img_cache", new object[]
{
"location", img.Location,
"cache_file_name", fileName,
"pub_date", img.PubDate
});
}
return(cachePathName);
}
catch (Exception ex)
{
Log.Write(ex, "Error when saving cached image.");
return(null);
}
}
public static ImageLayout FromDataRow(DataRow row)
{
var imageRec = ImageRec.FromDataRow(row);
if (imageRec == null)
{
return(null);
}
var monitors = new List <int>();
foreach (var monStr in row.GetString("monitors").Split(','))
{
int monitor;
if (int.TryParse(monStr.Trim(), out monitor))
{
monitors.Add(monitor);
}
}
if (monitors.Count == 0)
{
monitors.Add(0);
}
return(new ImageLayout(imageRec, monitors.ToArray()));
}
private void LoadAtom(XmlDocument xmlDoc)
{
foreach (XmlElement entry in xmlDoc.GetElementsByTagName("entry"))
{
var pubDate = GetPubDateForItem(entry);
foreach (XmlNode node in entry.ChildNodes)
{
if (node.NodeType != XmlNodeType.Element)
{
continue;
}
if (node.Name == "content")
{
XmlElement content = (XmlElement)node;
var type = content.GetAttribute("type");
if (string.IsNullOrEmpty(type) || type == "html" || type == "xhtml")
{
SearchHtmlForImages(content.InnerText, pubDate);
}
else if (type.StartsWith("image/"))
{
var src = content.GetAttribute("src");
if (!string.IsNullOrWhiteSpace(src))
{
_images.Add(ImageRec.FromUrl(src, pubDate));
}
}
}
}
}
}
private void LoadRss(XmlDocument xmlDoc)
{
foreach (XmlElement item in xmlDoc.GetElementsByTagName("item"))
{
var pubDate = GetPubDateForItem(item);
// Check for an image element.
var node = item.SelectSingleNode("image");
if (node != null && node.NodeType == XmlNodeType.Element)
{
node = node.SelectSingleNode("url");
if (node != null && node.NodeType == XmlNodeType.Element)
{
var url = node.InnerText;
if (!string.IsNullOrWhiteSpace(url))
{
Log.Write(LogLevel.Debug, "Found image in item image element '{0}'.", url);
_images.Add(ImageRec.FromUrl(url, pubDate));
}
}
}
// Scrape the HTML in the description.
node = item.SelectSingleNode("description");
if (node != null && node.NodeType == XmlNodeType.Element)
{
SearchHtmlForImages(node.InnerText, pubDate);
}
}
}
public void Save(XmlWriter xml)
{
var sb = new StringBuilder();
foreach (var monitor in Monitors)
{
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(monitor);
}
xml.WriteAttributeString("Monitors", sb.ToString());
ImageRec.Save(xml);
}
public static HistoryItem FromImageRec(HistoryList list, Database db, ImageRec rec)
{
if (rec == null)
{
throw new ArgumentNullException(nameof(rec));
}
var ret = new HistoryItem(list);
ret._thumbnail = rec.Thumbnail;
ret._location = rec.Location;
ret._locationOnDisk = rec.LocationOnDisk;
ret._rating = rec.Rating;
return(ret);
}
private void SearchHtmlNodeForImages(HtmlNode parentNode, DateTime pubDate)
{
foreach (var node in (from n in parentNode.ChildNodes
where n.NodeType == HtmlNodeType.Element
select n))
{
if (node.Name == "img")
{
var src = node.GetAttributeValue("src", "");
if (!string.IsNullOrWhiteSpace(src))
{
Log.Write(LogLevel.Debug, "Found image in item HTML '{0}'.", src);
_images.Add(ImageRec.FromUrl(src, pubDate));
}
}
else if (node.HasChildNodes)
{
SearchHtmlNodeForImages(node, pubDate);
}
}
}
private IEnumerable <ImageRec> SearchDir(string dir)
{
try
{
var files = new List <ImageRec>();
// Search for image files in this directory.
string[] imageFiles = Directory.GetFiles(dir);
foreach (string file in imageFiles)
{
if (Settings.IgnoreHiddenFiles == false || (File.GetAttributes(file) & FileAttributes.Hidden) == 0)
{
if (ImageFormatDesc.FileNameToImageFormat(file) != null)
{
files.Add(ImageRec.FromFile(file));
}
}
}
// Search sub-folders in this directory.
string[] subDirs = Directory.GetDirectories(dir);
foreach (string subDir in subDirs)
{
if (Settings.IgnoreHiddenFiles == false || (File.GetAttributes(subDir) & FileAttributes.Hidden) == 0)
{
files.AddRange(SearchDir(subDir));
}
}
return(files);
}
catch (Exception ex)
{
Log.Write(ex, "Exception when searching directory '{0}'.", dir);
return(new ImageRec[0]);
}
}
/// <summary>
/// Draws a full screen image to a single monitor.
/// </summary>
/// <param name="file">The image to be drawn</param>
/// <param name="screenRect">The rectangle of the current screen</param>
/// <param name="spanRect">The rectangle for all screens that this image is to be spanned across</param>
public void RenderFullScreenImageOnScreen(ImageRec file, Rectangle screenRect, Rectangle spanRect)
{
try
{
if (file == null || !file.IsPresent)
{
return;
}
Image img = file.Image;
Image imgToDraw = null;
lock (img)
{
RectangleF spanRectF = spanRect;
RectangleF imgRect = new RectangleF(0, 0, img.Width, img.Height);
RectangleF srcRect = imgRect;
_g.SetClip(screenRect);
imgRect = FitFullScreenImage(imgRect, spanRectF, img.Size, _theme);
imgToDraw = img;
if (_theme.ColorEffectFore == ColorEffect.None)
{
_g.DrawImage(imgToDraw, imgRect, srcRect, GraphicsUnit.Pixel);
}
else
{
_g.DrawImageWithColorMatrix(imgToDraw, imgRect, srcRect, _theme.ColorEffectFore.GetColorMatrix());
}
}
}
catch (Exception ex)
{
Log.Write(ex, "Exception when drawing full screen image '{0}':", file);
}
}
public ImageLayout(ImageRec img, int[] monitors)
{
ImageRec = img;
Monitors = monitors;
}
public void RenderCollageImageOnScreen(Database db, ImageRec file, Rectangle screenRect)
{
try
{
if (file == null || !file.IsPresent)
{
return;
}
_g.SetClip(screenRect);
var img = file.Image;
lock (img)
{
// The maximum image size will be determined by the number of pixels (area), not by the max width/height.
// This will provide a more consistent image size when there are pictures with different aspect ratios.
float imgWidth = file.Image.Width;
float imgHeight = file.Image.Height;
float imgArea = imgWidth * imgHeight;
float imgSize = (float)_theme.ImageSize / 100.0f;
float screenArea = screenRect.Width * imgSize * screenRect.Height * imgSize;
float scale = (float)Math.Sqrt(screenArea / imgArea);
if (_theme.MaxImageScale > 0)
{
var maxScale = (float)_theme.MaxImageScale / 100.0f;
if (maxScale > 0.0f && scale > maxScale)
{
scale = maxScale;
}
}
imgWidth *= scale;
imgHeight *= scale;
// If one of the dimensions is still wider/taller than the screen, then scale it down more.
if (imgWidth > screenRect.Width)
{
float ratio = screenRect.Width / imgWidth;
imgWidth = screenRect.Width;
imgHeight *= ratio;
scale *= ratio;
}
if (imgHeight > screenRect.Height)
{
float ratio = screenRect.Height / imgHeight;
imgHeight = screenRect.Height;
imgWidth *= ratio;
scale *= ratio;
}
var imgRect = GetRandomImageRect(db, screenRect, imgWidth, imgHeight);
var imgToDraw = img;
RectangleF srcRect = new RectangleF(0, 0, img.Width, img.Height);
// Feather edges
if (scale > 0.0f)
{
switch (_theme.EdgeMode)
{
case EdgeMode.Feather:
if (_theme.EdgeDist > 0)
{
int featherWidth = (int)((float)_theme.EdgeDist / scale);
if (featherWidth > 0)
{
imgToDraw = FeatherImage(img, featherWidth);
}
else
{
imgToDraw = img;
}
}
break;
case EdgeMode.SolidBorder:
if (_theme.EdgeDist > 0)
{
int edgeWidth = (int)((float)_theme.EdgeDist / scale);
if (edgeWidth > 0)
{
imgToDraw = CreateSolidBorderImage(img, edgeWidth, _theme.BorderColor, ref srcRect);
}
else
{
imgToDraw = img;
}
}
break;
case EdgeMode.None:
imgToDraw = img;
break;
}
}
if (_theme.DropShadow)
{
DrawDropShadow(imgRect);
}
if (_theme.ColorEffectFore == ColorEffect.None)
{
_g.DrawImage(imgToDraw, imgRect, srcRect, GraphicsUnit.Pixel);
}
else
{
_g.DrawImageWithColorMatrix(imgToDraw, imgRect, srcRect, _theme.ColorEffectFore.GetColorMatrix());
}
}
}
catch (Exception ex)
{
Log.Write(ex, "Exception when drawing collage image '{0}':", file);
}
}
