C#

.
.
.
MSG = lblMSG.Text.Trim();
SendKeys.Send(MSG);
SendKeys.SendWait("{ENTER}");
SendKeys.Flush();

sqlcomm = new SqlCommand("mainreport query", conn);           
 SqlDataAdapter dataAdapter = new SqlDataAdapter(sqlcomm);            
dataAdapter.Fill(dataset);            
this.reportViewer1.ProcessingMode = ProcessingMode.Local;            
this.reportViewer1.LocalReport.ReportPath = Application.StartupPath + "\\sale_dept.rdl";           
this.reportViewer1.LocalReport.DataSources.Clear();
this.reportViewer1.LocalReport.DataSources.Add(new Microsoft.Reporting.WinForms.ReportDataSource("DataSet1", dataset.Tables[0]));   
         this.reportViewer1.LocalReport.SubreportProcessing += new SubreportProcessingEventHandler(addsubreport); 
this.reportViewer1.LocalReport.Refresh(); 
this.reportViewer1.RefreshReport();
private void addsubreport(object sender, SubreportProcessingEventArgs e)       
 {            
SqlConnection conn = new SqlConnection(source);  
DataSet dataset = new DataSet();
conn.Open(); 
SqlCommand sqlcomm = new SqlCommand("subreport query", conn); 
 SqlDataAdapter dataAdapter = new SqlDataAdapter(sqlcomm); 
dataAdapter.Fill(dataset); 
e.DataSources.Add(new ReportDataSource("discount", dataset.Tables[0])); 
}

public class GlobalKeyboardHook
{
    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr hhk, int code, int wParam, ref keyBoardHookStruct lParam);
    [DllImport("user32.dll")]
    static extern IntPtr SetWindowsHookEx(int idHook, LLKeyboardHook callback, IntPtr hInstance, uint theardID);
    [DllImport("user32.dll")]
    static extern bool UnhookWindowsHookEx(IntPtr hInstance);
    [DllImport("kernel32.dll")]
    static extern IntPtr LoadLibrary(string lpFileName);

    public delegate int LLKeyboardHook(int Code, int wParam, ref keyBoardHookStruct lParam);

    public struct keyBoardHookStruct
    {
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
        public int dwExtraInfo;
    }

    const int WH_KEYBOARD_LL = 13;
    const int WM_KEYDOWN = 0x0100;
    const int WM_KEYUP = 0x0101;
    const int WM_SYSKEYDOWN = 0x0104;
    const int WM_SYSKEYUP = 0x0105;

    LLKeyboardHook llkh;
    public List<Keys> HookedKeys = new List<Keys>();

    IntPtr Hook = IntPtr.Zero;

    public event KeyEventHandler KeyDown;
    public event KeyEventHandler KeyUp;

    // This is the Constructor. This is the code that runs every time you create a new GlobalKeyboardHook object
    public GlobalKeyboardHook()
    {
        llkh = new LLKeyboardHook(HookProc);
        // This starts the hook. You can leave this as comment and you have to start it manually (the thing I do in the tutorial, with the button)
        // Or delete the comment mark and your hook will start automatically when your program starts (because a new GlobalKeyboardHook object is created)
        // That's why there are duplicates, because you start it twice! I'm sorry, I haven't noticed this...
        // hook(); <-- Choose!
    }
    ~GlobalKeyboardHook()
    { unhook(); }

    public void hook()
    {
        IntPtr hInstance = LoadLibrary("User32");
        Hook = SetWindowsHookEx(WH_KEYBOARD_LL, llkh, hInstance, 0);
    }

    public void unhook()
    {
        UnhookWindowsHookEx(Hook);
    }

    public int HookProc(int Code, int wParam, ref keyBoardHookStruct lParam)
    {
        if (Code >= 0)
        {
            Keys key = (Keys)lParam.vkCode;
            if (HookedKeys.Contains(key))
            {
                KeyEventArgs kArg = new KeyEventArgs(key);
                if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null))
                    KeyDown(this, kArg);
                else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null))
                    KeyUp(this, kArg);
                if (kArg.Handled)
                    return 1;
            }
        }
        return CallNextHookEx(Hook, Code, wParam, ref lParam);
    }

