int centroAncho = Image2->Left / 2 + Image2->Width / 2; //Centro del ancho de la imagen
int centroAlto = Image2->Top / 2 + Image2->Height / 2; //Centro del alto de la imagen
int centroScrollAncho = ScrollBox2->Width / 2; //Centro del ancho del ScrollBox
int centroScrollAlto = ScrollBox2->Height / 2; //Centro del alto del scrollbox

Image2->Left = (centroScrollAncho - Image2->Width / 2) * 2;
Image2->Top = (centroScrollAlto - Image2->Height / 2) * 2;

//La siguiente linea es necesaria para evitar el error de compilacion
//'E2015 Ambiguity between 'TBitmap' and 'Windows::TBitmap'
#define TBitmap Graphics::TBitmap

void CopyImageToClipboard(HANDLE hwnd, int Width, int Height, unsigned int CopyImageFormat, unsigned int cbFormat)
{
        //ENVIANDO UNA IMAGEN BMP AL PORTAPAPELES
        //Creamos una copia de la imágen ya escalada y la asignamos a un Handle
        HANDLE hNew = CopyImage(hwnd,
                                CopyImageFormat,
                                Width, //NULL para no escalar el ancho
                                Height, //NULL para no escalar el alto
                                LR_COPYRETURNORG);

        //Abrimos el portapapeles pasandole el hwnd de
        //nuestra aplicación
        OpenClipboard(Application->Handle);

        //Borramos el contenido del portapapeles con
        //EmptyClipboard para luego pegar la imagen
        EmptyClipboard();

        //Pegamos la imagen con el Api SetClipBoardData _
        //indicando que es un mapa de bits y le enviamos _
        //el handle de la imagen obtenido anteriormente
        SetClipboardData(cbFormat, (long*)hNew);

        //Cerramos el portapapeles usando el Api CloseClipboard
        CloseClipboard();
        //FIN DEL ENVIO
}

void PasteImageToClipboard(TBitmap *picture, unsigned int cbFormat)
{
        //COPIANDO LA IMAGEN DESDE EL PORTAPAPELES
        //Abrimos el portapapeles pasandole el hwnd de
        //nuestra aplicación
        OpenClipboard(Application->Handle);

        //Obtenemos el contenido con GetClipboardData y
        //se lo asignamos al Image2
        picture->Handle = GetClipboardData(cbFormat);

        //Cerramos el portapapeles usando el Api CloseClipboard
        CloseClipboard();
        //FIN DE LA RECEPCION
}

CopyImageToClipboard(hwnd, Form1->Image2->Width, Form1->Image2->Height, IMAGE_BITMAP, CF_BITMAP);
PasteImageToClipboard(Form1->Image2->Picture->Bitmap, CF_BITMAP);

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

void done(HBITMAP hbmScreen, HDC hdcMemDC, HDC hdcScreen, HWND hWnd, HDC hdcWindow);
int CaptureAnImage(HWND hWnd, HWND MyBitmap);
//--------------------------------------------------------------------------

BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam)
{

        char clase[256];

        //memset(clase,0, sizeof(clase));
        GetClassName(hwnd, clase, sizeof(clase));
        if(strcmp(clase, "AfxOleControl42") == 0)
        {
                HWND MyVentana = FindWindow(NULL, "Form1");

                int retval = CaptureAnImage(hwnd, MyVentana);
                return FALSE;
        }
        return TRUE;
}

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
        HWND hwnd;

        hwnd = FindWindow("ThunderRT6FormDC", "Visustin Editor");

        if(!hwnd)
                MessageBox(Application->Handle,"No se encuentra abierto el editor de Visustin.", "Error", MB_OK | MB_APPLMODAL | MB_ICONERROR);
        else
                EnumChildWindows(hwnd, (WNDENUMPROC)EnumChildProc, 0);
}
//---------------------------------------------------------------------------

