diff --git a/generators/epub/CMakeLists.txt b/generators/epub/CMakeLists.txt
index 9442f61..dc827ef 100644
--- a/generators/epub/CMakeLists.txt
+++ b/generators/epub/CMakeLists.txt
@@ -7,14 +7,15 @@ include_directories(
 ########### next target ###############
 
 set(okularGenerator_epub_PART_SRCS
-  converter.cpp
+  #converter.cpp
+  epubnetworkmanager.cpp
   epubdocument.cpp
   generator_epub.cpp
 )
 
 kde4_add_plugin(okularGenerator_epub ${okularGenerator_epub_PART_SRCS})
 
-target_link_libraries(okularGenerator_epub okularcore ${EPUB_LIBRARIES} ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} ${QT_QTGUI_LIBRARY})
+target_link_libraries(okularGenerator_epub okularcore ${EPUB_LIBRARIES} ${KDE4_KDECORE_LIBS} ${KDE4_KDEUI_LIBS} ${KDE4_KDEWEBKIT_LIBS} ${QT_QTGUI_LIBRARY} ${QT_QTXML_LIBRARY})
 
 install(TARGETS okularGenerator_epub DESTINATION ${PLUGIN_INSTALL_DIR})
 
diff --git a/generators/epub/epubdocument.cpp b/generators/epub/epubdocument.cpp
index ae19f8a..c90c2ef 100644
--- a/generators/epub/epubdocument.cpp
+++ b/generators/epub/epubdocument.cpp
@@ -8,24 +8,22 @@
  ***************************************************************************/
 
 #include "epubdocument.h"
+#include "epubnetworkmanager.h"
+#include <QDomNodeList>
+#include <QtCore/qmath.h>
+#include <QWebFrame>
 
 using namespace Epub;
 
-namespace {
 
-QString resourceUrl(const KUrl &baseUrl, const QString &u)
-{
-  KUrl newUrl(KUrl(baseUrl.directory(KUrl::AppendTrailingSlash)), u);
-  QString newDir = newUrl.toLocalFile();
-  newDir.remove(0, 1);
-  return newDir;
-}
-
-}
-
-EpubDocument::EpubDocument(const QString &fileName) : QTextDocument()
+EpubDocument::EpubDocument(const QString &fileName) : KWebPage(), m_size(600,800)
 {
   mEpub = epub_open(qPrintable(fileName), 3);
+  if(!isValid())
+      return;
+
+  setNetworkAccessManager(new EpubNetworkManager(mEpub, this));
+  perparePage();
 }
 
 bool EpubDocument::isValid()
