/// <summary> /// Determines whether a <see cref="Wallpaper" /> object is in one of the <see cref="WallpaperCategory" /> instances or /// not. /// </summary> /// <param name="wallpaper"> /// The <see cref="Wallpaper" /> object to check for. /// </param> /// <returns> /// A <see cref="bool" /> indicating whether one of the <see cref="WallpaperCategory" /> instances contains a given /// <see cref="Wallpaper" /> object or not. /// </returns> protected bool IsWallpaperInAnyCategory(Wallpaper wallpaper) { foreach (WallpaperCategory category in this) { if (category.Contains(wallpaper)) { return(true); } } return(false); }
/// <inheritdoc /> public override object Clone() { Wallpaper clonedInstance = new Wallpaper(this.ImagePath); // Clone all fields defined by WallpaperSettingsBase. base.Clone(clonedInstance); clonedInstance.IsBlank = this.IsBlank; clonedInstance.imagePath = this.ImagePath; clonedInstance.imageSize = this.ImageSize; return(clonedInstance); }
/// <summary> /// Initializes a new instance of the <see cref="ScreenSettings" /> class for the screen with the given index. /// </summary> /// <param name="index"> /// The index of the screen of which this instance defines settings for. /// </param> public ScreenSettings(int index) { this.Index = index; this.cycleRandomly = true; this.staticWallpaper = null; this.staticWallpaper = new Wallpaper(); this.Margins = new ScreenMargins(); PropertyChangedEventManager.AddListener(this.Margins, this, string.Empty); // Cache the Bounds and BoundsWithMargin rectangles for this first time. this.RefreshBounds(); this.TextOverlays = new ObservableCollection <WallpaperTextOverlay>(); }
/// <summary> /// Creates a new <see cref="Wallpaper" /> instance and adds it to the collection. /// </summary> /// <param name="imagePath"> /// The path of the wallpaper image. /// </param> /// <remarks> /// <para> /// The wallpaper is created asynchronously by using a <see cref="BackgroundWorker" />. If two wallpapers refering to /// the same image paths are added, one of them will be automatically ignored. /// </para> /// <para> /// If the file where <paramref name="imagePath" /> is refering to is not found, no exception will be thrown. /// </para> /// </remarks> /// <exception cref="ArgumentNullException"> /// <paramref name="imagePath" /> is <c>null</c>. /// </exception> private void AddAsync(Path imagePath) { if (imagePath == Path.None) { throw new ArgumentException(); } BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (sender, e) => { Path imagePathLocal = (Path)e.Argument; Wallpaper newWallpaper = new Wallpaper(imagePathLocal); using (Image wallpaperImage = Image.FromFile(imagePathLocal)) newWallpaper.ImageSize = wallpaperImage.Size; e.Result = newWallpaper; }; worker.RunWorkerCompleted += (sender, e) => { if (e.Error != null) { // We simply ignore if the file couldn't be found or is invalid / unsupported. if ((e.Error is FileNotFoundException) || (e.Error is OutOfMemoryException)) { return; } throw e.Error; } if (!e.Cancelled) { Wallpaper newWallpaperLocal = (Wallpaper)e.Result; // Make sure the item wasn't already added by another thread. if (this.IndexOfByImagePath(newWallpaperLocal.ImagePath) == -1) { base.InsertItem(this.Count, newWallpaperLocal); } } ((BackgroundWorker)sender).Dispose(); }; // By using BackgroundWorker we make sure this operation is thread safe. worker.RunWorkerAsync(imagePath); }
/// <summary> /// Assigns all member values of this instance to the respective members of the given instance. /// </summary> /// <param name="other"> /// The target instance to assign to. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="other" /> is <c>null</c>. /// </exception> protected override void AssignTo(WallpaperSettingsBase other) { if (other == null) { throw new ArgumentNullException(); } // Assign all members defined by WallpaperSettingsBase. base.AssignTo(other); Wallpaper wallpaperInstance = (other as Wallpaper); if (wallpaperInstance != null) { wallpaperInstance.ImagePath = this.ImagePath; wallpaperInstance.ImageSize = this.ImageSize; } }
/// <summary> /// Draws a wallpaper image by using the given <see cref="Graphics" /> object. /// </summary> /// <param name="destGraphics"> /// The <see cref="Graphics" /> object used to draw. /// </param> /// <param name="destScreenRect"> /// The destination screen's rectangle. /// </param> /// <param name="wallpaper"> /// The <see cref="Wallpaper" /> object to draw. /// </param> /// <param name="placement"> /// The type how the wallpaper image should be aligned. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="destGraphics" /> is <c>null</c> or <paramref name="wallpaper" /> is <c>null</c>. /// </exception> /// <exception cref="ArgumentOutOfRangeException"> /// <paramref name="placement" /> is not a constant defined by the <see cref="WallpaperPlacement" /> enumeration. /// </exception> /// <seealso cref="Graphics">Graphics Class</seealso> /// <seealso cref="Wallpaper">Wallpaper Class</seealso> /// <seealso cref="WallpaperPlacement">WallpaperPlacement Enumeration</seealso> /// . protected static void DrawWallpaper(Graphics destGraphics, Rectangle destScreenRect, Wallpaper wallpaper, WallpaperPlacement placement) { if (destGraphics == null) { throw new ArgumentNullException(); } if (wallpaper == null) { throw new ArgumentNullException(); } if (!Enum.IsDefined(typeof(WallpaperPlacement), placement)) { throw new ArgumentException(); } using (SolidBrush backgroundBrush = new SolidBrush(wallpaper.BackgroundColor)) destGraphics.FillRectangle(backgroundBrush, destScreenRect); if ((wallpaper.ImagePath != Path.None) && (File.Exists(wallpaper.ImagePath))) { Image originalImage = null; Image imageToDraw = null; try { originalImage = Image.FromFile(wallpaper.ImagePath); imageToDraw = originalImage; if (wallpaper.Effects != 0) { #region Mirror Effect // Required images to draw for the mirror effect. int horizontalImages = 1; int verticalImages = 1; // This values "move" the texture of the brush. int horizontalBrushTransform = 0; int verticalBrushTransform = 0; TextureBrush mirrorBrush = new TextureBrush(originalImage, WrapMode.TileFlipXY); if (((wallpaper.Effects & WallpaperEffects.MirrorLeft) == WallpaperEffects.MirrorLeft)) { horizontalImages++; mirrorBrush.WrapMode = WrapMode.TileFlipX; // This will make the brush start with the mirrored image. horizontalBrushTransform = originalImage.Width; } if (((wallpaper.Effects & WallpaperEffects.MirrorRight) == WallpaperEffects.MirrorRight)) { horizontalImages++; mirrorBrush.WrapMode = WrapMode.TileFlipX; if (((wallpaper.Effects & WallpaperEffects.MirrorLeft) != WallpaperEffects.MirrorLeft)) { // This will make the brush start with the unmirrored image. horizontalBrushTransform = 0; } } if (((wallpaper.Effects & WallpaperEffects.FlipHorizontal) == WallpaperEffects.FlipHorizontal)) { mirrorBrush.WrapMode = WrapMode.TileFlipX; if (horizontalBrushTransform == 0) { // This will make the brush start with the mirrored image. horizontalBrushTransform = originalImage.Width; } else { // This will make the brush start with the unmirrored image. horizontalBrushTransform = 0; } } if (((wallpaper.Effects & WallpaperEffects.MirrorTop) == WallpaperEffects.MirrorTop)) { verticalImages++; if (mirrorBrush.WrapMode != WrapMode.TileFlipXY) { if (mirrorBrush.WrapMode == WrapMode.TileFlipX) { mirrorBrush.WrapMode = WrapMode.TileFlipXY; } else { mirrorBrush.WrapMode = WrapMode.TileFlipY; } } // This will make the brush start with the mirrored image. verticalBrushTransform = originalImage.Height; } if (((wallpaper.Effects & WallpaperEffects.MirrorBottom) == WallpaperEffects.MirrorBottom)) { verticalImages++; if (mirrorBrush.WrapMode != WrapMode.TileFlipXY) { if (mirrorBrush.WrapMode == WrapMode.TileFlipX) { mirrorBrush.WrapMode = WrapMode.TileFlipXY; } else { mirrorBrush.WrapMode = WrapMode.TileFlipY; } } if (((wallpaper.Effects & WallpaperEffects.MirrorTop) != WallpaperEffects.MirrorTop)) { // This will make the brush start with the unmirrored image. verticalBrushTransform = 0; } } if (((wallpaper.Effects & WallpaperEffects.FlipVertical) == WallpaperEffects.FlipVertical)) { if (mirrorBrush.WrapMode != WrapMode.TileFlipXY) { if (mirrorBrush.WrapMode == WrapMode.TileFlipX) { mirrorBrush.WrapMode = WrapMode.TileFlipXY; } else { mirrorBrush.WrapMode = WrapMode.TileFlipY; } } if (verticalBrushTransform == 0) { // This will make the brush start with the mirrored image. verticalBrushTransform = originalImage.Height; } else { // This will make the brush start with the unmirrored image. verticalBrushTransform = 0; } } mirrorBrush.TranslateTransform(horizontalBrushTransform, verticalBrushTransform); Image modifiedImage = new Bitmap(originalImage.Width * horizontalImages, originalImage.Height * verticalImages); Graphics modifiedImageGraphics = null; try { modifiedImageGraphics = Graphics.FromImage(modifiedImage); modifiedImageGraphics.FillRectangle(mirrorBrush, new Rectangle(0, 0, modifiedImage.Width, modifiedImage.Height)); imageToDraw = modifiedImage; } finally { modifiedImageGraphics?.Dispose(); } #endregion } GraphicsContainer graphicalContext = null; try { graphicalContext = destGraphics.BeginContainer(); // Place the origin in the center of the screen. float xTranslationForScale = destScreenRect.X + (destScreenRect.Width / 2f); float yTranslationForScale = destScreenRect.Y + (destScreenRect.Height / 2f); destGraphics.TranslateTransform(xTranslationForScale, yTranslationForScale); destGraphics.ScaleTransform((wallpaper.Scale.X + 100) / 100f, (wallpaper.Scale.Y + 100) / 100f); // And reset it, that way we have a nice scaling of the image. destGraphics.TranslateTransform(-xTranslationForScale, -yTranslationForScale); // Now apply the offset. destGraphics.TranslateTransform(wallpaper.Offset.X, wallpaper.Offset.Y); destGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic; destGraphics.PixelOffsetMode = PixelOffsetMode.Half; destGraphics.CompositingMode = CompositingMode.SourceOver; switch (placement) { case WallpaperPlacement.Uniform: destGraphics.DrawImageUniformed(imageToDraw, destScreenRect); break; case WallpaperPlacement.UniformToFill: destGraphics.DrawImageUniformedToFill(imageToDraw, destScreenRect); break; case WallpaperPlacement.Stretch: destGraphics.DrawImage(imageToDraw, destScreenRect); break; case WallpaperPlacement.Center: destGraphics.DrawImageCentered(imageToDraw, destScreenRect); break; case WallpaperPlacement.Tile: destGraphics.ScaleTransform((wallpaper.Scale.X + 100) / 100f, (wallpaper.Scale.Y + 100) / 100f); destGraphics.DrawImageTiled(imageToDraw, destScreenRect); break; } } finally { if (graphicalContext != null) { destGraphics.EndContainer(graphicalContext); } } } finally { originalImage?.Dispose(); imageToDraw?.Dispose(); } } }
/// <summary> /// Creates a multiscreen wallpaper from one <see cref="Wallpaper" /> object (from one image). /// </summary> /// <inheritdoc cref="CreateMultiscreenFromMultipleInternal" select='remarks|param|returns' /> /// <param name="multiscreenWallpaper"> /// The <see cref="Wallpaper" /> object to use. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="multiscreenWallpaper" /> is <c>null</c>. /// </exception> /// <exception cref="FileNotFoundException"> /// The image file where the <paramref name="multiscreenWallpaper" /> object refers to could not be found. /// </exception> /// <seealso cref="Wallpaper">Wallpaper Class</seealso> public Image CreateMultiscreenFromSingle(Wallpaper multiscreenWallpaper, float scaleFactor, bool useWindowsFix) { if (multiscreenWallpaper == null) { throw new ArgumentNullException(); } Rectangle fullScreenBounds = WallpaperBuilderBase.FullScreenBounds; Bitmap wallpaperImage = new Bitmap((int)(fullScreenBounds.Width * scaleFactor), (int)(fullScreenBounds.Height * scaleFactor)); using (Graphics graphics = Graphics.FromImage(wallpaperImage)) { Graphics destinationGraphics = graphics; Bitmap preWallpaperImage = null; try { // If the fullscreenbounds rectangle has a negative x or y values, we normalize them by using 0,0 as origin and adding // the difference to each drawn wallpaper later. int xOriginAdd; if (fullScreenBounds.X < 0) { xOriginAdd = Math.Abs(WallpaperBuilderBase.FullScreenBounds.X); } else { xOriginAdd = 0; } int yOriginAdd; if (fullScreenBounds.Y < 0) { yOriginAdd = Math.Abs(WallpaperBuilderBase.FullScreenBounds.Y); } else { yOriginAdd = 0; } // Check if we have to redraw the end-wallpaper to fix it for Windows. bool requiresWindowsFix = ((useWindowsFix) && ((fullScreenBounds.Left < 0) || (fullScreenBounds.Top < 0))); if (requiresWindowsFix) { // We have to redraw it, we need another temporary image and draw on this one instead. preWallpaperImage = new Bitmap(wallpaperImage.Width, wallpaperImage.Height); destinationGraphics = Graphics.FromImage(preWallpaperImage); } destinationGraphics.ScaleTransform(scaleFactor, scaleFactor); // The rectangle of the multiscreen wallpaper should span across all screens except the ones which should display // a statical wallpaper. Rectangle?multiscreenWallpaperRect = null; for (int i = 0; i < this.ScreensSettings.Count; i++) { if (this.ScreensSettings[i].CycleRandomly || !this.ScreensSettings[i].StaticWallpaper.EvaluateCycleConditions()) { if (multiscreenWallpaperRect == null) { multiscreenWallpaperRect = this.ScreensSettings[i].BoundsWithMargin; } else { multiscreenWallpaperRect = Rectangle.Union(multiscreenWallpaperRect.Value, this.ScreensSettings[i].BoundsWithMargin); } } } // null would mean that all screens should display static wallpapers. if (multiscreenWallpaperRect != null) { Rectangle multiscreenWallpaperRectValue = multiscreenWallpaperRect.Value; multiscreenWallpaperRectValue.X += xOriginAdd; multiscreenWallpaperRectValue.Y += yOriginAdd; destinationGraphics.SetClip(multiscreenWallpaperRectValue); WallpaperBuilderBase.DrawWallpaper(destinationGraphics, multiscreenWallpaperRectValue, multiscreenWallpaper, multiscreenWallpaper.Placement); destinationGraphics.ResetClip(); } // Draw or overdraw all static wallpapers and draw the Overlay Texts for all screens. for (int i = 0; i < this.ScreensSettings.Count; i++) { destinationGraphics.SetClip(this.ScreensSettings[i].BoundsWithMargin); if (!this.ScreensSettings[i].CycleRandomly && this.ScreensSettings[i].StaticWallpaper.EvaluateCycleConditions()) { WallpaperBuilderBase.DrawWallpaper( destinationGraphics, this.ScreensSettings[i].BoundsWithMargin, this.ScreensSettings[i].StaticWallpaper, this.ScreensSettings[i].StaticWallpaper.Placement); } WallpaperBuilderBase.DrawOverlayTexts( destinationGraphics, this.ScreensSettings[i].BoundsWithMargin, new[] { multiscreenWallpaper }, this.ScreensSettings[i].TextOverlays); destinationGraphics.ResetClip(); } if (requiresWindowsFix) { // Now redraw the wallpaper but fixed. WallpaperBuilderBase.DrawFullWallpaperFixed(graphics, preWallpaperImage); } } finally { destinationGraphics.Dispose(); preWallpaperImage?.Dispose(); } } return(wallpaperImage); }
/// <inheritdoc /> protected override void SetItem(int index, Wallpaper item) { // TODO: Throwing this exception is not allowed here. throw new InvalidOperationException("Category is read only."); }
/// <summary> /// Adds wallpaper related settings to a given <see cref="XmlElement" />. /// </summary> /// <param name="document"> /// The <see cref="XmlDocument" /> to add the data for. /// </param> /// <param name="element"> /// The <see cref="XmlElement" /> to add the data to. /// </param> /// <param name="wallpaperBaseSettings"> /// The wallpaper settings to add. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="document" /> or <paramref name="element" /> or <paramref name="wallpaperBaseSettings" /> is /// <c>null</c>. /// </exception> protected static void AddWallpaperDataToXmlElement(XmlDocument document, XmlElement element, WallpaperSettingsBase wallpaperBaseSettings) { if (document == null) { throw new ArgumentNullException(); } if (element == null) { throw new ArgumentNullException(); } if (wallpaperBaseSettings == null) { throw new ArgumentNullException(); } Wallpaper wallpaperSettings = (wallpaperBaseSettings as Wallpaper); WallpaperDefaultSettings defaultSettings = (wallpaperBaseSettings as WallpaperDefaultSettings); XmlElement currentElement; if (wallpaperSettings != null) { currentElement = document.CreateElement("ImagePath"); if (wallpaperSettings.ImagePath != Path.None) { currentElement.InnerText = wallpaperSettings.ImagePath; } element.AppendChild(currentElement); } currentElement = document.CreateElement("IsActivated"); currentElement.InnerText = wallpaperBaseSettings.IsActivated.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("IsMultiscreen"); currentElement.InnerText = wallpaperBaseSettings.IsMultiscreen.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("Priority"); currentElement.InnerText = wallpaperBaseSettings.Priority.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("OnlyCycleBetweenStart"); currentElement.InnerText = wallpaperBaseSettings.OnlyCycleBetweenStart.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("OnlyCycleBetweenStop"); currentElement.InnerText = wallpaperBaseSettings.OnlyCycleBetweenStop.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("Placement"); currentElement.InnerText = wallpaperBaseSettings.Placement.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("HorizontalOffset"); currentElement.InnerText = wallpaperBaseSettings.Offset.X.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("VerticalOffset"); currentElement.InnerText = wallpaperBaseSettings.Offset.Y.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("HorizontalScale"); currentElement.InnerText = wallpaperBaseSettings.Scale.X.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("VerticalScale"); currentElement.InnerText = wallpaperBaseSettings.Scale.Y.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("Effects"); currentElement.InnerText = wallpaperBaseSettings.Effects.ToString(); element.AppendChild(currentElement); currentElement = document.CreateElement("BackgroundColor"); currentElement.InnerText = ColorTranslator.ToHtml(wallpaperBaseSettings.BackgroundColor); element.AppendChild(currentElement); currentElement = document.CreateElement("DisabledScreens"); StringBuilder disabledScreensString = new StringBuilder(wallpaperBaseSettings.DisabledScreens.Count * 2); for (int i = 0; i < wallpaperBaseSettings.DisabledScreens.Count; i++) { if (i > 0) { disabledScreensString.Append(','); } disabledScreensString.Append(wallpaperBaseSettings.DisabledScreens[i]); } currentElement.InnerText = disabledScreensString.ToString(); element.AppendChild(currentElement); if (defaultSettings != null) { currentElement = document.CreateElement("AutoDetermineIsMultiscreen"); currentElement.InnerText = defaultSettings.AutoDetermineIsMultiscreen.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); currentElement = document.CreateElement("AutoDeterminePlacement"); currentElement.InnerText = defaultSettings.AutoDeterminePlacement.ToString(CultureInfo.InvariantCulture); element.AppendChild(currentElement); } }
/// <summary> /// Gets wallpaper related settings from a given <see cref="XmlElement" />. /// </summary> /// <param name="element"> /// The <see cref="XmlElement" /> to get the data from. /// </param> /// <param name="wallpaperSettingsType"> /// The type of the wallpaper settings to read. /// </param> /// <returns> /// An instance of a type inherited from <see cref="WallpaperSettingsBase" /> containing the data get from the /// <see cref="XmlElement" />. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="element" /> or <paramref name="wallpaperSettingsType" /> is <c>null</c>. /// </exception> /// <exception cref="XmlException"> /// The XML Data are invalid. /// </exception> protected static WallpaperSettingsBase GetWallpaperDataFromXmlElement(XmlElement element, Type wallpaperSettingsType) { if (element == null) { throw new ArgumentNullException(); } if (wallpaperSettingsType == null) { throw new ArgumentNullException(); } WallpaperSettingsBase settings = null; WallpaperDefaultSettings defaultSettings = null; XmlElement subElement; if (wallpaperSettingsType == typeof(Wallpaper)) { subElement = element["ImagePath"]; if (subElement != null) { Wallpaper wallpaper; if (subElement.InnerText.Length > 0) { wallpaper = new Wallpaper(new Path(subElement.InnerText)); } else { wallpaper = new Wallpaper(); } wallpaper.SuggestIsMultiscreen = false; wallpaper.SuggestPlacement = false; settings = wallpaper; } } else if (wallpaperSettingsType == typeof(WallpaperDefaultSettings)) { defaultSettings = new WallpaperDefaultSettings(); settings = defaultSettings; } if (settings == null) { throw new XmlException("A wallpaper setting node is missing."); } subElement = element["IsActivated"]; if (subElement != null) { settings.IsActivated = bool.Parse(subElement.InnerText); } subElement = element["IsMultiscreen"]; if (subElement != null) { settings.IsMultiscreen = bool.Parse(subElement.InnerText); } subElement = element["Priority"]; if (subElement != null) { settings.Priority = byte.Parse(subElement.InnerText, CultureInfo.InvariantCulture); } subElement = element["OnlyCycleBetweenStart"]; if (subElement != null) { settings.OnlyCycleBetweenStart = TimeSpan.Parse(subElement.InnerText, CultureInfo.InvariantCulture); } subElement = element["OnlyCycleBetweenStop"]; if (subElement != null) { settings.OnlyCycleBetweenStop = TimeSpan.Parse(subElement.InnerText, CultureInfo.InvariantCulture); } subElement = element["Placement"]; if (subElement != null) { settings.Placement = (WallpaperPlacement)Enum.Parse(typeof(WallpaperPlacement), subElement.InnerText); } subElement = element["HorizontalOffset"]; if (subElement != null) { int horizontalOffset = int.Parse(subElement.InnerText, CultureInfo.InvariantCulture); subElement = element["VerticalOffset"]; if (subElement != null) { settings.Offset = new Point(horizontalOffset, int.Parse(subElement.InnerText, CultureInfo.InvariantCulture)); } } subElement = element["HorizontalScale"]; if (subElement != null) { int horizontalScale = int.Parse(subElement.InnerText, CultureInfo.InvariantCulture); subElement = element["VerticalScale"]; if (subElement != null) { settings.Offset = new Point(horizontalScale, int.Parse(subElement.InnerText, CultureInfo.InvariantCulture)); } } subElement = element["Effects"]; if (subElement != null) { settings.Effects = (WallpaperEffects)Enum.Parse(typeof(WallpaperEffects), subElement.InnerText); } subElement = element["BackgroundColor"]; if (subElement != null) { settings.BackgroundColor = ColorTranslator.FromHtml(subElement.InnerText); } subElement = element["DisabledScreens"]; if (subElement != null) { string[] disabledScreens = subElement.InnerText.Split(','); for (int i = 0; i < disabledScreens.Length; i++) { string disabledScreenString = disabledScreens[i].Trim(); if (disabledScreens[i].Length != 0) { settings.DisabledScreens.Add(int.Parse(disabledScreenString, CultureInfo.InvariantCulture)); } } } if (defaultSettings != null) { subElement = element["AutoDetermineIsMultiscreen"]; if (subElement != null) { defaultSettings.AutoDetermineIsMultiscreen = bool.Parse(subElement.InnerText); } subElement = element["AutoDeterminePlacement"]; if (subElement != null) { defaultSettings.AutoDeterminePlacement = bool.Parse(subElement.InnerText); } } return(settings); }
// TODO: Use XmlSerializer for reading and writing the config. // TODO: Extract Read/Write functionality into a new class (and interface perhaps) /// <summary> /// Creates a new <see cref="Configuration" /> instance by reading the data from a <see cref="Stream" />. /// </summary> /// <remarks> /// This method reads Wallpaper Manager configuration files (version 1.0, 1.1 and 1.2) by using /// <see cref="XmlDocument" />. /// </remarks> /// <param name="sourceStream"> /// The source <see cref="Stream" /> to read from. /// </param> /// <returns> /// A new <see cref="Configuration" /> instance containing the read data. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="sourceStream" /> is <c>null</c>. /// </exception> /// <exception cref="IOException"> /// <paramref name="sourceStream" /> is not readable. /// </exception> /// <exception cref="XmlException"> /// There is a load or parse error in the XML-Data. /// </exception> /// <exception cref="InvalidOperationException"> /// Error while deserializing. Refer to the object returned by the <see cref="Exception.InnerException" /> property /// for details. /// </exception> /// <overloads> /// <summary> /// Creates a new <see cref="Configuration" /> instance by reading the data from a data source. /// </summary> /// <returns> /// A new <see cref="Configuration" /> instance containing the read data. /// </returns> /// </overloads> /// <seealso cref="Stream">Stream Class</seealso> public static Configuration Read(Stream sourceStream) { if (sourceStream == null) { throw new ArgumentNullException(); } if (!sourceStream.CanRead) { throw new IOException(); } XmlDocument document = new XmlDocument(); document.Load(sourceStream); if ((document.DocumentElement == null) || (document.DocumentElement.Name != Configuration.RootNodeName)) { throw new XmlException("The configuration file has an invalid root element."); } XmlAttribute versionAttribute = document.DocumentElement.Attributes["Version"]; Version configVersion; if ((versionAttribute == null) || (!Version.TryParse(versionAttribute.InnerText, out configVersion))) { throw new XmlException("The configuration file has an invalid root element."); } Configuration configuration = new Configuration(); #region <General> XmlElement generalElement = document.DocumentElement["General"]; if (generalElement == null) { throw new XmlException("The configuration file does not contain expected element 'General'."); } XmlElement element = generalElement["CycleAfterStartup"]; if (element != null) { configuration.General.CycleAfterStartup = bool.Parse(element.InnerText); } element = generalElement["TerminateAfterStartup"]; if (element != null) { configuration.General.TerminateAfterStartup = bool.Parse(element.InnerText); } element = (generalElement["MinimizeAfterStart"] ?? generalElement["MinimizeAfterStartup"]); if (element != null) { configuration.General.MinimizeAfterStartup = bool.Parse(element.InnerText); } element = generalElement["StartAutoCyclingAfterStartup"]; if (element != null) { configuration.General.StartAutocyclingAfterStartup = bool.Parse(element.InnerText); } element = generalElement["WallpaperChangeType"]; if (element != null) { configuration.General.WallpaperChangeType = (WallpaperChangeType)Enum.Parse(typeof(WallpaperChangeType), element.InnerText); } element = generalElement["AutoCycleInterval"]; if (element != null) { configuration.General.AutocycleInterval = TimeSpan.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = generalElement["LastActiveListSize"]; if (element != null) { configuration.General.LastActiveListSize = byte.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = generalElement["CycleAfterDisplaySettingsChanged"]; if (element != null) { configuration.General.CycleAfterDisplaySettingsChanged = bool.Parse(element.InnerText); } element = generalElement["MinimizeOnClose"]; if (element != null) { configuration.General.MinimizeOnClose = bool.Parse(element.InnerText); } element = generalElement["DisplayCycleTimeAsIconOverlay"]; if (element != null) { configuration.General.DisplayCycleTimeAsIconOverlay = bool.Parse(element.InnerText); } element = generalElement["WallpaperDoubleClickAction"]; if (element != null) { configuration.General.WallpaperDoubleClickAction = (WallpaperClickAction)Enum.Parse(typeof(WallpaperClickAction), element.InnerText); } element = generalElement["TrayIconSingleClickAction"]; if (element != null) { configuration.General.TrayIconSingleClickAction = (TrayIconClickAction)Enum.Parse(typeof(TrayIconClickAction), element.InnerText); } element = generalElement["TrayIconDoubleClickAction"]; if (element != null) { configuration.General.TrayIconDoubleClickAction = (TrayIconClickAction)Enum.Parse(typeof(TrayIconClickAction), element.InnerText); } #endregion #region <ScreensSettings> XmlElement screensSettingsElement = document.DocumentElement["ScreensSettings"]; if (screensSettingsElement != null) { int settingsCounter = 0; var screensSettings = new List <ScreenSettings>(); foreach (XmlElement screenSettingsElement in screensSettingsElement) { if (screenSettingsElement.Name != "ScreenSettings") { continue; } // Make sure there aren't too many screen settings in the configuration. if (settingsCounter >= Screen.AllScreens.Length) { break; } ScreenSettings screenSettings = new ScreenSettings(settingsCounter); element = screenSettingsElement["CycleRandomly"]; if (element != null) { screenSettings.CycleRandomly = bool.Parse(element.InnerText); } element = screenSettingsElement["MarginLeft"]; if (element != null) { screenSettings.Margins.Left = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = screenSettingsElement["MarginRight"]; if (element != null) { screenSettings.Margins.Right = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = screenSettingsElement["MarginTop"]; if (element != null) { screenSettings.Margins.Top = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = screenSettingsElement["MarginBottom"]; if (element != null) { screenSettings.Margins.Bottom = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } #region <OverlayTexts> XmlElement overlayTextsElement = screenSettingsElement["OverlayTexts"]; if (overlayTextsElement != null) { foreach (XmlElement overlayTextElement in overlayTextsElement) { if (overlayTextElement.Name != "OverlayText") { continue; } WallpaperTextOverlay textOverlay = new WallpaperTextOverlay(); element = overlayTextElement["Format"]; if (element != null) { textOverlay.Format = element.InnerText; } element = overlayTextElement["Position"]; if (element != null) { textOverlay.Position = (TextOverlayPosition)Enum.Parse(typeof(TextOverlayPosition), element.InnerText); } element = overlayTextElement["FontName"]; if (element != null) { textOverlay.FontName = element.InnerText; } element = overlayTextElement["FontSize"]; if (element != null) { textOverlay.FontSize = float.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = overlayTextElement["FontStyle"]; if (element != null) { textOverlay.FontStyle = (FontStyle)Enum.Parse(typeof(FontStyle), element.InnerText); } element = overlayTextElement["ForeColor"]; if (element != null) { textOverlay.ForeColor = ColorTranslator.FromHtml(element.InnerText); } element = overlayTextElement["BorderColor"]; if (element != null) { textOverlay.BorderColor = ColorTranslator.FromHtml(element.InnerText); } element = overlayTextElement["HorizontalOffset"]; if (element != null) { textOverlay.HorizontalOffset = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } element = overlayTextElement["VerticalOffset"]; if (element != null) { textOverlay.VerticalOffset = int.Parse(element.InnerText, CultureInfo.InvariantCulture); } screenSettings.TextOverlays.Add(textOverlay); } } #endregion #region <StaticWallpaper> XmlElement staticWallpaperElement = screenSettingsElement["StaticWallpaper"]; if (staticWallpaperElement != null) { screenSettings.StaticWallpaper = (Wallpaper)Configuration.GetWallpaperDataFromXmlElement(staticWallpaperElement, typeof(Wallpaper)); } #endregion screensSettings.Add(screenSettings); settingsCounter++; } configuration.General.ScreensSettings = new ScreenSettingsCollection(screensSettings); } #endregion #region <WallpaperCategories> XmlElement wallpaperCategoriesElement = document.DocumentElement["WallpaperCategories"]; if (wallpaperCategoriesElement != null) { foreach (XmlElement wallpaperCategoryElement in wallpaperCategoriesElement) { if ( wallpaperCategoryElement.Name != "Category" && wallpaperCategoryElement.Name != "SynchronizedFolder" && wallpaperCategoryElement.Name != "WatchedCategory" /* Version 1.1 name for synchronized folders. */ ) { continue; } element = wallpaperCategoryElement["Name"]; if (element == null) { continue; } string categoryName = element.InnerText; WallpaperDefaultSettings defaultSettings = null; element = wallpaperCategoryElement["WallpaperDefaultSettings"]; if (element != null) { defaultSettings = (WallpaperDefaultSettings)Configuration.GetWallpaperDataFromXmlElement(element, typeof(WallpaperDefaultSettings)); } #region <Wallpapers> List <Wallpaper> wallpapers; XmlElement wallpapersElement = wallpaperCategoryElement["Wallpapers"]; if (wallpapersElement != null) { wallpapers = new List <Wallpaper>(wallpapersElement.ChildNodes.Count); foreach (XmlElement wallpaperElement in wallpapersElement) { if (wallpaperElement.Name != "Wallpaper") { continue; } Wallpaper wallpaper = (Wallpaper)Configuration.GetWallpaperDataFromXmlElement(wallpaperElement, typeof(Wallpaper)); wallpapers.Add(wallpaper); } } else { wallpapers = new List <Wallpaper>(0); } #endregion bool isSynchronizedFolder = ((wallpaperCategoryElement.Name == "SynchronizedFolder") || (wallpaperCategoryElement.Name == "WatchedCategory")); WallpaperCategory category; if (isSynchronizedFolder) { element = (wallpaperCategoryElement["SynchronizedFolderPath"] ?? wallpaperCategoryElement["WatchedDirectoryPath"]); if (element == null) { continue; } Path synchronizedDirPath = new Path(element.InnerText); if (!Directory.Exists(synchronizedDirPath)) { continue; } category = new SynchronizedWallpaperCategory(categoryName, synchronizedDirPath, wallpapers); } else { category = new WallpaperCategory(categoryName, wallpapers); } category.WallpaperDefaultSettings = defaultSettings; configuration.WallpaperCategories.Add(category); } } #endregion return(configuration); }