C#

// FormButton.cs
using System;
using System.Windows.Forms;

public partial class FormButton : Form
{
    public FormButton()
    {
        InitializeComponent();
    }

    private void FormButton_Load(object sender, EventArgs e)
    {
        FormCheckBox formCheckBox = new FormCheckBox();
        formCheckBox.CheckStateChanged += formCheckBox_CheckStateChanged;
        formCheckBox.Show();
    }

    void formCheckBox_CheckStateChanged(object sender, CheckStateEventArgs e)
    {
        button1.Enabled = e.IsChecked;
    }
}

// FormCheckBox.cs
using System;
using System.Windows.Forms;

public partial class FormCheckBox : Form
{
    public event EventHandler<CheckStateEventArgs> CheckStateChanged;
    public FormCheckBox()
    {
        InitializeComponent();
    }

    private void checkBox1_CheckStateChanged(object sender, EventArgs e)
    {
        OnCheckStateChanged(new CheckStateEventArgs(checkBox1.Checked));
    }

    protected virtual void OnCheckStateChanged(CheckStateEventArgs e)
    {
        EventHandler<CheckStateEventArgs> eh = CheckStateChanged;
        if (eh != null)
            eh(this, e);
    }
}

// CheckStateEventArgs.cs
public class CheckStateEventArgs : EventArgs
{
    public CheckStateEventArgs(bool isChecked)
    {
        IsChecked = isChecked;
    }
    public bool IsChecked
    {
        get;
        private set;
    }
}

{
// Add the event handler for handling UI thread exceptions to the event.
    Application.ThreadException += new ThreadExceptionEventHandler(MyErrorHandler);

// Set the unhandled exception mode to force all Windows Forms errors 
// to go through our handler.
    Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
    Application.Run(new Form1());
}

private static void MyErrorHandler(object sender, ThreadExceptionEventArgs t)
{
    ShowMessage(t.ToString());
}

I are Troll

PC17 wrote:

I look for a code!

I are Troll

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.ComponentModel;

namespace KillFirefox
{
  class Program
  {

    static void Main(string[] args)
    {
      KillWindowProcesses.KillProcess("Mozilla Firefox");
    }


    /// <summary>
    /// Certain window applications open up multiple top level windows, but only
    /// run as one process. This makes them difficult to kill using the standard
    /// <see cref="Process"/> methods. This class provides the ability to kill a
    /// process based on it's name.
    /// </summary>
    public class KillWindowProcesses
    {
      const int MAXTITLE = 255;
      const int WM_CLOSE = 0x0010;
      private static string name = string.Empty;

      private delegate bool EnumDelegate(IntPtr hWnd, int lParam);

      [DllImport("user32.dll", EntryPoint = "EnumDesktopWindows",
       ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
      private static extern bool _EnumDesktopWindows(
        IntPtr hDesktop,
        EnumDelegate lpEnumCallbackFunction, 
        IntPtr lParam);

      [DllImport("user32.dll", EntryPoint = "GetWindowText",
       ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
      private static extern int _GetWindowText(
        IntPtr hWnd,
        StringBuilder lpWindowText, 
        int nMaxCount);

      // Used to post the close message
      [return: MarshalAs(UnmanagedType.Bool)]
      [DllImport("user32.dll", SetLastError = true)]
      static extern bool PostMessage(
        IntPtr hWnd, 
        uint Msg, IntPtr 
        wParam, IntPtr 
        lParam);

      public static void KillProcess(string processName)
      {
        name = processName;
        // Retrieve the list of processes.
        GetDesktopWindowsCaptions();
      }

      /// <summary>
      /// Call the PostMessage API.
      /// </summary>
      private static void PostMessageSafe(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
      {
        bool returnValue = PostMessage(hWnd, msg, wParam, lParam);
        if (!returnValue)
        {
          // An error occured
          throw new Win32Exception(Marshal.GetLastWin32Error());
        }
      }

      /// <summary>
      /// Callback method for the enumerate windows procedure.
      /// </summary>
      private static bool EnumWindowsProc(IntPtr hWnd, int lParam)
      {
        string title = GetWindowText(hWnd);
        if (!string.IsNullOrEmpty(title) && title.Contains(name))
        {
          PostMessageSafe(hWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
        }
        return true;
      }

      /// <summary>
      /// Returns the caption of a windows by given HWND identifier.
      /// </summary>
      private static string GetWindowText(IntPtr hWnd)
      {
        StringBuilder title = new StringBuilder(MAXTITLE);
        int titleLength = _GetWindowText(hWnd, title, title.Capacity + 1);
        title.Length = titleLength;

        return title.ToString();
      }

      /// <summary>
      /// Returns the caption of all desktop windows.
      /// </summary>
      private static void GetDesktopWindowsCaptions()
      {
        EnumDelegate enumfunc = new EnumDelegate(EnumWindowsProc);
        IntPtr hDesktop = IntPtr.Zero; // current desktop
        bool success = _EnumDesktopWindows(hDesktop, enumfunc, IntPtr.Zero);

        if (!success)
        {
          // Get the last Win32 error code
          int errorCode = Marshal.GetLastWin32Error();

          string errorMessage = String.Format(
          "EnumDesktopWindows failed with code {0}.", errorCode);
          throw new Exception(errorMessage);
        }
      }
    }
  }
}