コード例 #1
0
ファイル: NexusTheme.cs プロジェクト: pederjohnsen/Nimbus
        public static void ProcessIniLine(string read, NimbusTheme theme)
        {
            if (read.StartsWith("//"))
            {
                return;                        //is a comment
            }
            string trigger = read.Split('=')[0].ToLower();
            string val     = read.Split('=')[1];

            switch (trigger)
            {
            case "backgroundcolor":
            {
                try
                {
                    theme.BackgroundColor = ParseColor(val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "panelcolor":
            {
                try
                {
                    theme.PanelColor = ParseColor(val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "icon":
            {
                try
                {
                    theme.Icon = new Icon(theme.LocalPath + "\\" + val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captionbarcolor":
            {
                try
                {
                    theme.CaptionBarColor = ParseColor(val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "toolbarcolor":
            {
                try
                {
                    theme.ToolbarColor = ParseColor(val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captionfont":
            {
                try
                {
                    theme.CaptionFontFamily = theme.LoadFontFamily(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "buttonfont":
            {
                try
                {
                    theme.ButtonFont = theme.LoadFontFamily(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captionfontsize":
            {
                try
                {
                    theme.CaptionFontSize = Int32.Parse(val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captiontextcolor":
            {
                try
                {
                    theme.CaptionTextColor = ParseColor(val);
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captiontitleoffsetx":
            {
                try
                {
                    theme.CaptionOffsetX = Int32.Parse(val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "captiontitleoffsety":
            {
                try
                {
                    theme.CaptionOffsetY = Int32.Parse(val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "nexuswatermark":
            {
                try
                {
                    theme.NexusWatermark = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "closenormal":
            {
                try
                {
                    theme.CloseButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "closehover":
            {
                try
                {
                    theme.CloseButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "closepressed":
            {
                try
                {
                    theme.CloseButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "minimizenormal":
            {
                try
                {
                    theme.MinimizeButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "minimizehover":
            {
                try
                {
                    theme.MinimizeButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "minimizepressed":
            {
                try
                {
                    theme.MinimizeButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "maximizenormal":
            {
                try
                {
                    theme.MaximizeButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "maximizehover":
            {
                try
                {
                    theme.MaximizeButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "maximizepressed":
            {
                try
                {
                    theme.MaximizeButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "librarynormal":
            {
                try
                {
                    theme.LibraryButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "libraryhover":
            {
                try
                {
                    theme.LibraryButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "librarypressed":
            {
                try
                {
                    theme.LibraryButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "gamesnormal":
            {
                try
                {
                    theme.GamesButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "gameshover":
            {
                try
                {
                    theme.GamesButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "gamespressed":
            {
                try
                {
                    theme.GamesButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "confignormal":
            {
                try
                {
                    theme.ConfigButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "confighover":
            {
                try
                {
                    theme.ConfigButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "configpressed":
            {
                try
                {
                    theme.ConfigButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "friendsnormal":
            {
                try
                {
                    theme.FriendsButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "friendshover":
            {
                try
                {
                    theme.FriendsButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "friendspressed":
            {
                try
                {
                    theme.FriendsButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "backbuttonnormal":
            {
                try
                {
                    theme.BackButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "backbuttonhover":
            {
                try
                {
                    theme.BackButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "backbuttonpressed":
            {
                try
                {
                    theme.BackButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "forwardbuttonnormal":
            {
                try
                {
                    theme.ForwardButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "forwardbuttonhover":
            {
                try
                {
                    theme.ForwardButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "forwardbuttonpressed":
            {
                try
                {
                    theme.ForwardButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "splash":
            {
                try
                {
                    theme.SplashFile = theme.LocalPath + "\\" + val.Trim();
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "toolbarleft":
            {
                try
                {
                    theme.ToolbarLeft = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "toolbarright":
            {
                try
                {
                    theme.ToolbarRight = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "toolbarstretch":
            {
                try
                {
                    theme.ToolbarStretch = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "shadowtopright":
            {
                try
                {
                    theme.ShadowTopRight = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "shadowbottomleft":
            {
                try
                {
                    theme.ShadowBottomLeft = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "shadowhorizontal":
            {
                try
                {
                    theme.ShadowHorizontal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "shadowvertical":
            {
                try
                {
                    theme.ShadowVertical = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }

            case "shadowcorner":
            {
                try
                {
                    theme.ShadowCorner = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                }
                catch
                {
                    throw new ThemingError(null, String.Format("Error parsing {0}", read));
                }
                break;
            }
            }
        }
コード例 #2
0
ファイル: NexusTheme.cs プロジェクト: pederjohnsen/Nimbus
        public static void ProcessIniLine(string read, NimbusTheme theme)
        {
            if (read.StartsWith("//")) return; //is a comment
            string trigger = read.Split('=')[0].ToLower();
            string val = read.Split('=')[1];
            switch (trigger)
            {
                case "backgroundcolor":
                    {
                        try
                        {
                            theme.BackgroundColor = ParseColor(val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "panelcolor":
                    {
                        try
                        {
                            theme.PanelColor = ParseColor(val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "icon":
                    {
                        try
                        {
                            theme.Icon = new Icon(theme.LocalPath + "\\" + val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captionbarcolor":
                    {
                        try
                        {
                            theme.CaptionBarColor = ParseColor(val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "toolbarcolor":
                    {
                        try
                        {
                            theme.ToolbarColor = ParseColor(val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captionfont":
                    {
                        try
                        {
                            theme.CaptionFontFamily = theme.LoadFontFamily(theme.LocalPath + "\\" + val.Trim());

                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "buttonfont":
                    {
                        try
                        {
                            theme.ButtonFont = theme.LoadFontFamily(theme.LocalPath + "\\" + val.Trim());

                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captionfontsize":
                    {
                        try
                        {
                            theme.CaptionFontSize = Int32.Parse(val.Trim());

                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captiontextcolor":
                    {
                        try
                        {
                            theme.CaptionTextColor = ParseColor(val);
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captiontitleoffsetx":
                    {
                        try
                        {
                            theme.CaptionOffsetX = Int32.Parse(val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "captiontitleoffsety":
                    {
                        try
                        {
                            theme.CaptionOffsetY = Int32.Parse(val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "nexuswatermark":
                    {
                        try
                        {
                            theme.NexusWatermark = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "closenormal":
                    {
                        try
                        {
                            theme.CloseButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "closehover":
                    {
                        try
                        {
                            theme.CloseButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "closepressed":
                    {
                        try
                        {
                            theme.CloseButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "minimizenormal":
                    {
                        try
                        {
                            theme.MinimizeButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "minimizehover":
                    {
                        try
                        {
                            theme.MinimizeButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "minimizepressed":
                    {
                        try
                        {
                            theme.MinimizeButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "maximizenormal":
                    {
                        try
                        {
                            theme.MaximizeButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "maximizehover":
                    {
                        try
                        {
                            theme.MaximizeButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "maximizepressed":
                    {
                        try
                        {
                            theme.MaximizeButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "librarynormal":
                    {
                        try
                        {
                            theme.LibraryButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "libraryhover":
                    {
                        try
                        {
                            theme.LibraryButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "librarypressed":
                    {
                        try
                        {
                            theme.LibraryButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "gamesnormal":
                    {
                        try
                        {
                            theme.GamesButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "gameshover":
                    {
                        try
                        {
                            theme.GamesButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "gamespressed":
                    {
                        try
                        {
                            theme.GamesButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "confignormal":
                    {
                        try
                        {
                            theme.ConfigButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "confighover":
                    {
                        try
                        {
                            theme.ConfigButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "configpressed":
                    {
                        try
                        {
                            theme.ConfigButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "friendsnormal":
                    {
                        try
                        {
                            theme.FriendsButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "friendshover":
                    {
                        try
                        {
                            theme.FriendsButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "friendspressed":
                    {
                        try
                        {
                            theme.FriendsButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "backbuttonnormal":
                    {
                        try
                        {
                            theme.BackButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "backbuttonhover":
                    {
                        try
                        {
                            theme.BackButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "backbuttonpressed":
                    {
                        try
                        {
                            theme.BackButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "forwardbuttonnormal":
                    {
                        try
                        {
                            theme.ForwardButton.Normal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "forwardbuttonhover":
                    {
                        try
                        {
                            theme.ForwardButton.Hover = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "forwardbuttonpressed":
                    {
                        try
                        {
                            theme.ForwardButton.Pressed = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "splash":
                    {
                        try
                        {
                            theme.SplashFile = theme.LocalPath + "\\" + val.Trim();
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "toolbarleft":
                    {
                        try
                        {
                            theme.ToolbarLeft = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "toolbarright":
                    {
                        try
                        {
                            theme.ToolbarRight = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "toolbarstretch":
                    {
                        try
                        {
                            theme.ToolbarStretch = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "shadowtopright":
                    {
                        try
                        {
                            theme.ShadowTopRight = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "shadowbottomleft":
                    {
                        try
                        {
                            theme.ShadowBottomLeft = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "shadowhorizontal":
                    {
                        try
                        {
                            theme.ShadowHorizontal = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "shadowvertical":
                    {
                        try
                        {
                            theme.ShadowVertical = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }
                case "shadowcorner":
                    {
                        try
                        {
                            theme.ShadowCorner = Image.FromFile(theme.LocalPath + "\\" + val.Trim());
                        }
                        catch
                        {
                            throw new ThemingError(null, String.Format("Error parsing {0}", read));
                        }
                        break;
                    }

            }
        }