public static void CreateDefaultThemes()
    {
      // Define list of effects to be applied to source logo, order matters here. Add only effects that are enabled by configuration.
      List<AbstractEffect> effects = new List<AbstractEffect>
      {
        new EffectAutoCrop(),
        new EffectResize {TargetSize = new Size(200, 110), MaxSize = new Size(200, 110)},
        // new EffectGlow {Color = Color.Red, Radius = 15},
        new EffectShadow {Color = Color.FromArgb(200, 0, 0, 0), Radius = 5, ShadowXOffset = 5, ShadowYOffset = 5},
        new EffectOuterGlow {Color = Color.Black, Width = 1, Transparency = 0.8f}
      };

      ThemeHandler themeHandler = new ThemeHandler();
      string theme = string.Format("{0}-{1}", DESIGN, THEMES[0]);
      if (!File.Exists(theme))
      {
        Theme themeModern = new Theme { DesignName = DESIGN, ThemeName = THEMES[0] };
        themeHandler.Save(theme, themeModern);
      }
      theme = string.Format("{0}-{1}", DESIGN, THEMES[1]);
      if (!File.Exists(theme))
      {
        Theme themeModernMaxEffects = new Theme { DesignName = DESIGN, ThemeName = THEMES[1], Effects = effects };
        themeHandler.Save(theme, themeModernMaxEffects);
      }
    }
    /// <summary>
    /// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
    /// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
    /// </summary>
    /// <param name="mediaType">Requested FanArtMediaType</param>
    /// <param name="fanArtType">Requested FanArtType</param>
    /// <param name="name">Requested name of Series, Actor, Artist...</param>
    /// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
    /// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
    /// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
    /// <param name="result">Result if return code is <c>true</c>.</param>
    /// <returns><c>true</c> if at least one match was found.</returns>
    public bool TryGetFanArt(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList<IResourceLocator> result)
    {
      result = null;
      if (mediaType != FanArtConstants.FanArtMediaType.ChannelTv && mediaType != FanArtConstants.FanArtMediaType.ChannelRadio)
        return false;

      try
      {
        string designsFolder = FileUtils.BuildAssemblyRelativePath("Designs");

        ChannelType logoChannelType = mediaType == FanArtConstants.FanArtMediaType.ChannelTv ? ChannelType.Tv : ChannelType.Radio;
        ThemeHandler themeHandler = new ThemeHandler();
        Theme theme = themeHandler.Load(Path.Combine(designsFolder, _settings.LogoTheme));

        string logoFolder = Path.Combine(_dataFolder, string.Format("{0}-{1}-{2}", logoChannelType, theme.DesignName, theme.ThemeName));
        string logoFileName = Path.Combine(logoFolder, FileUtils.GetSafeFilename(string.Format("{0}.png", name)));

        if (!Directory.Exists(logoFolder))
          Directory.CreateDirectory(logoFolder);

        if (File.Exists(logoFileName))
        {
          result = new List<IResourceLocator>{new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName))};
          return true;
        }

        LogoProcessor processor = new LogoProcessor { DesignsFolder = designsFolder };

        // From repository
        using (var repo = new LogoRepository { RepositoryUrl = _settings.RepositoryUrl })
        {
          var stream = repo.Download(name, logoChannelType, _country.TwoLetterISORegionName);
          if (stream == null)
            return false;
          using (stream)
            if (processor.CreateLogo(theme, stream, logoFileName))
            {
              result = new List<IResourceLocator> { new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName)) };
              return true;
            }
        }
      }
      catch (Exception ex)
      {
        ServiceRegistration.Get<ILogger>().Error("SlimTv Logos: Error processing logo image.", ex);
      }
      return false;
    }
        public override void Fire()
        {
            Thread thread = new(() =>
            {
                try
                {
                    State.CurrentWindowsThemeName = ThemeHandler.GetCurrentThemeName();
                }
                catch (Exception ex)
                {
                    Logger.Error(ex, $"couldn't refresh currently active theme");
                }
            })
            {
                Name = "COMThemeManagerThread"
            };

            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
        }
Example #4
0
        public ActionResult Settings(bool ismobile)
        {
            // we need to parse settings file
            var theme        = new ThemeHandler(MASTERdomain, ismobile);
            var settingHtml  = theme.GetSettingsHtml();
            var settingsText = theme.GetSettingsText();
            var serializer   = new JavaScriptSerializer();
            var settings     = serializer.Deserialize <ThemeSettings>(settingsText);

            // set current theme settings if set
            if (!string.IsNullOrEmpty(MASTERdomain.theme.preset))
            {
                settings.current = MASTERdomain.theme.preset;
                settingsText     = serializer.Serialize(settings);
            }

            var viewmodel = new ThemeSettingsViewModel
            {
                SettingsHtml = settingHtml,
                SettingsJson = string.IsNullOrEmpty(settingsText) ? "{}": settingsText,
                ThemeTitle   = MASTERdomain.theme.title,
                themeType    = ismobile ? ThemeType.MOBILE : ThemeType.MAIN
            };

            if (settings != null &&
                settings.presets != null &&
                settings.presets.Count != 0)
            {
                foreach (var key in settings.presets.Keys)
                {
                    viewmodel.presetList.Add(new SelectListItem()
                    {
                        Text     = key,
                        Value    = key,
                        Selected = key == MASTERdomain.theme.preset
                    });
                }
            }

            return(View(viewmodel));
        }
