├── SciLorsMashedRunnerv4.jpg
├── tmp
    └── SciLorsEmptyVideo.mpg
├── VersionMashed.cs
├── Version.cs
├── Properties
    ├── Settings.settings
    ├── AssemblyInfo.cs
    ├── Settings.Designer.cs
    ├── Resources.Designer.cs
    └── Resources.resx
├── .github
    └── FUNDING.yml
├── IconFile.cs
├── Language.cs
├── Program.cs
├── app.config
├── Settings.cs
├── Util.cs
├── VersionMFL.cs
├── ByteMask.cs
├── README.md
├── Intro.cs
├── SearchAndReplace.cs
├── SciLor's Mashed Runner.csproj
├── Mashed.cs
├── frmMashed.resx
├── .gitignore
├── frmMashed.cs
└── frmMashed.Designer.cs


/SciLorsMashedRunnerv4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SciLor/MashedRunner/master/SciLorsMashedRunnerv4.jpg


--------------------------------------------------------------------------------
/tmp/SciLorsEmptyVideo.mpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SciLor/MashedRunner/master/tmp/SciLorsEmptyVideo.mpg


--------------------------------------------------------------------------------
/VersionMashed.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     public class VersionMashed : VersionMFL {
 7 |         public override string NAME() {
 8 |             return "Mashed";
 9 |         }
10 |         public override string EXE() {
11 |             return "Mashed.exe";
12 |         }
13 |         public override string REGISTRY_SUBKEY() {
14 |             return "Mashed";
15 |         }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Version.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     public abstract class Version {
 7 |         public abstract string NAME();
 8 |         public abstract string EXE();
 9 |         public abstract string LAUNCHER();
10 |         public abstract string REGISTRY_BASE();
11 |         public abstract string REGISTRY_SUBKEY();
12 | 
13 |         public abstract ByteMask[] NOCD_SEARCH();
14 |         public abstract ByteMask[] NOCD_REPLACE();
15 | 
16 |         public bool EXE_EXISTS() {
17 |             return System.IO.File.Exists(Util.GetMashedDir() + EXE());
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/Properties/Settings.settings:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='utf-8'?>
 2 | <SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)" GeneratedClassNamespace="SciLor_s_Mashed_Runner.Properties" GeneratedClassName="Settings">
 3 |   <Profiles />
 4 |   <Settings>
 5 |     <Setting Name="Language" Type="System.Int32" Scope="User">
 6 |       <Value Profile="(Default)">1</Value>
 7 |     </Setting>
 8 |     <Setting Name="Path" Type="System.String" Scope="User">
 9 |       <Value Profile="(Default)" />
10 |     </Setting>
11 |     <Setting Name="Icon" Type="System.String" Scope="User">
12 |       <Value Profile="(Default)" />
13 |     </Setting>
14 |   </Settings>
15 | </SettingsFile>


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: SciLor # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | 


--------------------------------------------------------------------------------
/IconFile.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | using System.IO;
 5 | 
 6 | namespace SciLor_s_Mashed_Runner {
 7 |     public class IconFile {
 8 |         public String path;
 9 |         public IconFile(String path) {
10 |             this.path = path;
11 |         }
12 |         public override string ToString() {
13 |             string filename = Path.GetFileNameWithoutExtension(path);
14 |             filename = filename.Substring(3);
15 |             return filename;
16 |         }
17 |         public override bool Equals(object obj) {
18 |             if (!(obj is IconFile)) return false;
19 |             IconFile icon = (IconFile)obj;
20 |             if (icon.path != this.path) return false;
21 |             return true;
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Language.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     public class Language {
 7 |         private String name;
 8 |         private String nameEnglish;
 9 | 
10 |         private int id;
11 |         public int Id {
12 |             get { return id; }
13 |         }
14 |         private String identifier;
15 |         public String Identifier {
16 |             get { return identifier; }
17 |         }
18 | 
19 |         public Language(String name, String nameEnglish, String identifier, int id) {
20 |             this.name = name;
21 |             this.nameEnglish = nameEnglish;
22 |             this.id = id;
23 |             this.identifier = identifier;
24 |         }
25 | 
26 |         public override string ToString() {
27 |             return name + " (" + nameEnglish + ")";
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Windows.Forms;
 4 | using System.Diagnostics;
 5 | 
 6 | namespace SciLor_s_Mashed_Runner {
 7 |     static class Program {
 8 |         /// <summary>
 9 |         /// The main entry point for the application.
10 |         /// </summary>
11 |         [STAThread]
12 |         static void Main(String[] args) {
13 |             /*
14 |             if (args.Length == 1) {
15 |                 if (args[0] == "-fix") {
16 |                     Process.Start(Application.ExecutablePath);
17 |                     Application.Exit();
18 |                     return;
19 |                 } else if (args[0] == "-registry") {
20 |                     frmMashed.setRegistry = true;
21 |                 }
22 |             }
23 |              * */
24 | 
25 |             Application.EnableVisualStyles();
26 |             Application.SetCompatibleTextRenderingDefault(false);
27 |             Application.Run(new frmMashed());
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/app.config:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8" ?>
 2 | <configuration>
 3 |     <configSections>
 4 |         <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
 5 |             <section name="SciLor_s_Mashed_Runner.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
 6 |         </sectionGroup>
 7 |     </configSections>
 8 |     <userSettings>
 9 |         <SciLor_s_Mashed_Runner.Properties.Settings>
10 |             <setting name="Language" serializeAs="String">
11 |                 <value>1</value>
12 |             </setting>
13 |             <setting name="Path" serializeAs="String">
14 |                 <value />
15 |             </setting>
16 |             <setting name="Icon" serializeAs="String">
17 |                 <value />
18 |             </setting>
19 |         </SciLor_s_Mashed_Runner.Properties.Settings>
20 |     </userSettings>
21 | </configuration>


--------------------------------------------------------------------------------
/Settings.cs:
--------------------------------------------------------------------------------
 1 | namespace SciLor_s_Mashed_Runner.Properties {
 2 |     
 3 |     
 4 |     // This class allows you to handle specific events on the settings class:
 5 |     //  The SettingChanging event is raised before a setting's value is changed.
 6 |     //  The PropertyChanged event is raised after a setting's value is changed.
 7 |     //  The SettingsLoaded event is raised after the setting values are loaded.
 8 |     //  The SettingsSaving event is raised before the setting values are saved.
 9 |     internal sealed partial class Settings {
10 |         
11 |         public Settings() {
12 |             // // To add event handlers for saving and changing settings, uncomment the lines below:
13 |             //
14 |             // this.SettingChanging += this.SettingChangingEventHandler;
15 |             //
16 |             // this.SettingsSaving += this.SettingsSavingEventHandler;
17 |             //
18 |         }
19 |         
20 |         private void SettingChangingEventHandler(object sender, System.Configuration.SettingChangingEventArgs e) {
21 |             // Add code to handle the SettingChangingEvent event here.
22 |         }
23 |         
24 |         private void SettingsSavingEventHandler(object sender, System.ComponentModel.CancelEventArgs e) {
25 |             // Add code to handle the SettingsSaving event here.
26 |         }
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following 
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("SciLor's Mashed Runner")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("SciLor's Mashed Runner")]
13 | [assembly: AssemblyCopyright("Copyright ©  2011")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible 
18 | // to COM components.  If you need to access a type in this assembly from 
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("b5a2c1f7-625e-4297-bdfe-ce8952b29af5")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version 
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers 
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/Util.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | using System.IO;
 5 | using System.Security.Principal;
 6 | using System.Runtime.InteropServices;
 7 | using System.Windows.Forms;
 8 | 
 9 | namespace SciLor_s_Mashed_Runner {
10 |     class Util {
11 |         [DllImport("user32")]
12 |         public static extern UInt32 SendMessage(IntPtr hWnd, UInt32 msg, UInt32 wParam, UInt32 lParam);
13 |         private const uint BCM_SETSHIELD = 0x0000160C;
14 | 
15 |         public static String GetExePath() {
16 |             String path = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;
17 |             if (path.StartsWith("file:///")) {
18 |                 path = path.Substring("file:///".Length);
19 |             }
20 |             path = path.Replace('/', '\\');
21 |             return path;
22 |         }
23 |         public static String GetExeDir() {
24 |             return Path.GetDirectoryName(GetExePath());
25 |         }
26 |         public static String GetMashedDir() {
27 |             return Properties.Settings.Default.Path;
28 |         }
29 |         public static bool IsAnAdministrator() {
30 |             WindowsIdentity identity = WindowsIdentity.GetCurrent();
31 |             WindowsPrincipal principal = new WindowsPrincipal(identity);
32 |             return principal.IsInRole(WindowsBuiltInRole.Administrator);
33 |         }
34 |         public static void setUAC(Button btn) {
35 |             btn.FlatStyle = FlatStyle.System;
36 |             SendMessage(btn.Handle, BCM_SETSHIELD, 0, 1);
37 |         }
38 | 
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/VersionMFL.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     public class VersionMFL : Version {
 7 | 
 8 |         public override string NAME() {
 9 |             return "Mashed Fully Loaded";
10 |         }
11 | 
12 |         public override string EXE() {
13 |             return "MFL.exe";
14 |         }
15 | 
16 |         public override string LAUNCHER() {
17 |             return "launch.exe";
18 |         }
19 | 
20 |         public override string REGISTRY_BASE() {
21 |             return "empire interactive";
22 |         }
23 | 
24 |         public override string REGISTRY_SUBKEY() {
25 |             return "mfl";
26 |         }
27 | 
28 |         public override ByteMask[] NOCD_SEARCH() {
29 |             return new ByteMask[] {
30 |                 new ByteMask("FF 90 0C 07 00 00 3B C3 7D 12 68 0C 07 00 00 68 ?? 43 4E 00 56 50 FF 15 50 10 40 00 83 C8 FF 66"), //Messagebox 
31 |                 new ByteMask("0F 85 54 02 00 00 8B 17 8B 3D 40 10 40 00 52 68 ?? 49 4E 00 66 89 86 A8 00 00 00 FF D7 8B D0 8D"), //Do not run
32 |                                    };
33 |         }
34 | 
35 |         public override ByteMask[] NOCD_REPLACE() {
36 |             return new ByteMask[] {
37 |                 new ByteMask("90 ?? 90 90 90 90 ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ??"), //NOP it out ;)
38 |                 new ByteMask("EB 04 90 90 90 90 ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ??"), //JMP always :P
39 |                                    };
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/ByteMask.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Text;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     public class ByteMask {
 7 |         private byte[] pattern;
 8 |         public byte[] Pattern {
 9 |             get { return pattern; }
10 |         }
11 |         private bool[] mask;
12 |         public bool[] Mask {
13 |             get { return mask; }
14 |         }
15 | 
16 |         private String maskString;
17 |         private string p;
18 | 
19 |         public ByteMask(String maskString) {
20 |             this.maskString = maskString;
21 |             this.pattern = stringToPattern(maskString);
22 |             this.mask = stringToMask(maskString);
23 |         }
24 | 
25 |         private byte[] stringToPattern(String pattern) {
26 |             String[] byteText = pattern.Split(' ');
27 |             byte[] bytes = new byte[byteText.Length];
28 | 
29 |             for (int i = 0; i < byteText.Length; i++) {
30 |                 String text = byteText[i];
31 |                 if (text != "??") {
32 |                     bytes[i] = byte.Parse(text, System.Globalization.NumberStyles.HexNumber);
33 |                 } else {
34 |                     bytes[i] = 0;
35 |                 }
36 |             }
37 |             return bytes;
38 |         }
39 |         private bool[] stringToMask(String pattern) {
40 |             String[] byteText = pattern.Split(' ');
41 |             bool[] bytes = new bool[byteText.Length];
42 | 
43 |             for (int i = 0; i < byteText.Length; i++) {
44 |                 String text = byteText[i];
45 |                 if (text != "??") {
46 |                     bytes[i] = true;
47 |                 } else {
48 |                     bytes[i] = false;
49 |                 }
50 |             }
51 |             return bytes;
52 |         }
53 | 
54 |         public int Length() {
55 |             return this.pattern.Length;
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Properties/Settings.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.237
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace SciLor_s_Mashed_Runner.Properties {
12 |     
13 |     
14 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
15 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "10.0.0.0")]
16 |     internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
17 |         
18 |         private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
19 |         
20 |         public static Settings Default {
21 |             get {
22 |                 return defaultInstance;
23 |             }
24 |         }
25 |         
26 |         [global::System.Configuration.UserScopedSettingAttribute()]
27 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
28 |         [global::System.Configuration.DefaultSettingValueAttribute("1")]
29 |         public int Language {
30 |             get {
31 |                 return ((int)(this["Language"]));
32 |             }
33 |             set {
34 |                 this["Language"] = value;
35 |             }
36 |         }
37 |         
38 |         [global::System.Configuration.UserScopedSettingAttribute()]
39 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
40 |         [global::System.Configuration.DefaultSettingValueAttribute("")]
41 |         public string Path {
42 |             get {
43 |                 return ((string)(this["Path"]));
44 |             }
45 |             set {
46 |                 this["Path"] = value;
47 |             }
48 |         }
49 |         
50 |         [global::System.Configuration.UserScopedSettingAttribute()]
51 |         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
52 |         [global::System.Configuration.DefaultSettingValueAttribute("")]
53 |         public string Icon {
54 |             get {
55 |                 return ((string)(this["Icon"]));
56 |             }
57 |             set {
58 |                 this["Icon"] = value;
59 |             }
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # SciLor's Mashed Runner v5
 2 | 
 3 | ![Screenshot](https://raw.githubusercontent.com/SciLor/MashedRunner/master/SciLorsMashedRunnerv4.jpg)
 4 | 
 5 | ## Sidenode
 6 | [Mashed Fully Loaded Trainer](https://github.com/SciLor/MashedTrainer)
 7 | 
 8 | ## ReadMe
 9 | 
10 | You will need the .NET Framework 2.0
11 | http://www.microsoft.com/download/en/details.aspx?id=19
12 | 
13 | SciLor's Mashed Runner allows you to run Mashed Fully Loaded and Mashed ;).
14 | 
15 | It bypasses the launcher of the game, so you can run the game without installation and any cd.
16 | This way you may just copy the game onto an usb-stick and play it anywhere.
17 | 
18 | Additionally you can select the game's language, disable the intros and create a shortcut on your desktop for this launcher
19 | with the click of a button.
20 | 
21 | ## Additional
22 | This is no crack, nocd or how you want to call it. The game implements the copy protection in the launcher (launch.exe),
23 | but the game is in the "MFL.exe"/"MASHED.exe". The launcher runs the "MFL.exe"/"MASHED.exe" with different command line parameters,
24 | that define the language and if it should show the settings.
25 | If you run the "MFL.exe" directly the game will run in english and prompt for video/control settings on every statup.
26 | 
27 | This application replaces the launcher and runs the "MFL.exe"/"MASHED.exe" with the fitting parameters.
28 | 
29 | ## Known Bugs
30 | 
31 | If you like my hard work PLEASE DONATE! :)
32 | http://www.scilor.com/donate.html
33 | 
34 | ## ChangeLog
35 | 
36 | ### v5(2012-03-21)
37 | - New: The old version of Mashed is now also supported (The one before Fully Loaded)
38 | 
39 | ### v4(2012-01-14)
40 | - Fix: Wrong language Portuese -> Italiano
41 | - Fix: Various Errors.
42 | - Enhancement: Create Registry entries if the game is not installed.
43 | - Enhancement: NoCD Patch for the original launch.exe.
44 | 	There was any need for that, more or less interesting for people that want to write patches.
45 | 	Just take a look at the source, especially the "SearchAndReplace.cs"
46 | 	that implements the Search and Replace Engine of the dup2 patcher, so you can use its generated patterns
47 | - Enhancement: Run launch.exe.
48 | 
49 | ### v3(2011-12-23)
50 | - Fix: Disabled looking comboboxes after using settings
51 | - Fix: Low quality taskbar icon, when using a shortcut.
52 | - Enhancement: Source code design, some classes etc.
53 | 
54 | ### v2(2011-12-22)
55 | - Feature: Disable Intro videos
56 | - Enhancement: Less IO usage
57 | 
58 | ### v1(2011-12-21)
59 | - Initial Release
60 | 
61 | 
62 | ## Web
63 | My Website: http://www.scilor.com/
64 | 
65 | SciLor's Mashed Runner Website: http://www.scilor.com/mashed-runner.html
66 | 
67 | Donation: http://www.scilor.com/donate.html
68 | 


--------------------------------------------------------------------------------
/Intro.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Reflection;
 4 | 
 5 | namespace SciLor_s_Mashed_Runner {
 6 |     class Intro {
 7 |         public static void Enable() {
 8 |             String path = Properties.Settings.Default.Path + Mashed.BASE_VIDEO_DIR;
 9 |             if (!Directory.Exists(path) || !Directory.Exists(path + "backup")) {
10 |                 return;
11 |             }
12 | 
13 |             DirectoryInfo dir = new DirectoryInfo(path);
14 |             foreach (FileInfo file in dir.GetFiles()) {
15 |                 String tmp = path + "backup" + "\\" + file.Name;
16 |                 if (System.IO.File.Exists(tmp)) {
17 |                     file.Delete();
18 |                     System.IO.File.Move(tmp, file.FullName);
19 |                 }
20 |             }
21 |             Directory.Delete(path + "backup", true);
22 |         }
23 | 
24 |         public static void Disable() {
25 |             String path = Properties.Settings.Default.Path + Mashed.BASE_VIDEO_DIR;
26 |             if (!Directory.Exists(path)) {
27 |                 return;
28 |             }
29 | 
30 |             Stream resStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(
31 |                 "SciLor_s_Mashed_Runner.tmp.SciLorsEmptyVideo.mpg");
32 |             FileStream fileStream = new FileStream(Path.GetDirectoryName(Util.GetExePath()) + "\\" + Mashed.EMPTY_VIDEO,
33 |                 FileMode.Create);
34 | 
35 |             int read = 1;
36 |             byte[] buffer = new byte[1024];
37 |             while (read > 0) {
38 |                 read = resStream.Read(buffer, 0, buffer.Length);
39 |                 fileStream.Write(buffer, 0, read);
40 |             }
41 | 
42 |             resStream.Close();
43 |             fileStream.Flush();
44 |             fileStream.Close();
45 | 
46 |             if (!Directory.Exists(path + "backup"))
47 |                 Directory.CreateDirectory(path + "backup");
48 | 
49 |             DirectoryInfo dir = new DirectoryInfo(path);
50 |             foreach (FileInfo file in dir.GetFiles()) {
51 |                 bool active = false;
52 |                 foreach (String allowed in Mashed.VIDEO_NAMES) {
53 |                     if (file.Name == allowed) {
54 |                         active = true;
55 |                         break;
56 |                     }
57 |                 }
58 |                 if (!active) continue;
59 | 
60 |                 String tmp = path + "backup" + "\\" + file.Name;
61 |                 String old = file.FullName;
62 | 
63 |                 if (System.IO.File.Exists(tmp))
64 |                     System.IO.File.Delete(tmp);
65 |                 file.MoveTo(tmp);
66 |                 System.IO.File.Copy(Path.GetDirectoryName(Util.GetExePath()) + "\\" + Mashed.EMPTY_VIDEO, old);
67 |             }
68 | 
69 |             System.IO.File.Delete(Path.GetDirectoryName(Util.GetExePath()) + "\\" + Mashed.EMPTY_VIDEO);
70 |         }
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.237
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace SciLor_s_Mashed_Runner.Properties {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     public class Resources {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal Resources() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         public static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("SciLor_s_Mashed_Runner.Properties.Resources", typeof(Resources).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         public static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/SearchAndReplace.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Text;
  4 | using System.Runtime.InteropServices;
  5 | using System.IO;
  6 | 
  7 | namespace SciLor_s_Mashed_Runner {
  8 | 
  9 |     class SearchAndReplace {
 10 | 
 11 |         public static bool SearchNReplace(String file, ByteMask[] searchPattern, ByteMask[] replacePattern) {
 12 |             bool patched = false;
 13 |             if (File.Exists(file + ".bak") || File.Exists(file + ".tmp")) return false;
 14 |             if (searchPattern.Length != replacePattern.Length) return false;
 15 | 
 16 |             int length = 0;
 17 |             foreach (ByteMask byteMask in searchPattern) {
 18 |                 length = Math.Max(length, byteMask.Length());
 19 |             }
 20 | 
 21 | 
 22 |             File.Copy(file, file + ".bak");
 23 |             File.Delete(file);
 24 | 
 25 |             FileStream fread = File.OpenRead(file + ".bak");
 26 |             if (fread.Length < length) {
 27 |                 fread.Close();
 28 |                 File.Copy(file + ".bak", file);
 29 |                 File.Delete(file + ".bak");
 30 |                 return false;
 31 |             }
 32 |             FileStream fwrite = File.OpenWrite(file + ".tmp");
 33 | 
 34 |             byte[] buffer = new byte[length];
 35 | 
 36 |             int filled = 0;
 37 |             while (filled < buffer.Length) {
 38 |                 buffer[filled] = (byte)fread.ReadByte();
 39 |                 filled++;
 40 |             }
 41 | 
 42 |             while (fread.Position < fread.Length) {
 43 |                 patched = replacePatterns(ref buffer, searchPattern, replacePattern) || patched;
 44 |                 fwrite.WriteByte(buffer[0]);
 45 |                 buffer = moveOne(buffer);
 46 |                 buffer[buffer.Length - 1] = (byte)fread.ReadByte();
 47 |             }
 48 |             fread.Close();
 49 |             patched = replacePatterns(ref buffer, searchPattern, replacePattern) || patched;
 50 | 
 51 |             for (int i = 0; i<buffer.Length; i++) {
 52 |                 fwrite.WriteByte(buffer[i]);
 53 |             }
 54 |             fwrite.Close();
 55 | 
 56 |             File.Copy(file + ".tmp", file);
 57 |             File.Delete(file + ".tmp");
 58 |             return patched;
 59 |         }
 60 | 
 61 |         private static bool isSame(byte[] buffer, ByteMask search) {
 62 |             for (int i=0; i<search.Length(); i++) {
 63 |                 if (!search.Mask[i]) continue;
 64 |                 if (buffer[i] != search.Pattern[i]) return false;
 65 |             }
 66 |             return true;
 67 |         }
 68 |         private static byte[] replaceBuffer(byte[] buffer, ByteMask replace) {
 69 |             byte[] replacedBuffer = new byte[buffer.Length];
 70 |             for (int i=0; i<replace.Length(); i++) {
 71 |                 if (replace.Mask[i]) {
 72 |                     replacedBuffer[i] = replace.Pattern[i];
 73 |                 } else {
 74 |                     replacedBuffer[i] = buffer[i];
 75 |                 }
 76 |             }
 77 |             return replacedBuffer;
 78 |         }
 79 |         private static bool replacePatterns(ref byte[] buffer, ByteMask[] search, ByteMask[] replace) {
 80 |             for (int i = 0; i < search.Length; i++) {
 81 |                 if (isSame(buffer, search[i])) {
 82 |                     buffer = replaceBuffer(buffer, replace[i]);
 83 |                     return true;
 84 |                 }
 85 |             }
 86 |             return false;
 87 |         }
 88 | 
 89 |         private static byte[] moveOne(byte[] buffer) {
 90 |             byte[] tmp = new byte[buffer.Length];
 91 |             for (int i = 1; i < buffer.Length; i++) {
 92 |                 tmp[i - 1] = buffer[i];
 93 |             }
 94 |             return tmp;
 95 |         }
 96 | 
 97 |         public static bool PatchLauncher(String path, ByteMask[] search, ByteMask[] replace) {
 98 |             return SearchNReplace(path,
 99 |                     search,
100 |                     replace);
101 |         }
102 |         public static void RevertLauncher(String path) {
103 |             File.Copy(path + ".bak", path);
104 |             File.Delete(path + ".bak");
105 |         }
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/SciLor's Mashed Runner.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <PropertyGroup>
  4 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  5 |     <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
  6 |     <ProductVersion>8.0.30703</ProductVersion>
  7 |     <SchemaVersion>2.0</SchemaVersion>
  8 |     <ProjectGuid>{469A08C3-2C68-41B4-A6F6-50281956586F}</ProjectGuid>
  9 |     <OutputType>WinExe</OutputType>
 10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 11 |     <RootNamespace>SciLor_s_Mashed_Runner</RootNamespace>
 12 |     <AssemblyName>SciLors Mashed Runner</AssemblyName>
 13 |     <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
 14 |     <FileAlignment>512</FileAlignment>
 15 |   </PropertyGroup>
 16 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
 17 |     <PlatformTarget>x86</PlatformTarget>
 18 |     <DebugSymbols>true</DebugSymbols>
 19 |     <DebugType>full</DebugType>
 20 |     <Optimize>false</Optimize>
 21 |     <OutputPath>bin\Debug\</OutputPath>
 22 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 23 |     <ErrorReport>prompt</ErrorReport>
 24 |     <WarningLevel>4</WarningLevel>
 25 |   </PropertyGroup>
 26 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
 27 |     <PlatformTarget>x86</PlatformTarget>
 28 |     <DebugType>pdbonly</DebugType>
 29 |     <Optimize>true</Optimize>
 30 |     <OutputPath>bin\Release\</OutputPath>
 31 |     <DefineConstants>TRACE</DefineConstants>
 32 |     <ErrorReport>prompt</ErrorReport>
 33 |     <WarningLevel>4</WarningLevel>
 34 |   </PropertyGroup>
 35 |   <ItemGroup>
 36 |     <Reference Include="System" />
 37 |     <Reference Include="System.Data" />
 38 |     <Reference Include="System.Deployment" />
 39 |     <Reference Include="System.Drawing" />
 40 |     <Reference Include="System.Windows.Forms" />
 41 |     <Reference Include="System.Xml" />
 42 |   </ItemGroup>
 43 |   <ItemGroup>
 44 |     <Compile Include="ByteMask.cs" />
 45 |     <Compile Include="frmMashed.cs">
 46 |       <SubType>Form</SubType>
 47 |     </Compile>
 48 |     <Compile Include="frmMashed.Designer.cs">
 49 |       <DependentUpon>frmMashed.cs</DependentUpon>
 50 |     </Compile>
 51 |     <Compile Include="IconFile.cs" />
 52 |     <Compile Include="Intro.cs" />
 53 |     <Compile Include="Language.cs" />
 54 |     <Compile Include="Mashed.cs" />
 55 |     <Compile Include="Program.cs" />
 56 |     <Compile Include="Properties\AssemblyInfo.cs" />
 57 |     <Compile Include="SearchAndReplace.cs" />
 58 |     <Compile Include="Settings.cs" />
 59 |     <Compile Include="Util.cs" />
 60 |     <Compile Include="Version.cs" />
 61 |     <Compile Include="VersionMashed.cs" />
 62 |     <Compile Include="VersionMFL.cs" />
 63 |     <EmbeddedResource Include="frmMashed.resx">
 64 |       <DependentUpon>frmMashed.cs</DependentUpon>
 65 |     </EmbeddedResource>
 66 |     <EmbeddedResource Include="Properties\Resources.resx">
 67 |       <Generator>PublicResXFileCodeGenerator</Generator>
 68 |       <LastGenOutput>Resources.Designer.cs</LastGenOutput>
 69 |       <SubType>Designer</SubType>
 70 |     </EmbeddedResource>
 71 |     <Compile Include="Properties\Resources.Designer.cs">
 72 |       <AutoGen>True</AutoGen>
 73 |       <DependentUpon>Resources.resx</DependentUpon>
 74 |       <DesignTime>True</DesignTime>
 75 |     </Compile>
 76 |     <None Include="app.config" />
 77 |     <None Include="Properties\Settings.settings">
 78 |       <Generator>SettingsSingleFileGenerator</Generator>
 79 |       <LastGenOutput>Settings.Designer.cs</LastGenOutput>
 80 |     </None>
 81 |     <Compile Include="Properties\Settings.Designer.cs">
 82 |       <AutoGen>True</AutoGen>
 83 |       <DependentUpon>Settings.settings</DependentUpon>
 84 |       <DesignTimeSharedInput>True</DesignTimeSharedInput>
 85 |     </Compile>
 86 |   </ItemGroup>
 87 |   <ItemGroup>
 88 |     <COMReference Include="IWshRuntimeLibrary">
 89 |       <Guid>{F935DC20-1CF0-11D0-ADB9-00C04FD58A0B}</Guid>
 90 |       <VersionMajor>1</VersionMajor>
 91 |       <VersionMinor>0</VersionMinor>
 92 |       <Lcid>0</Lcid>
 93 |       <WrapperTool>tlbimp</WrapperTool>
 94 |       <Isolated>False</Isolated>
 95 |       <EmbedInteropTypes>True</EmbedInteropTypes>
 96 |     </COMReference>
 97 |   </ItemGroup>
 98 |   <ItemGroup>
 99 |     <EmbeddedResource Include="tmp\SciLorsEmptyVideo.mpg" />
100 |   </ItemGroup>
101 |   <ItemGroup>
102 |     <ProjectReference Include="..\SciLors AppRunner\SciLors AppRunner.csproj">
103 |       <Project>{2452F916-FC0D-405A-97C7-4E17991CDE49}</Project>
104 |       <Name>SciLors AppRunner</Name>
105 |     </ProjectReference>
106 |   </ItemGroup>
107 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
108 |   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
109 |        Other similar extension points exist, see Microsoft.Common.targets.
110 |   <Target Name="BeforeBuild">
111 |   </Target>
112 |   <Target Name="AfterBuild">
113 |   </Target>
114 |   -->
115 | </Project>


--------------------------------------------------------------------------------
/Mashed.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Text;
  4 | using System.Windows.Forms;
  5 | using System.Diagnostics;
  6 | using System.Runtime.InteropServices;
  7 | using Microsoft.Win32;
  8 | using System.Security.Permissions;
  9 | using System.Security;
 10 | 
 11 | namespace SciLor_s_Mashed_Runner {
 12 |     class Mashed {
 13 | 
 14 |         public static Version version = null;
 15 | 
 16 |         [DllImport("user32.dll")]
 17 |         private static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);
 18 | 
 19 |         public const String EMPTY_VIDEO = "SciLorsEmptyVideo.mpg";
 20 |         public const String BASE_VIDEO_DIR = @"TOASTART\PC\MOVIES\";
 21 |         public static String[] VIDEO_NAMES = { 
 22 |                                                   "empire.mpg",
 23 |                                                   "intro.mpg",
 24 |                                                   "renderware.mpg",
 25 |                                                   "small.mpg",
 26 |                                                   "supersonic.mpg"
 27 |                                               };
 28 | 
 29 |         public const String SAVE = ""; //@"save\";
 30 | 
 31 |         public static IconFile[] ICOS = {
 32 |             new IconFile(@"TOASTART\Common\PANEL\NFLRed.png"),
 33 |             new IconFile(@"TOASTART\Common\PANEL\NFLBluejay.png"),
 34 |             new IconFile(@"TOASTART\Common\PANEL\NFLGold.png"),
 35 |             new IconFile(@"TOASTART\Common\PANEL\NFLMelon.png"),
 36 |             new IconFile(@"TOASTART\Common\PANEL\NFLPink.png"),
 37 |             new IconFile(@"TOASTART\Common\PANEL\NFLShadow.png"),
 38 |                                               };
 39 | 
 40 |         public const String ICO = @"TOASTART\Common\PANEL\NFLRed.png";
 41 |         public const String ICO_SMALL = "mashed.ICO";
 42 |        
 43 |         public static void Run(bool video, bool control, bool exit, frmMashed form) { //-VS0 -CS0 -L1
 44 |             if (!checkExe()) return;
 45 |             form.Enabled = false;
 46 |             //form.WindowState = FormWindowState.Minimized;
 47 | 
 48 |             int lang = 0;
 49 |             if (form.cmbLanguage.SelectedItem != null) {
 50 |                 Language langObj = (Language)form.cmbLanguage.SelectedItem;
 51 |                 lang = langObj.Id;
 52 |             }
 53 | 
 54 |             Process p = new Process();
 55 |             p.StartInfo.FileName = Properties.Settings.Default.Path + version.EXE();
 56 |             p.StartInfo.Arguments = "-VS" + bool2int(video) + " " + "-CS" + bool2int(control) + " " + "-L" + lang;
 57 |             p.StartInfo.WorkingDirectory = Properties.Settings.Default.Path + Mashed.SAVE;
 58 |             p.Start();
 59 | 
 60 |             if (exit) {
 61 |                 form.Close();
 62 |                 Application.Exit();
 63 |             } else {
 64 |                 p.WaitForExit();
 65 |                 form.Enabled = true;
 66 |                 form.Refresh();
 67 |                 if (form.WindowState != FormWindowState.Minimized) 
 68 |                     form.WindowState = FormWindowState.Minimized;
 69 |                 //form.WindowState = FormWindowState.Normal;
 70 |                 SwitchToThisWindow(form.Handle, true);
 71 |                 form.Show();
 72 | 
 73 |             }
 74 |         }
 75 |         private static int bool2int(bool value) {
 76 |             if (value) return 1;
 77 |             return 0;
 78 |         }
 79 | 
 80 |         private static RegistryKey getRegistryBase(String subkey) {
 81 |             RegistryKey baseKey = Registry.LocalMachine.OpenSubKey("Software", true);
 82 |             return baseKey.CreateSubKey(version.REGISTRY_BASE()).CreateSubKey(subkey);
 83 |         }
 84 |         private static bool setRegistryInstallation(String path, RegistryKey key) {
 85 |             try {
 86 |                 key.DeleteValue("installpath", false);
 87 |                 key.SetValue("installpath", path, RegistryValueKind.String);
 88 |                 key.DeleteValue("installstatus", false);
 89 |                 key.SetValue("installstatus", "2", RegistryValueKind.String);
 90 | 
 91 |                 key.Close();
 92 |                 return true;
 93 |             } catch (SecurityException) {}
 94 |             return false;
 95 |         }
 96 |         public static bool setRegistryInstallation(String path) {
 97 |             bool fine = false;
 98 |             fine = setRegistryInstallation(path, getRegistryBase(version.REGISTRY_SUBKEY()));
 99 |             return fine;
100 |         }
101 |         public static bool setRegistryLanguage(Language lang, RegistryKey key) {
102 |             try {
103 |                 key.SetValue("language", lang.Identifier, RegistryValueKind.String);
104 |                 key.Close();
105 |             } catch (SecurityException) { }
106 |             return false;
107 |         }
108 |         public static bool setRegistryLanguage(Language lang) {
109 |             bool fine = false;
110 |             fine = setRegistryLanguage(lang, getRegistryBase(version.REGISTRY_SUBKEY()));
111 |             return fine;
112 |         }
113 | 
114 |         public static bool checkExe() {
115 |             if (!System.IO.File.Exists(Util.GetMashedDir() + version.EXE())) {
116 |                 MessageBox.Show(version.EXE() + " " + "not found" + "\r\n" +
117 |                     "Please copy this application into the " + version.NAME() + " directory" + "\r\n" +
118 |                     "or select the right path to its executable.",
119 |                     "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
120 |                 return false;
121 |             }
122 |             return true;
123 |         }
124 |     }
125 | }
126 | 


--------------------------------------------------------------------------------
/frmMashed.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 | </root>


--------------------------------------------------------------------------------
/Properties/Resources.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 | </root>


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.suo
  8 | *.user
  9 | *.userosscache
 10 | *.sln.docstates
 11 | 
 12 | # User-specific files (MonoDevelop/Xamarin Studio)
 13 | *.userprefs
 14 | 
 15 | # Build results
 16 | [Dd]ebug/
 17 | [Dd]ebugPublic/
 18 | [Rr]elease/
 19 | [Rr]eleases/
 20 | x64/
 21 | x86/
 22 | bld/
 23 | [Bb]in/
 24 | [Oo]bj/
 25 | [Ll]og/
 26 | 
 27 | # Visual Studio 2015 cache/options directory
 28 | .vs/
 29 | # Uncomment if you have tasks that create the project's static files in wwwroot
 30 | #wwwroot/
 31 | 
 32 | # MSTest test Results
 33 | [Tt]est[Rr]esult*/
 34 | [Bb]uild[Ll]og.*
 35 | 
 36 | # NUNIT
 37 | *.VisualState.xml
 38 | TestResult.xml
 39 | 
 40 | # Build Results of an ATL Project
 41 | [Dd]ebugPS/
 42 | [Rr]eleasePS/
 43 | dlldata.c
 44 | 
 45 | # .NET Core
 46 | project.lock.json
 47 | project.fragment.lock.json
 48 | artifacts/
 49 | **/Properties/launchSettings.json
 50 | 
 51 | *_i.c
 52 | *_p.c
 53 | *_i.h
 54 | *.ilk
 55 | *.meta
 56 | *.obj
 57 | *.pch
 58 | *.pdb
 59 | *.pgc
 60 | *.pgd
 61 | *.rsp
 62 | *.sbr
 63 | *.tlb
 64 | *.tli
 65 | *.tlh
 66 | *.tmp
 67 | *.tmp_proj
 68 | *.log
 69 | *.vspscc
 70 | *.vssscc
 71 | .builds
 72 | *.pidb
 73 | *.svclog
 74 | *.scc
 75 | 
 76 | # Chutzpah Test files
 77 | _Chutzpah*
 78 | 
 79 | # Visual C++ cache files
 80 | ipch/
 81 | *.aps
 82 | *.ncb
 83 | *.opendb
 84 | *.opensdf
 85 | *.sdf
 86 | *.cachefile
 87 | *.VC.db
 88 | *.VC.VC.opendb
 89 | 
 90 | # Visual Studio profiler
 91 | *.psess
 92 | *.vsp
 93 | *.vspx
 94 | *.sap
 95 | 
 96 | # TFS 2012 Local Workspace
 97 | $tf/
 98 | 
 99 | # Guidance Automation Toolkit
100 | *.gpState
101 | 
102 | # ReSharper is a .NET coding add-in
103 | _ReSharper*/
104 | *.[Rr]e[Ss]harper
105 | *.DotSettings.user
106 | 
107 | # JustCode is a .NET coding add-in
108 | .JustCode
109 | 
110 | # TeamCity is a build add-in
111 | _TeamCity*
112 | 
113 | # DotCover is a Code Coverage Tool
114 | *.dotCover
115 | 
116 | # Visual Studio code coverage results
117 | *.coverage
118 | *.coveragexml
119 | 
120 | # NCrunch
121 | _NCrunch_*
122 | .*crunch*.local.xml
123 | nCrunchTemp_*
124 | 
125 | # MightyMoose
126 | *.mm.*
127 | AutoTest.Net/
128 | 
129 | # Web workbench (sass)
130 | .sass-cache/
131 | 
132 | # Installshield output folder
133 | [Ee]xpress/
134 | 
135 | # DocProject is a documentation generator add-in
136 | DocProject/buildhelp/
137 | DocProject/Help/*.HxT
138 | DocProject/Help/*.HxC
139 | DocProject/Help/*.hhc
140 | DocProject/Help/*.hhk
141 | DocProject/Help/*.hhp
142 | DocProject/Help/Html2
143 | DocProject/Help/html
144 | 
145 | # Click-Once directory
146 | publish/
147 | 
148 | # Publish Web Output
149 | *.[Pp]ublish.xml
150 | *.azurePubxml
151 | # TODO: Comment the next line if you want to checkin your web deploy settings
152 | # but database connection strings (with potential passwords) will be unencrypted
153 | *.pubxml
154 | *.publishproj
155 | 
156 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
157 | # checkin your Azure Web App publish settings, but sensitive information contained
158 | # in these scripts will be unencrypted
159 | PublishScripts/
160 | 
161 | # NuGet Packages
162 | *.nupkg
163 | # The packages folder can be ignored because of Package Restore
164 | **/packages/*
165 | # except build/, which is used as an MSBuild target.
166 | !**/packages/build/
167 | # Uncomment if necessary however generally it will be regenerated when needed
168 | #!**/packages/repositories.config
169 | # NuGet v3's project.json files produces more ignorable files
170 | *.nuget.props
171 | *.nuget.targets
172 | 
173 | # Microsoft Azure Build Output
174 | csx/
175 | *.build.csdef
176 | 
177 | # Microsoft Azure Emulator
178 | ecf/
179 | rcf/
180 | 
181 | # Windows Store app package directories and files
182 | AppPackages/
183 | BundleArtifacts/
184 | Package.StoreAssociation.xml
185 | _pkginfo.txt
186 | 
187 | # Visual Studio cache files
188 | # files ending in .cache can be ignored
189 | *.[Cc]ache
190 | # but keep track of directories ending in .cache
191 | !*.[Cc]ache/
192 | 
193 | # Others
194 | ClientBin/
195 | ~$*
196 | *~
197 | *.dbmdl
198 | *.dbproj.schemaview
199 | *.jfm
200 | *.pfx
201 | *.publishsettings
202 | orleans.codegen.cs
203 | 
204 | # Since there are multiple workflows, uncomment next line to ignore bower_components
205 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
206 | #bower_components/
207 | 
208 | # RIA/Silverlight projects
209 | Generated_Code/
210 | 
211 | # Backup & report files from converting an old project file
212 | # to a newer Visual Studio version. Backup files are not needed,
213 | # because we have git ;-)
214 | _UpgradeReport_Files/
215 | Backup*/
216 | UpgradeLog*.XML
217 | UpgradeLog*.htm
218 | 
219 | # SQL Server files
220 | *.mdf
221 | *.ldf
222 | *.ndf
223 | 
224 | # Business Intelligence projects
225 | *.rdl.data
226 | *.bim.layout
227 | *.bim_*.settings
228 | 
229 | # Microsoft Fakes
230 | FakesAssemblies/
231 | 
232 | # GhostDoc plugin setting file
233 | *.GhostDoc.xml
234 | 
235 | # Node.js Tools for Visual Studio
236 | .ntvs_analysis.dat
237 | node_modules/
238 | 
239 | # Typescript v1 declaration files
240 | typings/
241 | 
242 | # Visual Studio 6 build log
243 | *.plg
244 | 
245 | # Visual Studio 6 workspace options file
246 | *.opt
247 | 
248 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
249 | *.vbw
250 | 
251 | # Visual Studio LightSwitch build output
252 | **/*.HTMLClient/GeneratedArtifacts
253 | **/*.DesktopClient/GeneratedArtifacts
254 | **/*.DesktopClient/ModelManifest.xml
255 | **/*.Server/GeneratedArtifacts
256 | **/*.Server/ModelManifest.xml
257 | _Pvt_Extensions
258 | 
259 | # Paket dependency manager
260 | .paket/paket.exe
261 | paket-files/
262 | 
263 | # FAKE - F# Make
264 | .fake/
265 | 
266 | # JetBrains Rider
267 | .idea/
268 | *.sln.iml
269 | 
270 | # CodeRush
271 | .cr/
272 | 
273 | # Python Tools for Visual Studio (PTVS)
274 | __pycache__/
275 | *.pyc
276 | 
277 | # Cake - Uncomment if you are using it
278 | # tools/**
279 | # !tools/packages.config
280 | 
281 | # Telerik's JustMock configuration file
282 | *.jmconfig
283 | 
284 | # BizTalk build output
285 | *.btp.cs
286 | *.btm.cs
287 | *.odx.cs
288 | *.xsd.cs
289 | 


--------------------------------------------------------------------------------
/frmMashed.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Drawing;
  3 | using System.Windows.Forms;
  4 | using IWshRuntimeLibrary;
  5 | using System.IO;
  6 | using System.Diagnostics;
  7 | 
  8 | namespace SciLor_s_Mashed_Runner {
  9 |     public partial class frmMashed : Form {
 10 |         public frmMashed() {
 11 |             InitializeComponent();
 12 | 
 13 |             setMashedVersion();
 14 |             btnRunMashed.Text = Mashed.version.NAME();
 15 | 
 16 |             cmbLanguage.SelectedIndexChanged -= new System.EventHandler(this.cmbLanguage_SelectedIndexChanged);
 17 |             cmbIcon.SelectedIndexChanged -= new System.EventHandler(this.cmbIcon_SelectedIndexChanged);
 18 | 
 19 | 
 20 |             cmbLanguage.Items.Add(new Language("English", "English", "ENG", 0));
 21 |             cmbLanguage.Items.Add(new Language("Français", "French", "FRA", 1));
 22 |             cmbLanguage.Items.Add(new Language("Deutsch", "German", "DEU", 2));
 23 |             cmbLanguage.Items.Add(new Language("Español", "Spanish", "ESN", 3));
 24 |             cmbLanguage.Items.Add(new Language("Italiano", "Italian", "ITA", 4));
 25 | 
 26 |             cmbLanguage.SelectedIndex = Properties.Settings.Default.Language;
 27 | 
 28 |             if (Properties.Settings.Default.Path.Length == 0) {
 29 |                 Properties.Settings.Default.Path = Util.GetExeDir() + "\\";
 30 |                 if (Mashed.checkExe()) {
 31 |                     Properties.Settings.Default.Save();
 32 |                 }
 33 |             }
 34 |             txtPath.Text = Util.GetMashedDir();
 35 |             txtPath.Text += Mashed.version.EXE();
 36 | 
 37 |             for (int i = 0; i < Mashed.ICOS.Length; i++) {
 38 |                 IconFile icon = Mashed.ICOS[i];
 39 |                 cmbIcon.Items.Add(icon);
 40 |             }
 41 | 
 42 |             if (Properties.Settings.Default.Icon.Length == 0) {
 43 |                 Properties.Settings.Default.Icon = Mashed.ICO;
 44 |             }
 45 |             foreach (Object obj in cmbIcon.Items) {
 46 |                 if (obj.Equals(new IconFile(Properties.Settings.Default.Icon))) {
 47 |                     cmbIcon.SelectedItem = obj;
 48 |                 }
 49 |             }
 50 | 
 51 |             loadICO();
 52 |             setIntroState();
 53 | 
 54 | 
 55 |             cmbLanguage.SelectedIndexChanged += new System.EventHandler(this.cmbLanguage_SelectedIndexChanged);
 56 |             cmbIcon.SelectedIndexChanged += new System.EventHandler(this.cmbIcon_SelectedIndexChanged);
 57 | 
 58 |             if (Util.IsAnAdministrator()) {
 59 |                 this.grpLaunch.Enabled = true;
 60 |                 this.grpSettings.Enabled = true;
 61 |                 this.btnAccess.Visible = false;
 62 |             } else {
 63 |                 Util.setUAC(btnAccess);
 64 |             }
 65 |         }
 66 | 
 67 |         private void setMashedVersion() {
 68 |             Version tmp = new VersionMFL();
 69 |             if (!tmp.EXE_EXISTS()) {
 70 |                 tmp = new VersionMashed();
 71 |                 if (!tmp.EXE_EXISTS()) {
 72 |                     tmp = new VersionMFL();
 73 |                 }
 74 |             }
 75 |             Mashed.version = tmp;
 76 |         }
 77 | 
 78 |         private void btnRunMashed_Click(object sender, EventArgs e) {
 79 |             Mashed.Run(false, false, true, this);
 80 |         }
 81 | 
 82 |         private void btnRunVideo_Click(object sender, EventArgs e) {
 83 |             Mashed.Run(true, false, false, this);
 84 |         }
 85 | 
 86 |         private void btnRunController_Click(object sender, EventArgs e) {
 87 |             Mashed.Run(false, true, false, this);
 88 |         }
 89 | 
 90 |         private void cmbLanguage_SelectedIndexChanged(object sender, EventArgs e) {
 91 |             Properties.Settings.Default.Language = cmbLanguage.SelectedIndex;
 92 |             Properties.Settings.Default.Save();
 93 |         }
 94 | 
 95 | 
 96 |         private void btnPath_Click(object sender, EventArgs e) {
 97 |             OpenFileDialog ofd = new OpenFileDialog();
 98 |             Version mfl = new VersionMFL();
 99 |             Version mashed = new VersionMashed();
100 | 
101 |             ofd.Filter = mfl.EXE() + "/" + mashed.EXE() + "|" + mfl.EXE() + ";"+ mashed.EXE();
102 |             ofd.CheckFileExists = true;
103 | 
104 |             if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK) {
105 |                     txtPath.Text = ofd.FileName;
106 |                     setMashedVersion();
107 |                     Properties.Settings.Default.Path = txtPath.Text.Remove(txtPath.TextLength -System.IO.Path.GetFileName(ofd.FileName).Length);
108 |                     Properties.Settings.Default.Save();
109 |                     //loadICO();
110 |                     //setIntroState();
111 |                     Application.Restart();
112 |             }
113 |         }
114 | 
115 |         private void btnShortcut_Click(object sender, EventArgs e) {
116 |             SaveFileDialog sfd = new SaveFileDialog();
117 |             sfd.DefaultExt = ".lnk";
118 |             sfd.FileName = Mashed.version.NAME()+ ".lnk";
119 |             sfd.Filter = "Shortcut (*.lnk)|*.lnk";
120 |             sfd.ValidateNames = true;
121 |             if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK && sfd.FileName != null) {
122 |                 WshShellClass wshShell = new WshShellClass();
123 |                 try {
124 |                     IWshShortcut link = (IWshShortcut)(wshShell.CreateShortcut(sfd.FileName));
125 |                     link.TargetPath = Util.GetExePath();
126 |                     link.Arguments = "-fix";
127 |                     link.Description = "Starts "+ Mashed.version.NAME();
128 |                     if (Mashed.checkExe()) 
129 |                         link.IconLocation = Util.GetExeDir() + "\\" +
130 |                             "icon" + cmbIcon.SelectedItem + ".ico";
131 |                     link.Save();
132 | 
133 |                 } catch (Exception ex) {
134 |                     MessageBox.Show(ex.Message);
135 |                 }
136 |             }
137 |         }
138 | 
139 |         private void cmbIcon_SelectedIndexChanged(object sender, EventArgs e) {
140 |             Properties.Settings.Default.Icon = (cmbIcon.SelectedItem as IconFile).path;
141 |             Properties.Settings.Default.Save();
142 |             loadICO();
143 |         }
144 | 
145 |         private void cmbIntro_SelectedIndexChanged(object sender, EventArgs e) {
146 |             if ((String)cmbIntro.SelectedItem == "Enabled") {
147 |                 Intro.Enable();
148 |             } else {
149 |                 Intro.Disable();
150 |             }
151 |             setIntroState();
152 |         }
153 | 
154 | 
155 | 
156 |         private void setIntroState() {
157 |             String path = Properties.Settings.Default.Path + Mashed.BASE_VIDEO_DIR + "backup";
158 |             cmbIntro.SelectedIndexChanged -= new System.EventHandler(this.cmbIntro_SelectedIndexChanged);
159 |             if (!System.IO.Directory.Exists(path)) {
160 |                 cmbIntro.SelectedItem = "Enabled";
161 |             } else {
162 |                 cmbIntro.SelectedItem = "Disabled";
163 |             }
164 |             cmbIntro.SelectedIndexChanged += new System.EventHandler(this.cmbIntro_SelectedIndexChanged);
165 | 
166 |         }
167 |         private void loadICO() {
168 |             String path = Util.GetMashedDir() + Properties.Settings.Default.Icon;
169 |             if (!System.IO.File.Exists(path)) {
170 |                 return;
171 |             }
172 | 
173 |             btnRunMashed.Image = new Bitmap(path);
174 |             btnRunVideo.Image = btnRunMashed.Image;
175 |             btnRunController.Image = btnRunMashed.Image;
176 | 
177 |             btnRunMashed.ImageAlign = ContentAlignment.TopLeft;
178 |             btnRunVideo.ImageAlign = ContentAlignment.MiddleLeft;
179 |             btnRunController.ImageAlign = ContentAlignment.BottomLeft;
180 | 
181 |             this.ShowIcon = false;
182 |             this.Icon = null;
183 |             this.ShowIcon = true;
184 |             this.Icon = Icon.FromHandle(new Bitmap(path).GetHicon());
185 | 
186 |             String iconPath = Util.GetExeDir() + "\\" +
187 |                 "icon" + cmbIcon.SelectedItem + ".ico";
188 | 
189 |             if (!System.IO.File.Exists(iconPath)) {
190 |                 try {
191 |                     FileStream fs = new FileStream(iconPath, FileMode.Create);
192 |                     this.Icon.Save(fs);
193 |                     fs.Close();
194 |                 } catch (Exception) { }
195 |             }
196 |         }
197 | 
198 |         private void btnPatch_Click(object sender, EventArgs e) {
199 |             if (!Mashed.checkExe()) return;
200 |             if (SearchAndReplace.PatchLauncher(Util.GetMashedDir() + Mashed.version.LAUNCHER(), Mashed.version.NOCD_SEARCH(), Mashed.version.NOCD_REPLACE())) {
201 |                 MessageBox.Show("Launch.exe successfully patched.\r\nYou can now run " + Mashed.version.NAME() + " without CD using the original launcher.\r\n\r\nBackup created.");
202 |             } else {
203 |                 MessageBox.Show("Launch.exe not patched.\r\nMaybe you already installed the patch.\r\n(You can delete the backup file Launch.exe.bak, if you want to try again.)");
204 |             }
205 |         }
206 | 
207 |         private void btnInstall_Click(object sender, EventArgs e) {
208 |             if (!Mashed.checkExe()) return;
209 |             Mashed.setRegistryLanguage((Language)cmbLanguage.SelectedItem);
210 |             Mashed.setRegistryInstallation(Util.GetMashedDir());
211 |         }
212 | 
213 |         private void btnLaunch_Click(object sender, EventArgs e) {
214 |             if (!Mashed.checkExe()) return;
215 |             Process.Start(Util.GetMashedDir() + Mashed.version.LAUNCHER());
216 | 
217 |                 this.Close();
218 |                 Application.Exit();
219 |         }
220 | 
221 |         private void btnAccess_Click(object sender, EventArgs e) {
222 |             try {
223 |                 Process p = new Process();
224 |                 p.StartInfo.FileName = Application.ExecutablePath;
225 |                 //Vista or higher check
226 |                 if (System.Environment.OSVersion.Version.Major >= 6) {
227 |                     p.StartInfo.Verb = "runas";
228 |                 }
229 |                 p.Start();
230 |                 this.Close();
231 |                 Application.Exit();
232 |             } catch (Exception) { }
233 |         }
234 |     }
235 | }
236 | 


--------------------------------------------------------------------------------
/frmMashed.Designer.cs:
--------------------------------------------------------------------------------
  1 | namespace SciLor_s_Mashed_Runner {
  2 |     partial class frmMashed {
  3 |         /// <summary>
  4 |         /// Required designer variable.
  5 |         /// </summary>
  6 |         private System.ComponentModel.IContainer components = null;
  7 | 
  8 |         /// <summary>
  9 |         /// Clean up any resources being used.
 10 |         /// </summary>
 11 |         /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
 12 |         protected override void Dispose(bool disposing) {
 13 |             if (disposing && (components != null)) {
 14 |                 components.Dispose();
 15 |             }
 16 |             base.Dispose(disposing);
 17 |         }
 18 | 
 19 |         #region Windows Form Designer generated code
 20 | 
 21 |         /// <summary>
 22 |         /// Required method for Designer support - do not modify
 23 |         /// the contents of this method with the code editor.
 24 |         /// </summary>
 25 |         private void InitializeComponent() {
 26 |             this.btnRunMashed = new System.Windows.Forms.Button();
 27 |             this.btnRunVideo = new System.Windows.Forms.Button();
 28 |             this.btnRunController = new System.Windows.Forms.Button();
 29 |             this.lblVersion = new System.Windows.Forms.Label();
 30 |             this.grpSettings = new System.Windows.Forms.GroupBox();
 31 |             this.label1 = new System.Windows.Forms.Label();
 32 |             this.cmbIntro = new System.Windows.Forms.ComboBox();
 33 |             this.lblIcon = new System.Windows.Forms.Label();
 34 |             this.lblPath = new System.Windows.Forms.Label();
 35 |             this.lblLanguage = new System.Windows.Forms.Label();
 36 |             this.cmbIcon = new System.Windows.Forms.ComboBox();
 37 |             this.btnShortcut = new System.Windows.Forms.Button();
 38 |             this.btnPath = new System.Windows.Forms.Button();
 39 |             this.txtPath = new System.Windows.Forms.TextBox();
 40 |             this.cmbLanguage = new System.Windows.Forms.ComboBox();
 41 |             this.grpLaunch = new System.Windows.Forms.GroupBox();
 42 |             this.btnLaunch = new System.Windows.Forms.Button();
 43 |             this.btnPatch = new System.Windows.Forms.Button();
 44 |             this.btnInstall = new System.Windows.Forms.Button();
 45 |             this.btnAccess = new System.Windows.Forms.Button();
 46 |             this.grpSettings.SuspendLayout();
 47 |             this.grpLaunch.SuspendLayout();
 48 |             this.SuspendLayout();
 49 |             // 
 50 |             // btnRunMashed
 51 |             // 
 52 |             this.btnRunMashed.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
 53 |                         | System.Windows.Forms.AnchorStyles.Right)));
 54 |             this.btnRunMashed.BackgroundImageLayout = System.Windows.Forms.ImageLayout.None;
 55 |             this.btnRunMashed.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft;
 56 |             this.btnRunMashed.Location = new System.Drawing.Point(12, 12);
 57 |             this.btnRunMashed.Name = "btnRunMashed";
 58 |             this.btnRunMashed.Size = new System.Drawing.Size(233, 45);
 59 |             this.btnRunMashed.TabIndex = 0;
 60 |             this.btnRunMashed.Text = "Run";
 61 |             this.btnRunMashed.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
 62 |             this.btnRunMashed.UseVisualStyleBackColor = true;
 63 |             this.btnRunMashed.Click += new System.EventHandler(this.btnRunMashed_Click);
 64 |             // 
 65 |             // btnRunVideo
 66 |             // 
 67 |             this.btnRunVideo.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
 68 |                         | System.Windows.Forms.AnchorStyles.Right)));
 69 |             this.btnRunVideo.Location = new System.Drawing.Point(12, 59);
 70 |             this.btnRunVideo.Name = "btnRunVideo";
 71 |             this.btnRunVideo.Size = new System.Drawing.Size(233, 45);
 72 |             this.btnRunVideo.TabIndex = 1;
 73 |             this.btnRunVideo.Text = "Video Configuration";
 74 |             this.btnRunVideo.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
 75 |             this.btnRunVideo.UseVisualStyleBackColor = true;
 76 |             this.btnRunVideo.Click += new System.EventHandler(this.btnRunVideo_Click);
 77 |             // 
 78 |             // btnRunController
 79 |             // 
 80 |             this.btnRunController.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
 81 |                         | System.Windows.Forms.AnchorStyles.Right)));
 82 |             this.btnRunController.Location = new System.Drawing.Point(12, 106);
 83 |             this.btnRunController.Name = "btnRunController";
 84 |             this.btnRunController.Size = new System.Drawing.Size(233, 45);
 85 |             this.btnRunController.TabIndex = 2;
 86 |             this.btnRunController.Text = "Controller Configuration";
 87 |             this.btnRunController.TextAlign = System.Drawing.ContentAlignment.MiddleRight;
 88 |             this.btnRunController.UseVisualStyleBackColor = true;
 89 |             this.btnRunController.Click += new System.EventHandler(this.btnRunController_Click);
 90 |             // 
 91 |             // lblVersion
 92 |             // 
 93 |             this.lblVersion.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
 94 |             this.lblVersion.AutoSize = true;
 95 |             this.lblVersion.Location = new System.Drawing.Point(232, 386);
 96 |             this.lblVersion.Name = "lblVersion";
 97 |             this.lblVersion.Size = new System.Drawing.Size(19, 13);
 98 |             this.lblVersion.TabIndex = 7;
 99 |             this.lblVersion.Text = "v5";
100 |             this.lblVersion.TextAlign = System.Drawing.ContentAlignment.BottomRight;
101 |             // 
102 |             // grpSettings
103 |             // 
104 |             this.grpSettings.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
105 |                         | System.Windows.Forms.AnchorStyles.Right)));
106 |             this.grpSettings.Controls.Add(this.label1);
107 |             this.grpSettings.Controls.Add(this.cmbIntro);
108 |             this.grpSettings.Controls.Add(this.lblIcon);
109 |             this.grpSettings.Controls.Add(this.lblPath);
110 |             this.grpSettings.Controls.Add(this.lblLanguage);
111 |             this.grpSettings.Controls.Add(this.cmbIcon);
112 |             this.grpSettings.Controls.Add(this.btnShortcut);
113 |             this.grpSettings.Controls.Add(this.btnPath);
114 |             this.grpSettings.Controls.Add(this.txtPath);
115 |             this.grpSettings.Controls.Add(this.cmbLanguage);
116 |             this.grpSettings.Enabled = false;
117 |             this.grpSettings.Location = new System.Drawing.Point(12, 167);
118 |             this.grpSettings.Name = "grpSettings";
119 |             this.grpSettings.Size = new System.Drawing.Size(233, 161);
120 |             this.grpSettings.TabIndex = 9;
121 |             this.grpSettings.TabStop = false;
122 |             // 
123 |             // label1
124 |             // 
125 |             this.label1.AutoSize = true;
126 |             this.label1.Location = new System.Drawing.Point(48, 132);
127 |             this.label1.Name = "label1";
128 |             this.label1.Size = new System.Drawing.Size(31, 13);
129 |             this.label1.TabIndex = 18;
130 |             this.label1.Text = "Intro:";
131 |             // 
132 |             // cmbIntro
133 |             // 
134 |             this.cmbIntro.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
135 |                         | System.Windows.Forms.AnchorStyles.Right)));
136 |             this.cmbIntro.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
137 |             this.cmbIntro.FormattingEnabled = true;
138 |             this.cmbIntro.Items.AddRange(new object[] {
139 |             "Disabled",
140 |             "Enabled"});
141 |             this.cmbIntro.Location = new System.Drawing.Point(85, 129);
142 |             this.cmbIntro.Name = "cmbIntro";
143 |             this.cmbIntro.Size = new System.Drawing.Size(142, 21);
144 |             this.cmbIntro.Sorted = true;
145 |             this.cmbIntro.TabIndex = 14;
146 |             this.cmbIntro.SelectedIndexChanged += new System.EventHandler(this.cmbIntro_SelectedIndexChanged);
147 |             // 
148 |             // lblIcon
149 |             // 
150 |             this.lblIcon.AutoSize = true;
151 |             this.lblIcon.Location = new System.Drawing.Point(15, 77);
152 |             this.lblIcon.Name = "lblIcon";
153 |             this.lblIcon.Size = new System.Drawing.Size(64, 13);
154 |             this.lblIcon.TabIndex = 16;
155 |             this.lblIcon.Text = "Select Icon:";
156 |             // 
157 |             // lblPath
158 |             // 
159 |             this.lblPath.AutoSize = true;
160 |             this.lblPath.Location = new System.Drawing.Point(6, 52);
161 |             this.lblPath.Name = "lblPath";
162 |             this.lblPath.Size = new System.Drawing.Size(73, 13);
163 |             this.lblPath.TabIndex = 15;
164 |             this.lblPath.Text = "Mashed Path:";
165 |             // 
166 |             // lblLanguage
167 |             // 
168 |             this.lblLanguage.AutoSize = true;
169 |             this.lblLanguage.Location = new System.Drawing.Point(21, 22);
170 |             this.lblLanguage.Name = "lblLanguage";
171 |             this.lblLanguage.Size = new System.Drawing.Size(58, 13);
172 |             this.lblLanguage.TabIndex = 14;
173 |             this.lblLanguage.Text = "Language:";
174 |             // 
175 |             // cmbIcon
176 |             // 
177 |             this.cmbIcon.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
178 |                         | System.Windows.Forms.AnchorStyles.Right)));
179 |             this.cmbIcon.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
180 |             this.cmbIcon.FormattingEnabled = true;
181 |             this.cmbIcon.Location = new System.Drawing.Point(85, 74);
182 |             this.cmbIcon.Name = "cmbIcon";
183 |             this.cmbIcon.Size = new System.Drawing.Size(142, 21);
184 |             this.cmbIcon.Sorted = true;
185 |             this.cmbIcon.TabIndex = 12;
186 |             this.cmbIcon.SelectedIndexChanged += new System.EventHandler(this.cmbIcon_SelectedIndexChanged);
187 |             // 
188 |             // btnShortcut
189 |             // 
190 |             this.btnShortcut.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
191 |                         | System.Windows.Forms.AnchorStyles.Right)));
192 |             this.btnShortcut.Location = new System.Drawing.Point(85, 101);
193 |             this.btnShortcut.Name = "btnShortcut";
194 |             this.btnShortcut.Size = new System.Drawing.Size(142, 22);
195 |             this.btnShortcut.TabIndex = 13;
196 |             this.btnShortcut.Text = "Create Shortcut";
197 |             this.btnShortcut.UseVisualStyleBackColor = true;
198 |             this.btnShortcut.Click += new System.EventHandler(this.btnShortcut_Click);
199 |             // 
200 |             // btnPath
201 |             // 
202 |             this.btnPath.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
203 |             this.btnPath.Location = new System.Drawing.Point(197, 48);
204 |             this.btnPath.Name = "btnPath";
205 |             this.btnPath.Size = new System.Drawing.Size(30, 20);
206 |             this.btnPath.TabIndex = 11;
207 |             this.btnPath.Text = "...";
208 |             this.btnPath.UseVisualStyleBackColor = true;
209 |             this.btnPath.Click += new System.EventHandler(this.btnPath_Click);
210 |             // 
211 |             // txtPath
212 |             // 
213 |             this.txtPath.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
214 |                         | System.Windows.Forms.AnchorStyles.Right)));
215 |             this.txtPath.Location = new System.Drawing.Point(85, 49);
216 |             this.txtPath.Name = "txtPath";
217 |             this.txtPath.ReadOnly = true;
218 |             this.txtPath.Size = new System.Drawing.Size(106, 20);
219 |             this.txtPath.TabIndex = 10;
220 |             this.txtPath.TabStop = false;
221 |             // 
222 |             // cmbLanguage
223 |             // 
224 |             this.cmbLanguage.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
225 |                         | System.Windows.Forms.AnchorStyles.Right)));
226 |             this.cmbLanguage.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
227 |             this.cmbLanguage.FormattingEnabled = true;
228 |             this.cmbLanguage.Location = new System.Drawing.Point(85, 19);
229 |             this.cmbLanguage.Name = "cmbLanguage";
230 |             this.cmbLanguage.Size = new System.Drawing.Size(142, 21);
231 |             this.cmbLanguage.Sorted = true;
232 |             this.cmbLanguage.TabIndex = 9;
233 |             this.cmbLanguage.SelectedIndexChanged += new System.EventHandler(this.cmbLanguage_SelectedIndexChanged);
234 |             // 
235 |             // grpLaunch
236 |             // 
237 |             this.grpLaunch.Controls.Add(this.btnLaunch);
238 |             this.grpLaunch.Controls.Add(this.btnPatch);
239 |             this.grpLaunch.Controls.Add(this.btnInstall);
240 |             this.grpLaunch.Enabled = false;
241 |             this.grpLaunch.Location = new System.Drawing.Point(12, 334);
242 |             this.grpLaunch.Name = "grpLaunch";
243 |             this.grpLaunch.Size = new System.Drawing.Size(210, 68);
244 |             this.grpLaunch.TabIndex = 10;
245 |             this.grpLaunch.TabStop = false;
246 |             this.grpLaunch.Text = "Original Launcher";
247 |             // 
248 |             // btnLaunch
249 |             // 
250 |             this.btnLaunch.Location = new System.Drawing.Point(143, 19);
251 |             this.btnLaunch.Name = "btnLaunch";
252 |             this.btnLaunch.Size = new System.Drawing.Size(60, 40);
253 |             this.btnLaunch.TabIndex = 20;
254 |             this.btnLaunch.Text = "Run Launcher";
255 |             this.btnLaunch.UseVisualStyleBackColor = true;
256 |             this.btnLaunch.Click += new System.EventHandler(this.btnLaunch_Click);
257 |             // 
258 |             // btnPatch
259 |             // 
260 |             this.btnPatch.Location = new System.Drawing.Point(6, 19);
261 |             this.btnPatch.Name = "btnPatch";
262 |             this.btnPatch.Size = new System.Drawing.Size(50, 40);
263 |             this.btnPatch.TabIndex = 18;
264 |             this.btnPatch.Text = "NoCD Patch";
265 |             this.btnPatch.UseVisualStyleBackColor = true;
266 |             this.btnPatch.Click += new System.EventHandler(this.btnPatch_Click);
267 |             // 
268 |             // btnInstall
269 |             // 
270 |             this.btnInstall.Location = new System.Drawing.Point(62, 19);
271 |             this.btnInstall.Name = "btnInstall";
272 |             this.btnInstall.Size = new System.Drawing.Size(75, 40);
273 |             this.btnInstall.TabIndex = 19;
274 |             this.btnInstall.Text = "Install + Set Language";
275 |             this.btnInstall.UseVisualStyleBackColor = true;
276 |             this.btnInstall.Click += new System.EventHandler(this.btnInstall_Click);
277 |             // 
278 |             // btnAccess
279 |             // 
280 |             this.btnAccess.FlatStyle = System.Windows.Forms.FlatStyle.System;
281 |             this.btnAccess.Location = new System.Drawing.Point(20, 159);
282 |             this.btnAccess.Name = "btnAccess";
283 |             this.btnAccess.Size = new System.Drawing.Size(115, 25);
284 |             this.btnAccess.TabIndex = 11;
285 |             this.btnAccess.Text = "Change Settings";
286 |             this.btnAccess.UseVisualStyleBackColor = true;
287 |             this.btnAccess.Click += new System.EventHandler(this.btnAccess_Click);
288 |             // 
289 |             // frmMashed
290 |             // 
291 |             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
292 |             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
293 |             this.ClientSize = new System.Drawing.Size(257, 408);
294 |             this.Controls.Add(this.btnAccess);
295 |             this.Controls.Add(this.grpLaunch);
296 |             this.Controls.Add(this.grpSettings);
297 |             this.Controls.Add(this.lblVersion);
298 |             this.Controls.Add(this.btnRunController);
299 |             this.Controls.Add(this.btnRunVideo);
300 |             this.Controls.Add(this.btnRunMashed);
301 |             this.DoubleBuffered = true;
302 |             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
303 |             this.MaximizeBox = false;
304 |             this.Name = "frmMashed";
305 |             this.ShowIcon = false;
306 |             this.Text = "SciLor\'s Mashed Runner";
307 |             this.grpSettings.ResumeLayout(false);
308 |             this.grpSettings.PerformLayout();
309 |             this.grpLaunch.ResumeLayout(false);
310 |             this.ResumeLayout(false);
311 |             this.PerformLayout();
312 | 
313 |         }
314 | 
315 |         #endregion
316 | 
317 |         private System.Windows.Forms.Button btnRunMashed;
318 |         private System.Windows.Forms.Button btnRunVideo;
319 |         private System.Windows.Forms.Button btnRunController;
320 |         private System.Windows.Forms.Label lblVersion;
321 |         private System.Windows.Forms.GroupBox grpSettings;
322 |         private System.Windows.Forms.Label lblLanguage;
323 |         private System.Windows.Forms.ComboBox cmbIcon;
324 |         private System.Windows.Forms.Button btnShortcut;
325 |         private System.Windows.Forms.Button btnPath;
326 |         private System.Windows.Forms.TextBox txtPath;
327 |         private System.Windows.Forms.Label lblPath;
328 |         private System.Windows.Forms.Label lblIcon;
329 |         private System.Windows.Forms.Label label1;
330 |         private System.Windows.Forms.ComboBox cmbIntro;
331 |         internal System.Windows.Forms.ComboBox cmbLanguage;
332 |         private System.Windows.Forms.GroupBox grpLaunch;
333 |         private System.Windows.Forms.Button btnLaunch;
334 |         private System.Windows.Forms.Button btnPatch;
335 |         private System.Windows.Forms.Button btnInstall;
336 |         private System.Windows.Forms.Button btnAccess;
337 |     }
338 | }
339 | 
340 | 


--------------------------------------------------------------------------------