C#

Window 00040616 "C:\DummyRepo - Log Messages - TortoiseGit" #32770 (Dialog)

[DllImport("user32.dll", EntryPoint = "GetWindowText",
ExactSpelling = false, CharSet = CharSet.Auto, SetLastError = true)]
public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpWindowText, int nMaxCount);

private bool checkWindow(IntPtr hWnd, IntPtr lp)
{
    // Checks if <hWnd> is a dialog
    StringBuilder sb = new StringBuilder(260);
    GetClassName(hWnd, sb, sb.Capacity);

    // My added code to log all window texts
    StringBuilder strbTitle = new StringBuilder(255);
    int nLength = GetWindowText(hWnd, strbTitle, strbTitle.Capacity + 1);
    string strTitle = strbTitle.ToString();
    Debug.WriteLine("The window text is: " + strTitle);

    if (sb.ToString() != "#32770")
    {
        return true;
    }
    return true;    // My modified code to check all windows

return true;    // My modified code to check all windows

Window 000C0678 "C:\DummyRepo - Switch/Checkout - TortoiseGit" #32770 (Dialog)

const uint WM_GETTEXT = 0x000D;
StringBuilder message = new StringBuilder(1000);
SendMessage(handle, WM_GETTEXT, message.Capacity, message);

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        WindowWrapper parentForm = ProcessWindowsHelper.getHandleToAnotherProcessWindow("TortoiseGitProc", "Switch/Checkout");
        MessageBoxEx.Show(parentForm, "Hello on top of TortoiseGit Switch/Checkout dialog");
    }
}
public class ProcessWindowsHelper
{
    private delegate bool EnumThreadWndProc(IntPtr hWnd, IntPtr lp);
    [DllImport("user32.dll")]
    private static extern bool EnumThreadWindows(int tid, EnumThreadWndProc callback, IntPtr lp);
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, int wParam, StringBuilder lParam);
    delegate bool EnumThreadDelegate(IntPtr hWnd, IntPtr lParam);

    private const uint WM_GETTEXT = 0x000D;

    public static WindowWrapper getHandleToAnotherProcessWindow(string processName, string substringInAnotherProcessWindow)
    {
        Process myProcess = findProcessByName(processName);
        IEnumerable<IntPtr> allHandlesInMyProcess = EnumerateProcessWindowHandles(myProcess.Id);
        foreach (IntPtr handle in allHandlesInMyProcess)
        {
            StringBuilder message = new StringBuilder(1000);
            SendMessage(handle, WM_GETTEXT, message.Capacity, message);
            if (message.ToString().Contains(substringInAnotherProcessWindow))
            {
                Debug.WriteLine(message);
                return new WindowWrapper(handle);
            }
        }
        return null;
    }

    private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
    {
        List<IntPtr> handles = new List<IntPtr>();
        ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
        for (int i = 0; i < processThreadCollection.Count; i++)
        {
            ProcessThread thread;
            thread = processThreadCollection[i];
            EnumThreadWindows(thread.Id, 
                delegate(IntPtr hWnd, IntPtr lParam)
                {
                    handles.Add(hWnd);
                    return true;
                }, 
                IntPtr.Zero);
        }
        return handles;
    }

    private static Process findProcessByName(string processName)
    {
        Process[] allProcesses = Process.GetProcesses();
        for (int j = 0; j < allProcesses.Length; j++)
        {
            if (allProcesses[j].ProcessName.Equals(processName))
            {
                return allProcesses[j];
            }
        }
        return null;
    }
}


public class WindowWrapper : IWin32Window
{
    public WindowWrapper(IntPtr handle)
    {
        _hwnd = handle;
    }

    public IntPtr Handle
    {
        get { return _hwnd; }
    }

    private IntPtr _hwnd;
}

parentForm = ProcessWindowsHelper.getHandleToAnotherProcessWindow("bash", "MING")

private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
{
    List<IntPtr> handles = new List<IntPtr>();
    ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
    for (int i = 0; i < processThreadCollection.Count; i++)
    {
        ProcessThread thread;
        thread = processThreadCollection[i];
        EnumThreadWindows(thread.Id,
            delegate(IntPtr hWnd, IntPtr lParam)
            {
                handles.Add(hWnd);
                return true;
            },
            IntPtr.Zero);
    }
    return handles;
}

Window OOOA9B72 "MINGW64:/c/dummyRepo" mintty

Window Caption: MINGW64:/c/dummyRepo
Window Handle:  OOOA9B72
Window Proc:    (Unavailable)(Unicode)
Rectangle:      (86, 89)-(681, 466), 595x377
Restored Rect:  (86, 89)-(681, 466), 595x377
Client Rect:    (8, 31)-(570, 369), 562x338
Instance Handle 00400000
Menu Handle     00000000
User Data       00000000
Windows Bytes:

private static List<IntPtr> handles;

private static IEnumerable<IntPtr> EnumerateProcessWindowHandles(int processId)
{
    handles = new List<IntPtr>();
    ProcessThreadCollection processThreadCollection = Process.GetProcessById(processId).Threads;
    for (int i = 0; i < processThreadCollection.Count; i++)
    {
        ProcessThread thread;   // If I put a breakpoint here, the debugger stops 3 times
        thread = processThreadCollection[i];
        EnumThreadWindows(thread.Id, myDelegate, IntPtr.Zero);
    }
    return handles;
}

private static bool myDelegate(IntPtr hWnd, IntPtr lParam)
{
    handles.Add(hWnd);  // If I put a breakpoint here, then the debugger never stops
    return true;
}

$ git.exe checkout develop

pkfox wrote:

It must be the UI thread in Winforms

this.GetAccessToken().GetAwaiter().GetResult(); // Blocks the UI thread

this.Result = await this.App.AcquireTokenForClient(this.ResourceIds).ExecuteAsync().ConfigureAwait(false);

private void ButtonClick(object sender, EventArgs e)
{
    // Some code...
    this.GetAccessToken().GetAwaiter().GetResult();
    // Some more code...
}

private async void ButtonClick(object sender, EventArgs e)
{
    // Some code...
    await this.GetAccessToken();
    // Some more code
}

private void ButtonClick(object sender, EventArgs e)
{
    _ = SomeMethodAsync();
}

private async Task SomeMethodAsync()
{
    // Some code...
    await this.GetAccessToken();
    // Some more code
}