Example #5
0
        public ActionResult DeleteFile(string path, bool ismobile)
        {
            var handler = new ThemeHandler(MASTERdomain, ismobile);
            var file    = string.Format("{0}{1}{2}", GeneralConstants.APP_ROOT_DIR, handler.GetThemeUrl(), path);

            // prevent critical files from being deleted
            if (CriticalThemeFiles.Contains(path))
            {
                return(Json("Unable to delete critical theme files".ToJsonFail()));
            }

            try
            {
                System.IO.File.Delete(file);
            }
            catch (Exception ex)
            {
                return(SendJsonErrorResponse(ex));
            }
            return(Json("File deleted".ToJsonOKMessage()));
        }
Example #6
0
        public ActionResult AddAsset(string qqfile, bool ismobile)
        {
            Stream inputStream;

            if (Request.Files.Count != 0)
            {
                inputStream = Request.Files[0].InputStream;
            }
            else
            {
                inputStream = Request.InputStream;
            }
            inputStream.Position = 0;

            var handler = new ThemeHandler(MASTERdomain, ismobile);
            var dirs    = handler.GetThemeDirectory().GetDirectories("assets");

            if (dirs.Length == 0)
            {
                return(Json("Theme directory corrupted. Please select theme from gallery again.".ToJsonFail()));
            }

            // try to get existing template
            // if none exist then create blank file
            var filename = qqfile;
            var dest     = Path.Combine(dirs[0].FullName, filename);

            // if destination file exist, then delete destination file
            if (System.IO.File.Exists(dest))
            {
                System.IO.File.Delete(dest);
            }

            using (Stream file = System.IO.File.OpenWrite(dest))
            {
                Utility.CopyStream(inputStream, file);
            }

            return(Json("File uploaded successfully".ToJsonOKMessage()));
        }
Example #7
0
        /// <summary>
        /// Applies the theme using the KAWAII Theme switcher logic for windows theme files
        /// </summary>
        /// <param name="config"></param>
        /// <param name="newTheme"></param>
        /// <param name="automatic"></param>
        /// <param name="sunset"></param>
        /// <param name="sunrise"></param>
        /// <returns>true if an update was performed; false otherwise</returns>
        private static bool ApplyTheme(AdmConfig config, Theme newTheme)
        {
            GlobalState state = GlobalState.Instance();

            if (config.WindowsThemeMode.DarkThemePath == null || config.WindowsThemeMode.LightThemePath == null)
            {
                Logger.Error("dark or light theme path empty");
                return(false);
            }
            if (!File.Exists(config.WindowsThemeMode.DarkThemePath))
            {
                Logger.Error($"invalid dark theme path: {config.WindowsThemeMode.DarkThemePath}");
                return(false);
            }
            if (!File.Exists(config.WindowsThemeMode.LightThemePath))
            {
                Logger.Error($"invalid light theme path: {config.WindowsThemeMode.LightThemePath}");
                return(false);
            }
            if (!config.WindowsThemeMode.DarkThemePath.EndsWith(".theme") || !config.WindowsThemeMode.DarkThemePath.EndsWith(".theme"))
            {
                Logger.Error("both theme paths must have a .theme extension");
                return(false);
            }

            // TODO change tracking when having active theme monitor disabled
            if (newTheme == Theme.Dark && !state.CurrentWindowsThemeName.Equals(Path.GetFileNameWithoutExtension(config.WindowsThemeMode.DarkThemePath), StringComparison.Ordinal))
            {
                PowerHandler.DisableEnergySaver(config);
                ThemeHandler.Apply(config.WindowsThemeMode.DarkThemePath);
                return(true);
            }
            else if (newTheme == Theme.Light && !state.CurrentWindowsThemeName.Equals(Path.GetFileNameWithoutExtension(config.WindowsThemeMode.LightThemePath), StringComparison.Ordinal))
            {
                PowerHandler.DisableEnergySaver(config);
                ThemeHandler.Apply(config.WindowsThemeMode.LightThemePath);
                return(true);
            }
            return(false);
        }
        protected RuntimeConfig()
        {
            CurrentAppsTheme   = RegistryHandler.AppsUseLightTheme() ? Theme.Light : Theme.Dark;
            CurrentSystemTheme = RegistryHandler.SystemUsesLightTheme() ? Theme.Light : Theme.Dark;

            try
            {
                CurrentEdgeTheme = RegistryHandler.EdgeUsesLightTheme() ? Theme.Light : Theme.Dark;
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "could not retrieve edge theme key value");
                CurrentEdgeTheme = Theme.Undefined;
            }

            CurrentColorPrevalence  = RegistryHandler.IsColorPrevalence();
            CurrentWallpaperTheme   = Theme.Undefined;
            CurrentWindowsThemeName = ThemeHandler.GetCurrentThemeName();
            CurrentOfficeTheme      = Theme.Undefined;
            ForcedTheme             = Theme.Undefined;
            PostponeSwitch          = false;
        }
Example #9
0
 public void ApplySettings()
 {
     if (Properties.Settings.Default.Appearance_DarkMode)
     {
         ThemeHandler.SetColors(this,
                                (44, 47, 51),
                                (255, 255, 255),
                                Color.Black,
                                Color.White);
     }
     else
     {
         ThemeHandler.SetColors(this, (Properties.Settings.Default.Appearance_AccentColorRed, Properties.Settings.Default.Appearance_AccentColorGreen, Properties.Settings.Default.Appearance_AccentColorBlue), (255, 255, 255), Color.White, Color.Black);
     }
     if (Properties.Settings.Default.General_DiscordIntegration)
     {
         Player.InitDiscordRPC();
     }
     else
     {
         Player.DisposeRPC();
     }
 }
