c# - cientifico - La aplicación de la ventana parpadea como naranja en la barra de tareas cuando se minimiza

naranja beneficios

Question

tengo una aplicación de ventana. cuando minimizo la aplicación de ventana en la barra de tareas para trabajar en otra aplicación. tenemos una instalación como enviar mensaje de una aplicación de ventana a otra aplicación de ventana

entonces mi primera aplicación ganadora se minimiza y ahora abro mi otra aplicación ganadora y luego envío el mensaje a la primera aplicación, pero la primera aplicación está en la barra de tareas. así que quiero funcionalidades como cuando cualquier mensaje captura mi primera aplicación y luego parpadea como Skype o cualquier Messenger.

Probé el método "FlashWindowEx" de User32.dll. pero sin suerte. Había intentado con la opción "Flash continuamente hasta que la ventana aparezca en primer plano". pero sin suerte.

Por favor ayuda a resolver este problema con un ejemplo

Gracias

Answer 1

¡Chicos, encontré una forma mucho más fácil de hacerlo! Si este es el caso, lo estás usando para.

En .NET 4.0, C #, si solo usa

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

La primera línea se asegura de que no se minimice, la segunda línea lo convierte en el foco. No estoy seguro de por qué (ninguno de los dos hace esto), pero combinados, si muestra un MessageBox desde este formulario, ¡su programa parpadea en naranja en la barra de tareas!

Answer 2

Lo hago como se muestra a continuación, asegurándome de agregar las referencias requeridas como se muestra

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);
}

Esto debería contener todo lo que necesita.

Espero que esto ayude.

Answer 3

Sé que esta pregunta es bastante antigua, pero en base a la respuesta de MoonKnight hice una mejora, que algunos podrían encontrarle útil. Lo convertí en una extensión de formulario.

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);
}
}

Para usarlo en un formulario, solo necesita llamar

this.FlashNotification();

Para cambiar la forma en que parpadea, mira esta tabla

Answer 4

C #: Flash Window en la barra de tareas a través de Win32 FlashWindowEx me funciona.

La API de Windows (Win32) tiene el método FlashWindowEx dentro de la biblioteca User32; este método le permite a usted (el desarrollador) destellar una ventana, lo que significa para el usuario que ocurrió algún evento importante dentro de la aplicación que requiere su atención. El uso más común de esto es mostrar la ventana hasta que el usuario vuelva a enfocar la aplicación. Sin embargo, también puede mostrar la ventana un número específico de veces, o simplemente continuar destellando hasta que decida cuándo parar.

Sin embargo, el uso del método FlashWindowEx no está incorporado en .NET Framework en ninguna parte. Para acceder, debe usar las funciones de Invocación de plataforma (PInvoke) de .NET para "soltar" la API de Windows (Win32) y llamarla directamente. Además, como ocurre con muchas otras funcionalidades en la API de Windows (que no están directamente expuestas por .NET), el método FlashWindowEx puede ser un poco complicado de usar si no está familiarizado con el trabajo con la API de Windows desde .NET.

Ahora, en lugar de profundizar en los detalles de PInvoke o el método Win32 FlashWindowEx, a continuación se muestra una clase estática simple en C # que le permite utilizar este método fácilmente. En realidad, se necesita bastante información para explicar cómo usar PInvoke para utilizar la API de Windows (Win32), así que tal vez lo cubra en un artículo futuro.

Aquí hay un ejemplo de uso de esta clase estática:

// 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);

Una cosa a tener en cuenta sobre el método FlashWindowEx es que requiere (y solo funcionará) Windows 2000 o posterior.

Aquí está el código para la clase estática en 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; }
}
}