28 respuestas en este tema

[escafandra]

Para conseguir desplegar una ventana tenemos la API AnimateWindow que funciona razonablemente bien. El problema surge cuando queremos desplegar una ventana semitransparente, en este caso el efecto visual es francamente malo, al menos en Windows XP.

Pues visto lo visto he escrito una función que realiza el efecto. Despliega una ventana semitransparente con un texto en el systray, la muestra un tiempo y la repliega.

Hacer el efecto con la VCL es muy sencillo, pero nos ata a ella y a ejecutables muy pesados. Si queremos el efecto para mini ejecutables (estoy hablando de ejecutables de 5 a 10k) tenemos que bajar a la API. Eso es lo que muestro en este truco que además puede servir de ejemplo o punto de partida para modificaciones posteriores o mostrar ventanas mas complejas pasando su Handle.

Aquí muestro el código en C++

cpp

void TaskBarUpMessage(char *Msg, int cX, int cY, int cW, int cH, int cTime, HINSTANCE chInstance)
{
  RECT RectArea;
  SystemParametersInfo(SPI_GETWORKAREA, 0, &RectArea, 0);
  static YMax = RectArea.bottom;
  static int X = cX;
  static int Y = cY;
  static int W = cW;
  static int H = cH;
  static int Time = cTime;
  static HINSTANCE hInstance = chInstance;
  int Margin = 10;
  SIZE Size;
  HDC hDC = GetDC(0);
  int nLines = 1;
  int Ancho = 0;
  for(char *C = Msg, *Ini = Msg; *C; C++)
   if(*C=='\n') {
     GetTextExtentPoint32(hDC, Ini, DWORD(C)-DWORD(Ini), &Size);
     if(Ancho < Size.cx) Ancho = Size.cx;
     Ini = C;
     nLines++;
   }
  if(!W) W = Ancho + Margin*2;
  if(!H) H = Size.cy*nLines + Margin*2.5;
  if(!X) X = RectArea.right - W;
  if(Y)  YMax = H+Y;
  Y = YMax;
  ReleaseDC(0, hDC);
  struct Timer{
    static VOID __stdcall OnTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime){
      static Inc = 1;
      if(YMax-Y >= H && Inc>0){
         Inc = -Inc;
         Sleep(Time);
      }
      if(YMax<=Y && Inc<0){
         Inc = -Inc;
         SendMessage(hWnd, WM_CLOSE, 0, 0);
         ::UnregisterClass("UPMSG", hInstance);
         return;
      }
      Y-=Inc;
//      SetWindowPos(hWnd, HWND_TOPMOST, X, Y, W, YMax-Y, SWP_SHOWWINDOW);
      SetWindowPos(hWnd, HWND_TOP, X, Y, W, H, SWP_SHOWWINDOW);
    }
  }TI;
 
  WNDCLASS WinClass = {0,DefWindowProc,0,0,hInstance,0,0,(HBRUSH)COLOR_BTNSHADOW,"","UPMSG"};
  ::RegisterClass(&WinClass);
  HANDLE hFrame = CreateWindowEx(WS_EX_LAYERED, "UPMSG", "",WS_VISIBLE | WS_POPUP |WS_THICKFRAME
                                 ,X, Y, W, 0, HWND_DESKTOP, (HMENU)0, hInstance, NULL);
 
  HANDLE hStatic = CreateWindow("STATIC", "", WS_VISIBLE | WS_CHILD
                                ,Margin, Margin, W-Margin*2, H-Margin*2, hFrame, (HMENU)0, hInstance, NULL);
 
  SetWindowText(hStatic, Msg);
  SetLayeredWindowAttributes(hFrame, NULL, 200, LWA_ALPHA);
  SetTimer(hFrame, 0, 10, (TIMERPROC)TI.OnTimer);
}

El uso es simple. Si damos los valores cero a las coordenadas de la ventana, la muestra en el systray y calcula el tamaño necesario para contener el texto según el número de líneas y tamaño.