GlobalKeyboardHook gHook;
gHook = new GlobalKeyboardHook(); // Create a new GlobalKeyboardHook
gHook.KeyDown += new KeyEventHandler(gHook_KeyDown);
foreach (Keys key in Enum.GetValues(typeof(Keys)))
{
     gHook.HookedKeys.Add(key);
}
gHook.hook();
 public void gHook_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyValue == KeyPressg)  //Pause-Break //19
            {
                ProccName = (GetActiveWindowTitle().ToString());
                Start(ProccName);
                gHook.unhook();
                gHook.hook();
            }
            else
            {

            }
        }
  private string GetActiveWindowTitle()
        {
            const int nChars = 256;
            StringBuilder Buff = new StringBuilder(nChars);
            IntPtr handle = GetForegroundWindow();
            if (GetWindowText(handle, Buff, nChars) > 0)
            {
                return Buff.ToString();
            }

            return null;
        }

        [DllImport("user32.dll")]
        static extern IntPtr GetForegroundWindow();

        [DllImport("user32.dll", CharSet = CharSet.Auto)]<br />
        static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);

        [DllImport("user32.dll")]
        private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("user32.dll")]
        private static extern bool SetForegroundWindow(IntPtr hWnd);

        public void Start(string NAME)
        {

             MSG = lblMSG.Text.Trim();
            IntPtr zero = IntPtr.Zero;
            for (int i = 0; (i < 60) && (zero == IntPtr.Zero); i++) 
            {
                Thread.Sleep(500);
                zero = FindWindow(null, NAME);
            }
            if (zero != IntPtr.Zero)
            {
                try
                {
                    string text = lblMSG.Text.Trim();
                    text = text.Replace("gHook", "");

                    //OLD
                    //foreach (char c in text)
                    //    SendKeys.SendWait(c.ToString());

                    //NEW
                    if (text.Length == 0) return;
                    SendKeys.SendWait(text);

                    if (MyParam._KeyAfter == "Enter")
                    {
                        MyParam.FromKEY = true;
                        SendKeys.SendWait("{ENTER}");
                    }
                    else if (MyParam._KeyAfter == "TAB")
                    {
                        SendKeys.SendWait("{TAB}");
                    }
                    else if (MyParam._KeyAfter == "Key Down")
                    {
                        SendKeys.SendWait("{DOWN}");
                    }

                    SendKeys.Flush();

                }
                catch { }
            }
        }

public void Start(string NAME)
        {
            // --> NAME  Contain -->    Word‪ - 123.docx  for example when Word window open

<pre>
        MSG = lblMSG.Text.Trim();
        IntPtr zero = IntPtr.Zero;
        for (int i = 0; (i < 60) && (zero == IntPtr.Zero); i++) 
        {
            Thread.Sleep(500);
            zero = FindWindow(null, NAME);  // <-- in Word zero Always Contain 0  And never goes on in the code so stuck
        }
        // <--- the program stops here and stuck 
        if (zero != IntPtr.Zero)
        {</pre>

[DllImport("user32.dll")]
static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);

private string GetActiveWindowTitle()
{
    const int nChars = 256;
    StringBuilder Buff = new StringBuilder(nChars);
    IntPtr handle = GetForegroundWindow();
    if (GetWindowText(handle, Buff, nChars) > 0)
    {
        return Buff.ToString();
    }
    return null;
}

[DllImport("user32.dll")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

[DllImport("user32.dll")]
private static extern bool SetForegroundWindow(IntPtr hWnd);

public void Start(string NAME)
{
    MSG = lblMSG.Text.Trim();
    IntPtr zero = IntPtr.Zero;
    for (int i = 0; (i < 60) && (zero == IntPtr.Zero); i++)
    {
        Thread.Sleep(500);
        zero = FindWindow(null, NAME);
    }
    if (zero != IntPtr.Zero)
    {
       .
       .
       .
    }
}