Помогите преобразовать код из VC++ в Delphi

[Moko]

в интернете нашел код на VC++, но язык я не очень хорошо знаю могли бы помочь преобразовать в Delphi

#ifndef GRAPHICS_H
#define GRAPHICS_H

//LOWORD(wParam): event ID, HIWORD(wParam): reserved, lParam: LPON_event_name_PARAMS 
#define WM_GRAPHICSEVENT      WM_USER + 0xFF

#define EVENT_ON_PROGRESS      0x10

typedef struct tagONPROGRESSPARAMS
{
   DWORD dwPercents;
} ONPROGRESSPARAMS, *LPONPROGRESSPARAMS;

BOOL Blur(HDC hDC, ULONG lLevel, LPRECT pRC, HWND hWndCallback = NULL);
#define R_BGR(Color)         ((BYTE)((Color) >> 16))
#define G_BGR(Color)         ((BYTE)(((WORD)(Color)) >> 8))
#define B_BGR(Color)         ((BYTE)(Color))

#define BGR(B, G, R)         (((BYTE)B) | ((BYTE)G << 8) | ((BYTE)R << 16))

#define GP_INVALIDPIXEL         0xFFFFFFFF

static COLORREF GetPixel(LPBYTE pPixels, LPBITMAPINFO pBMI, LONG x, LONG y);
static void SetPixel(LPBYTE pPixels, LPBITMAPINFO pBMI, LONG x, LONG y, COLORREF crValue);
static void ReverseBytes(LPBYTE pData, DWORD dwDataSize);
template <class T>
   static T CheckBounds(T tValue, T tMin, T tMax);
template <class T>
   static void SortArray_Shell(T *pArr, const int intArrSize);

#endif

и

#include <windows.h>
#include <math.h>

#include "graphics.h"

//-----------------------------------------------------------------------------------------
//Графические эффекты (фильтры)

//Фильтр "Пятно"
//Матрица:
//   n  n  n  n  n
//   n  1  1  1  n
//   n  1  1  1  n
//   n  1  1  1  n
//   n  n  n  n  n / 1
//Параметры:
//   hDC            DC назначения
//   lLevel         Радиус размывания
//   pRC            Указатель на структуру RECT, определяющую область изображения для изменения
//Возвращаемое значение: TRUE в случае успеха, FALSE в случае ошибки
BOOL Blur(HDC hDC, ULONG lLevel, LPRECT pRC, HWND hWndCallback)
{
   BITMAPINFO BMI = { 0 };
   HDC hTmpDC;
   HBITMAP hOldBitmap, hTmpBitmap;
   ULONG lBytesCnt;
   LPBYTE pPixels1, pPixels2;
   LONG x, x1, x2, x3;
   LONG y, y1, y2, y3;
   LONG lColor, lR, lG, lB, lPixels;

   //Параметры событий
   volatile ONPROGRESSPARAMS ONPP = { 0 };

   USHORT BPP = GetDeviceCaps(hDC, BITSPIXEL);

   //Не работаем с изображениями ниже 24 bpp (TrueColor)
   if ((BPP != 24) && (BPP != 32)) return FALSE;
   //Работаем только с обычным контекстом устройства, так как контекст устройства в памяти
   //на вызов GetDeviceCaps(hDC, ...RES) возвращает не свое разрешение, а разрешение связанного
   //с ним контекста устройства
   if (GetObjectType(hDC) != OBJ_DC) return FALSE;

   LONG W = GetDeviceCaps(hDC, HORZRES);
   LONG H = GetDeviceCaps(hDC, VERTRES);

   switch (BPP)
   {
      case 24:
         lBytesCnt = (((BPP / 8) * W + 3) / 4) * 4;
         lBytesCnt += ((lBytesCnt * H + 3) / 4) * 4;
         break;
      case 32:
         lBytesCnt = W * H * (BPP / 8);
         break;
   }

   pPixels1 = new BYTE[lBytesCnt];
   pPixels2 = new BYTE[lBytesCnt];

    hTmpDC = CreateCompatibleDC(hDC);
    hTmpBitmap = CreateCompatibleBitmap(hDC, W, H);
    hOldBitmap = (HBITMAP)SelectObject(hTmpDC, hTmpBitmap);
   BitBlt(hTmpDC, 0, 0, W, H, hDC, 0, 0, SRCCOPY);

    BMI.bmiHeader.biSize = sizeof(BMI.bmiHeader);
    BMI.bmiHeader.biWidth = W;
    BMI.bmiHeader.biHeight = H;
    BMI.bmiHeader.biPlanes = 1;
    BMI.bmiHeader.biBitCount = BPP;
    BMI.bmiHeader.biCompression = BI_RGB;
   GetDIBits(hTmpDC, hTmpBitmap, 0, H, pPixels1, &BMI, DIB_RGB_COLORS);
   GetDIBits(hTmpDC, hTmpBitmap, 0, H, pPixels2, &BMI, DIB_RGB_COLORS);

   y = pRC->top;
   while (y < pRC->bottom)
   {
      y1 = y - (lLevel / 2);
      if (y1 < pRC->top) y1 = pRC->top;
      y2 = y + (lLevel / 2);
      if (y2 > (pRC->bottom - 1)) y2 = (pRC->bottom - 1);
      x = pRC->left;
      while (x < pRC->right)
      {
         x1 = x - (lLevel / 2);
         if (x1 < pRC->left) x1 = pRC->left;
         x2 = x + (lLevel / 2);
         if (x2 > (pRC->right - 1)) x2 = (pRC->right - 1);
         lR = 0;
         lG = 0;
         lB = 0;
         for (x3 = x1; x3 <= x2; x3++)
         {
            for (y3 = y1; y3 <= y2; y3++)
            {
               lColor = GetPixel(pPixels2, &BMI, x3, y3);
               lR += R_BGR(lColor);
               lG += G_BGR(lColor);
               lB += B_BGR(lColor);
            }
         }
         lPixels = (x2 - x1 + 1) * (y2 - y1 + 1);
         lR /= lPixels;
         lG /= lPixels;
         lB /= lPixels;
         SetPixel(pPixels1, &BMI, x, y, BGR(lB, lG, lR));
         x++;
      }
      if (hWndCallback)
      {
         ONPP.dwPercents = (DWORD)(((double)y / (double)pRC->bottom) * 100);
         SendMessage(hWndCallback, WM_GRAPHICSEVENT, MAKEWPARAM(EVENT_ON_PROGRESS, 0),
            (LPARAM)&ONPP);
      }
      y++;
   }

   StretchDIBits(hDC, 0, 0, W, H, 0, 0, W, H, pPixels1, &BMI,
      DIB_RGB_COLORS, SRCCOPY);

   SelectObject(hTmpDC, hOldBitmap);
    DeleteObject(hTmpBitmap);
    DeleteDC(hTmpDC);
   delete[] pPixels1;
   delete[] pPixels2;
   return TRUE;
}

