Click here to Skip to main content
16,017,351 members
Articles / Programming Languages / C#

Window Hiding with C#

Rate me:
Please Sign up or sign in to vote.
4.89/5 (60 votes)
26 Mar 2012CPOL 356.7K   8.6K   166   46
A Window Hider program that demonstrates many C# features

Image 1

Introduction 

This source project will demonstrate the implementation of hot keys, enumerable collections, enums, binary serialization, DllImports of Win32 API, Window Enumeration, CallBacks/Delegates, Custom Events and Event Handlers, and more. It's quite a bit of code to look through but some of you may find it interesting.

Most of the heavy lifting in this project is in the Window and Windows classes that enumerate and manipulate the windows you choose:

C#
using System;
using System.Text;
using System.Collections;
using System.Runtime.InteropServices;

namespace WindowHider
{
    /// <summary>
    /// Object used to control a Windows Form.
    /// </summary>
    public class Window
    {
        /// <summary>
        /// Win32 API Imports
        /// </summary>
        [DllImport("user32.dll")] private static extern 
            bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);
        [DllImport("user32.dll")] private static extern 
            bool SetForegroundWindow(IntPtr hWnd);
        [DllImport("user32.dll")] private static extern 
            bool IsIconic(IntPtr hWnd);
        [DllImport("user32.dll")] private static extern 
            bool IsZoomed(IntPtr hWnd);
        [DllImport("user32.dll")] private static extern 
            IntPtr GetForegroundWindow();
        [DllImport("user32.dll")] private static extern 
            IntPtr GetWindowThreadProcessId(IntPtr hWnd, IntPtr ProcessId);
        [DllImport("user32.dll")] private static extern 
            IntPtr AttachThreadInput(IntPtr idAttach, IntPtr idAttachTo, int fAttach);

        /// <summary>
        /// Win32 API Constants for ShowWindowAsync()
        /// </summary>
        private const int SW_HIDE = 0;
        private const int SW_SHOWNORMAL = 1;
        private const int SW_SHOWMINIMIZED = 2;
        private const int SW_SHOWMAXIMIZED = 3;
        private const int SW_SHOWNOACTIVATE = 4;
        private const int SW_RESTORE = 9;
        private const int SW_SHOWDEFAULT = 10;

        /// <summary>
        /// Private Fields
        /// </summary>
        private IntPtr m_hWnd;
        private string m_Title;
        private bool m_Visible = true;
        private string m_Process;
        private bool m_WasMax = false;

        /// <summary>
        /// Window Object's Public Properties
        /// </summary>
        public IntPtr hWnd
        {
            get{return m_hWnd;}
        }
        public string Title
        {
            get{return m_Title;}
        }
        public string Process
        {
            get{return m_Process;}
        }

        /// <summary>
        /// Sets this Window Object's visibility
        /// </summary>
        public bool Visible
        {
            get{return m_Visible;}
            set
            {
                //show the window
                if(value == true)
                {
                    if(m_WasMax)
                    {
                        if(ShowWindowAsync(m_hWnd,SW_SHOWMAXIMIZED))
                            m_Visible = true;
                    }
                    else
                    {
                        if(ShowWindowAsync(m_hWnd,SW_SHOWNORMAL))
                            m_Visible = true;
                    }
                }
                //hide the window
                if(value == false)
                {
                    m_WasMax = IsZoomed(m_hWnd);
                    if(ShowWindowAsync(m_hWnd,SW_HIDE))
                        m_Visible = false;
                }
            }
        }

        /// <summary>
        /// Constructs a Window Object
        /// </summary>
        /// <param name="Title">Title Caption</param>
        /// <param name="hWnd">Handle</param>
        /// <param name="Process">Owning Process</param>
        public Window(string Title, IntPtr hWnd, string Process)
        {
            m_Title = Title;
            m_hWnd = hWnd;
            m_Process = Process;
        }

        //Override ToString() 
        public override string ToString()
        {
            //return the title if it has one, if not return the process name
            if (m_Title.Length > 0)
            {
                return m_Title;
            }
            else
            {
                return m_Process;
            }
        }

