Merge pull request #8 from qarkai/deprecated

Fix deprecation warnings

3rdparty/cmake/FindLibXML2.cmake

@@ -1,29 +0,0 @@
-# - Try to find LibXml2
-# Once done this will define
-#  LIBXML2_FOUND - System has LibXml2
-#  LIBXML2_INCLUDE_DIRS - The LibXml2 include directories
-#  LIBXML2_LIBRARIES - The libraries needed to use LibXml2
-#  LIBXML2_DEFINITIONS - Compiler switches required for using LibXml2
-
-find_package(PkgConfig)
-pkg_check_modules(PC_LIBXML QUIET libxml-2.0)
-set(LIBXML2_DEFINITIONS ${PC_LIBXML_CFLAGS_OTHER})
-
-find_path(LIBXML2_INCLUDE_DIR libxml/xpath.h
-          HINTS ${PC_LIBXML_INCLUDEDIR} ${PC_LIBXML_INCLUDE_DIRS}
-          PATH_SUFFIXES libxml2 )
-
-find_library(LIBXML2_LIBRARY NAMES xml2 libxml2
-             HINTS ${PC_LIBXML_LIBDIR} ${PC_LIBXML_LIBRARY_DIRS} )
-
-set(LIBXML2_LIBRARIES ${LIBXML2_LIBRARY} )
-set(LIBXML2_INCLUDE_DIRS ${LIBXML2_INCLUDE_DIR} )
-
-include(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set LIBXML2_FOUND to TRUE
-# if all listed variables are TRUE
-find_package_handle_standard_args(LibXml2  DEFAULT_MSG
-                                  LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
-
-mark_as_advanced(LIBXML2_INCLUDE_DIR LIBXML2_LIBRARY )
-

CMakeLists.txt

@@ -30,7 +30,6 @@ set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/3rdparty/cmake)
 
 #find_program( QT_QMAKE_EXECUTABLE NAMES qmake5 qmake-qt5 qmake-mac )
 find_package( Qt5 5.5.0 COMPONENTS Core Gui Network Widgets WebKitWidgets Xml XmlPatterns LinguistTools REQUIRED )
-find_package( LibXML2 )
 
 file( GLOB FB2_HEAD source/*.hpp     )
 file( GLOB FB2_SRCS source/*.cpp     )
@@ -72,16 +71,9 @@ add_executable(fb2edit ${FB2_SRCS} ${FB2_HEAD} ${UI_HEADERS} ${MOC_SRCS} ${RCC_S
 include_directories(${CMAKE_BINARY_DIR})
 target_link_libraries(fb2edit PUBLIC
     Qt5::Core Qt5::Gui Qt5::Network Qt5::Widgets Qt5::WebKitWidgets Qt5::Xml Qt5::XmlPatterns
-    ${LIBXML2_LIBRARIES}
     )
 #add_definitions(${QT_DEFINITIONS})
 
-include_directories(${LIBXML2_INCLUDE_DIRS})
-if (LIBXML2_FOUND) 
-    add_definitions(${LIBXML2_DEFINITIONS})
-    add_definitions(-DFB2_USE_LIBXML2)
-endif (LIBXML2_FOUND) 
-   
 #############################################################################
 # You can change the install location by 
 # running cmake like this:

debian/control

@@ -2,7 +2,7 @@ Source: fb2edit
 Section: x11
 Priority: optional
 Maintainer: Kandrashin Denis <mail@lintest.ru>
-Build-Depends: debhelper (>= 7), cmake, cdbs, libqt4-dev (>= 4.6), libxml2-dev
+Build-Depends: debhelper (>= 7), cmake, cdbs, libqt4-dev (>= 4.6)
 Standards-Version: 3.8.0
 Homepage: http://fb2edit.lintest.ru
 

fb2edit.pro

@@ -80,14 +80,6 @@ OTHER_FILES += \
     3rdparty/fb2/FictionBookGenres.xsd \
     3rdparty/fb2/FictionBook2.1.xsd
 
-if (unix) {
-
-    DEFINES += FB2_USE_LIBXML2
-    INCLUDEPATH += /usr/include/libxml2
-    LIBS += -lxml2
-
-}
-
 FORMS += \
     source/fb2find.ui \
     source/fb2setup.ui

rpmbuild/fb2edit.spec

@@ -26,7 +26,6 @@ BuildRequires:  pkgconfig(QtGui) >= 4.6.0
 BuildRequires:  pkgconfig(QtNetwork) >= 4.6.0
 BuildRequires:  pkgconfig(QtWebKit) >= 4.6.0
 BuildRequires:  pkgconfig(QtXml) >= 4.6.0
-BuildRequires:  pkgconfig(libxml-2.0)
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 
 %if 0%{?suse_version}

source/fb2code.cpp

@@ -548,9 +548,7 @@ bool FbCodeEdit::read(QIODevice *device)
 {
     QByteArray data = device->readAll();
     delete device;
-    QXmlInputSource source;
-    source.setData(data);
-    setPlainText(source.data());
+    setPlainText(data);
     return true;
 }
 
@@ -563,7 +561,7 @@ int FbCodeEdit::lineNumberAreaWidth()
         ++digits;
     }
 
-    int space = 3 + fontMetrics().width(QLatin1Char('9')) * digits;
+    int space = 3 + fontMetrics().horizontalAdvance(QLatin1Char('9')) * digits;
 
     return space;
 }

source/fb2code.hpp

@@ -37,7 +37,7 @@ public:
     void load(const QByteArray data)
         { setPlainText(QString::fromUtf8(data.data())); }
 
-    bool findText(const QString &exp, QTextDocument::FindFlags options = 0);
+    bool findText(const QString &exp, QTextDocument::FindFlags options = {});
 
     bool isModified() const { return document()->isModified(); }
 

source/fb2dlgs.cpp

@@ -41,7 +41,7 @@ void FbCodeFindDlg::find()
 {
     QString text = ui->editText->text();
     if (text.isEmpty()) return;
-    QTextDocument::FindFlags options = 0;
+    QTextDocument::FindFlags options;
     if (ui->radioUp->isChecked()) options |= QTextDocument::FindBackward;
     if (ui->checkCase->isChecked()) options |= QTextDocument::FindCaseSensitively;
     if (ui->checkHigh->isChecked()) options |= QTextDocument::FindWholeWords;

source/fb2head.cpp

@@ -536,7 +536,7 @@ bool FbHeadModel::setData(const QModelIndex &index, const QVariant &value, int r
 
 Qt::ItemFlags FbHeadModel::flags(const QModelIndex &index) const
 {
-    if (!index.isValid()) return 0;
+    if (!index.isValid()) return Qt::NoItemFlags;
     Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
     if (canEdit(index)) flags |= Qt::ItemIsEditable;
     return flags;

source/fb2logs.cpp

@@ -83,7 +83,7 @@ FbLogDock::FbLogDock(const QString &title, QWidget *parent, Qt::WindowFlags flag
 {
     m_list->setModel(m_model);
     connect(m_model, SIGNAL(changeCurrent(QModelIndex)), m_list, SLOT(setCurrentIndex(QModelIndex)));
-    setFeatures(QDockWidget::AllDockWidgetFeatures);
+    setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
     setAttribute(Qt::WA_DeleteOnClose);
     setWidget(m_list);
 }

source/fb2logs.hpp

@@ -68,7 +68,7 @@ class FbLogDock: public QDockWidget
     Q_OBJECT
 
 public:
-    explicit FbLogDock(const QString &title, QWidget *parent = 0, Qt::WindowFlags flags = 0);
+    explicit FbLogDock(const QString &title, QWidget *parent = 0, Qt::WindowFlags flags = {});
     void append(QtMsgType type, const QString &message);
 
 private:

source/fb2page.cpp

@@ -68,8 +68,7 @@ FbNetworkAccessManager *FbTextPage::manager()
 
 bool FbTextPage::read(const QString &html)
 {
-    QXmlInputSource *source = new QXmlInputSource();
-    source->setData(html);
+    QString *source = new QString(html);
     FbReadThread::execute(this, source, 0);
     return true;
 }
@@ -371,7 +370,7 @@ FbTextElement FbTextPage::current()
 FbTextElement FbTextPage::element(const QString &location)
 {
     if (location.isEmpty()) return FbTextElement();
-    QStringList list = location.split(",", QString::SkipEmptyParts);
+    QStringList list = location.split(",", Qt::SkipEmptyParts);
     QStringListIterator iterator(list);
     QWebElement result = doc();
     while (iterator.hasNext()) {

source/fb2read.cpp

@@ -9,14 +9,14 @@
 //  FbReadThread
 //---------------------------------------------------------------------------
 
-void FbReadThread::execute(QObject *parent, QXmlInputSource *source, QIODevice *device)
+void FbReadThread::execute(QObject *parent, QString *source, QIODevice *device)
 {
     FbReadThread *thread = new FbReadThread(parent, source, device);
     connect(thread, SIGNAL(html(QString, FbStore*)), parent, SLOT(html(QString, FbStore*)));
     thread->start();
 }
 
-FbReadThread::FbReadThread(QObject *parent, QXmlInputSource *source, QIODevice *device)
+FbReadThread::FbReadThread(QObject *parent, QString *source, QIODevice *device)
     : QThread(parent)
     , m_device(device)
     , m_source(source)
@@ -50,32 +50,20 @@ bool FbReadThread::parse()
     connect(&handler, SIGNAL(error(int,int,QString)), parent(), SIGNAL(error(int,int,QString)));
     connect(&handler, SIGNAL(fatal(int,int,QString)), parent(), SIGNAL(fatal(int,int,QString)));
 
-#ifdef FB2_USE_LIBXML2
     XML2::XmlReader reader;
-#else
-    QXmlSimpleReader reader;
-#endif
 
     reader.setContentHandler(&handler);
     reader.setLexicalHandler(&handler);
     reader.setErrorHandler(&handler);
 
-#ifdef FB2_USE_LIBXML2
     if (m_device) {
         return reader.parse(m_device);
     } else {
         return reader.parse(m_source);
     }
-#else
-    if (m_device) {
-        m_source = new QXmlInputSource();
-        m_source->setData(m_device->readAll());
-    }
-    return reader.parse(m_source);
-#endif
 }
 
-/*
+#if 0
 FbReadThread::FbReadThread(QObject *parent, const QString &filename, const QString &xml)
     : QThread(parent)
     , m_temp(0)
@@ -98,8 +86,6 @@ void FbReadThread::run()
     if (parse()) emit html(m_html);
 }
 
-#ifdef FB2_USE_LIBXML2
-
 bool FbReadThread::parse()
 {
     QXmlStreamWriter writer(&m_html);
@@ -121,36 +107,8 @@ bool FbReadThread::parse()
         return reader.parse(source);
     }
 }
-
-#else
-
-bool FbReadThread::parse()
-{
-    QXmlStreamWriter writer(&m_html);
-    FbReadHandler handler(*this, writer);
-    connect(&handler, SIGNAL(binary(QString,QByteArray)), this, SLOT(data(QString,QByteArray)));
-    QXmlSimpleReader reader;
-    reader.setContentHandler(&handler);
-    reader.setLexicalHandler(&handler);
-    reader.setErrorHandler(&handler);
-    QXmlInputSource source;
-    if (m_xml.isEmpty()) {
-        QFile file(m_filename);
-        if (!file.open(QFile::ReadOnly | QFile::Text)) {
-            qCritical() << QObject::tr("Cannot read file %1: %2.").arg(m_filename).arg(file.errorString());
-            return false;
-        }
-        source.setData(file.readAll());
-    } else {
-        source.setData(m_xml);
-    }
-    return reader.parse(source);
-}
-
 #endif
 
-*/
-
 //---------------------------------------------------------------------------
 //  FbReadHandler::RootHandler
 //---------------------------------------------------------------------------
@@ -168,7 +126,7 @@ FbReadHandler::RootHandler::RootHandler(FbReadHandler &owner, const QString &nam
 {
 }
 
-FbXmlHandler::NodeHandler * FbReadHandler::RootHandler::NewTag(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbReadHandler::RootHandler::NewTag(const QString &name, const QXmlStreamAttributes &atts)
 {
     switch (toKeyword(name)) {
         case Binary: return new BinaryHandler(m_owner, name, atts);
@@ -260,7 +218,7 @@ FB2_BEGIN_KEYHASH(FbReadHandler::TextHandler)
     FB2_KEY( Code    , "code"          );
 FB2_END_KEYHASH
 
-FbReadHandler::TextHandler::TextHandler(FbReadHandler &owner, const QString &name, const QXmlAttributes &atts, const QString &tag)
+FbReadHandler::TextHandler::TextHandler(FbReadHandler &owner, const QString &name, const QXmlStreamAttributes &atts, const QString &tag)
     : BaseHandler(owner, name)
     , m_parent(NULL)
     , m_tag(tag)
@@ -269,7 +227,7 @@ FbReadHandler::TextHandler::TextHandler(FbReadHandler &owner, const QString &nam
     Init(name, atts);
 }
 
-FbReadHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts, const QString &tag)
+FbReadHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts, const QString &tag)
     : BaseHandler(parent->m_owner, name)
     , m_parent(parent)
     , m_tag(tag)
@@ -278,26 +236,25 @@ FbReadHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name
     Init(name, atts);
 }
 
-void FbReadHandler::TextHandler::Init(const QString &name, const QXmlAttributes &atts)
+void FbReadHandler::TextHandler::Init(const QString &name, const QXmlStreamAttributes &atts)
 {
     Keyword key = toKeyword(name);
     writer().writeStartElement(m_tag);
-    int count = atts.count();
-    for (int i = 0; i < count; ++i) {
-        QString name = atts.qName(i);
+    for (const auto& attr : atts) {
+        QString name = attr.qualifiedName().toString();
         switch (key) {
-            case Anchor: { if (atts.localName(i) == "href") name = "href"; break; }
-            case Image:  { if (atts.localName(i) == "href") name = "src"; break; }
+            case Anchor: { if (attr.name() == "href") name = "href"; break; }
+            case Image:  { if (attr.name() == "href") name = "src"; break; }
             default: ;
         }
-        writer().writeAttribute(name, atts.value(i));
+        writer().writeAttribute(name, attr.value().toString());
     }
     if (m_tag == "p" && (name == "text-author" || name == "subtitle")) {
         writer().writeAttribute("fb:class", name);
     }
 }
 
-FbXmlHandler::NodeHandler * FbReadHandler::TextHandler::NewTag(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbReadHandler::TextHandler::NewTag(const QString &name, const QXmlStreamAttributes &atts)
 {
     m_empty = false;
     QString tag;
@@ -346,7 +303,7 @@ bool FbReadHandler::TextHandler::isNotes() const
 //  FbReadHandler::BinaryHandler
 //---------------------------------------------------------------------------
 
-FbReadHandler::BinaryHandler::BinaryHandler(FbReadHandler &owner, const QString &name, const QXmlAttributes &atts)
+FbReadHandler::BinaryHandler::BinaryHandler(FbReadHandler &owner, const QString &name, const QXmlStreamAttributes &atts)
     : BaseHandler(owner, name)
     , m_file(Value(atts, "id"))
 {
@@ -360,26 +317,21 @@ void FbReadHandler::BinaryHandler::TxtTag(const QString &text)
 void FbReadHandler::BinaryHandler::EndTag(const QString &name)
 {
     Q_UNUSED(name);
-    QByteArray in; in.append(m_text);
-    if (!m_file.isEmpty()) m_owner.addFile(m_file, QByteArray::fromBase64(in));
+    if (!m_file.isEmpty()) m_owner.addFile(m_file, QByteArray::fromBase64(m_text.toUtf8()));
 }
 
 //---------------------------------------------------------------------------
 //  FbReadHandler
 //---------------------------------------------------------------------------
 
-bool FbReadHandler::load(QObject *page, QXmlInputSource &source, QString &html)
+bool FbReadHandler::load(QObject *page, QString &source, QString &html)
 {
     QXmlStreamWriter writer(&html);
     FbReadHandler handler(writer);
 
     connect(&handler, SIGNAL(binary(QString,QByteArray)), page, SLOT(binary(QString,QByteArray)));
 
-#ifdef FB2_USE_LIBXML2
     XML2::XmlReader reader;
-#else
-    QXmlSimpleReader reader;
-#endif
 
     reader.setContentHandler(&handler);
     reader.setLexicalHandler(&handler);
@@ -402,7 +354,7 @@ FbReadHandler::~FbReadHandler()
     m_writer.writeEndElement();
 }
 
-FbXmlHandler::NodeHandler * FbReadHandler::CreateRoot(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbReadHandler::CreateRoot(const QString &name, const QXmlStreamAttributes &atts)
 {
     Q_UNUSED(atts);
     if (name == "fictionbook") return new RootHandler(*this, name);

source/fb2read.hpp

@@ -15,7 +15,7 @@ class FbReadThread : public QThread
     Q_OBJECT
 
 public:
-    static void execute(QObject *parent, QXmlInputSource *source, QIODevice *device);
+    static void execute(QObject *parent, QString *source, QIODevice *device);
     virtual ~FbReadThread();
 
 signals:
@@ -27,12 +27,12 @@ protected:
     void run();
 
 private:
-    explicit FbReadThread(QObject *parent, QXmlInputSource *source, QIODevice *device);
+    explicit FbReadThread(QObject *parent, QString *source, QIODevice *device);
     bool parse();
 
 private:
     QIODevice *m_device;
-    QXmlInputSource *m_source;
+    QString *m_source;
     FbStore *m_store;
     QString m_html;
 };
@@ -42,7 +42,7 @@ class FbReadHandler : public FbXmlHandler
     Q_OBJECT
 
 public:
-    static bool load(QObject *page, QXmlInputSource &source, QString &html);
+    static bool load(QObject *page, QString &source, QString &html);
     explicit FbReadHandler(QXmlStreamWriter &writer);
     virtual ~FbReadHandler();
     virtual bool comment(const QString& ch);
@@ -71,7 +71,7 @@ private:
     public:
         explicit RootHandler(FbReadHandler &owner, const QString &name);
     protected:
-        virtual NodeHandler * NewTag(const QString & name, const QXmlAttributes &atts);
+        virtual NodeHandler * NewTag(const QString & name, const QXmlStreamAttributes &atts);
         virtual void EndTag(const QString &name);
     private:
         void writeScript(const QString &src);
@@ -107,14 +107,14 @@ private:
             Code,
        FB2_END_KEYLIST
     public:
-        explicit TextHandler(FbReadHandler &owner, const QString &name, const QXmlAttributes &atts, const QString &tag);
-        explicit TextHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts, const QString &tag);
+        explicit TextHandler(FbReadHandler &owner, const QString &name, const QXmlStreamAttributes &atts, const QString &tag);
+        explicit TextHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts, const QString &tag);
     protected:
-        virtual NodeHandler * NewTag(const QString &name, const QXmlAttributes &atts);
+        virtual NodeHandler * NewTag(const QString &name, const QXmlStreamAttributes &atts);
         virtual void TxtTag(const QString &text);
         virtual void EndTag(const QString &name);
     protected:
-        void Init(const QString &name, const QXmlAttributes &atts);
+        void Init(const QString &name, const QXmlStreamAttributes &atts);
         bool isNotes() const;
     protected:
         TextHandler *m_parent;
@@ -126,7 +126,7 @@ private:
     class BinaryHandler : public BaseHandler
     {
     public:
-        explicit BinaryHandler(FbReadHandler &owner, const QString &name, const QXmlAttributes &atts);
+        explicit BinaryHandler(FbReadHandler &owner, const QString &name, const QXmlStreamAttributes &atts);
     protected:
         virtual void TxtTag(const QString &text);
         virtual void EndTag(const QString &name);
@@ -139,7 +139,7 @@ signals:
     void binary(const QString &name, const QByteArray &data);
 
 protected:
-    virtual NodeHandler * CreateRoot(const QString &name, const QXmlAttributes &atts);
+    virtual NodeHandler * CreateRoot(const QString &name, const QXmlStreamAttributes &atts);
 
 private:
     void addFile(const QString &name, const QByteArray &data);

source/fb2save.cpp

@@ -65,7 +65,7 @@ void FbSaveDialog::init()
     }
 
     setAcceptMode(AcceptSave);
-    setConfirmOverwrite(true);
+    setOption(DontConfirmOverwrite, false);
     setDefaultSuffix("fb2");
 
     QStringList filters;
@@ -111,7 +111,7 @@ QString FbHtmlHandler::local(const QString &name)
 
 void FbHtmlHandler::onAttr(const QString &name, const QString &value)
 {
-    m_atts.append(name, "", local(name), value);
+    m_atts.append(name, local(name), value);
 }
 
 void FbHtmlHandler::onNew(const QString &name)
@@ -274,7 +274,7 @@ void FbSaveWriter::writeStyle()
     writeAttribute("type", "text/css");
     writeCharacters(postfix);
 
-    QStringList list = m_style.split("}", QString::SkipEmptyParts);
+    QStringList list = m_style.split("}", Qt::SkipEmptyParts);
     QString line;
     for (const QString &str: list) {
         line = str.simplified();
@@ -362,7 +362,7 @@ FB2_BEGIN_KEYHASH(FbSaveHandler::TextHandler)
     FB2_KEY( Code    , "tt"     );
 FB2_END_KEYHASH
 
-FbSaveHandler::TextHandler::TextHandler(FbSaveWriter &writer, const QString &name, const QXmlAttributes &atts, const QString &tag)
+FbSaveHandler::TextHandler::TextHandler(FbSaveWriter &writer, const QString &name, const QXmlStreamAttributes &atts, const QString &tag)
     : NodeHandler(name)
     , m_writer(writer)
     , m_tag(tag)
@@ -374,7 +374,7 @@ FbSaveHandler::TextHandler::TextHandler(FbSaveWriter &writer, const QString &nam
     writeAtts(atts);
 }
 
-FbSaveHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts, const QString &tag)
+FbSaveHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts, const QString &tag)
     : NodeHandler(name)
     , m_writer(parent->m_writer)
     , m_tag(tag)
@@ -386,12 +386,11 @@ FbSaveHandler::TextHandler::TextHandler(TextHandler *parent, const QString &name
     writeAtts(atts);
 }
 
-void FbSaveHandler::TextHandler::writeAtts(const QXmlAttributes &atts)
+void FbSaveHandler::TextHandler::writeAtts(const QXmlStreamAttributes &atts)
 {
-    int count = atts.count();
-    for (int i = 0; i < count; ++i) {
-        QString name = atts.qName(i);
-        QString value = atts.value(i);
+    for (const auto& attr : atts) {
+        QString name = attr.qualifiedName().toString();
+        QString value = attr.value().toString();
         if (m_tag == "image") {
             if (name == "src") {
                 name = "l:href";
@@ -404,7 +403,7 @@ void FbSaveHandler::TextHandler::writeAtts(const QXmlAttributes &atts)
     }
 }
 
-FbXmlHandler::NodeHandler * FbSaveHandler::TextHandler::NewTag(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbSaveHandler::TextHandler::NewTag(const QString &name, const QXmlStreamAttributes &atts)
 {
     m_hasChild = true;
     QString tag = QString();
@@ -451,7 +450,7 @@ FbSaveHandler::RootHandler::RootHandler(FbSaveWriter &writer, const QString &nam
 {
 }
 
-FbXmlHandler::NodeHandler * FbSaveHandler::RootHandler::NewTag(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbSaveHandler::RootHandler::NewTag(const QString &name, const QXmlStreamAttributes &atts)
 {
     Q_UNUSED(atts);
     return name == "body" ? new BodyHandler(m_writer, name) : NULL;
@@ -462,7 +461,7 @@ FbXmlHandler::NodeHandler * FbSaveHandler::RootHandler::NewTag(const QString &na
 //---------------------------------------------------------------------------
 
 FbSaveHandler::BodyHandler::BodyHandler(FbSaveWriter &writer, const QString &name)
-    : TextHandler(writer, name, QXmlAttributes(), "FictionBook")
+    : TextHandler(writer, name, QXmlStreamAttributes(), "FictionBook")
 {
     m_writer.writeAttribute("xmlns", "http://www.gribuser.ru/xml/fictionbook/2.0");
     m_writer.writeAttribute("xmlns:l", "http://www.w3.org/1999/xlink");
@@ -479,7 +478,7 @@ void FbSaveHandler::BodyHandler::EndTag(const QString &name)
 //  FbSaveHandler::SpanHandler
 //---------------------------------------------------------------------------
 
-FbSaveHandler::SpanHandler::SpanHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts)
+FbSaveHandler::SpanHandler::SpanHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts)
     : TextHandler(parent, name, atts, Value(atts, "class") == "Apple-style-span" ? "" : "style")
 {
 }
@@ -488,24 +487,23 @@ FbSaveHandler::SpanHandler::SpanHandler(TextHandler *parent, const QString &name
 //  FbSaveHandler::ParagHandler
 //---------------------------------------------------------------------------
 
-FbSaveHandler::ParagHandler::ParagHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts)
+FbSaveHandler::ParagHandler::ParagHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts)
     : TextHandler(parent, name, atts, "")
     , m_parent(parent->tag())
     , m_empty(true)
 {
-    int count = atts.count();
-    for (int i = 0; i < count; ++i) {
-        QString qName = atts.qName(i);
-        QString value = atts.value(i);
+    for (const auto& attr : atts) {
+        QString qName = attr.qualifiedName().toString();
+        QString value = attr.value().toString();
         if (qName == "fb:class") {
             m_class = value;
         } else {
-            m_atts.append(qName, "", "", value);
+            m_atts.append(qName, value);
         }
     }
 }
 
-FbXmlHandler::NodeHandler * FbSaveHandler::ParagHandler::NewTag(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbSaveHandler::ParagHandler::NewTag(const QString &name, const QXmlStreamAttributes &atts)
 {
     if (m_empty && name != "br") start();
     return TextHandler::NewTag(name, atts);
@@ -567,7 +565,7 @@ void FbSaveHandler::onFocus(int offset)
     m_writer.setFocus(offset - m_lastTextLength);
 }
 
-FbXmlHandler::NodeHandler * FbSaveHandler::CreateRoot(const QString &name, const QXmlAttributes &atts)
+FbXmlHandler::NodeHandler * FbSaveHandler::CreateRoot(const QString &name, const QXmlStreamAttributes &atts)
 {
     Q_UNUSED(atts);
     if (name == "html") return new RootHandler(m_writer, name);

source/fb2save.hpp

@@ -63,7 +63,7 @@ private:
     static QString local(const QString &name);
 
 private:
-    QXmlAttributes m_atts;
+    QXmlStreamAttributes m_atts;
 };
 
 class FbSaveWriter : public QXmlStreamWriter
@@ -130,15 +130,15 @@ private:
             Code,
        FB2_END_KEYLIST
     public:
-        explicit TextHandler(FbSaveWriter &writer, const QString &name, const QXmlAttributes &atts, const QString &tag);
-        explicit TextHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts, const QString &tag);
+        explicit TextHandler(FbSaveWriter &writer, const QString &name, const QXmlStreamAttributes &atts, const QString &tag);
+        explicit TextHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts, const QString &tag);
         const QString & tag() { return m_tag; }
     protected:
-        virtual NodeHandler * NewTag(const QString &name, const QXmlAttributes &atts);
+        virtual NodeHandler * NewTag(const QString &name, const QXmlStreamAttributes &atts);
         virtual void TxtTag(const QString &text);
         virtual void EndTag(const QString &name);
     protected:
-        virtual void writeAtts(const QXmlAttributes &atts);
+        virtual void writeAtts(const QXmlStreamAttributes &atts);
         virtual int nextLevel() const;
     protected:
         FbSaveWriter &m_writer;
@@ -153,7 +153,7 @@ private:
     public:
         explicit RootHandler(FbSaveWriter &writer, const QString &name);
     protected:
-        virtual NodeHandler * NewTag(const QString &name, const QXmlAttributes &atts);
+        virtual NodeHandler * NewTag(const QString &name, const QXmlStreamAttributes &atts);
     protected:
         FbSaveWriter &m_writer;
     };
@@ -169,15 +169,15 @@ private:
     class SpanHandler : public TextHandler
     {
     public:
-        explicit SpanHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts);
+        explicit SpanHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts);
     };
 
     class ParagHandler : public TextHandler
     {
     public:
-        explicit ParagHandler(TextHandler *parent, const QString &name, const QXmlAttributes &atts);
+        explicit ParagHandler(TextHandler *parent, const QString &name, const QXmlStreamAttributes &atts);
     protected:
-        virtual NodeHandler * NewTag(const QString &name, const QXmlAttributes &atts);
+        virtual NodeHandler * NewTag(const QString &name, const QXmlStreamAttributes &atts);
         virtual void TxtTag(const QString &text);
         virtual void EndTag(const QString &name);
     private:
@@ -185,13 +185,13 @@ private:
         void start();
     private:
         const QString m_parent;
-        QXmlAttributes m_atts;
+        QXmlStreamAttributes m_atts;
         QString m_class;
         bool m_empty;
     };
 
 protected:
-    virtual NodeHandler * CreateRoot(const QString &name, const QXmlAttributes &atts);
+    virtual NodeHandler * CreateRoot(const QString &name, const QXmlStreamAttributes &atts);
 
 private:
     void setDocumentInfo(QWebFrame *frame);

source/fb2text.cpp

@@ -77,7 +77,7 @@ void FbTextAction::disconnectAction()
 FbDockWidget::FbDockWidget(const QString &title, QWidget *parent, Qt::WindowFlags flags)
     : QDockWidget(title, parent, flags)
 {
-    setFeatures(QDockWidget::AllDockWidgetFeatures);
+    setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
     setAttribute(Qt::WA_DeleteOnClose);
 }
 
@@ -424,7 +424,7 @@ void FbTextEdit::viewInspector(bool show)
         QWebInspector *inspector = new QWebInspector(this);
         inspector->setPage(page());
         dockInsp = new QDockWidget(tr("Web inspector"), this);
-        dockInsp->setFeatures(QDockWidget::AllDockWidgetFeatures);
+        dockInsp->setFeatures(QDockWidget::DockWidgetClosable|QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetFloatable);
         dockInsp->setWidget(inspector);
         connect(dockInsp, SIGNAL(visibilityChanged(bool)), act(Fb::ViewInspector), SLOT(setChecked(bool)));
         m_owner->addDockWidget(Qt::BottomDockWidgetArea, dockInsp);

source/fb2text.hpp

@@ -25,7 +25,7 @@ class FbDockWidget : public QDockWidget
 {
     Q_OBJECT
 public:
-    explicit FbDockWidget(const QString &title, QWidget *parent = 0, Qt::WindowFlags flags = 0);
+    explicit FbDockWidget(const QString &title, QWidget *parent = 0, Qt::WindowFlags flags = {});
 };
 
 class FbTextBase : public QWebView

source/fb2xml.cpp

@@ -5,18 +5,17 @@
 //  FbXmlHandler::NodeHandler
 //---------------------------------------------------------------------------
 
-QString FbXmlHandler::NodeHandler::Value(const QXmlAttributes &attributes, const QString &name)
+QString FbXmlHandler::NodeHandler::Value(const QXmlStreamAttributes &attributes, const QString &name)
 {
-    int count = attributes.count();
-    for (int i = 0; i < count; ++i ) {
-        if (attributes.localName(i).compare(name, Qt::CaseInsensitive) == 0) {
-            return attributes.value(i);
+    for (const auto& attr : attributes) {
+        if (attr.name().compare(name, Qt::CaseInsensitive) == 0) {
+            return attr.value().toString();
         }
     }
     return QString();
 }
 
-bool FbXmlHandler::NodeHandler::doStart(const QString &name, const QXmlAttributes &attributes)
+bool FbXmlHandler::NodeHandler::doStart(const QString &name, const QXmlStreamAttributes &attributes)
 {
     if (m_handler) return m_handler->doStart(name, attributes);
     m_handler = NewTag(name, attributes);
@@ -57,7 +56,7 @@ bool FbXmlHandler::NodeHandler::doEnd(const QString &name, bool & exists)
 //---------------------------------------------------------------------------
 
 FbXmlHandler::FbXmlHandler()
-    : QXmlDefaultHandler()
+    : QObject()
     , m_handler(0)
 {
 }
@@ -67,10 +66,8 @@ FbXmlHandler::~FbXmlHandler()
     if (m_handler) delete m_handler;
 }
 
-bool FbXmlHandler::startElement(const QString & namespaceURI, const QString & localName, const QString &qName, const QXmlAttributes &attributes)
+bool FbXmlHandler::startElement(const QString &, const QString &, const QString &qName, const QXmlStreamAttributes &attributes)
 {
-    Q_UNUSED(namespaceURI);
-    Q_UNUSED(localName);
     const QString name = qName.toLower();
     if (m_handler) return m_handler->doStart(name, attributes);
     m_handler = CreateRoot(name, attributes);
@@ -99,21 +96,21 @@ bool FbXmlHandler::endElement(const QString & namespaceURI, const QString & loca
     return m_handler && m_handler->doEnd(qName.toLower(), found);
 }
 
-bool FbXmlHandler::warning(const QXmlParseException& exception)
+bool FbXmlHandler::warning(const QString &msg, int row, int col)
 {
-    emit warning(exception.lineNumber(), exception.columnNumber(), exception.message());
+    emit warning(row, col, msg);
     return true;
 }
 
-bool FbXmlHandler::error(const QXmlParseException& exception)
+bool FbXmlHandler::error(const QString &msg, int row, int col)
 {
-    emit error(exception.lineNumber(), exception.columnNumber(), exception.message());
+    emit error(row, col, msg);
     return false;
 }
 
-bool FbXmlHandler::fatalError(const QXmlParseException &exception)
+bool FbXmlHandler::fatalError(const QString &msg, int row, int col)
 {
-    emit fatal(exception.lineNumber(), exception.columnNumber(), exception.message());
+    emit fatal(row, col, msg);
     return false;
 }
 

source/fb2xml.hpp

@@ -2,11 +2,9 @@
 #define FB2XML_H
 
 #include <QHash>
-#include <QXmlDefaultHandler>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
-#include "fb2logs.hpp"
 
 #define FB2_BEGIN_KEYLIST private: enum Keyword {
 
@@ -27,19 +25,20 @@ x::KeywordHash::KeywordHash() {
 
 #define FB2_KEY(key,str) insert(str,key);
 
-class FbXmlHandler : public QObject, public QXmlDefaultHandler
+class FbXmlHandler : public QObject
 {
     Q_OBJECT
 
 public:
     explicit FbXmlHandler();
     virtual ~FbXmlHandler();
-    bool startElement(const QString &namespaceURI, const QString &localName, const QString &qName, const QXmlAttributes &attributes);
+    bool startElement(const QString &namespaceURI, const QString &localName, const QString &qName, const QXmlStreamAttributes &attributes);
     bool endElement(const QString &namespaceURI, const QString &localName, const QString &qName);
     bool characters(const QString &str);
-    bool error(const QXmlParseException& exception);
-    bool warning(const QXmlParseException& exception);
-    bool fatalError(const QXmlParseException &exception);
+    bool comment(const QString &){return true;}
+    bool error(const QString &msg, int row, int col);
+    bool warning(const QString &msg, int row, int col);
+    bool fatalError(const QString &msg, int row, int col);
     QString errorString() const;
 
 signals:
@@ -51,16 +50,16 @@ protected:
     class NodeHandler
     {
     public:
-        static QString Value(const QXmlAttributes &attributes, const QString &name);
+        static QString Value(const QXmlStreamAttributes &attributes, const QString &name);
         explicit NodeHandler(const QString &name)
             : m_name(name), m_handler(0), m_closed(false) {}
         virtual ~NodeHandler()
             { if (m_handler) delete m_handler; }
-        bool doStart(const QString &name, const QXmlAttributes &attributes);
+        bool doStart(const QString &name, const QXmlStreamAttributes &attributes);
         bool doText(const QString &text);
         bool doEnd(const QString &name, bool & found);
     protected:
-        virtual NodeHandler * NewTag(const QString &name, const QXmlAttributes &attributes)
+        virtual NodeHandler * NewTag(const QString &name, const QXmlStreamAttributes &attributes)
             { Q_UNUSED(name); Q_UNUSED(attributes); return NULL; }
         virtual void TxtTag(const QString &text)
             { Q_UNUSED(text); }
@@ -75,7 +74,7 @@ protected:
     };
 
 protected:
-    virtual NodeHandler * CreateRoot(const QString &name, const QXmlAttributes &attributes) = 0;
+    virtual NodeHandler * CreateRoot(const QString &name, const QXmlStreamAttributes &attributes) = 0;
     static bool isWhiteSpace(const QString &str);
 
 protected:

source/fb2xml2.cpp

@@ -1,12 +1,6 @@
 #include "fb2xml2.h"
 
-#ifdef FB2_USE_LIBXML2
-
 #include <cstring>
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/HTMLparser.h>
-#include <libxml/xmlreader.h>
 #include <QtDebug>
 
 namespace XML2 {
@@ -15,134 +9,83 @@ namespace XML2 {
 //  XML2::XmlReader
 //---------------------------------------------------------------------------
 
-class XmlReaderLocator : public QXmlLocator {
-public:
-    XmlReaderLocator(XmlReader* r) : reader(r) {}
-    virtual int columnNumber(void) const;
-    virtual int lineNumber(void) const;
-private:
-    XmlReader* reader;
-};
-
 class XmlReaderPrivate {
 public:
     ~XmlReaderPrivate(void) {}
 private:
     XmlReaderPrivate(XmlReader* reader);
 
-    static void onError(void *arg, const char *msg, xmlParserSeverities severity, xmlTextReaderLocatorPtr locator);
-    static int onRead(void * context, char * buffer, int len);
-
-    static QString C2S(const xmlChar* text, int size = -1);
-
-    bool parse(const QXmlInputSource *input);
+    bool parse(const QString *input);
     bool parse(QIODevice *input);
-    void process(xmlTextReaderPtr reader);
+    bool process(QXmlStreamReader& reader);
 
-    QScopedPointer<XmlReaderLocator> locator;
     Q_DECLARE_PUBLIC(XmlReader)
     XmlReader* q_ptr;
 
-    QXmlEntityResolver* entityresolver;
-    QXmlDTDHandler*     dtdhandler;
-    QXmlContentHandler* contenthandler;
-    QXmlErrorHandler*   errorhandler;
-    QXmlLexicalHandler* lexicalhandler;
-    QXmlDeclHandler*    declhandler;
-
-    xmlTextReaderPtr m_reader;
-
-    friend class XmlReaderLocator;
+    FbXmlHandler* contenthandler;
+    FbXmlHandler* errorhandler;
+    FbXmlHandler* lexicalhandler;
 };
 
 XmlReaderPrivate::XmlReaderPrivate(XmlReader* reader)
-    : q_ptr(reader), entityresolver(0), dtdhandler(0), contenthandler(0), errorhandler(0), lexicalhandler(0), declhandler(0), m_reader(0)
+    : q_ptr(reader)
+    , contenthandler(nullptr)
+    , errorhandler(nullptr)
+    , lexicalhandler(nullptr)
 {
-    this->locator.reset(new XmlReaderLocator(reader));
 }
 
-QString XmlReaderPrivate::C2S(const xmlChar* text, int size)
+bool XmlReaderPrivate::process(QXmlStreamReader &reader)
 {
-    return QString::fromLocal8Bit(reinterpret_cast<const char*>(text), size);
-}
+    while (!reader.atEnd()) {
+        reader.readNext();
 
-void XmlReaderPrivate::onError(void * arg, const char * msg, xmlParserSeverities severity, xmlTextReaderLocatorPtr locator)
-{
-    XmlReaderPrivate* r = reinterpret_cast<XmlReaderPrivate*>(arg);
-    if (r->errorhandler) {
-        QXmlParseException e(QString::fromLocal8Bit(msg), xmlTextReaderGetParserColumnNumber(r->m_reader), xmlTextReaderGetParserLineNumber(r->m_reader));
-        switch (severity) {
-            case XML_PARSER_SEVERITY_VALIDITY_WARNING: r->errorhandler->warning(e); break;
-            case XML_PARSER_SEVERITY_VALIDITY_ERROR: r->errorhandler->error(e); break;
-            case XML_PARSER_SEVERITY_WARNING: r->errorhandler->warning(e); break;
-            case XML_PARSER_SEVERITY_ERROR: r->errorhandler->error(e); break;
+        if (reader.hasError()) {
+            return errorhandler->error(reader.errorString(), reader.lineNumber(), reader.columnNumber());
         }
-    }
-}
 
-void XmlReaderPrivate::process(xmlTextReaderPtr reader)
-{
-    if (!contenthandler) return;
-    switch (xmlTextReaderNodeType(reader)) {
-        case XML_READER_TYPE_ELEMENT: {
-            QString localName = C2S(xmlTextReaderConstLocalName(reader));
-            QString qName = C2S(xmlTextReaderConstName(reader));
-            bool empty = xmlTextReaderIsEmptyElement(reader);
-            QXmlAttributes atts;
-            while (xmlTextReaderMoveToNextAttribute(reader)) {
-                QString localName = C2S(xmlTextReaderConstLocalName(reader));
-                QString qName = C2S(xmlTextReaderConstName(reader));
-                QString value = C2S(xmlTextReaderConstValue(reader));
-                atts.append(qName, "", localName, value);
+        switch (reader.tokenType()) {
+        case QXmlStreamReader::StartElement:
+            if (!contenthandler->startElement(reader.namespaceUri().toString(), reader.name().toString(),
+                                              reader.qualifiedName().toString(), reader.attributes())) {
+                return false;
+            }
+            break;
+        case QXmlStreamReader::EndElement:
+            if (!contenthandler->endElement(reader.namespaceUri().toString(), reader.name().toString(),
+                                            reader.qualifiedName().toString())) {
+                return false;
             }
-            contenthandler->startElement("", localName, qName, atts);
-            if (empty) contenthandler->endElement("", localName, qName);
-        } break;
-        case XML_READER_TYPE_TEXT: {
-            QString value = C2S(xmlTextReaderConstValue(reader));
-            contenthandler->characters(value);
-        } break;
-        case XML_READER_TYPE_END_ELEMENT: {
-            QString localName = C2S(xmlTextReaderConstLocalName(reader));
-            QString qName = C2S(xmlTextReaderConstName(reader));
-            contenthandler->endElement("", localName, qName);
-        } break;
-        case XML_READER_TYPE_COMMENT: {
-            if (lexicalhandler) {
-                QString value = C2S(xmlTextReaderConstValue(reader));
-                lexicalhandler->comment(value);
+        case QXmlStreamReader::Characters:
+            if (!contenthandler->characters(reader.text().toString())) {
+                return false;
             }
-        } break;
+            break;
+        case QXmlStreamReader::Comment:
+            if (lexicalhandler && !lexicalhandler->comment(reader.text().toString())) {
+                return false;
+            }
+            break;
+        default:
+            break;
+        }
     }
-}
 
-int XmlReaderPrivate::onRead(void * context, char * buffer, int len)
-{
-    QIODevice *device = reinterpret_cast<QIODevice*>(context);
-    return device->read(buffer, len);
+    return !reader.isEndDocument();
 }
 
-bool XmlReaderPrivate::parse(const QXmlInputSource *input)
+bool XmlReaderPrivate::parse(const QString *input)
 {
-    QByteArray arr = input->data().toUtf8();
-    int options = XML_PARSE_RECOVER | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NONET;
-    m_reader = xmlReaderForMemory(arr.constData(), arr.size(), NULL, NULL, options);
-    if (!m_reader) return false;
-    xmlTextReaderSetErrorHandler(m_reader, &XmlReaderPrivate::onError, this);
-    while (xmlTextReaderRead(m_reader) == 1) process(m_reader);
-    xmlFreeTextReader(m_reader);
-    return true;
+    QXmlStreamReader reader(*input);
+
+    return process(reader);
 }
 
 bool XmlReaderPrivate::parse(QIODevice *input)
 {
-    int options = XML_PARSE_RECOVER | XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NONET;
-    m_reader = xmlReaderForIO(&XmlReaderPrivate::onRead, NULL, input, NULL, NULL, options);
-    if (!m_reader) return false;
-    xmlTextReaderSetErrorHandler(m_reader, &XmlReaderPrivate::onError, this);
-    while (xmlTextReaderRead(m_reader) == 1) process(m_reader);
-    xmlFreeTextReader(m_reader);
-    return true;
+    QXmlStreamReader reader(input);
+
+    return process(reader);
 }
 
 XmlReader::XmlReader(void)
@@ -184,91 +127,51 @@ bool XmlReader::hasProperty(const QString&) const
     return false;
 }
 
-void XmlReader::setEntityResolver(QXmlEntityResolver* handler)
-{
-    Q_D(XmlReader);
-    d->entityresolver = handler;
-}
-
-QXmlEntityResolver* XmlReader::entityResolver(void) const
-{
-    const XmlReaderPrivate* d = this->d_func();
-    return d->entityresolver;
-}
-
-void XmlReader::setDTDHandler(QXmlDTDHandler* handler)
-{
-    Q_D(XmlReader);
-    d->dtdhandler = handler;
-}
-
-QXmlDTDHandler* XmlReader::DTDHandler(void) const
-{
-    const XmlReaderPrivate* d = this->d_func();
-    return d->dtdhandler;
-}
-
-void XmlReader::setContentHandler(QXmlContentHandler* handler)
+void XmlReader::setContentHandler(FbXmlHandler* handler)
 {
     Q_D(XmlReader);
     d->contenthandler = handler;
 }
 
-QXmlContentHandler* XmlReader::contentHandler(void) const
+FbXmlHandler* XmlReader::contentHandler(void) const
 {
     const XmlReaderPrivate* d = this->d_func();
     return d->contenthandler;
 }
 
-void XmlReader::setErrorHandler(QXmlErrorHandler* handler)
+void XmlReader::setErrorHandler(FbXmlHandler* handler)
 {
     Q_D(XmlReader);
     d->errorhandler = handler;
 }
 
-QXmlErrorHandler* XmlReader::errorHandler(void) const
+FbXmlHandler* XmlReader::errorHandler(void) const
 {
     const XmlReaderPrivate* d = this->d_func();
     return d->errorhandler;
 }
 
-void XmlReader::setLexicalHandler(QXmlLexicalHandler* handler)
+void XmlReader::setLexicalHandler(FbXmlHandler* handler)
 {
     Q_D(XmlReader);
     d->lexicalhandler = handler;
 }
 
-QXmlLexicalHandler* XmlReader::lexicalHandler(void) const
+FbXmlHandler* XmlReader::lexicalHandler(void) const
 {
     const XmlReaderPrivate* d = this->d_func();
     return d->lexicalhandler;
 }
 
-void XmlReader::setDeclHandler(QXmlDeclHandler* handler)
-{
-    Q_D(XmlReader);
-    d->declhandler = handler;
-}
-
-QXmlDeclHandler* XmlReader::declHandler(void) const
-{
-    const XmlReaderPrivate* d = this->d_func();
-    return d->declhandler;
-}
-
-bool XmlReader::parse(const QXmlInputSource& input)
+bool XmlReader::parse(const QString& input)
 {
     return this->parse(&input);
 }
 
-bool XmlReader::parse(const QXmlInputSource* input)
+bool XmlReader::parse(const QString* input)
 {
     Q_D(XmlReader);
 
-    if (d->contenthandler) {
-        d->contenthandler->setDocumentLocator(d->locator.data());
-    }
-
     d->parse(input);
 
     return true;
@@ -278,25 +181,9 @@ bool XmlReader::parse(QIODevice *input)
 {
     Q_D(XmlReader);
 
-    if (d->contenthandler) {
-        d->contenthandler->setDocumentLocator(d->locator.data());
-    }
-
     d->parse(input);
 
     return true;
 }
 
-int XmlReaderLocator::columnNumber(void) const
-{
-    return xmlTextReaderGetParserColumnNumber(this->reader->d_func()->m_reader);
-}
-
-int XmlReaderLocator::lineNumber(void) const
-{
-    return xmlTextReaderGetParserLineNumber(this->reader->d_func()->m_reader);
-}
-
 } // namespace XML2
-
-#endif // FB2_USE_LIBXML2

source/fb2xml2.h

@@ -1,74 +1,44 @@
 #ifndef FB2XML2_H
 #define FB2XML2_H
 
-#ifdef FB2_USE_LIBXML2
-
-/////////////////////////////////////////////////////////////////////////////
-//
-//   Append into project file:
-//     INCLUDEPATH += /usr/include/libxml2
-//     LIBS        += -lxml2
-//
-//   http://blog.sjinks.pro/c-cpp/qt/942-html-parser-qt/
-//
-//
-//     QByteArray data;
-//     QXmlInputSource src;
-//     HtmlReader reader;
-//     QDomDocument doc;
-//     src.setData(data);
-//     doc.setContent(&src, &reader);
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#include <QtXml/QXmlReader>
-#include <libxml/xmlstring.h>
+#include <QtXml>
+#include "fb2xml.hpp"
 
 namespace XML2 {
 
 class XmlReaderPrivate;
 
-class XmlReader : public QXmlReader
+class XmlReader
 {
 public:
     XmlReader(void);
-    virtual ~XmlReader(void);
+    ~XmlReader(void);
 
-    virtual bool feature(const QString& name, bool* ok = 0) const;
-    virtual void setFeature(const QString& name, bool value);
-    virtual bool hasFeature(const QString& name) const;
-    virtual void* property(const QString& name, bool* ok = 0) const;
-    virtual void setProperty(const QString& name, void* value);
-    virtual bool hasProperty(const QString& name) const;
+    bool feature(const QString& name, bool* ok = 0) const;
+    void setFeature(const QString& name, bool value);
+    bool hasFeature(const QString& name) const;
+    void* property(const QString& name, bool* ok = 0) const;
+    void setProperty(const QString& name, void* value);
+    bool hasProperty(const QString& name) const;
 
-    virtual void setEntityResolver(QXmlEntityResolver* handler);
-    virtual QXmlEntityResolver* entityResolver(void) const;
-    virtual void setDTDHandler(QXmlDTDHandler* handler);
-    virtual QXmlDTDHandler* DTDHandler(void) const;
-    virtual void setContentHandler(QXmlContentHandler* handler);
-    virtual QXmlContentHandler* contentHandler(void) const;
-    virtual void setErrorHandler(QXmlErrorHandler* handler);
-    virtual QXmlErrorHandler* errorHandler(void) const;
-    virtual void setLexicalHandler(QXmlLexicalHandler* handler);
-    virtual QXmlLexicalHandler* lexicalHandler(void) const;
-    virtual void setDeclHandler(QXmlDeclHandler* handler);
-    virtual QXmlDeclHandler* declHandler(void) const;
+    void setContentHandler(FbXmlHandler* handler);
+    FbXmlHandler* contentHandler(void) const;
+    void setErrorHandler(FbXmlHandler* handler);
+    FbXmlHandler* errorHandler(void) const;
+    void setLexicalHandler(FbXmlHandler* handler);
+    FbXmlHandler* lexicalHandler(void) const;
 
-    virtual bool parse(QIODevice *input);
-    virtual bool parse(const QXmlInputSource&);
-    virtual bool parse(const QXmlInputSource*);
+    bool parse(QIODevice *input);
+    bool parse(const QString&);
+    bool parse(const QString*);
 
 
 private:
     Q_DISABLE_COPY(XmlReader)
     Q_DECLARE_PRIVATE(XmlReader)
     QScopedPointer<XmlReaderPrivate> d_ptr;
-
-    friend class XmlReaderLocator;
 };
 
 } // namespace XML2
 
-#endif // FB2_USE_LIBXML2
-
 #endif // FB2XML2_H

ubuntu.sh

@@ -26,11 +26,10 @@ mkdir ../osc_${PROJECT}
 mv ../*squeeze* ../osc_${PROJECT}
 cp ../${PROJECT}_${VERSION}.orig.tar.bz2 ../osc_${PROJECT}
 
-cat ../../debian/control | sed 's/libxml2-dev/libqtwebkit-dev, libxml2-dev/' > debian/control
+cat ../../debian/control | sed 's/cdbs/cdbs, libqtwebkit-dev/' > debian/control
 for DISTRIB in $LIST;
 do
   echo "${PROJECT} (${VERSION}-${DISTRIB}${NUMBER}) ${DISTRIB}; urgency=low" > debian/changelog
   cat ../../debian/changelog | sed '1d'>> debian/changelog
   debuild -S -sa
 done
-