Fenster Anwendung Flash wie Orange auf Taskleiste, wenn minimieren

Question

Ich habe eine Anwendung Fenster. wenn ich die Fensteranwendung in der Taskleiste minimiere, um an einer anderen Anwendung zu arbeiten. Wir haben eine Einrichtung wie Senden einer Nachricht von einem Fenster Anwendung zu einem anderen Fenster Anwendung

so meine erste Win-Anwendung minimieren und jetzt öffne ich meine andere Win-Anwendung und dann Nachricht an die erste Anwendung senden, aber erste Anwendung ist auf der Taskleiste. also möchte ich Funktionalität wie wenn jede Nachricht erfassen meine erste Anwendung dann wird es blinken wie Skype oder Messenger.

Ich hatte "FlashWindowEx" Methode von User32.dll versucht. aber kein Glück. Ich hatte mit der Option "Flash kontinuierlich versucht, bis das Fenster in den Vordergrund kommt". aber kein Glück.

Bitte helfen, dieses Problem mit Beispiel zu lösen

Dank

Answer 1

C#: Flash Window in Taskbar via Win32 FlashWindowEx es für mich funktioniert.

Die Windows-API (Win32) verfügt über die FlashWindowEx-Methode innerhalb der User32-Bibliothek ; Mit dieser Methode können Sie (der Entwickler) ein Fenster mit dem Namen flashen, das dem Benutzer anzeigt, dass ein wichtiges Ereignis innerhalb der Anwendung aufgetreten ist, die seine Aufmerksamkeit erfordert. Die häufigste Verwendung dieser ist, das Fenster zu blinken, bis der Benutzer den Fokus auf die Anwendung zurückgibt. Sie können aber auch das Fenster einer bestimmten Nummer mal aufblitzen lassen, oder einfach weiter blitzen, bis Sie entscheiden, wann Sie aufhören sollen.

Die Verwendung der FlashWindowEx-Methode ist jedoch nirgends in das .NET Framework integriert. Um darauf zugreifen zu können, müssen Sie die Platform Invoke (PInvoke) -Features von .NET verwenden, um die Windows-API (Win32) aufzurufen und direkt aufzurufen. Wie bei vielen anderen Funktionen in der Windows-API (die nicht direkt von .NET verfügbar gemacht werden) kann die FlashWindowEx-Methode ein wenig schwierig zu verwenden sein, wenn Sie nicht mit der Windows-API von innen vertraut sind. NETZ.

Jetzt anstatt gehen zu tief in die Besonderheiten von PInvoke oder der Win32 FlashWindowEx Methode ist unten eine einfache statische Klasse in C#, die Sie diese Methode leicht nutzen kann. Es gibt tatsächlich ziemlich viel von Informationen benötigt, um zu erklären, wie man PInvoke verwendet, um die Windows API (Win32) zu verwenden, also werde ich das vielleicht in einem zukünftigen Artikel behandeln.

Hier einige Beispiele für die Verwendung dieser statischen Klasse:

// One this to note with this example usage code, is the "this" keyword is referring to 
// the current System.Windows.Forms.Form. 

// Flash window until it recieves focus 
FlashWindow.Flash(this); 

// Flash window 5 times 
FlashWindow.Flash(this, 5); 

// Start Flashing "Indefinately" 
FlashWindow.Start(this); 

// Stop the "Indefinate" Flashing 
FlashWindow.Stop(this); 

Einer Sache zu beachten über die FlashWindowEx Methode ist, dass es erfordert (und funktioniert nur auf) Windows 2000 oder höher.

Hier ist der Code für die statische Klasse in C#:

public static class FlashWindow 
{ 
    [DllImport("user32.dll")] 
    [return: MarshalAs(UnmanagedType.Bool)] 
    private static extern bool FlashWindowEx(ref FLASHWINFO pwfi); 