        /// <summary>
        /// Sets focus to this Window Object
        /// </summary>
        public void Activate()
        {
            if(m_hWnd == GetForegroundWindow())
                return;

            IntPtr ThreadID1 = GetWindowThreadProcessId(GetForegroundWindow(),
                                                        IntPtr.Zero);
            IntPtr ThreadID2 = GetWindowThreadProcessId(m_hWnd,IntPtr.Zero);
            
            if (ThreadID1 != ThreadID2)
            {
                AttachThreadInput(ThreadID1,ThreadID2,1);
                SetForegroundWindow(m_hWnd);
                AttachThreadInput(ThreadID1,ThreadID2,0);
            }
            else
            {
                SetForegroundWindow(m_hWnd);
            }

            if (IsIconic(m_hWnd))
            {
                ShowWindowAsync(m_hWnd,SW_RESTORE);
            }
            else
            {
                ShowWindowAsync(m_hWnd,SW_SHOWNORMAL);
            }
        }
    }

    /// <summary>
    /// Collection used to enumerate Window Objects
    /// </summary>
    public class Windows : IEnumerable, IEnumerator
    {
        /// <summary>
        /// Win32 API Imports
        /// </summary>
        [DllImport("user32.dll")] private static extern 
              int GetWindowText(int hWnd, StringBuilder title, int size);
        [DllImport("user32.dll")] private static extern 
              int GetWindowModuleFileName(int hWnd, StringBuilder title, int size);
        [DllImport("user32.dll")] private static extern 
              int EnumWindows(EnumWindowsProc ewp, int lParam); 
        [DllImport("user32.dll")] private static extern 
              bool IsWindowVisible(int hWnd);

        //delegate used for EnumWindows() callback function
        public delegate bool EnumWindowsProc(int hWnd, int lParam);

        private int m_Position = -1; // holds current index of wndArray, 
                                     // necessary for IEnumerable
        
        ArrayList wndArray = new ArrayList(); //array of windows
        
        //Object's private fields
        private bool m_invisible = false;
        private bool m_notitle = false;

        /// <summary>
        /// Collection Constructor with additional options
        /// </summary>
        /// <param name="Invisible">Include invisible Windows</param>
        /// <param name="Untitled">Include untitled Windows</param>
        public Windows(bool Invisible, bool Untitled)
        {
            m_invisible = Invisible;
            m_notitle = Untitled;

            //Declare a callback delegate for EnumWindows() API call
            EnumWindowsProc ewp = new EnumWindowsProc(EvalWindow);
            //Enumerate all Windows
            EnumWindows(ewp, 0);
        }
        /// <summary>
        /// Collection Constructor
        /// </summary>
        public Windows()
        {
            //Declare a callback delegate for EnumWindows() API call
            EnumWindowsProc ewp = new EnumWindowsProc(EvalWindow);
            //Enumerate all Windows
            EnumWindows(ewp, 0);
        }
        //EnumWindows CALLBACK function
        private bool EvalWindow(int hWnd, int lParam)
        {
            if (m_invisible == false && !IsWindowVisible(hWnd))
                return(true);

            StringBuilder title = new StringBuilder(256);
            StringBuilder module = new StringBuilder(256);

            GetWindowModuleFileName(hWnd, module, 256);
            GetWindowText(hWnd, title, 256);

            if (m_notitle == false && title.Length == 0)
                return(true);

            wndArray.Add(new Window(title.ToString(), (IntPtr)hWnd, 
                                    module.ToString()));

            return(true);
        }
        
        //implement IEnumerable
        public IEnumerator GetEnumerator()
        {
            return (IEnumerator)this;
        }
        //implement IEnumerator
        public bool MoveNext()
        {
            m_Position++;
            if (m_Position < wndArray.Count)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public void Reset()
        {
            m_Position = -1;
        }
        public object Current
        {
            get
            {
                return wndArray[m_Position];
            }
        }
    }
}

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Web Developer
United States United States
I write c#

Comments and Discussions

 
QuestionWindow Hiding with C# (View) Pin
Linhtv210-Dec-17 18:29
Linhtv210-Dec-17 18:29 
GeneralNICE Pin
Cosmic_Spy24-Feb-14 20:35
Cosmic_Spy24-Feb-14 20:35 
GeneralMy vote of 5 Pin
Albert Jann11-May-12 7:07
Albert Jann11-May-12 7:07 
Questionnot bad Pin
BillW3327-Mar-12 6:14
professionalBillW3327-Mar-12 6:14 
QuestionGreat article. Pin
JimShat3-Sep-11 16:45
JimShat3-Sep-11 16:45 
GeneralMy vote of 5 Pin
Jaikrishan17-Feb-11 0:45
Jaikrishan17-Feb-11 0:45 
GeneralMy vote of 4 Pin
Rajdeep Pathak20-Nov-10 0:09
Rajdeep Pathak20-Nov-10 0:09 
GeneralExcellent! Pin
flippydeflippydebop4-Oct-10 4:42
flippydeflippydebop4-Oct-10 4:42 
Questionhide window after startup ??? Pin
pukino1802-Oct-10 22:48
pukino1802-Oct-10 22:48 
GeneralMy vote of 5 Pin
alpesh_11_3_198914-Sep-10 2:30
alpesh_11_3_198914-Sep-10 2:30 
Generalreading control details on window Pin
Codecodile3-Oct-09 4:20
Codecodile3-Oct-09 4:20 
QuestionProblem with user32.dll API Pin
bennykatz20-Mar-09 9:20
bennykatz20-Mar-09 9:20 
GeneralHelp reqd for adding a button to a different app. Pin
aditya.jk@gmail.com19-Feb-09 5:36
aditya.jk@gmail.com19-Feb-09 5:36 
GeneralRe: Help reqd for adding a button to a different app. Pin
Codecodile3-Oct-09 4:23
Codecodile3-Oct-09 4:23 
GeneralCreate an application like Microsoft On Screen Keyboard. Pin
novarajat13-Dec-08 6:10
novarajat13-Dec-08 6:10 
GeneralRe: Create an application like Microsoft On Screen Keyboard. Pin
styloverte11618-Jan-09 11:14
styloverte11618-Jan-09 11:14 
Generalhiding window during a startup - shorter varinat Pin
drweb8615-Jul-08 3:28
drweb8615-Jul-08 3:28 
GeneralBug with .Net Form containing a TabControl (and correction). Pin
ikharus21-May-08 2:32
ikharus21-May-08 2:32 
QuestionProcess Handle? Pin
Martio17-Nov-07 10:32
Martio17-Nov-07 10:32 
AnswerRe: Process Handle? Pin
Martio17-Nov-07 10:36
Martio17-Nov-07 10:36 
GeneralRe: Process Handle? Pin
tajally123-Apr-08 23:15
tajally123-Apr-08 23:15 
General.net Lösung Pin
umbauer30-Sep-07 20:55
umbauer30-Sep-07 20:55 
Questioncapture application start? Pin
evrastil28-Aug-07 4:18
evrastil28-Aug-07 4:18 
Generalvista Pin
Mr Jen Withers17-Jun-07 3:41
Mr Jen Withers17-Jun-07 3:41 
GeneralRe: vista Pin
User 69352825-Jun-07 4:22
User 69352825-Jun-07 4:22 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.