Example #10
0
        public static void CreateDefaultThemes()
        {
            // Define list of effects to be applied to source logo, order matters here. Add only effects that are enabled by configuration.
            List <AbstractEffect> effects = new List <AbstractEffect>
            {
                new EffectAutoCrop(),
                new EffectResize {
                    TargetSize = new Size(200, 110), MaxSize = new Size(200, 110)
                },
                // new EffectGlow {Color = Color.Red, Radius = 15},
                new EffectShadow {
                    Color = Color.FromArgb(200, 0, 0, 0), Radius = 5, ShadowXOffset = 5, ShadowYOffset = 5
                },
                new EffectOuterGlow {
                    Color = Color.Black, Width = 1, Transparency = 0.8f
                }
            };

            ThemeHandler themeHandler = new ThemeHandler();
            string       theme        = string.Format("{0}-{1}", DESIGN, THEMES[0]);

            if (!File.Exists(theme))
            {
                Theme themeModern = new Theme {
                    DesignName = DESIGN, ThemeName = THEMES[0]
                };
                themeHandler.Save(theme, themeModern);
            }
            theme = string.Format("{0}-{1}", DESIGN, THEMES[1]);
            if (!File.Exists(theme))
            {
                Theme themeModernMaxEffects = new Theme {
                    DesignName = DESIGN, ThemeName = THEMES[1], Effects = effects
                };
                themeHandler.Save(theme, themeModernMaxEffects);
            }
        }
        /// <summary>
        /// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
        /// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
        /// </summary>
        /// <param name="mediaType">Requested FanArtMediaType</param>
        /// <param name="fanArtType">Requested FanArtType</param>
        /// <param name="name">Requested name of Series, Actor, Artist...</param>
        /// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
        /// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
        /// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
        /// <param name="result">Result if return code is <c>true</c>.</param>
        /// <returns><c>true</c> if at least one match was found.</returns>
        public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
        {
            result = null;
            if (mediaType != FanArtMediaTypes.ChannelTv && mediaType != FanArtMediaTypes.ChannelRadio)
            {
                return(false);
            }

            try
            {
                string designsFolder = FileUtils.BuildAssemblyRelativePath("Designs");

                ChannelType  logoChannelType = mediaType == FanArtMediaTypes.ChannelTv ? ChannelType.Tv : ChannelType.Radio;
                ThemeHandler themeHandler    = new ThemeHandler();
                Theme        theme           = themeHandler.Load(Path.Combine(designsFolder, _settings.LogoTheme));

                string logoFolder   = Path.Combine(_dataFolder, string.Format("{0}-{1}-{2}", logoChannelType, theme.DesignName, theme.ThemeName));
                string logoFileName = Path.Combine(logoFolder, FileUtils.GetSafeFilename(string.Format("{0}.png", name)));

                if (!Directory.Exists(logoFolder))
                {
                    Directory.CreateDirectory(logoFolder);
                }

                if (File.Exists(logoFileName))
                {
                    result = new List <IResourceLocator> {
                        new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName))
                    };
                    return(true);
                }

                LogoProcessor processor = new LogoProcessor {
                    DesignsFolder = designsFolder
                };

                // From repository
                using (var repo = new LogoRepository {
                    RepositoryUrl = _settings.RepositoryUrl
                })
                {
                    var stream = repo.Download(name, logoChannelType, _country.TwoLetterISORegionName);
                    if (stream == null)
                    {
                        return(false);
                    }
                    using (stream)
                        if (processor.CreateLogo(theme, stream, logoFileName))
                        {
                            result = new List <IResourceLocator> {
                                new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, logoFileName))
                            };
                            return(true);
                        }
                }
            }
            catch (Exception ex)
            {
                ServiceRegistration.Get <ILogger>().Error("SlimTv Logos: Error processing logo image.", ex);
            }
            return(false);
        }
