C# - How can I rename a process window that I started?

Question

Is there any way I can rename the window titlebar of an application that I've launched? I.e. if I launched Notepad.exe, I could rename its title bar from "Untitled - Notepad" to "New Notepad Name".

Inexecution

Do you mean while it's running? – Terraqueous

Yep... although if I could specify the title bar before I launch the process, that would also be acceptable. – Inexecution

Generally, not unless the application supports that. Many don't. Notepad includes the name of the file currently open in its title bar, for example, and does not support any other changes to the title. On the other hand, CMD.EXE has the built-in command TITLE that allows the title of the console window to be controlled. – Mitchelmitchell

Unless the app supports it as RBerteig mentions, I can't think of a way to do that. – Terraqueous

Answer 1

You can do it using P/Invoke:

[DllImport("user32.dll")]
static extern int SetWindowText(IntPtr hWnd, string text);



private void StartMyNotepad()
{
    Process p = Process.Start("notepad.exe");
    Thread.Sleep(100);  // <-- ugly hack
    SetWindowText(p.MainWindowHandle, "My Notepad");
}

The background of the ugly hack in the code sample is that it seems as if you call SetWindowText immediately after starting the process, the title will not change. Perhaps the message ends up too early in the message queue of Notepad, so that notepad will set the title again afterwards.

Also note that this is a very brief change; if the user selects File -> New (or does anything else that will cause Notepad to update the window title), the original title will be back...

Garica

Like I said in my answer and a comment on the question, Notepad (and most other apps) don't support this. Forcing the title to change with SetWindowText() is not a real solution because the App will just put it back at some moment of its own choosing. – Mitchelmitchell

It is a solution to my problem as the app I'm using wont ever set it back. I only used notepad as an example. Plus if you really wanted to, it's quite simple to create your own event to handle the window handle's title change and then reset it again. – Inexecution

Just to note on the 'ugly hack', I didn't require that as I already had control of the process and know that it's running with it's titlebar visible. – Inexecution

I would argue that changing another application's window title is a Really Bad Idea if it wasn't designed to support it through a documented API of some form. – Mitchelmitchell