@@ -43,40 +41,63 @@ EpubDocument::~EpubDocument() {
 
 struct epub *EpubDocument::getEpub()
 {
-  return mEpub;
+    return mEpub;
 }
 
-void EpubDocument::setCurrentSubDocument(const QString &doc)
+int EpubDocument::pageCount() const
 {
-  mCurrentSubDocument = KUrl::fromPath("/" + doc);
+    return (qCeil(this->mainFrame()->contentsSize().height()/800));
 }
 
-QVariant EpubDocument::loadResource(int type, const QUrl &name)
+QSize EpubDocument::pageSize() const
 {
-  int size;
-  char *data;
-
-  // Get the data from the epub file
-  size = epub_get_data(mEpub, resourceUrl(mCurrentSubDocument, name.toString()).toUtf8(), &data);
-
-  QVariant resource;
+    return m_size;
+}
 
-  if (data) {
-    switch(type) {
-    case QTextDocument::ImageResource:
-      resource.setValue(QImage::fromData((unsigned char *)data, size));
-      break;
+KWebPage *EpubDocument::perparePage()
+{
+    struct eiterator *it = epub_get_iterator(mEpub, EITERATOR_SPINE, 0);
+    QString html;
+    do {
+        if (epub_it_get_curr(it)) {
+            QString temp = QString::fromUtf8(epub_it_get_curr(it));
+            html += enableNetworkDownload(temp);
+        }
+    } while (epub_it_get_next(it));
+
+    mainFrame()->setHtml(html);
+    epub_free_iterator(it);
+
+    return this;
+}
 
-    default:
-      resource.setValue(QString::fromUtf8(data));
-      break;
+QString EpubDocument::enableNetworkDownload(QString html)
+{
+    QDomDocument doc;
+    doc.setContent(html);
+    // images
+    QDomNodeList list = doc.elementsByTagName("img");
+    for(int i=0;i<list.count();i++){
+        QString src = list.at(i).attributes().namedItem("src").nodeValue();
+        list.at(i).attributes().namedItem("src").setNodeValue("http://"+src);
     }
 
-    free(data);
-  }
+    // style sheets
+    list = doc.elementsByTagName("link");
+    for(int i=0;i<list.count();i++){
+        if(list.at(i).attributes().namedItem("type").nodeValue() == "text/css"){
+            // Check for case sensitivity above
 
-  // add to cache
-  addResource(type, name, resource); 
+            QString href = list.at(i).attributes().namedItem("href").nodeValue();
+            list.at(i).attributes().namedItem("href").setNodeValue("http://"+href);
+        }
+    }
 
-  return resource;
+    // svgs
+    list = doc.elementsByTagName("image");
+    for(int i=0;i<list.count();i++){
+        QString src = list.at(i).attributes().namedItem("xlink:href").nodeValue();
+        list.at(i).attributes().namedItem("xlink:href").setNodeValue("http://"+src);
+    }
+    return doc.toString();
 }
diff --git a/generators/epub/epubdocument.h b/generators/epub/epubdocument.h
index 714ede6..78ce426 100644
--- a/generators/epub/epubdocument.h
+++ b/generators/epub/epubdocument.h
@@ -10,31 +10,38 @@
 #ifndef EPUB_DOCUMENT_H
 #define EPUB_DOCUMENT_H
 
-#include <QTextDocument>
+#include <KWebPage>
 #include <QUrl>
 #include <QVariant>
 #include <QImage>
 #include <kurl.h>
 #include <epub.h>
 
-namespace Epub {
+namespace Epub
+{
 
-  class EpubDocument : public QTextDocument {
-
-  public:
+class EpubDocument : public KWebPage
+{
+    Q_OBJECT
+public:
     EpubDocument(const QString &fileName);
     bool isValid();
     ~EpubDocument();
     struct epub *getEpub();
-    void setCurrentSubDocument(const QString &doc);
+    int pageCount() const;
+    QSize pageSize() const;
+
+    KWebPage *perparePage();
+    //void setCurrentSubDocument(const QString &doc);
 
-  protected:
-    virtual QVariant loadResource(int type, const QUrl &name);
+protected:
+    //virtual QVariant loadResource(int type, const QUrl &name);
 
-  private:
+private:
     struct epub *mEpub;
-    KUrl mCurrentSubDocument;
-  };
+    QString enableNetworkDownload(QString html);
+    QSize m_size;
+};
 
 }
 #endif
diff --git a/generators/epub/epubnetworkmanager.cpp b/generators/epub/epubnetworkmanager.cpp
new file mode 100755
index 0000000..613ab45
--- /dev/null
+++ b/generators/epub/epubnetworkmanager.cpp
@@ -0,0 +1,111 @@
+#include "epubnetworkmanager.h"
+
+
+
+EpubNetworkManager::EpubNetworkManager(struct epub *mepub, QObject *parent)
+{
+    m_epub = mepub;
+}
+
+QNetworkReply *EpubNetworkManager::createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &request, QIODevice *outgoingData)
+{
+    if (op != GetOperation)
+        return QNetworkAccessManager::createRequest(op, request, outgoingData);
+    return new RendererReply(this, request, m_epub);
+}
+
+
+RendererReply::RendererReply(QObject *object, const QNetworkRequest &request, epub *mEpub)
+    : QNetworkReply(object), position(0)
+{
+    setRequest(request);
+    setOperation(QNetworkAccessManager::GetOperation);
+    QString path = request.url().host() + request.url().path();
+    if(path.at(0)==QDir::separator())
+        path = path.right(path.length()-1);
+    if(path.at(path.length()-1)==QDir::separator())
+        path.chop(1);
+    filetype = getQVariantFromExt(QFileInfo(path).suffix());
+    setHeader(QNetworkRequest::ContentTypeHeader,filetype);
+    open(ReadOnly|Unbuffered);
+    setUrl(request.url());
+    QString pattern = request.url().queryItemValue("pattern");
+    connect(&watcher, SIGNAL(finished()), SLOT(generateDone()));
+    QFuture<QByteArray> future = QtConcurrent::run<QByteArray>(this,&RendererReply::generate, path, mEpub);
+    watcher.setFuture(future);
+}
+
+qint64 RendererReply::readData(char *data, qint64 maxSize)
+{
+    const qint64 readSize = qMin(maxSize, (qint64)(buffer.size() - position));
+    memcpy(data, buffer.constData() + position, readSize);
+    position += readSize;
+    return readSize;
+}
+
+qint64 RendererReply::bytesAvailable() const
+{
+    return buffer.size() - position;
+}
+
+qint64 RendererReply::pos() const
+{
+    return position;
+}
+
+bool RendererReply::seek(qint64 pos)
+{
+    if (pos < 0 || pos >= buffer.size())
+        return false;
+    position = pos;
+    return true;
+}
+
+qint64 RendererReply::size() const
+{
+    return buffer.size();
+}
+
+QByteArray RendererReply::generate(QString path, epub *Epub)
+{
+    int size;
+    char *data;
+
+    // Get the data from the epub file
+    size = epub_get_data(Epub, path.toUtf8(), &data);
+
+    QByteArray saveData(data,size);
+    return saveData;
+}
+
+QVariant RendererReply::getQVariantFromExt(QString ext)
+{
+    if(ext == "css"){
+        return QVariant("text/css");
+    } else if (ext == "js"){
+        return QVariant("application/x-javascript");
+    } else if(ext == "png"){
+        return QVariant("image/"+ext);
+    } else if(ext == "jpg" || ext == "jpeg"){
+        return QVariant("image/jpeg");
+    } else if ( ext == "svg") {
+        return QVariant("image/svg+xml");
+    } else {
+        return QVariant();
+    }
+}
+
+void RendererReply::generateDone()
+{
+    setHeader(QNetworkRequest::ContentTypeHeader, filetype);
+    position = 0;
+    buffer = watcher.result();
+    emit readyRead();
+    emit finished();
+}
+
+void RendererReply::abort()
+{
+}
+
+
diff --git a/generators/epub/epubnetworkmanager.h b/generators/epub/epubnetworkmanager.h
new file mode 100755
index 0000000..28efab2
--- /dev/null
+++ b/generators/epub/epubnetworkmanager.h
@@ -0,0 +1,52 @@
+#ifndef EPUBNETWORKMANAGER_H
+#define EPUBNETWORKMANAGER_H
+
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QtConcurrentRun>
+#include <QFutureWatcher>
+#include <QDir>
+
+#include <epub.h>
+
+class EpubNetworkManager : public QNetworkAccessManager
+{
+    Q_OBJECT
+public:
+    explicit EpubNetworkManager(struct epub* mepub, QObject *parent = 0);
+    QNetworkReply *createRequest(Operation op, const QNetworkRequest &request, QIODevice *outgoingData);
+
+private:
+    struct epub* m_epub;
+    
+};
+
+
+class RendererReply : public QNetworkReply
+{
+    Q_OBJECT
+public:
+    RendererReply(QObject* object, const QNetworkRequest& request, struct epub *mEpub);
+    qint64 readData(char* data, qint64 maxSize);
+    qint64 bytesAvailable() const;
+    qint64 pos() const;
+    bool seek( qint64 pos );
+    qint64 size() const;
+
+private:
+    QByteArray generate(QString path, struct epub* Epub);
+    QVariant getQVariantFromExt(QString ext);
+
+public slots:
+    void generateDone();
+    void abort();
+
+private:
+    QFutureWatcher<QByteArray> watcher;
+    QVariant filetype;
+    QByteArray buffer;
+    int position;
+};
+
+
+#endif // EPUBNETWORKMANAGER_H
diff --git a/generators/epub/generator_epub.cpp b/generators/epub/generator_epub.cpp
index 68875d1..bd5aa3a 100644
--- a/generators/epub/generator_epub.cpp
+++ b/generators/epub/generator_epub.cpp
@@ -9,10 +9,13 @@
 
 #include "generator_epub.h"
 
-#include "converter.h"
+//#include "converter.h"
 
 #include <kaboutdata.h>
 #include <kconfigdialog.h>
+#include <core/page.h>
+#include <QEventLoop>
+#include <QPainter>
 
 static KAboutData createAboutData()
 {
@@ -34,14 +37,74 @@ static KAboutData createAboutData()
 OKULAR_EXPORT_PLUGIN( EPubGenerator, createAboutData() )
 
 EPubGenerator::EPubGenerator( QObject *parent, const QVariantList &args )
-: Okular::TextDocumentGenerator( new Epub::Converter, "okular_epub_generator_settings", parent, args )
+: Okular::Generator( parent, args )
+{
+}
+
+EPubGenerator::~EPubGenerator()
 {
 }
 
 void EPubGenerator::addPages( KConfigDialog* dlg )
 {
-  Okular::TextDocumentSettingsWidget *widget = generalSettingsWidget();
-  widget->setParent( dlg );
+    Q_UNUSED(dlg)
+//  Okular::TextDocumentSettingsWidget *widget = generalSettingsWidget();
+//  widget->setParent( dlg );
+
+//  dlg->addPage( widget, generalSettings(), i18n("EPub"), "application-epub+zip", i18n("EPub Backend Configuration") );
+}
+
+bool EPubGenerator::loadDocument(const QString &fileName, QVector<Okular::Page *> &pagesVector)
+{
+    mDoc = new Epub::EpubDocument(fileName);
+
+    QEventLoop loop;
+    connect(mDoc,SIGNAL(loadFinished(bool)),&loop,SLOT(quit()));
+    loop.exec();
+
+    int count = mDoc->pageCount();
+    pagesVector.resize(count);
+    QSize size = mDoc->pageSize();
+
+    for(int i = 0; i < count; i++)
+    {
+        Okular::Page * pg = new Okular::Page( i, size.width(), size.height(), Okular::Rotation0 );
+        pagesVector[ i ] = pg;
+    }
+    return true;
+}
 
-  dlg->addPage( widget, generalSettings(), i18n("EPub"), "application-epub+zip", i18n("EPub Backend Configuration") );
+bool EPubGenerator::reparseConfig()
+{
+    return false;
+}
+
+QImage EPubGenerator::image(PixmapRequest *page)
+{
+    int i = page->pageNumber();
+    QWebFrame *webFrame = mDoc->mainFrame();
+    webFrame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
+    webFrame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
+
+    //int wd = 600, ht = 800, x = 0, y = 0;
+    int wd = page->width(), ht = page->height(), x = 0, y = 0;
+    mDoc->setViewportSize(QSize(wd,ht));
+
+
+    if(i > 0){
+        y = i * ht;
+    }
+    mDoc->mainFrame()->setScrollPosition(QPoint(x,y));
+    QImage img(mDoc->viewportSize(),QImage::Format_ARGB32);
+    QPainter paint(&img);
+    mDoc->mainFrame()->render(&paint);
+    paint.end();
+    return img;
+}
+
+bool EPubGenerator::doCloseDocument()
+{
+    delete mDoc;
+    mDoc = 0;
+    return true;
 }
diff --git a/generators/epub/generator_epub.h b/generators/epub/generator_epub.h
index 02cecb2..3f1eaa2 100644
--- a/generators/epub/generator_epub.h
+++ b/generators/epub/generator_epub.h
@@ -9,16 +9,39 @@
 
 #ifndef _OKULAR_GENERATOR_EPUB_H_
 #define _OKULAR_GENERATOR_EPUB_H_
-#include <core/textdocumentgenerator.h>
 
-class EPubGenerator : public Okular::TextDocumentGenerator
+#include "epubdocument.h"
+#include <core/generator.h>
+#include <interfaces/configinterface.h>
+
+#include <QWebFrame>
+
+using namespace Okular;
+
+class OKULAR_EXPORT EPubGenerator : public Generator, public Okular::ConfigInterface
 {
+    Q_OBJECT
+    Q_INTERFACES( Okular::ConfigInterface )
  public:
   EPubGenerator( QObject *parent, const QVariantList &args );
-  ~EPubGenerator() {}
+  ~EPubGenerator();
 
   // [INHERITED] reparse configuration
   void addPages( KConfigDialog* dlg );
+
+  bool loadDocument( const QString & fileName, QVector< Page * > & pagesVector );
+
+  bool reparseConfig();
+
+  // [INHERITED] perform actions on document / pages
+  QImage image( Okular::PixmapRequest *page );
+
+protected:
+    bool doCloseDocument();
+    Epub::EpubDocument *mDoc;
+
+private:
+
 };
 
 #endif