Example #12
0
        public ActionResult Settings(bool?save_preset, string save_preset_existing, string save_preset_custom, string preset, ThemeType themeType)
        {
            if (!save_preset.HasValue)
            {
                save_preset = false;
            }

            if (string.IsNullOrEmpty(preset))
            {
                preset = "Default";
            }

            var theme = new ThemeHandler(MASTERdomain, themeType == ThemeType.MOBILE);

            // handle files
            if (Request.Files.Count != 0)
            {
                foreach (var filename in Request.Files.AllKeys)
                {
                    var file = Request.Files[filename];
                    if (file == null ||
                        file.ContentLength == 0)
                    {
                        continue;
                    }
                    theme.SaveImage(filename, file.InputStream);
                }
            }

            // duplicate collection as original is read-only
            var values = new Dictionary <string, object>();

            foreach (string entry in Request.Form.Keys)
            {
                if (entry == "save_preset" ||
                    entry == "save_preset_existing" ||
                    entry == "save_preset_custom" ||
                    entry == "preset")
                {
                    continue;
                }

                var  val = Request.Form.GetValues(entry).FirstOrDefault();
                bool boolval;
                if (bool.TryParse(val, out boolval))
                {
                    values[entry] = boolval;
                }
                else
                {
                    values[entry] = val;
                }
            }

            var selectedPreset = "";

            if (save_preset.Value)
            {
                if (save_preset_existing == "new" && !string.IsNullOrEmpty(save_preset_custom))
                {
                    // if new preset name is specified then use the defined name
                    selectedPreset = save_preset_custom;
                }
                else
                {
                    // otherwise we just use current preset
                    selectedPreset = preset;
                }
            }
            else
            {
                selectedPreset = preset;
            }


            // convert to json string
            // read current settings from file
            var old_settings = JsonConvert.DeserializeObject <ThemeSettings>(theme.GetSettingsText());

            // just set preset
            old_settings.presets[selectedPreset] = values;
            old_settings.current = selectedPreset;

            // serialise and save to file
            var settings_string = JsonConvert.SerializeObject(old_settings, Formatting.Indented);

            theme.SaveSettings(settings_string);

            // save preset to db
            MASTERdomain.theme.preset = selectedPreset;

            // update versions
            switch (themeType)
            {
            case ThemeType.MAIN:
                MASTERdomain.theme.theme_version = DateTime.UtcNow.Ticks.ToString("x");
                break;

            case ThemeType.MOBILE:
                MASTERdomain.theme.theme_mobile_version = DateTime.UtcNow.Ticks.ToString("x");
                break;

            default:
                throw new ArgumentOutOfRangeException("themeType");
            }

            repository.Save();

            // need to invalidate any cached liquid assets
            CacheHelper.Instance.invalidate_dependency(DependencyType.liquid_assets, MASTERdomain.uniqueid);

            return(RedirectToAction("Index"));
        }
        /// <summary>
        /// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
        /// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
        /// </summary>
        /// <param name="mediaType">Requested FanArtMediaType</param>
        /// <param name="fanArtType">Requested FanArtType</param>
        /// <param name="name">Requested name of Series, Actor, Artist...</param>
        /// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
        /// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
        /// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
        /// <param name="result">Result if return code is <c>true</c>.</param>
        /// <returns><c>true</c> if at least one match was found.</returns>
        public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
        {
            result = null;
            if (mediaType != FanArtMediaTypes.ChannelTv && mediaType != FanArtMediaTypes.ChannelRadio)
            {
                return(false);
            }

            try
            {
                string designsFolder = _designsFolder ?? FileUtils.BuildAssemblyRelativePath("Designs");

                ChannelType  logoChannelType = mediaType == FanArtMediaTypes.ChannelTv ? ChannelType.Tv : ChannelType.Radio;
                ThemeHandler themeHandler    = new ThemeHandler();
                Theme        theme           = themeHandler.Load(Path.Combine(designsFolder, _settings.LogoTheme));

                string logoFolder   = Path.Combine(_dataFolder, string.Format("{0}-{1}-{2}", logoChannelType, theme.DesignName, theme.ThemeName));
                string logoFileName = Path.Combine(logoFolder, FileUtils.GetSafeFilename(string.Format("{0}.png", name)));

                if (!Directory.Exists(logoFolder))
                {
                    Directory.CreateDirectory(logoFolder);
                }

                if (File.Exists(logoFileName) && IsCacheValid(theme, logoFileName))
                {
                    return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
                }

                LogoProcessor processor = new LogoProcessor {
                    DesignsFolder = designsFolder
                };

                // From repository
                using (var repo = new LogoRepository {
                    RepositoryUrl = _settings.RepositoryUrl
                })
                {
                    var stream = repo.Download(name, logoChannelType, _country.TwoLetterISORegionName);
                    if (stream == null)
                    {
                        return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
                    }
                    using (stream)
                    {
                        // First download and process the new logo, but keep the existing file if something fails.
                        string tmpLogoFileName = Path.ChangeExtension(logoFileName, ".tmplogo");
                        if (processor.CreateLogo(theme, stream, tmpLogoFileName))
                        {
                            if (File.Exists(logoFileName))
                            {
                                File.Delete(logoFileName);
                            }
                            File.Move(tmpLogoFileName, logoFileName);
                        }
                        return(BuildLogoResourceLocatorAndReturn(ref result, logoFileName));
                    }
                }
            }
            catch (Exception ex)
            {
                ServiceRegistration.Get <ILogger>().Error("SlimTv Logos: Error processing logo image.", ex);
            }
            return(false);
        }
Example #14
0
        public ActionResult Editor(bool ismobile)
        {
            // check that there are theme files, otherwise copy
            var handler = new ThemeHandler(MASTERdomain, ismobile);

            if (!handler.IsCustom && !handler.ThemeCopiedOK())
            {
                DirectoryInfo sourceThemeDir = ismobile
                                                   ? handler.GetMobileThemeRepositorySourceDir()
                                                   : handler.GetThemeRepositorySourceDir();
                if (sourceThemeDir == null)
                {
                    throw new NotImplementedException();
                }
                handler.CopyThemeToUserThemeDirectory(sourceThemeDir);
            }

            var viewmodel = new ThemeEditorViewModel()
            {
                themeType = ismobile ? ThemeType.MOBILE : ThemeType.MAIN
            };

            var themedir = handler.GetThemeDirectory();

            foreach (var dir in themedir.GetDirectories().OrderByDescending(x => x.Name))
            {
                var folder = new ThemeDirectory()
                {
                    foldername = dir.Name
                };
                switch (dir.Name)
                {
                case "templates":
                    viewmodel.templates_folder = folder;
                    break;

                case "assets":
                    viewmodel.asset_folder = folder;
                    break;

                case "snippets":
                    viewmodel.snippets_folder = folder;
                    break;

                case "layout":
                    viewmodel.layout_folder = folder;
                    break;

                case "config":
                    viewmodel.config_folder = folder;
                    break;

                default:
                    throw new ArgumentException("Unknown directory " + dir.Name);
                }
                foreach (var entry in dir.GetFiles())
                {
                    var ext  = entry.Extension.ToLower();
                    var file = new ThemeFile();
                    file.classname = string.Format("ext_{0}", ext.Substring(1));
                    file.url       = string.Format("/{0}/{1}", dir.Name, entry.Name);
                    file.filename  = entry.Name;

                    folder.files.Add(file);
                }
            }

            return(View(viewmodel));
        }
