#define CURL_STATICLIB
#include <stdio.h>
#include <curl/curl.h>
#include <curl/types.h>
#include <curl/easy.h>
#include <string>

class MyClass;

typedef struct job_info_t {
 int jobID;
 MyClass *parent;
} struct job_info_t;

int progress_callback(void *data, double download_total_size, double download_total_size_done, double ultotal, double uldone)
{
    job_info_t *jinfo = (job_info_t *)data;
    if(!jinfo) return 1;
   
    jinfo->parent->reportProgress(jinfo->jobID, download_total_size, download_total_size_done);
    return 0;
}

void MyClass::reportProgress(int jobID, double download_total_size, double download_total_size_done)
{
    printf("DLFile-%04d|progress: %0.3f\n", jobID, download_total_size_done / download_total_size);
}

int MyClass::downloadFile(int jobID, std::string localFile, string url)
{
    job_info jinfo;
    jinfo.parent = this;
    jinfo.jobID = jobID;
   
    CURL *curl = curl_easy_init();
    if(!curl)
    {
        printf("DLFile-%04d|error creating curl: %s\n", jobID, localFile.string().c_str());
        printf("DLFile-%04d|download URL: %s\n", jobID, url.c_str());
        return 1;
    }
    FILE *outFile = fopen(localFile.string().c_str(), "wb");
    if(!outFile)
    {
        perror("error opening file");
        printf("DLFile-%04d|error opening local file: %s.\n", jobID, localFile.string().c_str());
        printf("DLFile-%04d|download URL: %s\n", jobID, url.c_str());
        return 2;
    }

    char *curl_err_str[CURL_ERROR_SIZE];
    memset(curl_err_str, 0, CURL_ERROR_SIZE);

    CURLcode res;
    curl_easy_setopt(curl, CURLOPT_URL,              url.c_str());
   
    // logging stuff
//  curl_easy_setopt(curl, CURLOPT_STDERR,           InstallerLog::getSingleton()->getLogFilePtr());
    curl_easy_setopt(curl, CURLOPT_ERRORBUFFER,      curl_err_str[0]);

    // progess stuff
    curl_easy_setopt(curl, CURLOPT_NOPROGRESS,       0);
    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA,     &jinfo);
    curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, &progress_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA,        outFile);

    // http related settings
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION,   1); // follow redirects
    curl_easy_setopt(curl, CURLOPT_AUTOREFERER,      1); // set the Referer: field in requests where it follows a Location: redirect.
    curl_easy_setopt(curl, CURLOPT_MAXREDIRS,        20);
    curl_easy_setopt(curl, CURLOPT_USERAGENT,        "YourUserAgent");
    curl_easy_setopt(curl, CURLOPT_FILETIME,         1);
   
   
    res = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
    fclose(outFile);

    // print curl error if existing
    if(res != CURLE_OK)
    {
        printf("DLFile-%04d| CURL returned: %d\n", jobID, res);
        printf("DLFile-%04d| CURL error: %s\n", jobID, curl_err_str);
        return 3;
    }
    return 0;
}

/*
 * File:   wxutils.h
 * Author: thomas
 *
 * Created on May 12, 2010, 9:23 AM
 */

#ifndef _WXUTILS_H
#define _WXUTILS_H

#include <wx/wx.h>
#include <string.h>

std::string getWindowHandle(wxWindow *window);

#endif  /* _WXUTILS_H */

#include "wxutils.h"

#include <iostream>
#include <sstream>

// this is in a separate file to reduce the clutter in the global namespace and their conflicts

#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX
# ifdef __WXGTK__
#include <gdk/gdk.h>
#include <gtk/gtk.h> // just this should suffice as it should include gdk.h itself
/* Seems to be needed under Linux */
//#include <wx/gtk/win_gtk.h>
#include "wx/gtk/private/win_gtk.h"
#include <gdk/gdkx.h>
#include <GL/glx.h>

#if  wxCHECK_VERSION(2, 9, 0)
#define piz(wxwin) WX_PIZZA((wxwin)->m_wxwindow)
#define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \
        GDK_WINDOW_XWINDOW(((GtkWidget*)piz(wxwin))->window) : \
        GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)
#else
#define GetXWindow(wxwin) (wxwin)->m_wxwindow ? \
        GDK_WINDOW_XWINDOW(GTK_PIZZA((wxwin)->m_wxwindow)->bin_window) : \
        GDK_WINDOW_XWINDOW((wxwin)->m_widget->window)
#endif

#ifdef __WXX11__
#include "wx/x11/privx.h"
#define GetXWindow(wxwin)   ((Window)(wxwin)->GetHandle())
#endif

# endif //__WXGTK__
#endif //OGRE_PLATFORM_LINUX

std::string getWindowHandle(wxWindow *window)
{
#if WIN32
    std::stringstream sstr;
    size_t hWnd = (size_t)window->GetHandle();
    sstr << hWnd;
    std::string result = sstr.str();
    return result;
#else

    // TODO: Someone test this. you might to use "parentWindowHandle" if this
    // does not work.  Ogre 1.2 + Linux + GLX platform wants a string of the
    // format display:screen:window, which has variable types ulong:uint:ulong.
    GtkWidget* widget = window->GetHandle();
    //gtk_widget_set_double_buffered (widget, FALSE);
    gtk_widget_realize( widget );   // Mandatory. Otherwise, a segfault happens.
    //XSync(GDK_WINDOW_XDISPLAY(widget->window), False);
   
    Display* display = GDK_WINDOW_XDISPLAY( widget->window );

   
    //Window wid = GetXWindow(window);
    Window wid = GDK_WINDOW_XWINDOW( widget->window );

    std::stringstream sstr;
    /* Get the right display (DisplayString() returns ":display.screen") */
    std::string displayStr = DisplayString( display );
    displayStr = displayStr.substr( 1, ( displayStr.find( ".", 0 ) - 1 ) );

    int screenNum = DefaultScreen( display );

    /* Put all together */
    printf("using display: %s\n", displayStr.c_str());
    printf("using screen: %d\n", screenNum);
    printf("using window: 0x%x\n", wid);

    // old format:
    sstr << displayStr << ':' << screenNum << ':' << wid;
    std::string result = sstr.str();

    printf("getWindowHandle() = %s\n", result.c_str());
    return result;
#endif
}

...
mWindow = mRoot->initialise(false);
Ogre::NameValuePairList params;
params["externalWindowHandle"] = getWindowHandle(panel_viewport);
mWindow = Ogre::Root::getSingleton().createRenderWindow("OgreRenderWindow", 640, 480, false, &params);
...