public class MainWindow : MetroWindow, IComponentConnector
{
    // Fields
    private bool _contentLoaded;
    private readonly Username _User = new Username();
    internal ComboBox ComboBox1;
    internal Label label1;
    internal PasswordBox Password;
    internal TextBox TextBox;

    // Methods
    public MainWindow()
    {
        this.InitializeComponent();
        this.Scanner();
    }

    private void Button_Click(object Sender, RoutedEventArgs e)
    {
        new Login().AuthAsync(this._User.User, this._User.Password);
        Settings.Default.Save();
    }

    private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        Variables.Selected = int.Parse((sender as ComboBox).SelectedItem.ToString());
        Console.WriteLine(this._User.selection);
    }

    [DebuggerNonUserCode, GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
    public void InitializeComponent()
    {
        if (!this._contentLoaded)
        {
            this._contentLoaded = true;
            Uri resourceLocator = new Uri("/Waterhack loader;component/views/mainwindow.xaml", UriKind.Relative);
            Application.LoadComponent(this, resourceLocator);
        }
    }

    private void MainWindow_OnLoaded(object Sender, RoutedEventArgs E)
    {
        this._User.User = Settings.Default.Username;
        this._User.Password = Settings.Default.Password;
        this.TextBox.Text = Settings.Default.Username;
        this.Password.Password = Settings.Default.Password;
        this.label1.Content = "v" + Assembly.GetExecutingAssembly().GetName().Version.ToString();
    }

    private void myEvent(object source, ElapsedEventArgs e)
    {
        processes();
        int count = this.ComboBox1.Items.Count;
        using (List<string>.Enumerator enumerator = processes().GetEnumerator())
        {
            while (enumerator.MoveNext())
            {
                string item = enumerator.Current;
                base.Dispatcher.Invoke(delegate {
                    if (!this.ComboBox1.Items.Contains(item))
                    {
                        this.ComboBox1.Items.Add(item);
                        this.ComboBox1.SelectedIndex = 0;
                    }
                });
            }
        }
        using (IEnumerator enumerator2 = ((IEnumerable) this.ComboBox1.Items).GetEnumerator())
        {
            while (enumerator2.MoveNext())
            {
                object item = enumerator2.Current;
                base.Dispatcher.Invoke(delegate {
                    if (!processes().Contains<object>(item))
                    {
                        this.ComboBox1.Items.Remove(item);
                        this.ComboBox1.SelectedIndex = 0;
                    }
                });
            }
        }
    }

    private void PasswordLogin(object Sender, RoutedEventArgs RoutedEventArgs)
    {
        this._User.Password = this.Password.Password;
        Settings.Default.Password = this.Password.Password;
        Settings.Default.Save();
    }

    public static List<string> processes()
    {
        List<string> source = new List<string>();
        Process[] processes = Process.GetProcesses();
        for (int i = 0; i < processes.Length; i++)
        {
            Process proc = processes[i];
            if ((proc.ProcessName == "Wow-64") && !source.Any<string>(item => (item == proc.Id.ToString())))
            {
                source.Add(proc.Id.ToString());
            }
        }
        return source;
    }

    private void Scanner()
    {
        Console.WriteLine("Scanner Started");
        Timer timer1 = new Timer();
        timer1.Elapsed += new ElapsedEventHandler(this.myEvent);
        timer1.Interval = 100.0;
        timer1.Enabled = true;
    }

    [AsyncStateMachine(typeof(<showMessageAsync>d__5))]
    internal static Task showMessageAsync(string v)
    {
        <showMessageAsync>d__5 d__;
        d__.v = v;
        d__.<>t__builder = AsyncTaskMethodBuilder.Create();
        d__.<>1__state = -1;
        d__.<>t__builder.Start<<showMessageAsync>d__5>(ref d__);
        return d__.<>t__builder.Task;
    }

    [DebuggerNonUserCode, GeneratedCode("PresentationBuildTasks", "4.0.0.0"), EditorBrowsable(EditorBrowsableState.Never)]
    void IComponentConnector.Connect(int connectionId, object target)
    {
        switch (connectionId)
        {
            case 1:
                ((MainWindow) target).Loaded += new RoutedEventHandler(this.MainWindow_OnLoaded);
                return;

            case 2:
                this.TextBox = (TextBox) target;
                this.TextBox.TextChanged += new TextChangedEventHandler(this.UsernameLogin);
                return;

            case 3:
                this.Password = (PasswordBox) target;
                this.Password.PasswordChanged += new RoutedEventHandler(this.PasswordLogin);
                return;

            case 4:
                this.ComboBox1 = (ComboBox) target;
                this.ComboBox1.SelectionChanged += new SelectionChangedEventHandler(this.ComboBox_SelectionChanged);
                return;

            case 5:
                ((Button) target).Click += new RoutedEventHandler(this.Button_Click);
                return;

            case 6:
                this.label1 = (Label) target;
                return;
        }
        this._contentLoaded = true;
    }

    private void UsernameLogin(object Sender, TextChangedEventArgs e)
    {
        this._User.User = this.TextBox.Text;
        Settings.Default.Username = this.TextBox.Text;
        Settings.Default.Save();
    }

    // Nested Types
    [CompilerGenerated]
    private struct <showMessageAsync>d__5 : IAsyncStateMachine
    {
        // Fields
        public int <>1__state;
        public AsyncTaskMethodBuilder <>t__builder;
        private TaskAwaiter<MessageDialogResult> <>u__1;
        public string v;

        // Methods
        private void MoveNext()
        {
            int num = this.<>1__state;
            try
            {
                TaskAwaiter<MessageDialogResult> awaiter;
                if (num != 0)
                {
                    awaiter = DialogManager.ShowMessageAsync(Application.Current.MainWindow as MetroWindow, "WaterHack", this.v, 0, null).GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        this.<>1__state = num = 0;
                        this.<>u__1 = awaiter;
                        this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<MessageDialogResult>, MainWindow.<showMessageAsync>d__5>(ref awaiter, ref this);
                        return;
                    }
                }
                else
                {
                    awaiter = this.<>u__1;
                    this.<>u__1 = new TaskAwaiter<MessageDialogResult>();
                    this.<>1__state = num = -1;
                }
                awaiter.GetResult();
                awaiter = new TaskAwaiter<MessageDialogResult>();
            }
            catch (Exception exception)
            {
                this.<>1__state = -2;
                this.<>t__builder.SetException(exception);
                return;
            }
            this.<>1__state = -2;
            this.<>t__builder.SetResult();
        }

        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            this.<>t__builder.SetStateMachine(stateMachine);
        }
    }
}