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);
        }
      }
    }
  }
}

Computafreak wrote:

That seems a little odd. What if I've got a window of my own which has got the title "Mozilla Firefox Bookmark Importer"? It might be more effective to alter EnumWindowsProc so that it gets the process id of the given handle, and closes the window if the process id is correct.

int i = 0;

foreach (Process p in Process.GetProcessesByName("firefox"))
    Console.WriteLine(i = p.Id);
if (i != 0)
    Process.GetProcessById(i).Kill();