Question

I am writing a Console application using C#, in which I am firing Print jobs through code. My issue is I do not know how much time I should wait for Print Dialog after sending commands to Print. For the time being I am using Thread sleep of 1000 milliseconds.

//Sending Commands to Print(to press "Ctrl+P" button).
 SendKeys.SendWait("^(p)");

 Thread.Sleep(1000);

 //Sending Commands to Print(to press "Enter" Button).
 SendKeys.SendWait("{ENTER}");

Can anybody help me to fix this issue please. Any help will be appreciated.

Thanks in advance

Update:

Here is my whole code:

//Launch the file from the location specified in.
White.Core.Application application =White.Core.Application.Launch(@path);

Console.WriteLine("launch is done");

Thread.Sleep(_delayOfPrint);

//Sending Commands to Print(to press "Ctrl+P" button).
SendKeys.SendWait("^(p)");

Thread.Sleep(1000);

//Sending Commands to Print(to press "Enter" Button).
SendKeys.SendWait("{ENTER}");

//Get the current time as the document fired for print job.
_printedTime = DateTime.Now;

Thread.Sleep(1500);

//Closing the window.
SendKeys.SendWait("%{F4}");

Answer 1

I would have a maximum wait of a few seconds, but during that time I would periodically use the Win32 function FindWindowEx to see if the print dialog actually came up, and if so proceed. You can get a process’ main window with code like this:

Process[] processes = Process.GetProcessesByName(appName);
foreach (Process p in processes)
{
     IntPtr pFoundWindow = p.MainWindowHandle;
}

You can then pass the found main window handle to FindWindowEx to peruse the child windows to check for the print dialog. FindWindowEx has PInvoke signatures like this:

[DllImport("user32.dll", SetLastError = true)]
static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);

[DllImport("user32.dll", SetLastError = true)]
public static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string className,  IntPtr windowTitle);

Edit 2: Since the OP seems to be demanding I give a perfectly working function, I wrote a general one that does the trick and tested it. Here it is, working general code to wait for any child window. Call as WaitForChildWindow(“myApp”, “Print”, 5000) for this case:

/// <summary>
/// Wait for a child window of an application to appear
/// </summary>
/// <param name="appName">Application name to check (will check all instances)</param>
/// <param name="childWindowName">Name of child window to look for (titlebar)</param>
/// <param name="timeout">Maximum time, in milliseconds, to wait</param>
/// <returns>True if the window was found; false if it wasn't.</returns>
public static bool WaitForChildWindow(string appName, string childWindowName, int timeout)
{
    int sleepTime = timeout;
    while (sleepTime > 0)
    {
        Process[] processes = Process.GetProcessesByName(appName);
        foreach (Process p in processes)
        {
            IntPtr pMainWindow = p.MainWindowHandle;
            IntPtr pFoundWindow = FindWindowEx(pMainWindow, IntPtr.Zero, null, childWindowName);
            if (pFoundWindow != IntPtr.Zero)
                return true;
        }
        Thread.Sleep(100);
        sleepTime -= 100;
    }

    // Timed out!
    return false;
}

Edit 3: Here’s another way of doing it for merely owned windows that don’t have a child relationship:

[DllImport("user32.dll", SetLastError = true)]
static extern uint GetWindowThreadProcessId(IntPtr hwnd, IntPtr processId);
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool EnumThreadWindows(uint dwThreadId, EnumThreadDelegate lpfn, IntPtr lParam);
[DllImport("user32", SetLastError = true, CharSet = CharSet.Auto)]
private extern static int GetWindowText(IntPtr hWnd, StringBuilder text, int maxCount);

public delegate bool EnumThreadDelegate(IntPtr hwnd, IntPtr lParam);

static bool EnumThreadCallback(IntPtr hWnd, IntPtr lParam)
{
    StringBuilder text = new StringBuilder(500);
    GetWindowText(hWnd, text, 500);
    if (text.ToString() == "Print")
        return false;
    return true;
}

public static bool FindThreadPrintWindow(uint threadId)
{
    return !EnumThreadWindows(threadId, EnumThreadCallback, IntPtr.Zero);
}

public static bool WaitForOwnedPrintWindow(string appName, int timeout)
{
    int sleepTime = timeout;
    while (sleepTime > 0)
    {
        Process[] processes = Process.GetProcessesByName(appName);
        foreach (Process p in processes)
        {
            IntPtr pMainWindow = p.MainWindowHandle;
            uint threadId = GetWindowThreadProcessId(pMainWindow, IntPtr.Zero);
            if (FindThreadPrintWindow(threadId))
                return true;
        }
        Thread.Sleep(100);
        sleepTime -= 100;
    }

    // Timed out!
    return false;
}