MS recommends calling WaitForInputIdle where you have the Sleep call. msdn.microsoft.com/en-us/library/… This takes it from "Hack" to "Recommended Practice" (which I've found necessary some of the time) – Demagoguery

Answer 2

Actually, I sorted it myself and it works perfectly. Thanks anyway.

[DllImport("user32.dll")]
static extern SetWindowText(IntPtr hWnd, string windowName);

IntPtr handle = p.MainWindowHandle;
SetWindowText(handle, "This is my new title");

Inexecution

Don't expect your title to survive past the arbitrary event in the other application that causes it to update its title. Notepad will do that when the user opens a different document, chooses File|New, or File|Save As for instance. – Mitchelmitchell

I just created an event to handle such a possibility, so as soon as the text changes, it's set back again. – Inexecution

Answer 3

As @Fredrik Mörk thinks, the problem is that there's need to wait for the window to be able to receive messages, before its title can be set. Waiting 100 milliseconds can break the internal message looper of the program and it's just a workaround. To receive a message, the window must have a handle that's used for referencing that window, thus you can simply wait for the window to have a handle, like this:

Process p = Process.Start("notepad.exe");
while (p.MainWindowHandle == IntPtr.Zero)
    Application.DoEvents();
SetWindowText(p.MainWindowHandle, "My Notepad");

Using Application.DoEvents() the program will continue to receive and process system messages, so it won't block (nor crash), although it isn't asynchronous.

You can also think to avoid CPU overhead by replacing the while statement with a SpinWait.SpinUntil call (from System.Threading):

Process p = Process.Start("notepad.exe");
SpinWait.SpinUntil(() => p.MainWindowHandle != IntPtr.Zero);
SetWindowText(p.MainWindowHandle, "My Notepad");

Otterburn

This was the easiest to implement using the SpinWait option. I used slightly more compact notation: SpinWait.SpinUntil( () => p.MainWindowHandle != IntPtr.Zero ); – Floccule

You're right, @Marc Meketon. The syntax I had been using looked old and weird, lambdas are more friendly. I've just updated my answer. Thanks for your remark – Otterburn

After implementing this, I ran into an error that needed an adjustment of the SpinUntil condition. I just left a new answer so I could display the complete code.. – Floccule

Thanks, @Marc Meketon. I didn't face that issue when I've written the answer, so I'm happy that you have found a solution to a problem you noticed yourself. – Otterburn

Answer 4

You can't do it in C#, but you can do it using low level API. Inject a thread into the process, call SetWindowText() from it

Federal

Any app that uses the title to convey information will overwrite that text with its own at some point, as Notepad does. – Mitchelmitchell

Answer 5

I implemented @Davide Cannizo solution and found an issue that is probably also true with other solutions that loop - that the process could have finished before realization that the MainWindowHandle is non-zero. This happened to me when I ran a lot of processes in parallel and one or two were very short-lived. The specific issue was a SystemAggregrationError because the check p.MainWindowHandle != IntPtr.Zero was causing multiple InvalidOperationError's.

The solution was to add a check on whether the process exited. Look for the p.HasExited below.

using System;
using System.Runtime.InteropServices;

class Program
{
  [DllImport("user32.dll")]
  static extern int SetWindowText(IntPtr hWnd, string text);

  static void Main(string[] args)
  {
    using (System.Diagnostics.Process p = new System.Diagnostics.Process())
    {
      p.StartInfo = new System.Diagnostics.ProcessStartInfo()
      {
        FileName = @"notepad.exe",
        Arguments = @""
      };

      string window_title = "notepad demo";
      p.Start();
      System.Threading.SpinWait.SpinUntil(() => p.HasExited || p.MainWindowHandle != IntPtr.Zero);
      if (!p.HasExited)
        SetWindowText(p.MainWindowHandle, window_title);
      p.WaitForExit();
    }
  }
}

Two other things to note:

• in developing this, I first tried to use .NET Core. That failed - p.MainWindowHandler was always 0. I had to switch to .NET Framework.
• I do not believe that SetWindowText(p.MainWindowHandle, window_title) causes an exception if the process has exited. According to the documentation here, it can fail but will only return 0 instead of a non-zero. That means that if we finish the SpinUntil because the MainWindowHandle is non-zero, but between that point and the SetWindowText the process exited, it will not cause an exception. However, in my testing I did have to add the if (!p.HasExited) line.

Floccule

Thanks - It is working fine, but I had to remove "p.WaitForExit();". In my case, I do not wait for exit (e.g. launching a shell renaming its title). – Martynne

Answer 6

I had to use the following code to get it work:

while (p.MainWindowHandle == IntPtr.Zero)
      Thread.Sleep(100);

Villada

Answer 7

No.

This would require that the target application allow the window title to be modified at all. Many programs use their titles to show useful information (such as the name of the file open for editing in Notepad, or the <TITLE> of the HTML document open in Firefox).

The one case I am aware of that lets a user set the title text with few restrictions is CMD.EXE running in a console window. CMD supports the TITLE built-in command that sets the window title based on its arguments. But that can't be done by a second window without injecting key strokes into the particular console window, which is generally not recommended.

Edit:

Since the idea is floating that SetWindowText() will do this for you, let me clarify.

That API function does indeed change the title bar of a top level window. It is, in fact, the call that an application like Notepad is likely using to set its own title any time it thinks that the title has changed.

The reason I claim that this is not a solution is that Notepad does indeed change the title when it wants to. An application that supported arbitrary changes to its title would have a mechanism of some kind to remember that the title was changed and not arbitrarily restore its preferred title string.

Mitchelmitchell

SetWindowText IS a solution to the problem. It performs exactly what I asked for, therefore there's no denying it's a solution to the problem. I didn't actually ask for it to be permanent anyway, but like I've posted in other comments, there's an easy workaround to keep it permanent anyway. – Inexecution

It is not a general solution. You asked for a general solution, and used an application that maintains information in the title as an example. – Mitchelmitchell