Si damos tamaño a la ventana, el texto se tratará de ajustar a ella.
cTime es el tiempo durante el que mostrará la ventana una vez desplegada antes de comenzar a ocultarse.

Ejemplo de uso automático:

cpp

TaskBarUpMessage("Mensage secundario\nMicroondas\ncocedero", 0, 0, 0, 0, 1000, 0);

Saludos.

[egostar]

Caramba!!!, yo he tenido problema con esos mensajes, por alguna causa no se ocultan en el tiempo que le asigno en el componente. Me parece que me viene genial esta función.

Salud OS

PD, ¿ Me esperaré a que salga la versión de Delphi ?

[escafandra]

Ya sabéis que me gusta poner el código en C/C++ y en delphi y en este caso no iba a ser menos (aunque me toca escribir por dos )

La versión delphi es muy similar a la versión C++ y he preferido usar submétodos para compactar el código y hacer honores a Delphius en su gran esfuerzo. Creo que se entiende bien.

delphi

procedure TaskBarUpMessage(Msg: string; cX, cY, cW, cH, cTime: integer; chInstance: LongWord);
const
{$J+}
  YMax: integer = 0;
  X: integer = 0;
  Y: integer = 0;
  W: integer = 0;
  H: integer = 0;
  Time: integer = 0;
  hInstance: LongWord = 0;
  Margin: integer = 10;
 
