• 0

[C#] List running Applications


Question

14 answers to this question

Recommended Posts

  • 0

Ack! My old thread! It lives again?

For anyone interested, here's how I ended up doing it.

private const int GWL_EXSTYLE = (-20);
        private const int WS_EX_TOOLWINDOW = 0x80;
        private const int WS_EX_APPWINDOW = 0x40000;
        private const int GW_OWNER = 4;
        public delegate int EnumWindowsProcDelegate(int hWnd, int lParam);
        [DllImport("user32")]
        private static extern int EnumWindows(Pop.EnumWindowsProcDelegate lpEnumFunc, int lParam);
        [DllImport("User32.Dll")]
        public static extern void GetWindowText(int h, StringBuilder s, int nMaxCount);
        [DllImport("user32", EntryPoint = "GetWindowLongA")]
        private static extern int GetWindowLongPtr(int hwnd, int nIndex);
        [DllImport("user32")]
        private static extern int GetParent(int hwnd);
        [DllImport("user32")]
        private static extern int GetWindow(int hwnd, int wCmd);
        [DllImport("user32")]
        private static extern int IsWindowVisible(int hwnd);
        [DllImport("user32")]
        private static extern int GetDesktopWindow();

        private static bool IsTaskbarWindow(int hWnd)
        {
            int lExStyle;
            int hParent;
            lExStyle = GetWindowLongPtr(hWnd, GWL_EXSTYLE);
            hParent = GetParent(hWnd);
            bool fTaskbarWindow = ((IsWindowVisible(hWnd) != 0) & (GetWindow(hWnd, GW_OWNER) == 0) & (hParent == 0 | hParent == GetDesktopWindow()));
            if ((lExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW)
            {
                fTaskbarWindow = false;
            }
            if ((lExStyle & WS_EX_APPWINDOW) == WS_EX_APPWINDOW)
            {
                fTaskbarWindow = true;
            }
            return fTaskbarWindow;
        }
        public static int EnumWindowsProc(int hWnd, int lParam)
        {
            if (IsTaskbarWindow(hWnd))
            {
                StringBuilder sb = new StringBuilder(1024);
                GetWindowText(hWnd, sb, sb.Capacity);
                String xMsg = sb.ToString();
                {
                    if (xMsg.Length > 0)
                    {
                        //Do whatever.
                    }
                }
            }
            return 1;
        }

Call it like so:

EnumWindows(EnumWindowsProc, 0);

  • 0
  Dayon said:
Ack! My old thread! It lives again?

For anyone interested, here's how I ended up doing it.

private const int GWL_EXSTYLE = (-20);
        private const int WS_EX_TOOLWINDOW = 0x80;
        private const int WS_EX_APPWINDOW = 0x40000;
        private const int GW_OWNER = 4;
        public delegate int EnumWindowsProcDelegate(int hWnd, int lParam);
        [DllImport("user32")]
        private static extern int EnumWindows(Pop.EnumWindowsProcDelegate lpEnumFunc, int lParam);
        [DllImport("User32.Dll")]
        public static extern void GetWindowText(int h, StringBuilder s, int nMaxCount);
        [DllImport("user32", EntryPoint = "GetWindowLongA")]
        private static extern int GetWindowLongPtr(int hwnd, int nIndex);
        [DllImport("user32")]
        private static extern int GetParent(int hwnd);
        [DllImport("user32")]
        private static extern int GetWindow(int hwnd, int wCmd);
        [DllImport("user32")]
        private static extern int IsWindowVisible(int hwnd);
        [DllImport("user32")]
        private static extern int GetDesktopWindow();

        private static bool IsTaskbarWindow(int hWnd)
        {
            int lExStyle;
            int hParent;
            lExStyle = GetWindowLongPtr(hWnd, GWL_EXSTYLE);
            hParent = GetParent(hWnd);
            bool fTaskbarWindow = ((IsWindowVisible(hWnd) != 0) & (GetWindow(hWnd, GW_OWNER) == 0) & (hParent == 0 | hParent == GetDesktopWindow()));
            if ((lExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW)
            {
                fTaskbarWindow = false;
            }
            if ((lExStyle & WS_EX_APPWINDOW) == WS_EX_APPWINDOW)
            {
                fTaskbarWindow = true;
            }
            return fTaskbarWindow;
        }
        public static int EnumWindowsProc(int hWnd, int lParam)
        {
            if (IsTaskbarWindow(hWnd))
            {
                StringBuilder sb = new StringBuilder(1024);
                GetWindowText(hWnd, sb, sb.Capacity);
                String xMsg = sb.ToString();
                {
                    if (xMsg.Length > 0)
                    {
                        //Do whatever.
                    }
                }
            }
            return 1;
        }

Call it like so:

EnumWindows(EnumWindowsProc, 0);

586592243[/snapback]

This looks great. But I'm confused about how exactly to use it.

I've got a form set up, and added another class to it: WindowScraper - which has the following code:

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace WindowScraper
{
	/// <summary>
	/// Summary description for WindowScraper.
	/// </summary>
	public class WindowScraper
	{
  public WindowScraper()
  {
  	//
  	// TODO: Add constructor logic here
  	//
  }

  /// <summary>
  /// Imported user32 functions.
  /// </summary>

  private const int GWL_EXSTYLE = (-20);
  private const int WS_EX_TOOLWINDOW = 0x80;
  private const int WS_EX_APPWINDOW = 0x40000;
  private const int GW_OWNER = 4;

  public delegate int EnumWindowsProcDelegate(int hWnd, int lParam);

  [DllImport("user32")]
  private static extern int EnumWindows(EnumWindowsProcDelegate lpEnumFunc, int lParam);

  [DllImport("User32.Dll")]
  public static extern void GetWindowText(int h, StringBuilder s, int nMaxCount);

  [DllImport("user32", EntryPoint = "GetWindowLongA")]
  private static extern int GetWindowLongPtr(int hwnd, int nIndex);

  [DllImport("user32")]
  private static extern int GetParent(int hwnd);

  [DllImport("user32")]
  private static extern int GetWindow(int hwnd, int wCmd);

  [DllImport("user32")]
  private static extern int IsWindowVisible(int hwnd);

  [DllImport("user32")]
  private static extern int GetDesktopWindow();

  /// <summary>
  /// Functions
  /// </summary>

  private static bool IsTaskbarWindow(int hWnd)
  {
  	int lExStyle;
  	int hParent;
  	lExStyle = GetWindowLongPtr(hWnd, GWL_EXSTYLE);
  	hParent = GetParent(hWnd);
  	bool fTaskbarWindow = ((IsWindowVisible(hWnd) != 0) & (GetWindow(hWnd, GW_OWNER) == 0) & (hParent == 0 | hParent == GetDesktopWindow()));
  	if ((lExStyle & WS_EX_TOOLWINDOW) == WS_EX_TOOLWINDOW)
  	{
    fTaskbarWindow = false;
  	}
  	if ((lExStyle & WS_EX_APPWINDOW) == WS_EX_APPWINDOW)
  	{
    fTaskbarWindow = true;
  	}
  	return fTaskbarWindow;
  }

  /// <summary>
  /// 
  /// </summary>
  /// <param name="hWnd"></param>
  /// <param name="lParam"></param>
  /// <returns></returns>

  public static int EnumWindowsProc(int hWnd, int lParam)
  {
  	if (IsTaskbarWindow(hWnd))
  	{
    StringBuilder sb = new StringBuilder(1024);
    GetWindowText(hWnd, sb, sb.Capacity);
    String xMsg = sb.ToString();
  	{
    if (xMsg.Length > 0)
    {
    	//Do whatever.
    }
  	}
  	}
  	return 1;
  }

	}
}

Now, In my form, I want to do the following: Create a function which Clears the listbox and adds an item for each found window (text). I know manipulate the listbox, obviously, but I don't know how to return a list of the window names.

I also want to return a list of the window handles, so that I can create bitmap's of them to save.

Any idea how to do this?

Thanks.

Oh, and one more thing, In the original code, this:

        [DllImport("user32")]
        private static extern int EnumWindows(Pop.EnumWindowsProcDelegate lpEnumFunc, int lParam);

Will not compile because pop is not a valid namespace. I deleted "pop." and it compiled fine, though i don't know if that will affect it working.

  • 0
  Bi0haZarD said:
Sep 7 2005 -> Dec 30 2005.

:blink:

lols.. :D

that was a stupid question !! I admit ! now dont gimme scary looks..

i was an open source guy thrown in this .net stuff by organization, so got stuck up that time.. lols

well for rest, it worked for me too, if anyone need help, post.

  • 0
  aby said:
just one problem, how did you invoke "EnumWindowsProc"?

You don't. The window manager does. EnumWindowsProc is a callback function. You define the function, pass a function pointer (delegate) in the EnumWindows call, and then EnumWindows will call you back by calling that function once for every window in its list.

  Goalie_CA said:
WEll, i believe the terminology in windows is a "job". A "job" contains several processes which in turn contains several threads.

That is not correct. Well, it is correct that Windows has a concept called "job" that groups processes together. But it has nothing to do with what shows up in the Applications tab of Task Manager.

That list uses a similar mechanism to what the taskbar uses. It enumerates top-level windows and decides whether to display each one based on specific properties (WS_EX_APPWINDOW, etc).

  • 0

hey thanks Brandon,

but I've already found the solution. yes the same way I did.

  Brandon Live said:
You don't. The window manager does. EnumWindowsProc is a callback function. You define the function, pass a function pointer (delegate) in the EnumWindows call, and then EnumWindows will call you back by calling that function once for every window in its list.

That is not correct. Well, it is correct that Windows has a concept called "job" that groups processes together. But it has nothing to do with what shows up in the Applications tab of Task Manager.

That list uses a similar mechanism to what the taskbar uses. It enumerates top-level windows and decides whether to display each one based on specific properties (WS_EX_APPWINDOW, etc).

This topic is now closed to further replies.
  • Recently Browsing   0 members

    • No registered users viewing this page.
  • Posts

    • If you look at all RAID implementations that exist, you're going to find exceptions. However, all the modern consumer varieties tend to have some things in common (by default). I'll stick to describing those. When you add a disk to a RAID array, metadata is stored at the end of the disk. It records the array the disk is part of, which other disks are in the array, etc. This is called the RAID superblock. If you create a RAID 1 array, your operating system will see them all as a single disk that is very slightly smaller than a single disk (due to the superblock). Everything you write to the RAID disk gets written identically to each of its member disks by the storage controller. Technically, disks are read/written in blocks (each block is multiple sectors in size), but this is all transparent to the user. Every file you create or change or delete is created/changed/deleted on every member disk simultaneously. This is true whether you have 2 disks in the array or more than 2.  If one disk completely fails, you can still operate just fine off the remaining disk(s) (but see the caution below). If you remove one disk and attach it to another PC, it should work fine. The partition information and everything is all at the front of the disk, just as expected. The superblock will just appear as some extra junk at the very end of the disk, outside any partition. In some scenarios, where it is recognized as a RAID member disk from another PC, there might be an extra step before it will let you use it, but it's all very doable. Caution:  Blocks are read from the disks in a staggered fashion. For example, with 2 disks, all the odd blocks are read from one disk and all the even blocks are read from the other. By working together like this, read speeds can be practically doubled. But this comes with a huge drawback. If a disk doesn't fail completely, but instead develops bad sectors, you may not realize it. The bad sectors may happen to be in blocks that are never read on that disk. In some cases, people have had bad sectors develop on one disk, then had the other disk fail, and only then realized that the remaining disk has bad sectors and corrupt data. Every backup method has its pros and cons. Never trust just RAID, or just an external HDD, or just the cloud. Use multiple methods to backup important data.
    • Evidence that it affects "most" people negatively? Based on what? The fact that their are millions of users in fact show me the opposite, that "most" are quite happy.
  • Recent Achievements

    • Conversation Starter
      Kavin25 earned a badge
      Conversation Starter
    • One Month Later
      Leonard grant earned a badge
      One Month Later
    • Week One Done
      pcdoctorsnet earned a badge
      Week One Done
    • Rising Star
      Phillip0web went up a rank
      Rising Star
    • One Month Later
      Epaminombas earned a badge
      One Month Later
  • Popular Contributors

    1. 1
      +primortal
      537
    2. 2
      ATLien_0
      205
    3. 3
      +FloatingFatMan
      167
    4. 4
      Michael Scrip
      151
    5. 5
      Som
      127
  • Tell a friend

    Love Neowin? Tell a friend!