Example #15
0
        public ActionResult Import(bool ismobile)
        {
            Stream inputStream;

            if (Request.Files.Count != 0)
            {
                inputStream = Request.Files[0].InputStream;
            }
            else
            {
                inputStream = Request.InputStream;
            }
            inputStream.Position = 0;
            var handler = new ThemeHandler(MASTERdomain, ismobile);

            try
            {
                var themedir = handler.ClearUserThemeDirectory();

                using (var s = new ZipInputStream(inputStream))
                {
                    ZipEntry theEntry;
                    while ((theEntry = s.GetNextEntry()) != null)
                    {
                        Console.WriteLine(theEntry.Name);

                        string directoryName = Path.GetDirectoryName(string.Format("{0}/{1}", themedir.FullName, theEntry.Name));
                        string fileName      = Path.GetFileName(string.Format("{0}/{1}", themedir.FullName, theEntry.Name));

                        // create directory
                        if (directoryName.Length > 0)
                        {
                            Directory.CreateDirectory(directoryName);
                        }

                        if (fileName != String.Empty)
                        {
                            using (FileStream streamWriter = System.IO.File.Create(string.Format("{0}/{1}", themedir.FullName, theEntry.Name)))
                            {
                                int    size = 2048;
                                byte[] data = new byte[2048];
                                while (true)
                                {
                                    size = s.Read(data, 0, data.Length);
                                    if (size > 0)
                                    {
                                        streamWriter.Write(data, 0, size);
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Syslog.Write(ex);
                return(Json("Failed to extract theme files".ToJsonFail()));
            }

            // update theme
            var theme = MASTERdomain.theme;

            if (theme == null)
            {
                theme = new theme();
                MASTERdomain.theme = theme;
            }

            theme.title   = ThemeHandler.CustomThemeName;
            theme.url     = "/Content/img/store/custom_theme.png";
            theme.created = DateTime.UtcNow;

            // remove custom templates from existing pages
            var pages = MASTERdomain.pages.Where(x => !string.IsNullOrEmpty(x.templatename));

            foreach (var page in pages)
            {
                page.templatename = "";
            }
            repository.Save();

            // need to invalidate any cached liquid assets
            CacheHelper.Instance.invalidate_dependency(DependencyType.liquid_assets, MASTERdomain.uniqueid);

            return(Json("Theme imported successfully".ToJsonOKMessage()));
        }
Example #16
0
        public static IEnumerable <Theme> LoadAllThemes()
        {
            ThemeHandler themeHandler = new ThemeHandler();

            return(THEMES.Select(theme => string.Format("{0}-{1}", DESIGN, theme)).Select(themeHandler.Load));
        }
Example #17
0
        // handles liquid template assets
        public ActionResult Handler(string filename, string domainpath)
        {
            string uniqueid;

            if (domainpath == "facebook")
            {
                uniqueid = domainpath;
            }
            else
            {
                var pathparts = domainpath.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries);
                uniqueid = pathparts[0];
            }

            // setup physical path first
            string liquidPhysicalPath;
            bool   isSVG = false;

            if (Request.RawUrl.IndexOf(".svg.png") != -1)
            {
                liquidPhysicalPath = Request.PhysicalPath.Replace(".png", ".liquid");
                isSVG = true;
            }
            else
            {
                liquidPhysicalPath = Request.PhysicalPath + ".liquid";
            }

            // cachekey = filename
            dynamic result;
            var     cachekey = ThemeHandler.GetCacheKey(uniqueid, filename, (bool)Session[BrowserCapability.IsMobileSession]);

            if (!CacheHelper.Instance.TryGetCache(CacheItemType.liquid_assets, cachekey, out result))
            {
                if (System.IO.File.Exists(liquidPhysicalPath))
                {
                    LiquidTemplateBase template;

                    var             accountHostname = Request.Headers["Host"];
                    MASTERsubdomain sd;
                    using (var db = new tradelrDataContext())
                    {
#if DEBUG
                        if (accountHostname.EndsWith("localhost"))
#else
                        if (accountHostname.EndsWith("tradelr.com"))
#endif
                        {
                            ////////////// handles case for subdomains
                            string[] host = accountHostname.Split('.');
                            // not on a subdomain

                            sd = db.GetSubDomain(host[0]);
                        }
                        else
                        {
                            ////////////////// handles case for custom subdomains
                            sd = db.GetCustomHostname(accountHostname);
                        }

                        template = new LiquidTemplateBase(sd,
                                                          (bool)Session[BrowserCapability.IsMobileSession]);

                        var parsed_string = template.ReadTemplateFile(liquidPhysicalPath);

                        template.InitContentTemplate(parsed_string);
                        template.AddParameters("shop", sd.ToLiquidModel());
                    }

                    var dirIndex = liquidPhysicalPath.LastIndexOf("\\");

                    // handle not found
                    var config_file = liquidPhysicalPath.Substring(0, dirIndex).Replace("assets", "config\\settings_data.json");
                    if (System.IO.File.Exists(config_file))
                    {
                        var current = template.ReadThemeSettings(config_file);
                        if (current != null)
                        {
                            template.AddParameters("settings", current);
                        }

                        if (isSVG)
                        {
                            // convert to png
                            using (var stream = template.RenderBasicToStreamNoHeader())
                            {
                                var svg = SvgDocument.Open(stream);
                                result = svg.Draw();
                            }
                        }
                        else
                        {
                            result = template.RenderBasicNoHeader();
                        }

                        CacheHelper.Instance.Insert(CacheItemType.liquid_assets, cachekey, result);
                        if (uniqueid != "facebook")
                        {
                            CacheHelper.Instance.add_dependency(DependencyType.liquid_assets, uniqueid, CacheItemType.liquid_assets, cachekey);
                        }
                    }
                }
            }

            if (Request.RawUrl.IndexOf(".css") != -1)
            {
                Response.ContentType = "text/css";
                return(Content(result));
            }

            if (Request.RawUrl.IndexOf(".js") != -1)
            {
                Response.ContentType = "application/x-javascript";
                return(Content(result));
            }

            if (isSVG)
            {
                return(new SvgToPngActionResult(result));
            }

            Syslog.Write(string.Format("Unknown filetype: {0}", Request.RawUrl));
            return(new EmptyResult());
        }
Example #18
0
 public static IEnumerable<Theme> LoadAllThemes()
 {
   ThemeHandler themeHandler = new ThemeHandler();
   return THEMES.Select(theme => string.Format("{0}-{1}", DESIGN, theme)).Select(themeHandler.Load);
 }
Example #19
0
        static void Main(string[] args)
        {
            try
            {
                //Set up Logger
                var config    = new NLog.Config.LoggingConfiguration();
                var configDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "AutoDarkMode");

                // Targets where to log to: File and Console
                var logfile = new NLog.Targets.FileTarget("logfile")
                {
                    FileName = Path.Combine(configDir, "service.log"),
                    Layout   = @"${date:format=yyyy-MM-dd HH\:mm\:ss} | ${level} | " +
                               "${callsite:includeNamespace=False:" +
                               "cleanNamesOfAnonymousDelegates=true:" +
                               "cleanNamesOfAsyncContinuations=true}: ${message} ${exception:separator=|}"
                };
                var logconsole = new NLog.Targets.ColoredConsoleTarget("logconsole")
                {
                    Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} | ${level} | " +
                             "${callsite:includeNamespace=False:" +
                             "cleanNamesOfAnonymousDelegates=true:" +
                             "cleanNamesOfAsyncContinuations=true}: ${message} ${exception:separator=|}"
                };

                List <string> argsList;
                if (args.Length > 0)
                {
                    argsList = new List <string>(args);
                }
                else
                {
                    argsList = new List <string>();
                }

                // Rules for mapping loggers to targets
                config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
                if (argsList.Contains("/debug"))
                {
                    config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
                }
                else
                {
                    config.AddRule(LogLevel.Info, LogLevel.Fatal, logfile);
                }
                // Apply config
                LogManager.Configuration = config;

                try
                {
                    Directory.CreateDirectory(configDir);
                }
                catch (Exception e)
                {
                    Logger.Fatal(e, "could not create config directory");
                }

                try
                {
                    if (!mutex.WaitOne(TimeSpan.FromSeconds(2), false))
                    {
                        Logger.Debug("app instance already open");
                        return;
                    }
                }
                catch (Exception ex)
                {
                    Logger.Error(ex, "failed getting mutex, " + ex.Message);
                    return;
                }

                //Instantiate Runtime config
                GlobalState.Instance();

                //Populate configuration
                AdmConfigBuilder Builder = AdmConfigBuilder.Instance();
                try
                {
                    Builder.Load();
                    Builder.LoadLocationData();
                    Logger.Debug("config builder instantiated and configuration loaded");
                }
                catch (Exception e)
                {
                    Logger.Fatal(e, "could not read config file. shutting down application!");
                    LogManager.Shutdown();
                    Environment.Exit(-1);
                }

                if (Builder.Config.Tunable.Debug && !argsList.Contains("/debug"))
                {
                    config = new NLog.Config.LoggingConfiguration();
                    config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
                    config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
                    LogManager.Configuration = config;
                }

                Logger.Debug("config file loaded");

                //if a path is set to null, set it to the currently actvie theme for convenience reasons
                bool configUpdateNeeded = false;
                if (!Builder.Config.ClassicMode)
                {
                    if (!File.Exists(Builder.Config.DarkThemePath) || Builder.Config.DarkThemePath == null)
                    {
                        Builder.Config.DarkThemePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)
                                                                    + @"\Microsoft\Windows\Themes", ThemeHandler.GetCurrentThemeName() + ".theme");
                        configUpdateNeeded = true;
                    }
                    if (!File.Exists(Builder.Config.DarkThemePath) || Builder.Config.LightThemePath == null)
                    {
                        Builder.Config.LightThemePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)
                                                                     + @"\Microsoft\Windows\Themes", ThemeHandler.GetCurrentThemeName() + ".theme");
                        configUpdateNeeded = true;
                    }
                    if (configUpdateNeeded)
                    {
                        Logger.Warn("one or more theme paths not set at program start, reinstantiation needed");
                        try
                        {
                            Builder.Save();
                        }
                        catch (Exception ex)
                        {
                            Logger.Error(ex, "couldn't save configuration file");
                        }
                    }
                }

                int timerMillis = 0;
                if (args.Length != 0)
                {
                    int.TryParse(args[0], out timerMillis);
                }
                timerMillis = (timerMillis == 0) ? TimerFrequency.Short : timerMillis;
                Application.SetHighDpiMode(HighDpiMode.SystemAware);
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Service = new Service(timerMillis);
                Application.Run(Service);
            }
            finally
            {
                //clean shutdown
                if (Service != null)
                {
                    Service.Cleanup();
                }
                mutex.Dispose();
            }
        }
