Return to SystemInfo.cs CVS log

Up to [cleanflash] / cleanflash / CleanFlashCommon

Annotation of cleanflash/CleanFlashCommon/SystemInfo.cs, revision 1.1.1.1

1.1       root        1: using System;
                      2: using System.Collections.Generic;
                      3: using System.IO;
                      4: 
                      5: namespace CleanFlashCommon {
                      6:     public class SystemInfo {
                      7: 
                      8:         private static string system32Path = Environment.GetFolderPath(Environment.SpecialFolder.SystemX86);
                      9:         private static string system64Path = Environment.GetFolderPath(Environment.SpecialFolder.System);
                     10:         private static string program32Path = Environment.GetEnvironmentVariable("PROGRAMFILES(X86)") ?? Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
                     11:         private static string flashProgram32Path = Path.Combine(program32Path, "Flash Player");
                     12:         private static string macromed32Path = Path.Combine(system32Path, "Macromed");
                     13:         private static string macromed64Path = Path.Combine(system64Path, "Macromed");
                     14:         private static string flash32Path = Path.Combine(macromed32Path, "Flash");
                     15:         private static string flash64Path = Path.Combine(macromed64Path, "Flash");
                     16:         private static string version = UpdateChecker.GetFlashVersion();
                     17:         private static string versionPath = version.Replace(".", "_");
                     18:         private static string versionComma = version.Replace(".", ",");
                     19:         private static Dictionary<string, string> replacementStrings = new Dictionary<string, string>() {
                     20:             { "${SYSTEM_32_PATH}", system32Path.Replace(@"\", @"\\") },
                     21:             { "${SYSTEM_64_PATH}", system64Path.Replace(@"\", @"\\") },
                     22:             { "${PROGRAM_32_PATH}", program32Path.Replace(@"\", @"\\") },
                     23:             { "${PROGRAM_FLASH_32_PATH}", flashProgram32Path.Replace(@"\", @"\\") },
                     24:             { "${FLASH_32_PATH}", flash32Path.Replace(@"\", @"\\") },
                     25:             { "${FLASH_64_PATH}", flash64Path.Replace(@"\", @"\\") },
                     26:             { "${VERSION}", version },
                     27:             { "${VERSION_PATH}", versionPath },
                     28:             { "${VERSION_COMMA}", versionComma },
                     29:             { "${ARCH}", Environment.Is64BitOperatingSystem ? "64" : "32" }
                     30:         };
                     31: 
                     32:         public static string GetSystem32Path() {
                     33:             return system32Path;
                     34:         }
                     35: 
                     36:         public static string GetSystem64Path() {
                     37:             return system64Path;
                     38:         }
                     39: 
                     40:         public static string GetProgram32Path()
                     41:         {
                     42:             return program32Path;
                     43:         }
                     44: 
                     45:         public static string GetProgramFlash32Path()
                     46:         {
                     47:             return flashProgram32Path;
                     48:         }
                     49: 
                     50:         public static string[] GetSystemPaths() {
                     51:             if (Environment.Is64BitOperatingSystem) {
                     52:                 return new string[] { system32Path, system64Path };
                     53:             } else {
                     54:                 return new string[] { system32Path };
                     55:             }
                     56:         }
                     57: 
                     58:         public static string GetMacromed32Path() {
                     59:             return macromed32Path;
                     60:         }
                     61: 
                     62:         public static string GetMacromed64Path() {
                     63:             return macromed64Path;
                     64:         }
                     65: 
                     66:         public static string[] GetMacromedPaths() {
                     67:             if (Environment.Is64BitOperatingSystem) {
                     68:                 return new string[] { macromed32Path, macromed64Path };
                     69:             } else {
                     70:                 return new string[] { macromed32Path };
                     71:             }
                     72:         }
                     73: 
                     74:         public static string GetFlash32Path() {
                     75:             return flash32Path;
                     76:         }
                     77: 
                     78:         public static string GetFlash64Path() {
                     79:             return flash64Path;
                     80:         }
                     81: 
                     82:         public static string GetVersionPath() {
                     83:             return versionPath;
                     84:         }
                     85: 
                     86:         public static bool IsLegacyWindows() {
                     87:             System.Version version = Environment.OSVersion.Version;
                     88: 
                     89:             return version.Major <= 6 && (version.Major != 6 || version.Minor < 2);
                     90:         }
                     91: 
                     92:         public static Dictionary<string, string> GetReplacementStrings() {
                     93:             return replacementStrings;
                     94:         }
                     95: 
                     96:         public static string FillString(string str) {
                     97:             // Some registry values require special strings to be filled out.
                     98:             foreach (KeyValuePair<string, string> pair in replacementStrings) {
                     99:                 str = str.Replace(pair.Key, pair.Value);
                    100:             }
                    101: 
                    102:             return str;
                    103:         }
                    104:     }
                    105: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.