int CaptureAnImage(HWND hWnd, HWND MyBitmap)
{
    HDC hdcScreen;
    HDC hdcWindow;
    HDC hdcMemDC = NULL;
    HBITMAP hbmScreen = NULL;
    BITMAP bmpScreen;

    // Retrieve the handle to a display device context for the client 
    // area of the window. 
    hdcScreen = GetDC(hWnd);
    hdcWindow = GetDC(MyBitmap);

    // Create a compatible DC which is used in a BitBlt from the window DC
    hdcMemDC = CreateCompatibleDC(hdcWindow);

    if(!hdcMemDC)
    {
        MessageBox(hWnd, "CreateCompatibleDC has failed", "Failed", MB_OK);
        done(hbmScreen, hdcMemDC, hdcScreen, hWnd, hdcWindow);
        return 1;
    }

    // Get the client area for size calculation
    RECT rcClient;
    GetClientRect(hWnd, &rcClient);

    //This is the best stretch mode
    SetStretchBltMode(hdcWindow,HALFTONE);

    //The source DC is the entire screen and the destination DC is the current window (HWND)
    if(!StretchBlt(hdcWindow, 
               0,0, 
               rcClient.right, rcClient.bottom, 
               hdcScreen, 
               0,0,
               GetSystemMetrics (SM_CXSCREEN),
               GetSystemMetrics (SM_CYSCREEN),
               SRCCOPY))
    {
        MessageBox(hWnd, "StretchBlt has failed", "Failed", MB_OK);
        done(hbmScreen, hdcMemDC, hdcScreen, hWnd, hdcWindow);
        return 1;
    }
    
    // Create a compatible bitmap from the Window DC
    hbmScreen = CreateCompatibleBitmap(hdcWindow, rcClient.right-rcClient.left, rcClient.bottom-rcClient.top);
    
    if(!hbmScreen)
    {
        MessageBox(hWnd, "CreateCompatibleBitmap Failed", "Failed", MB_OK);
        done(hbmScreen, hdcMemDC, hdcScreen, hWnd, hdcWindow);
        return 1;
    }

    // Select the compatible bitmap into the compatible memory DC.
    SelectObject(hdcMemDC,hbmScreen);
    
    // Bit block transfer into our compatible memory DC.
    if(!BitBlt(hdcMemDC, 
               0,0, 
               rcClient.right-rcClient.left, rcClient.bottom-rcClient.top, 
               hdcWindow, 
               0,0,
               SRCCOPY))
    {
        MessageBox(hWnd, "BitBlt has failed", "Failed", MB_OK);
        done(hbmScreen, hdcMemDC, hdcScreen, hWnd, hdcWindow);
        return 1;
    }

    // Get the BITMAP from the HBITMAP
    GetObject(hbmScreen,sizeof(BITMAP),&bmpScreen);
     
    BITMAPFILEHEADER   bmfHeader;    
    BITMAPINFOHEADER   bi;
     
    bi.biSize = sizeof(BITMAPINFOHEADER);    
    bi.biWidth = bmpScreen.bmWidth;    
    bi.biHeight = bmpScreen.bmHeight;  
    bi.biPlanes = 1;    
    bi.biBitCount = 32;    
    bi.biCompression = BI_RGB;    
    bi.biSizeImage = 0;  
    bi.biXPelsPerMeter = 0;    
    bi.biYPelsPerMeter = 0;    
    bi.biClrUsed = 0;    
    bi.biClrImportant = 0;

    DWORD dwBmpSize = ((bmpScreen.bmWidth * bi.biBitCount + 31) / 32) * 4 * bmpScreen.bmHeight;

    // Starting with 32-bit Windows, GlobalAlloc and LocalAlloc are implemented as wrapper functions that 
    // call HeapAlloc using a handle to the process's default heap. Therefore, GlobalAlloc and LocalAlloc 
    // have greater overhead than HeapAlloc.
    HANDLE hDIB = GlobalAlloc(GHND,dwBmpSize); 
    char *lpbitmap = (char *)GlobalLock(hDIB);    

    // Gets the "bits" from the bitmap and copies them into a buffer 
    // which is pointed to by lpbitmap.
    GetDIBits(hdcWindow, hbmScreen, 0,
        (UINT)bmpScreen.bmHeight,
        lpbitmap,
        (BITMAPINFO *)&bi, DIB_RGB_COLORS);

    // A file is created, this is where we will save the screen capture.
    HANDLE hFile = CreateFile("captureqwsx.bmp",
        GENERIC_WRITE,
        0,
        NULL,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL, NULL);
    
    // Add the size of the headers to the size of the bitmap to get the total file size
    DWORD dwSizeofDIB = dwBmpSize + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
 
    //Offset to where the actual bitmap bits start.
    bmfHeader.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER); 
    
    //Size of the file
    bmfHeader.bfSize = dwSizeofDIB; 
    
    //bfType must always be BM for Bitmaps
    bmfHeader.bfType = 0x4D42; //BM   
 
    DWORD dwBytesWritten = 0;
    WriteFile(hFile, (LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER), &dwBytesWritten, NULL);
    WriteFile(hFile, (LPSTR)&bi, sizeof(BITMAPINFOHEADER), &dwBytesWritten, NULL);
    WriteFile(hFile, (LPSTR)lpbitmap, dwBmpSize, &dwBytesWritten, NULL);
    
    //Unlock and Free the DIB from the heap
    GlobalUnlock(hDIB);    
    GlobalFree(hDIB);

    //Close the handle for the file that was created
    CloseHandle(hFile);

    done(hbmScreen, hdcMemDC, hdcScreen, hWnd, hdcWindow);

    return 0;
}

void done(HBITMAP hbmScreen, HDC hdcMemDC, HDC hdcScreen, HWND hWnd, HDC hdcWindow)
{
        //Clean up
    DeleteObject(hbmScreen);
    DeleteObject(hdcMemDC);
    ReleaseDC(NULL,hdcScreen);
    ReleaseDC(hWnd,hdcWindow);
}