LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     static int   cxClientMax, cyClientMax, cxClient, cyClient, cxChar, cyChar ;
     static int   cLinesMax, cLines ;
     static PMSG  pmsg ;
     static RECT  rectScroll ;

     static TCHAR szTop[] = TEXT ("Nachricht      Taste   Zeichen      Wdh.  ")
                            TEXT ("OEM-Code Erw. ALT   vorher  jetzt") ;
     static TCHAR szUnd[] = TEXT ("_________      _____   _______      ____  ")
                            TEXT ("________ ____ ___   ______  ________") ;

     static TCHAR * szFormat[2] = {
               TEXT ("%-13s %3d %-13s%c%6u  %4d       %4s %4s %8s %8s"),
               TEXT ("%-13s          0x%04X%1s%c %6u  %4d       %4s %4s %8s %8s") } ;
     static TCHAR * szYes  = TEXT ("Ja") ;
     static TCHAR * szNo   = TEXT ("Nein") ;
     static TCHAR * szDown = TEXT ("gedrückt") ;
     static TCHAR * szUp   = TEXT ("gelöst") ;

     static TCHAR * szMessage [] = {
                         TEXT ("WM_KEYDOWN"),    TEXT ("WM_KEYUP"),
                         TEXT ("WM_CHAR"),       TEXT ("WM_DEADCHAR"),
                         TEXT ("WM_SYSKEYDOWN"), TEXT ("WM_SYSKEYUP"),
                         TEXT ("WM_SYSCHAR"),    TEXT ("WM_SYSDEADCHAR") } ;
     HDC          hdc ;
     int          i, iType ;
     PAINTSTRUCT  ps ;
     TCHAR        szBuffer[128], szKeyName [32] ;
     TEXTMETRIC   tm ;

     switch (message)
     {
     case WM_CREATE:
     case WM_DISPLAYCHANGE:

          // Maximalgröße des Anwendungsbereichs ermitteln
          cxClientMax = GetSystemMetrics (SM_CXMAXIMIZED) ;
          cyClientMax = GetSystemMetrics (SM_CYMAXIMIZED) ;

          // Zeichengröße für nicht proportionale Systemschrift
          hdc = GetDC (hwnd) ;

          SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
          GetTextMetrics (hdc, &tm) ;
          cxChar = tm.tmAveCharWidth ;
          cyChar = tm.tmHeight ;

          ReleaseDC (hwnd, hdc) ;

          // Speicherplatz für die Ausgabezeilen
          if (pmsg)
               free (pmsg) ;

          cLinesMax = cyClientMax / cyChar ;
          pmsg = malloc(cLinesMax * sizeof(MSG)) ;
          cLines = 0 ;
                                   // weiter mit WM_SIZE
      case WM_SIZE:
          if (message == WM_SIZE)
          {
               cxClient = LOWORD (lParam) ;
               cyClient = HIWORD (lParam) ;
          }
          // Rechteck für ScrollWindow
          rectScroll.left   = 0 ;
          rectScroll.right  = cxClient ;
          rectScroll.top    = cyChar ;
          rectScroll.bottom = cyChar * (cyClient / cyChar) ;

          InvalidateRect (hwnd, NULL, TRUE) ;
          return 0 ;

     case WM_KEYDOWN:
     case WM_KEYUP:
     case WM_CHAR:
     case WM_DEADCHAR:
     case WM_SYSKEYDOWN:
     case WM_SYSKEYUP:
     case WM_SYSCHAR:
     case WM_SYSDEADCHAR:

          // bereits gespeicherte Nachrichten nach hinten umstapeln
          for (i = cLinesMax - 1 ; i > 0 ; i--)
          {
               pmsg[i] = pmsg[i - 1] ;
          }
          // und neues Ereignis ins Element 0
          pmsg[0].hwnd = hwnd ;
          pmsg[0].message = message ;
          pmsg[0].wParam = wParam ;
          pmsg[0].lParam = lParam ;

          cLines = min (cLines + 1, cLinesMax) ;

           // Anzeige um eine Zeile nach oben
          ScrollWindow (hwnd, 0, -cyChar, &rectScroll, &rectScroll) ;

          break ;        // -> DefWindowProc - sonst würden Systemtasten nicht mehr funktionieren

     case WM_PAINT:
          hdc = BeginPaint (hwnd, &ps) ;

          SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
          SetBkMode (hdc, TRANSPARENT) ;
          TextOut (hdc, 0, 0, szTop, lstrlen (szTop)) ;
          TextOut (hdc, 0, 0, szUnd, lstrlen (szUnd)) ;

          for (i = 0 ; i < min (cLines, cyClient / cyChar - 1) ; i++)
          {
               iType = pmsg[i].message == WM_CHAR ||
                       pmsg[i].message == WM_SYSCHAR ||
                       pmsg[i].message == WM_DEADCHAR ||
                       pmsg[i].message == WM_SYSDEADCHAR ;

               GetKeyNameText (pmsg[i].lParam, szKeyName, sizeof (szKeyName) / sizeof (TCHAR)) ;

               TextOut (hdc, 0, (cyClient / cyChar - 1 - i) * cyChar, szBuffer,
                        wsprintf (szBuffer, szFormat [iType],
                             szMessage [pmsg[i].message - WM_KEYFIRST],
                             pmsg[i].wParam,
                             (PTSTR) (iType ? TEXT (" ") : szKeyName),
                             (TCHAR) (iType ? pmsg[i].wParam : ' '),
                             LOWORD (pmsg[i].lParam),
                             HIWORD (pmsg[i].lParam) & 0xFF,
                             0x01000000 & pmsg[i].lParam ? szYes  : szNo,
                             0x20000000 & pmsg[i].lParam ? szYes  : szNo,
                             0x40000000 & pmsg[i].lParam ? szDown : szUp,
                             0x80000000 & pmsg[i].lParam ? szUp   : szDown)) ;
          }
          EndPaint (hwnd, &ps) ;
          return 0 ;

     case WM_DESTROY:
          PostQuitMessage (0) ;
          return 0 ;
     }
     return DefWindowProc (hwnd, message, wParam, lParam) ;
}

Diese Code gibt in Form status eine Taste aus (gedrückt/los gelassen)

Nur beim Kompilieren zeigt er mir in Zeile 56 folgende Fehler an:
invalid conversion from 'void*' to 'PMSG {aka tagMSG*}' [-fpermissive]|

Wie kann ich diesen Fehler beheben ?
In Zeile 13 steht das hier: %-13s %3d %-13s%c%6u %4d
was hat das alles zu bedeuten ?

pmsg = (PMSG)malloc(cLinesMax * sizeof(MSG)) ;

malloc() ist übrigens aus C. In C++ nutzt man stattdessen new.

pmsg = new MSG [cLinesMax];

static TCHAR * szFormat[2] = {
               TEXT ("%-13s %3d %-13s%c%6u  %4d       %4s %4s %8s %8s"),
               TEXT ("%-13s          0x%04X%1s%c %6u  %4d       %4s %4s %8s %8s") } ;

Ich meine das hier "%-13s %3d %-13s%c%6u %4d %4s %4s %8s %8s", wie soll ich das verstehen ?

wie soll ich das verstehen?

Siehe Tabelle.