var
  RectArea: TRect;
  Size: TSize;
  DC: HDC;
  XMax: integer;
  WinClass: WNDCLASS;
  hFrame, hStatic: THandle;
 
  // El evento OnTimer
  procedure OnTimer(hWnd: THandle; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
  const
    Inc: integer = 2;
  begin
    if (YMax-Y >= H) and (Inc>0)then
    begin
      Inc:= -Inc;
      Sleep(Time);
    end;
    if (YMax<=Y) and(Inc<0) then
    begin
      Inc:= -Inc;
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      Windows.UnregisterClass('UPMSG', hInstance);
      exit;
    end;
    Y:= Y-Inc;
    SetWindowPos(hWnd, HWND_TOPMOST, X, Y, W, YMax-Y, SWP_SHOWWINDOW);
//    SetWindowPos(hWnd, HWND_TOP, X, Y, W, H, SWP_SHOWWINDOW);
  end;
 
  // Calcula el tamaño de ventana que contendrá el texto "Multiline"
  procedure GetTextExtentML(DC: HDC; Msg: String; Len: integer; var Size: TSize);
  var
    Ancho, Alto, nLines, Ini, i: integer;
  begin
    Ancho:= 0; Alto:= 0; nLines:= 1; Ini:= 1;
    for i:=1 to Length(Msg) do
    begin
      if Msg[i] = #13 then
      begin
        GetTextExtentPoint32(DC, PCHAR(@Msg[Ini]), i-Ini, Size);
        if Ancho < Size.cx then Ancho:= Size.cx;
        if Alto  < Size.cy then Alto:=  Size.cy;
        Ini:= i;
        inc(nLines);
      end;
    end;
    Size.cx:= Ancho;
    Size.cy:= Alto*nLines;
  end;
 
 
begin
  SystemParametersInfo(SPI_GETWORKAREA, 0, @RectArea, 0);
  YMax:= RectArea.bottom;
  X:= cX;
  Y:= cY;
  W:= cW;
  H:= cH;
  Time:= cTime;
  hInstance:= chInstance;
  DC:= GetDC(0);
  GetTextExtentML(DC, PCHAR(Msg), Length(Msg), Size);
  if W = 0 then W:= Size.cx + Margin*2;
  if H = 0 then H:= Size.cy + Margin*2;
  if X = 0 then X:= RectArea.right - W;
  if Y <>0 then YMax:= H+Y;
  Y:= YMax;
  ReleaseDC(0, DC);
  with WinClass do
  begin
    style:= 0;
    lpfnWndProc:= @DefWindowProc;
    cbClsExtra:= 0;
    cbWndExtra:= 0;
    hInstance:= chInstance;
    hIcon:= 0;
    hCursor:= 0;
    hbrBackground:= COLOR_BTNSHADOW;
    lpszMenuName:= '';
    lpszClassName:= 'UPMSG';
  end;
  Windows.RegisterClass(WinClass);
  hFrame:= CreateWindowEx(WS_EX_LAYERED, 'UPMSG', '',WS_POPUP or WS_THICKFRAME
                          ,X, Y, W, H, HWND_DESKTOP, HMENU(0), hInstance, nil);
 
  hStatic:= CreateWindow('STATIC', '', WS_VISIBLE or WS_CHILD
                        ,Margin, Margin, W-Margin*2, H-Margin*2, hFrame, HMENU(0), hInstance, nil);
 
  SetWindowText(hStatic, PCHAR(Msg));
  SetLayeredWindowAttributes(hFrame, 0, 200, LWA_ALPHA);
  SetTimer(hFrame, 0, 20, @OnTimer);
{$J-}
end;

Un ejemplo del uso:

delphi

TaskBarUpMessage('Mensage secundario'+#13+'Hola'+#13+'Tercero', 0, 0, 0, 0, 2000, 0);

Como explique en la versión C++, si damos los valores cero a las coordenadas de la ventana, la muestra en el systray y calcula el tamaño necesario para contener el texto según el número de líneas y tamaño. Si damos tamaño a la ventana, el texto se tratará de ajustar a ella. cTime es el tiempo durante el que mostrará la ventana una vez desplegada antes de comenzar a ocultarse.

Espero que sea de alguna utilidad.


Saludos.


PD: Edito por añadir una sugerencia de Desart

[escafandra]

PD, ¿ Me esperaré a que salga la versión de Delphi ?

Parece que no vas a tener que esperar mucho...

Saludos.

[egostar]

Lo sabía amigo, además el Prefijo [MULTILENGUAJE] lo auguraba

Por supuesto que me será de utilidad

Salud OS

[cadetill]

Buenas,

Es genial, me ha gustado mucho!!

Una pregunta, la directiva de compilación {$J-} qué hace??

Gracias

Nos leemos

PD: el fondo de escritorio lo mejor xD
PD2: el av no me mola jejejejejje

[egostar]

..........hacer honores a Delphius en su gran esfuerzo......

Tendrán que esperar un "poquitín" para ver ese gran esfuerzo de nuestro amigo Delphius

Salud OS

[egostar]

Hola

Intenté ejecutar la función y me muestra dos errores....

[DCC Error] Unit1.pas(59): E2010 Incompatible types: 'TPersistentClass' and 'string'

En la línea:      UnregisterClass('UPMSG', hInstance);

[DCC Error] Unit1.pas(119): E2010 Incompatible types: 'TPersistentClass' and 'tagWNDCLASSA'

En la línea:  RegisterClass(WinClass);

Que estoy haciendo mal

Salud OS

PD: Estoy usando D2007.

[egostar]

Ah vaya, pues es que en la unidad classes los procedimientos son así:

delphi

procedure UnRegisterClass(AClass: TPersistentClass);
procedure RegisterClass(AClass: TPersistentClass);

Con que versión de Delphi lo hiciste amigo escafandra....

Salud OS

[escafandra]

Bueno, esto me ha pasado por probarlo en un programa API exclusivo, sin VCL:

delphi

var
 Msg: TMsg;
begin
 
  TaskBarUpMessage('Mensage secundario'+#13+'Hola'+#13+'Tercero', 0, 0, 0, 0, 2000, 0);
  // Bucle de mensajes:
  repeat GetMessage(Msg, 0, 0, 0);
   DispatchMessage(Msg);
  until (Msg.Message = WM_QUIT);
 
end.

Es mi manía del bajo nivel.

Esas funciones de delphi se llaman como las correspondientes APIs. La solución es bien sencilla:

delphi

Windows.RegisterClass(WinClass);
Windows.UnregisterClass('UPMSG', hInstance);

Ya está corregido en el código delphi.

Saludos.

[escafandra]

Es genial, me ha gustado mucho!!

Me alegro.

Una pregunta, la directiva de compilación {$J-} qué hace??

{$J+} Sirve para poder asignar valores a las constantes, es decir las trata como variables globales de la función y permite reconocer su valor en las entradas de las subfunciones, en particular en las llamadas automáticas (por el S.O.) al evento OnTimer. {$J-} Lo anula.

PD: el fondo de escritorio lo mejor xD

Busqué un motivo contrastado...

PD2: el av no me mola jejejejejje

A mi tampoco me gusta nada, es el que tenemos en el curro...  un coladero de bichitos

Saludos.

[Delphius]

Por la imagen se ve que funciona muy bien. No he probado el código, y lo he visto de pasada.
¡Como será que te gusta ahorrar en recursos que hasta empleaste las API de timer!

Respecto al honor por el trabajo, como ha dicho Eliseo, habrá que esperar. Si puedo colocaré algo más entre hoy y mañana. Disculpen que vaya lento.
Te agradezco el interés... ha quien hay que darle honores es a tí. No muchos se animan o pueden lograr hacer las obras maestras que expones.

Respecto a la directiva +J, si no me falla la memoria tengo entendido que es para evitar que una variable constante pueda ser alterada.

Saludos,

[eduarcol]

Funciona muy bien en delphi 7 

[Desart]

Hola escafandra, con tu permiso me gustaría incorporar, este procedimiento como función a las que uso, ademas comentarte que he añadido a las lineas de definición de la ventana en automático para que no recorte el texto, estas lineas son originalmente

delphi

    Size.cx:= Ancho;         Size.cy:= (Alto*nLines);

y las he dejado así

delphi

   Size.cx:= Ancho+15;         Size.cy:= (Alto*nLines)+15;

Una última cosa, por que nada más me permite usarlo una vez, ¿estoy cometiendo un error? o como se puede solucionar

[escafandra]

Puedes modificar el código como gustes, de hecho ya comenté que podría servir de base para seguir su desarrollo. De hecho yo mismo he realizado alguna mejora en C++ de esa función mejorando el comportamiento y añadiendo colores. Si tengo un tiempo libre lo traduzco a delphi.

El problema que comentas radica en la siguiente parte del código en la función de tratan¡miento del evento Timer:

delphi

    if (YMax<=Y) and(Inc<0) then
    begin
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      Windows.UnregisterClass('UPMSG', hInstance);
      exit;
    end;

Debes añadir una línea de código para cambiar de signo a la constante inc y que permita el ascenso de la ventana:

delphi

    if (YMax<=Y) and(Inc<0) then
    begin
      Inc:= -Inc;
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      Windows.UnregisterClass('UPMSG', hInstance);
      exit;
    end;

Saludos.

[Desart]

Muchas gracias Escafandra funciono perfecto, y estoy seguro de que muchos quedamos a la espera de esas modificaciones.

[escafandra]

Voy a publicar las modificaciones que he realizado sobre el código inicial tanto en C++ como en delphi.

He añadido el parámetro Margin para configurar el margen entre el borde de la ventana y el texto, Ese valor también separará la ventana del borde derecho del escritorio si es en ese lugar donde colocamos la ventana (posición por defecto).

He eliminado el uso de una ventana estática para colocar el texto con el fin de tener mas control sobre el pintado. Con esto consigo que se pueda elegir un color de fondo, a cambio de tener que escribir la función de tratamiento del mensaje WM_PAINT.

La forma de como estera la ventana, una vez ha ascendido, es controlada ahora por otro timer para no bloquear la aplicación como ocurría con el anterior método (Sleep).

Por último he eliminado el parámetro HInstance.

Por supuesto, el código sigue siendo válido en miniaplicaciones que prescindan de la VCL.

Seguidamente os propongo el código en C++:
 

cpp

#include <Shlwapi.h>
void TaskBarUpMessage(char *cMsg, int cX, int cY, int cW, int cH, int cMargin, int cTime, COLORREF cColor)
{
  static char* Msg;
  static int X, Y, W, H, YMax, Time, Margin;
  static COLORREF Color;
 
  struct TPopUpWindow
  {
    static LRESULT  __stdcall WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
      if(uMsg == WM_PAINT){
        HDC hDC = GetWindowDC(hWnd);
        RECT Rect = {Margin, Margin, W-Margin, H};
        HBRUSH hBrush = CreateSolidBrush(Color);
        SelectObject(hDC, hBrush);
        Rectangle(hDC, 0, 0, W, H);
        SetTextColor(hDC, RGB(0,0,0));
        SetBkColor(hDC, Color);
        DrawText(hDC, Msg, lstrlen(Msg), &Rect, DT_LEFT);
        DeleteObject(hBrush);
        ReleaseDC(hWnd, hDC);
      }
      return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
 
    static void __stdcall OnTimer(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
    {
      if(idEvent) return;
      static Inc = 2;
      if(YMax-Y > H && Inc>0){
          Inc = -Inc;
          KillTimer(hWnd, 0);
          SetTimer(hWnd, 1, Time, (TIMERPROC)OnWait);
      }
      if(YMax<=Y && Inc<0){
          Inc = -Inc;
          SendMessage(hWnd, WM_CLOSE, 0, 0);
          UnregisterClass("UPMSG", 0);
          return;
      }
      Y-=Inc;
      MoveWindow(hWnd, X, Y, W, YMax-Y, true);
    }
 
    static void __stdcall OnWait(HWND hWnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
    {
      if(idEvent == 1){
        KillTimer(hWnd, 1);
        SetTimer(hWnd, 0, 5, (TIMERPROC)OnTimer);
      }
    }
 
  }WPopUp;
 
  RECT RectArea;
  SystemParametersInfo(SPI_GETWORKAREA, 0, &RectArea, 0);
  YMax = RectArea.bottom;
  X = cX; Y = cY; W=cW; H=cH; Time=cTime;
  Msg=cMsg; Color=cColor;
  // Tamaño del recuadro que contendrá el texto multiline
  SIZE Size;
  HDC hDC = GetDC(0);
  int nLines = 0;
  int Ancho = 0;
  char *C = Msg, *Ini = Msg, *Fin = Msg + lstrlen(Msg);
  do{
    C = StrStr(C, " ");
    if(!C) C = Fin;
    GetTextExtentPoint32(hDC, Ini, DWORD(C)-DWORD(Ini), &Size);
    if(Ancho < Size.cx) Ancho = Size.cx;
    Ini = C;
    nLines++;
  }while(*C++);
 
  if(!Margin) Margin = Size.cy;
  if(!W) W = Ancho + Margin*2;
  if(!H) H = Size.cy*nLines + Margin*2;
  if(!X) X = RectArea.right - W - Margin;
  if(Y && Y<YMax-H)  YMax = H+Y;
  Y = YMax;
  ReleaseDC(0, hDC);
 
  HWND hPrev = GetFocus();
  WNDCLASS WinClass = {0,(WNDPROC)WPopUp.WindowProc,0,0,0,0,0,0,"","UPMSG"};
  RegisterClass(&WinClass);
  HANDLE hFrame = CreateWindowEx(WS_EX_LAYERED|WS_EX_TOPMOST|WS_EX_TOOLWINDOW, "UPMSG", "",WS_VISIBLE | WS_POPUP
                                ,X, Y, W, 0, HWND_DESKTOP, (HMENU)0, 0, NULL);
  SetLayeredWindowAttributes(hFrame, NULL, 200, LWA_ALPHA);
  SetTimer(hFrame, 0, 5, (TIMERPROC)WPopUp.OnTimer);
  SetFocus(hPrev);
}

Que lo disfrutéis, os sea útil y le saquéis todo el partido posible.

Saludos.

[escafandra]

Y ahora le llega el turno a delphi, lo explicado en el anterior mensaje para la versión C++ vale para esta versión.

No he variado la filosofía del código en cuanto al uso de submétodos locales. Evidentemente se puede modificar para prescindir de ellos.

Está probado en delphi 7.

delphi

// La siguiente definición es para el caso de una aplicación que no use la VCL
function StrStr(s1: PCHAR; s2: PCHAR): PCHAR; stdcall;
        external 'Shlwapi.dll' name 'StrStrA';
 
procedure TaskBarUpMessage(cMsg: string; cX, cY, cW, cH, cMargin, cTime: integer; cColor: COLORREF);
const
{$J+}
  Msg: PCHAR = nil;
  YMax: integer = 0;
  X: integer = 0;
  Y: integer = 0;
  W: integer = 0;
  H: integer = 0;
  Color: COLORREF = 0;
  Time: integer = 0;
  hInstance: LongWord = 0;
  Margin: integer = 0;
  Wait: Pointer = 0;
var
  RectArea: TRect;
  Size: TSize;
  CharSize: TSize;
  DC: HDC;
  WinClass: WNDCLASS;
  hFrame, hPrev: THandle;
 
  function WindowProc(hWnd: THandle; uMsg, wParam, lParam: integer): LRESULT; stdcall;
  var
    DC: HDC;
    Rect: TRect;
    Brush: HBRUSH;
 
  begin
    if uMsg = WM_PAINT then
    begin
      DC:= GetWindowDC(hWnd);
      Rect.Left:= Margin; Rect.Top:= Margin; Rect.Right:= W; Rect.Bottom:= H;
      Brush:= CreateSolidBrush(Color);
      SelectObject(DC, Brush);
      Rectangle(DC, 0, 0, W, H);
      SetTextColor(DC, RGB(0,0,0));
      SetBkColor(DC, Color);
      DrawText(DC, Msg, lstrlen(Msg), Rect, DT_LEFT);
      DeleteObject(Brush);
      ReleaseDC(hWnd, DC);
    end;
    Result:= DefWindowProc(hWnd, uMsg, wParam, lParam);
  end;
 
  procedure OnTimer(hWnd: THandle; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
  const
    Inc: integer = 2;
  var
    Rect: TRect;
    DC: HDC;
    Brush: HBRUSH;
  begin
    if idEvent <> 0 then exit;
    if (YMax-Y > H) and (Inc>0)then
    begin
      Inc:= -Inc;
      KillTimer(hWnd, 0);
      SetTimer(hWnd, 1, Time, Wait);
    end;
    if (YMax<=Y) and(Inc<0) then
    begin
      Inc:= -Inc;
      SendMessage(hWnd, WM_CLOSE, 0, 0);
      Windows.UnregisterClass('UPMSG', hInstance);
      exit;
    end;
    Y:= Y-Inc;
    MoveWindow(hWnd, X, Y, W, YMax-Y, true);
  end;
 
  procedure OnWait(hWnd: THandle; uMsg: UINT; idEvent: UINT; dwTime: DWORD); stdcall;
  begin
    if idEvent = 1 then
    begin
      KillTimer(hWnd, 1);
      SetTimer(hWnd, 0, 5, @OnTimer);
    end;
  end;
 
  procedure GetTextExtentML(DC: HDC; Msg: PCHAR; Len: integer; var Size: TSize);
  var
    Ancho, Alto, nLines: integer;
    C, Ini: PCHAR;
  begin
    Ancho:= 0; Alto:= 0; nLines:= 0;
    Ancho:= 0; Alto:= 0; nLines:= 0;
    C:= Msg; Ini:= Msg;
    repeat
      if ((C+1)^ = #13) or ((C+1)^ = #0) then
      begin
        GetTextExtentPoint32(DC, Ini, DWORD(C)-DWORD(Ini)+1, Size);
        if Ancho < Size.cx then Ancho:= Size.cx;
        if Alto  < Size.cy then Alto:=  Size.cy;
        Ini:= C;
        inc(nLines);
      end;
      inc(C);
    until C^ = #0;
    Size.cx:= Ancho;
    Size.cy:= Alto*nLines;
  end;
 
begin
  Wait:= @OnWait;
  SystemParametersInfo(SPI_GETWORKAREA, 0, @RectArea, 0);
  Msg:= PCHAR(cMsg);
  YMax:= RectArea.bottom;
  X:= cX;
  Y:= cY;
  W:= cW;
  H:= cH;
  Color:= cColor;
  Time:= cTime;
  DC:= GetDC(0);
  GetTextExtentML(DC, PCHAR(Msg), Length(Msg), Size);
 
  GetTextExtentPoint32(DC, 'H', 1, CharSize);
  if Margin = 0 then Margin:= CharSize.cy;
  if W = 0 then W:= Size.cx + Margin*2;
  if H = 0 then H:= Size.cy + Margin*2;
  if X = 0 then X:= RectArea.right - W - Margin;;
  if (Y<>0) and (Y<YMax-H) then YMax:= H+Y;
 
  Y:= YMax;
  ReleaseDC(0, DC);
  with WinClass do
  begin
    style:= 0;
    lpfnWndProc:= @WindowProc;
    cbClsExtra:= 0;
    cbWndExtra:= 0;
    hInstance:= 0;
    hIcon:= 0;
    hCursor:= 0;
    hbrBackground:= 0;
    lpszMenuName:= '';
    lpszClassName:= 'UPMSG';
  end;
  Windows.RegisterClass(WinClass);
  hPrev:= GetFocus;
  hFrame:= CreateWindowEx(WS_EX_LAYERED or WS_EX_TOPMOST or WS_EX_TOOLWINDOW, 'UPMSG', '',WS_VISIBLE or WS_POPUP
                          ,X, Y, W, 0, HWND_DESKTOP, HMENU(0), hInstance, nil);
  SetLayeredWindowAttributes(hFrame, 0, 200, LWA_ALPHA);
  SetTimer(hFrame, 0, 20, @OnTimer);
  SetFocus(hPrev);
 
{$J-}
end;

Espero que sea de utilidad.

Saludos.

[seoane]

Muy bueno escafandra !!! 

Yo solo cambiaría esto:

delphi

hFrame:= CreateWindowEx(WS_EX_LAYERED or WS_EX_TOPMOST , 'UPMSG', '',WS_POPUP
                          ,X, Y, W, H, HWND_DESKTOP, HMENU(0), hInstance, nil);

Por esto otro, para evitar que la ventana emergente aparezca en la barra de tareas:

delphi

hFrame:= CreateWindowEx(WS_EX_LAYERED or WS_EX_TOPMOST or WS_EX_TOOLWINDOW, 'UPMSG', '',WS_POPUP
                          ,X, Y, W, H, HWND_DESKTOP, HMENU(0), hInstance, nil);

Y por otro lado, ¿por que no usar un Ballonhint? 

[escafandra]

Pues ahora que lo dices, seoane, tienes toda la razón, es mejor eliminarla de la barra de tareas.

Mostrar los mensajes con un BalloonHints es una buena opción como lo hice en el componente SysTrayIcon que muchos conocen y que publiqué en el foro. En esta ocasión trataba de conseguir otro efecto y sobre todo jugar con la API pues la idea nació para usarlo en programas sin VCL y al no convencerme del todo el comportamiento de AnimateWindow.

Saludos.

PD he incorporado en el código la sugerencia de seoane.