    [StructLayout(LayoutKind.Sequential)] 
    private struct FLASHWINFO 
    { 
     /// <summary> 
     /// The size of the structure in bytes. 
     /// </summary> 
     public uint cbSize; 
     /// <summary> 
     /// A Handle to the Window to be Flashed. The window can be either opened or minimized. 
     /// </summary> 
     public IntPtr hwnd; 
     /// <summary> 
     /// The Flash Status. 
     /// </summary> 
     public uint dwFlags; 
     /// <summary> 
     /// The number of times to Flash the window. 
     /// </summary> 
     public uint uCount; 
     /// <summary> 
     /// The rate at which the Window is to be flashed, in milliseconds. If Zero, the function uses the default cursor blink rate. 
     /// </summary> 
     public uint dwTimeout; 
    } 

    /// <summary> 
    /// Stop flashing. The system restores the window to its original stae. 
    /// </summary> 
    public const uint FLASHW_STOP = 0; 

    /// <summary> 
    /// Flash the window caption. 
    /// </summary> 
    public const uint FLASHW_CAPTION = 1; 

    /// <summary> 
    /// Flash the taskbar button. 
    /// </summary> 
    public const uint FLASHW_TRAY = 2; 

    /// <summary> 
    /// Flash both the window caption and taskbar button. 
    /// This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags. 
    /// </summary> 
    public const uint FLASHW_ALL = 3; 

    /// <summary> 
    /// Flash continuously, until the FLASHW_STOP flag is set. 
    /// </summary> 
    public const uint FLASHW_TIMER = 4; 

    /// <summary> 
    /// Flash continuously until the window comes to the foreground. 
    /// </summary> 
    public const uint FLASHW_TIMERNOFG = 12; 


    /// <summary> 
    /// Flash the spacified Window (Form) until it recieves focus. 
    /// </summary> 
    /// <param name="form">The Form (Window) to Flash.</param> 
    /// <returns></returns> 
    public static bool Flash(System.Windows.Forms.Form form) 
    { 
     // Make sure we're running under Windows 2000 or later 
     if (Win2000OrLater) 
     { 
      FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL | FLASHW_TIMERNOFG, uint.MaxValue, 0); 
      return FlashWindowEx(ref fi); 
     } 
     return false; 
    } 

    private static FLASHWINFO Create_FLASHWINFO(IntPtr handle, uint flags, uint count, uint timeout) 
    { 
     FLASHWINFO fi = new FLASHWINFO(); 
     fi.cbSize = Convert.ToUInt32(Marshal.SizeOf(fi)); 
     fi.hwnd = handle; 
     fi.dwFlags = flags; 
     fi.uCount = count; 
     fi.dwTimeout = timeout; 
     return fi; 
    } 

    /// <summary> 
    /// Flash the specified Window (form) for the specified number of times 
    /// </summary> 
    /// <param name="form">The Form (Window) to Flash.</param> 
    /// <param name="count">The number of times to Flash.</param> 
    /// <returns></returns> 
    public static bool Flash(System.Windows.Forms.Form form, uint count) 
    { 
     if (Win2000OrLater) 
     { 
      FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, count, 0); 
      return FlashWindowEx(ref fi); 
     } 
     return false; 
    } 

    /// <summary> 
    /// Start Flashing the specified Window (form) 
    /// </summary> 
    /// <param name="form">The Form (Window) to Flash.</param> 
    /// <returns></returns> 
    public static bool Start(System.Windows.Forms.Form form) 
    { 
     if (Win2000OrLater) 
     { 
      FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_ALL, uint.MaxValue, 0); 
      return FlashWindowEx(ref fi); 
     } 
     return false; 
    } 

    /// <summary> 
    /// Stop Flashing the specified Window (form) 
    /// </summary> 
    /// <param name="form"></param> 
    /// <returns></returns> 
    public static bool Stop(System.Windows.Forms.Form form) 
    { 
     if (Win2000OrLater) 
     { 
      FLASHWINFO fi = Create_FLASHWINFO(form.Handle, FLASHW_STOP, uint.MaxValue, 0); 
      return FlashWindowEx(ref fi); 
     } 
     return false; 
    } 

    /// <summary> 
    /// A boolean value indicating whether the application is running on Windows 2000 or later. 
    /// </summary> 
    private static bool Win2000OrLater 
    { 
     get { return System.Environment.OSVersion.Version.Major >= 5; } 
    } 
} 

Answer 2

ich es tun, wie unten gezeigt, wie

using System.Runtime.InteropServices; 
using Microsoft.Win32; 