[worm2]

Можно примерно так:

{ ... } => begin ... end;
#define a b => const a = b;
#define a(b) XXXX => оформляется как функция a(b)
LONG => LongInt
ULONG => LongWord
DWORD => DWORD
LPBYTE => PByteArray
BOOL => LongBool
SHORT => SmallInt
USHORT => WORD
BYTE => Byte
0xXXXX => $XXXX
TYPEXXXX YYYY; => var YYYY: TYPEXXXX; или просто YYYY: TYPEXXXX (в параметрах функции)
TYPEXXXX YYYY = { ... } => var YYYY: TYPEXXXX = ( ... );
(TYPEXXXX) Y => TYPEXXXX(Y)
TYPEXXXX YYYY(ZZZZ) => function YYYY(ZZZZ): TYPEXXXX;
void YYYY(ZZZZ) => procedure YYYY(ZZZZ);
new TYPEXXX[N] => AllocMem(N*SizeOf(TYPEXXX));
delete [] P => ReallocMem(P, 0);
typedef struct tagXXXX {....} XXXX, *LPXXXX; => type XXXX = record ... end; LPXXXX = ^XXXX;
= => :=
== => =
* => ^, но не везде, а только там, где не означает умножения
& => @
-> => ^.
/ => div для целочисл., / для веществ.
A >> B => A shr B
A << B => A shl B
XXXX++ => Inc(XXXX)
XXXX += YYYY => Inc(XXXX, YYYY)
XXXX /= YYYY => XXXX := XXXX div YYYY;
static => игнорируется
volatile => игнорируется
for(XXXX = AAAA; XXXX <= BBBB; XXXX++) {...} => for XXXX := AAAA to BBBB do begin ... end;
switch(XXX) { case A: ... break; case B: ... break; .... default: ... } => case XXX of A: ...; B: ...; .... else ... end;
template <XXXX> YYYY => надо апгрейдиться до D2009 или D2010 и курить гугель на тему Delphi Generics, иначе epic fail