Example #20
0
        //private static readonly ComponentManager cm = ComponentManager.Instance();

        /// <summary>
        /// Parses a command message and invokes a callback function delegate for status reporting
        /// </summary>
        /// <param name="msg">list of messages to parse</param>
        /// <param name="SendResponse">Callback taking a string as parameter to report return values back to sender</param>
        /// <param name="service">Service class for invoking application exit</param>
        public static void Parse(List <string> msg, Action <string> SendResponse, Service service)
        {
            //WaitForConfigUpdateCompletion();
            _ = state.ConfigIsUpdatingWaitHandle.WaitOne();
            msg.ForEach(message =>
            {
                switch (message)
                {
                    #region Switch
                case Command.Switch:
                    Logger.Info("signal received: invoke theme switch");
                    //cm.ForceAll();
                    ThemeManager.RequestSwitch(builder, new(SwitchSource.Manual));
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region Swap
                case Command.Swap:
                    Logger.Info("signal received: swap themes");
                    if (RegistryHandler.AppsUseLightTheme())
                    {
                        ThemeManager.UpdateTheme(builder.Config, Theme.Dark, new(SwitchSource.Manual));
                    }
                    else
                    {
                        ThemeManager.UpdateTheme(builder.Config, Theme.Light, new(SwitchSource.Manual));
                    }
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region AddAutoStart
                case Command.AddAutostart:
                    Logger.Info("signal received: add service to autostart");
                    SendResponse(AutoStartHandler.AddAutostart().ToString());
                    break;
                    #endregion

                    #region RemoveAutostart
                case Command.RemoveAutostart:
                    Logger.Info("signal received: remove service from autostart");
                    SendResponse(AutoStartHandler.RemoveAutostart().ToString());
                    break;
                    #endregion

                    #region GetAutostartState
                case Command.GetAutostartState:
                    Logger.Info("signal recevied: get autostart state");
                    SendResponse(AutoStartHandler.GetAutostartState().ToString());
                    break;
                    #endregion

                    #region ValidateAutostartAutostart
                case string s when s.StartsWith(Command.ValidateAutostart):
                    Logger.Info("signal received: validate autostart entries");
                    string[] split = s.Split(" ");
                    if (split.Length > 1)
                    {
                        SendResponse(AutoStartHandler.Validate(true).ToString());
                    }
                    else
                    {
                        SendResponse(AutoStartHandler.Validate(false).ToString());
                    }
                    break;
                    #endregion

                    #region LocationAccess
                case Command.LocationAccess:
                    Logger.Info("signal received: checking location access permissions");
                    Task <bool> geoTask = Task.Run(async() => await LocationHandler.HasLocation());
                    geoTask.Wait();
                    var result = geoTask.Result;
                    if (result)
                    {
                        SendResponse(new ApiResponse()
                        {
                            StatusCode = StatusCode.Ok
                        }.ToString());
                    }
                    else
                    {
                        SendResponse(new ApiResponse()
                        {
                            StatusCode = StatusCode.NoLocAccess,
                            Message    = "location service needs to be enabled"
                        }.ToString());
                    }
                    break;
                    #endregion

                    #region GeoloatorIsUpdating
                case Command.GeolocatorIsUpdating:
                    Logger.Info("signal received: check if geolocator is busy");
                    if (state.GeolocatorIsUpdating)
                    {
                        SendResponse(new ApiResponse()
                        {
                            StatusCode = StatusCode.InProgress
                        }.ToString());
                    }
                    else
                    {
                        SendResponse(new ApiResponse()
                        {
                            StatusCode = StatusCode.Ok
                        }.ToString());
                    }
                    break;
                    #endregion

                    #region CheckForUpdates
                case Command.CheckForUpdate:
                    Logger.Info("signal received: checking for update");
                    SendResponse(UpdateHandler.CheckNewVersion().ToString());
                    break;
                    #endregion

                    #region CheckForUpdateNotify
                case Command.CheckForUpdateNotify:
                    Logger.Info("signal received: checking for update and requesting notification");
                    ApiResponse updateCheckData = UpdateHandler.CheckNewVersion();
                    updateCheckData             = UpdateHandler.CanUseUpdater();
                    if (updateCheckData.StatusCode == StatusCode.New)
                    {
                        ToastHandler.InvokeUpdateToast();
                    }
                    else if (updateCheckData.StatusCode == StatusCode.UnsupportedOperation || updateCheckData.StatusCode == StatusCode.Disabled)
                    {
                        ToastHandler.InvokeUpdateToast(canUseUpdater: false);
                    }
                    SendResponse(updateCheckData.ToString());
                    break;
                    #endregion

                    #region Update
                case Command.Update:
                    Logger.Info("signal received: update adm");
                    if (!UpdateHandler.Updating)
                    {
                        ApiResponse response = UpdateHandler.CanUseUpdater();
                        if (response.StatusCode == StatusCode.New)
                        {
                            SendResponse(response.ToString());
                            // this is run sync, as such it will block the ZMQ thread!
                            _ = Task.Run(() => UpdateHandler.Update());
                        }
                        else
                        {
                            SendResponse(response.ToString());
                        }
                    }
                    else
                    {
                        SendResponse(new ApiResponse()
                        {
                            StatusCode = StatusCode.InProgress,
                            Message    = "Update already in progress",
                            Details    = $"Download Progress: {UpdateHandler.Progress}"
                        }.ToString());
                    }
                    //_ = UpdateHandler.CheckNewVersion();

                    break;
                    #endregion

                    #region CheckForDowngradeNotify
                case Command.CheckForDowngradeNotify:
                    Logger.Info("signal received: checking for downgrade and requesting notification");
                    ApiResponse downgradeCheckData = UpdateHandler.CheckDowngrade();
                    updateCheckData = UpdateHandler.CanUseUpdater();
                    if (updateCheckData.StatusCode == StatusCode.Downgrade)
                    {
                        ToastHandler.InvokeUpdateToast(downgrade: true);
                    }
                    else if (updateCheckData.StatusCode == StatusCode.UnsupportedOperation || updateCheckData.StatusCode == StatusCode.Disabled)
                    {
                        ToastHandler.InvokeUpdateToast(downgrade: true, canUseUpdater: false);
                    }
                    SendResponse(updateCheckData.ToString());
                    break;
                    #endregion

                    #region Shutdown
                case Command.Shutdown:
                    Logger.Info("signal received, exiting");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    service.RequestExit(null, null);
                    break;
                    #endregion

                    #region Restart
                case Command.Restart:
                    Logger.Info("signal received, restarting");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    service.Restart(null, new ExitEventArgs(false));
                    break;
                    #endregion

                    #region TestError
                case Command.TestError:
                    Logger.Info("signal received: test error");
                    Thread.Sleep(5000);
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Err
                    }.ToString());
                    break;
                    #endregion

                    #region Alive
                case Command.Alive:
                    Logger.Info("signal received: request for running status");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region Light
                case Command.Light:
                    Logger.Info("signal received: force light theme");
                    state.ForcedTheme = Theme.Light;
                    ThemeHandler.EnforceNoMonitorUpdates(builder, state, Theme.Light);
                    ThemeManager.UpdateTheme(builder.Config, Theme.Light, new(SwitchSource.Manual));
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region Dark
                case Command.Dark:
                    Logger.Info("signal received: force dark theme");
                    state.ForcedTheme = Theme.Dark;
                    ThemeHandler.EnforceNoMonitorUpdates(builder, state, Theme.Dark);
                    ThemeManager.UpdateTheme(builder.Config, Theme.Dark, new(SwitchSource.Manual));
                    SendResponse(StatusCode.Ok);
                    break;
                    #endregion

                    #region NoForce
                case Command.NoForce:
                    Logger.Info("signal received: resetting forced modes");
                    state.ForcedTheme = Theme.Unknown;
                    ThemeManager.RequestSwitch(builder, new(SwitchSource.Manual));
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region DetectMonitors
                case Command.DetectMonitors:
                    Logger.Info("signal received: detecting new monitors");
                    DisplayHandler.DetectMonitors();
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region CleanMonitors
                case Command.CleanMonitors:
                    Logger.Info("signal received: removing disconnected monitors");
                    DisplayHandler.CleanUpMonitors();
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region UpdateFailed
                case Command.UpdateFailed:
                    Logger.Info("signal received: notify about failed update");
                    ToastHandler.InvokeFailedUpdateToast();
                    SendResponse(StatusCode.Ok);
                    break;
                    #endregion

                    #region TestNotifications
                case Command.TestNotifications:
                    Logger.Info("signal received: test notifications");
                    ToastHandler.InvokeUpdateInProgressToast("TestVersion");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region TestNotifications2
                case Command.TestNotifications2:
                    Logger.Info("signal received: test notifications");
                    //ToastHandler.InvokeUpdateToast(true, true);
                    //ToastHandler.RemoveUpdaterToast();
                    //ToastHandler.UpdateProgressToast("0.5", "test");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok
                    }.ToString());
                    break;
                    #endregion

                    #region Test
                case Command.Test:
                    ThemeFile tf = new(@"C:\Users\Sam\AppData\Local\Microsoft\Windows\Themes\solid_test.theme");
                    tf.Save();
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Ok,
                        Message    = "it works"
                    }.ToString());
                    break;
                    #endregion

                default:
                    Logger.Debug("unknown message received");
                    SendResponse(new ApiResponse()
                    {
                        StatusCode = StatusCode.Err,
                        Message    = "requested command does not exist"
                    }.ToString());
                    break;
                }
            });
        }