// To support flashing. 
[DllImport("user32.dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
static extern bool FlashWindowEx(ref FLASHWINFO pwfi); 

//Flash both the window caption and taskbar button. 
//This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags. 
public const UInt32 FLASHW_ALL = 3; 

// Flash continuously until the window comes to the foreground. 
public const UInt32 FLASHW_TIMERNOFG = 12; 

[StructLayout(LayoutKind.Sequential)] 
public struct FLASHWINFO 
{ 
    public UInt32 cbSize; 
    public IntPtr hwnd; 
    public UInt32 dwFlags; 
    public UInt32 uCount; 
    public UInt32 dwTimeout; 
} 

// Do the flashing - this does not involve a raincoat. 
public static bool FlashWindowEx(Form form) 
{ 
    IntPtr hWnd = form.Handle; 
    FLASHWINFO fInfo = new FLASHWINFO(); 

    fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo)); 
    fInfo.hwnd = hWnd; 
    fInfo.dwFlags = FLASHW_ALL | FLASHW_TIMERNOFG; 
    fInfo.uCount = UInt32.MaxValue; 
    fInfo.dwTimeout = 0; 

    return FlashWindowEx(ref fInfo); 
} 

alles gezeigt wird, dass die erforderlichen Referenzen hinzufügen enthalten Dies sollte du brauchst.

Ich hoffe, das hilft.

Answer 3

Jungs Ich fand einen viel einfacheren Weg, es zu tun! Wenn dies der Fall ist, verwenden Sie es für.

In .NET 4.0, C#, wenn Sie verwenden nur

this.WindowState = FormWindowState.Normal; 
this.Activate(); 

Die erste Zeile sicher macht es nicht minimiert ist, macht die zweite Zeile es den Fokus. Ich bin nicht sicher, warum genau (einer von ihnen das nicht tun), aber kombiniert, wenn Sie eine MessageBox von diesem Formular zeigen, blinkt Ihr Programm orange in der Taskleiste!

Answer 4

Ich weiß, diese Frage ist ziemlich alt, aber basierend auf MoonKnight Antwort habe ich eine Verbesserung gemacht, die einige nützlich finden könnten. Ich konvertierte es in eine Formularerweiterung.

public static class ExtensionMethods 
{ 
    // To support flashing. 
    [DllImport("user32.dll", CallingConvention = CallingConvention.Cdecl)] 
    [return: MarshalAs(UnmanagedType.Bool)] 
    private static extern bool FlashWindowEx(ref FLASHWINFO pwfi); 

    //Flash both the window caption and taskbar button. 
    //This is equivalent to setting the FLASHW_CAPTION | FLASHW_TRAY flags. 
    private const uint FLASHW_ALL = 3; 

    // Flash continuously until the window comes to the foreground. 
    private const uint FLASHW_TIMERNOFG = 12; 

    [StructLayout(LayoutKind.Sequential)] 
    private struct FLASHWINFO 
    { 
     public uint cbSize; 
     public IntPtr hwnd; 
     public uint dwFlags; 
     public uint uCount; 
     public uint dwTimeout; 
    } 

    /// <summary> 
    /// Send form taskbar notification, the Window will flash until get's focus 
    /// <remarks> 
    /// This method allows to Flash a Window, signifying to the user that some major event occurred within the application that requires their attention. 
    /// </remarks> 
    /// </summary> 
    /// <param name="form"></param> 
    /// <returns></returns> 
    public static bool FlashNotification(this Form form) 
    { 
     IntPtr hWnd = form.Handle; 
     FLASHWINFO fInfo = new FLASHWINFO(); 

     fInfo.cbSize = Convert.ToUInt32(Marshal.SizeOf(fInfo)); 
     fInfo.hwnd = hWnd; 
     fInfo.dwFlags = FLASHW_ALL | FLASHW_TIMERNOFG; 
     fInfo.uCount = uint.MaxValue; 
     fInfo.dwTimeout = 0; 

     return FlashWindowEx(ref fInfo); 
    } 
} 

Um es auf einem Formular verwenden Sie nur

this.FlashNotification(); 

aufrufen müssen sie die Art und Weise zu ändern aussehen blinkt nur bei this table