Squashed 'qhexedit2/' content from commit 7f22526

git-subtree-dir: qhexedit2
git-subtree-split: 7f22526a86685aec1c5722154b8a7422d5037b77

12 files changed, 3072 insertions, 0 deletions

diff --git a/src/QHexEditPlugin.cpp b/src/QHexEditPlugin.cpp
new file mode 100644
index 0000000..543f149
--- /dev/null
+++ b/src/QHexEditPlugin.cpp
@@ -0,0 +1,89 @@
+#include "QHexEditPlugin.h"
+#include "qhexedit.h"
+
+#include <QtPlugin>
+
+QHexEditPlugin::QHexEditPlugin(QObject * parent) : QObject(parent)
+{
+    initialized = false;
+}
+
+
+bool QHexEditPlugin::isContainer() const
+{
+    return false;
+}
+
+bool QHexEditPlugin::isInitialized() const
+{
+    return initialized;
+}
+
+QIcon QHexEditPlugin::icon() const
+{
+    return QIcon();
+}
+
+QString QHexEditPlugin::domXml() const
+{
+    return "<ui language=\"c++\">\n"
+        " <widget class=\"QHexEdit\" name=\"hexEdit\">\n"
+        "  <property name=\"geometry\">\n"
+        "   <rect>\n"
+        "    <x>0</x>\n"
+        "    <y>0</y>\n"
+        "    <width>100</width>\n"
+        "    <height>100</height>\n"
+        "   </rect>\n"
+        "  </property>\n"
+        "  <property name=\"toolTip\" >\n"
+        "   <string>QHexEditWidget</string>\n"
+        "  </property>\n"
+        "  <property name=\"whatsThis\" >\n"
+        "   <string>QHexEdit widget allow to edit the data in hex view.</string>\n"
+        "  </property>\n"
+        " </widget>\n"
+        "</ui>\n";
+}
+
+QString QHexEditPlugin::group() const
+{
+    return "Input Widgets";
+}
+
+QString QHexEditPlugin::includeFile() const
+{
+    return "qhexedit.h";
+}
+
+QString QHexEditPlugin::name() const
+{
+    return "QHexEdit";
+}
+
+QString QHexEditPlugin::toolTip() const
+{
+    return "";
+}
+
+QString QHexEditPlugin::whatsThis() const
+{
+    return "";
+}
+
+QWidget * QHexEditPlugin::createWidget(QWidget *parent)
+{
+    return new QHexEdit(parent);
+}
+
+void QHexEditPlugin::initialize(QDesignerFormEditorInterface * /*core*/)
+{
+    if (initialized)
+        return;
+
+    initialized = true;
+}
+
+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
+Q_EXPORT_PLUGIN2(QHexEditPlugin, QHexEditPlugin)
+#endif
diff --git a/src/QHexEditPlugin.h b/src/QHexEditPlugin.h
new file mode 100644
index 0000000..a67179c
--- /dev/null
+++ b/src/QHexEditPlugin.h
@@ -0,0 +1,40 @@
+#ifndef QHEXEDITPLUGIN_H
+#define QHEXEDITPLUGIN_H
+
+#include <QObject>
+
+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
+#include <QtDesigner/QDesignerCustomWidgetInterface>
+#else
+#include <QDesignerCustomWidgetInterface>
+#endif
+
+class QHexEditPlugin : public QObject, public QDesignerCustomWidgetInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerCustomWidgetInterface)
+#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
+    Q_PLUGIN_METADATA(IID "com.qt-project.Qt.QHexEditPlugin")
+#endif
+
+public:
+    QHexEditPlugin(QObject * parent = 0);
+
+    bool isContainer() const;
+    bool isInitialized() const;
+    QIcon icon() const;
+    QString domXml() const;
+    QString group() const;
+    QString includeFile() const;
+    QString name() const;
+    QString toolTip() const;
+    QString whatsThis() const;
+    QWidget *createWidget(QWidget *parent);
+    void initialize(QDesignerFormEditorInterface *core);
+
+private:
+    bool initialized;
+
+};
+
+#endif
diff --git a/src/chunks.cpp b/src/chunks.cpp
new file mode 100644
index 0000000..f550f15
--- /dev/null
+++ b/src/chunks.cpp
@@ -0,0 +1,323 @@
+#include "chunks.h"
+#include <limits.h>
+
+#define NORMAL 0
+#define HIGHLIGHTED 1
+
+#define BUFFER_SIZE 0x10000
+#define CHUNK_SIZE 0x1000
+#define READ_CHUNK_MASK Q_INT64_C(0xfffffffffffff000)
+
+// ***************************************** Constructors and file settings
+
+Chunks::Chunks(QObject *parent): QObject(parent)
+{
+    QBuffer *buf = new QBuffer(this);
+    setIODevice(*buf);
+}
+
+Chunks::Chunks(QIODevice &ioDevice, QObject *parent): QObject(parent)
+{
+    setIODevice(ioDevice);
+}
+
+bool Chunks::setIODevice(QIODevice &ioDevice)
+{
+    _ioDevice = &ioDevice;
+    bool ok = _ioDevice->open(QIODevice::ReadOnly);
+    if (ok)   // Try to open IODevice
+    {
+        _size = _ioDevice->size();
+        _ioDevice->close();
+    }
+    else                                        // Fallback is an empty buffer
+    {
+        QBuffer *buf = new QBuffer(this);
+        _ioDevice = buf;
+        _size = 0;
+    }
+    _chunks.clear();
+    _pos = 0;
+    return ok;
+}
+
+
+// ***************************************** Getting data out of Chunks
+
+QByteArray Chunks::data(qint64 pos, qint64 maxSize, QByteArray *highlighted)
+{
+    qint64 ioDelta = 0;
+    int chunkIdx = 0;
+
+    Chunk chunk;
+    QByteArray buffer;
+
+    // Do some checks and some arrangements
+    if (highlighted)
+        highlighted->clear();
+
+    if (pos >= _size)
+        return buffer;
+
+    if (maxSize < 0)
+        maxSize = _size;
+    else
+        if ((pos + maxSize) > _size)
+            maxSize = _size - pos;
+
+    _ioDevice->open(QIODevice::ReadOnly);
+
+    while (maxSize > 0)
+    {
+        chunk.absPos = LLONG_MAX;
+        bool chunksLoopOngoing = true;
+        while ((chunkIdx < _chunks.count()) && chunksLoopOngoing)
+        {
+            // In this section, we track changes before our required data and
+            // we take the editdet data, if availible. ioDelta is a difference
+            // counter to justify the read pointer to the original data, if
+            // data in between was deleted or inserted.
+
+            chunk = _chunks[chunkIdx];
+            if (chunk.absPos > pos)
+                chunksLoopOngoing = false;
+            else
+            {
+                chunkIdx += 1;
+                qint64 count;
+                qint64 chunkOfs = pos - chunk.absPos;
+                if (maxSize > ((qint64)chunk.data.size() - chunkOfs))
+                {
+                    count = (qint64)chunk.data.size() - chunkOfs;
+                    ioDelta += CHUNK_SIZE - chunk.data.size();
+                }
+                else
+                    count = maxSize;
+                if (count > 0)
+                {
+                    buffer += chunk.data.mid(chunkOfs, (int)count);
+                    maxSize -= count;
+                    pos += count;
+                    if (highlighted)
+                        *highlighted += chunk.dataChanged.mid(chunkOfs, (int)count);
+                }
+            }
+        }
+
+        if ((maxSize > 0) && (pos < chunk.absPos))
+        {
+            // In this section, we read data from the original source. This only will
+            // happen, whe no copied data is available
+
+            qint64 byteCount;
+            QByteArray readBuffer;
+            if ((chunk.absPos - pos) > maxSize)
+                byteCount = maxSize;
+            else
+                byteCount = chunk.absPos - pos;
+
+            maxSize -= byteCount;
+            _ioDevice->seek(pos + ioDelta);
+            readBuffer = _ioDevice->read(byteCount);
+            buffer += readBuffer;
+            if (highlighted)
+                *highlighted += QByteArray(readBuffer.size(), NORMAL);
+            pos += readBuffer.size();
+        }
+    }
+    _ioDevice->close();
+    return buffer;
+}
+
+bool Chunks::write(QIODevice &iODevice, qint64 pos, qint64 count)
+{
+    if (count == -1)
+        count = _size;
+    bool ok = iODevice.open(QIODevice::WriteOnly);
+    if (ok)
+    {
+        for (qint64 idx=pos; idx < count; idx += BUFFER_SIZE)
+        {
+            QByteArray ba = data(idx, BUFFER_SIZE);
+            iODevice.write(ba);
+        }
+        iODevice.close();
+    }
+    return ok;
+}
+
+
+// ***************************************** Set and get highlighting infos
+
+void Chunks::setDataChanged(qint64 pos, bool dataChanged)
+{
+    if ((pos < 0) || (pos >= _size))
+        return;
+    int chunkIdx = getChunkIndex(pos);
+    qint64 posInBa = pos - _chunks[chunkIdx].absPos;
+    _chunks[chunkIdx].dataChanged[(int)posInBa] = char(dataChanged);
+}
+
+bool Chunks::dataChanged(qint64 pos)
+{
+    QByteArray highlighted;
+    data(pos, 1, &highlighted);
+    return bool(highlighted.at(0));
+}
+
+
+// ***************************************** Search API
+
+qint64 Chunks::indexOf(const QByteArray &ba, qint64 from)
+{
+    qint64 result = -1;
+    QByteArray buffer;
+
+    for (qint64 pos=from; (pos < _size) && (result < 0); pos += BUFFER_SIZE)
+    {
+        buffer = data(pos, BUFFER_SIZE + ba.size() - 1);
+        int findPos = buffer.indexOf(ba);
+        if (findPos >= 0)
+            result = pos + (qint64)findPos;
+    }
+    return result;
+}
+
+qint64 Chunks::lastIndexOf(const QByteArray &ba, qint64 from)
+{
+    qint64 result = -1;
+    QByteArray buffer;
+
+    for (qint64 pos=from; (pos > 0) && (result < 0); pos -= BUFFER_SIZE)
+    {
+        qint64 sPos = pos - BUFFER_SIZE - (qint64)ba.size() + 1;
+        if (sPos < 0)
+            sPos = 0;
+        buffer = data(sPos, pos - sPos);
+        int findPos = buffer.lastIndexOf(ba);
+        if (findPos >= 0)
+            result = sPos + (qint64)findPos;
+    }
+    return result;
+}
+
+
+// ***************************************** Char manipulations
+
+bool Chunks::insert(qint64 pos, char b)
+{
+    if ((pos < 0) || (pos > _size))
+        return false;
+    int chunkIdx;
+    if (pos == _size)
+        chunkIdx = getChunkIndex(pos-1);
+    else
+        chunkIdx = getChunkIndex(pos);
+    qint64 posInBa = pos - _chunks[chunkIdx].absPos;
+    _chunks[chunkIdx].data.insert(posInBa, b);
+    _chunks[chunkIdx].dataChanged.insert(posInBa, char(1));
+    for (int idx=chunkIdx+1; idx < _chunks.size(); idx++)
+        _chunks[idx].absPos += 1;
+    _size += 1;
+    _pos = pos;
+    return true;
+}
+
+bool Chunks::overwrite(qint64 pos, char b)
+{
+    if ((pos < 0) || (pos >= _size))
+        return false;
+    int chunkIdx = getChunkIndex(pos);
+    qint64 posInBa = pos - _chunks[chunkIdx].absPos;
+    _chunks[chunkIdx].data[(int)posInBa] = b;
+    _chunks[chunkIdx].dataChanged[(int)posInBa] = char(1);
+    _pos = pos;
+    return true;
+}
+
+bool Chunks::removeAt(qint64 pos)
+{
+    if ((pos < 0) || (pos >= _size))
+        return false;
+    int chunkIdx = getChunkIndex(pos);
+    qint64 posInBa = pos - _chunks[chunkIdx].absPos;
+    _chunks[chunkIdx].data.remove(posInBa, 1);
+    _chunks[chunkIdx].dataChanged.remove(posInBa, 1);
+    for (int idx=chunkIdx+1; idx < _chunks.size(); idx++)
+        _chunks[idx].absPos -= 1;
+    _size -= 1;
+    _pos = pos;
+    return true;
+}
+
+
+// ***************************************** Utility functions
+
+char Chunks::operator[](qint64 pos)
+{
+    return data(pos, 1).at(0);
+}
+
+qint64 Chunks::pos()
+{
+    return _pos;
+}
+
+qint64 Chunks::size()
+{
+    return _size;
+}
+
+int Chunks::getChunkIndex(qint64 absPos)
+{
+    // This routine checks, if there is already a copied chunk available. If os, it
+    // returns a reference to it. If there is no copied chunk available, original
+    // data will be copied into a new chunk.
+
+    int foundIdx = -1;
+    int insertIdx = 0;
+    qint64 ioDelta = 0;
+
+
+    for (int idx=0; idx < _chunks.size(); idx++)
+    {
+        Chunk chunk = _chunks[idx];
+        if ((absPos >= chunk.absPos) && (absPos < (chunk.absPos + chunk.data.size())))
+        {
+            foundIdx = idx;
+            break;
+        }
+        if (absPos < chunk.absPos)
+        {
+            insertIdx = idx;
+            break;
+        }
+        ioDelta += chunk.data.size() - CHUNK_SIZE;
+        insertIdx = idx + 1;
+    }
+
+    if (foundIdx == -1)
+    {
+        Chunk newChunk;
+        qint64 readAbsPos = absPos - ioDelta;
+        qint64 readPos = (readAbsPos & READ_CHUNK_MASK);
+        _ioDevice->open(QIODevice::ReadOnly);
+        _ioDevice->seek(readPos);
+        newChunk.data = _ioDevice->read(CHUNK_SIZE);
+        _ioDevice->close();
+        newChunk.absPos = absPos - (readAbsPos - readPos);
+        newChunk.dataChanged = QByteArray(newChunk.data.size(), char(0));
+        _chunks.insert(insertIdx, newChunk);
+        foundIdx = insertIdx;
+    }
+    return foundIdx;
+}
+
+
+#ifdef MODUL_TEST
+int Chunks::chunkSize()
+{
+    return _chunks.size();
+}
+
+#endif
diff --git a/src/chunks.h b/src/chunks.h
new file mode 100644
index 0000000..43df76c
--- /dev/null
+++ b/src/chunks.h
@@ -0,0 +1,77 @@
+#ifndef CHUNKS_H
+#define CHUNKS_H
+
+/** \cond docNever */
+
+/*! The Chunks class is the storage backend for QHexEdit.
+ *
+ * When QHexEdit loads data, Chunks access them using a QIODevice interface. When the app uses
+ * a QByteArray interface, QBuffer is used to provide again a QIODevice like interface. No data
+ * will be changed, therefore Chunks opens the QIODevice in QIODevice::ReadOnly mode. After every
+ * access Chunks closes the QIODevice, that's why external applications can overwrite files while
+ * QHexEdit shows them.
+ *
+ * When the the user starts to edit the data, Chunks creates a local copy of a chunk of data (4
+ * kilobytes) and notes all changes there. Parallel to that chunk, there is a second chunk,
+ * which keep track of which bytes are changed and which not.
+ *
+ */
+
+#include <QtCore>
+
+struct Chunk
+{
+    QByteArray data;
+    QByteArray dataChanged;
+    qint64 absPos;
+};
+
+class Chunks: public QObject
+{
+Q_OBJECT
+public:
+    // Constructors and file settings
+    Chunks(QObject *parent);
+    Chunks(QIODevice &ioDevice, QObject *parent);
+    bool setIODevice(QIODevice &ioDevice);
+
+    // Getting data out of Chunks
+    QByteArray data(qint64 pos=0, qint64 count=-1, QByteArray *highlighted=0);
+    bool write(QIODevice &iODevice, qint64 pos=0, qint64 count=-1);
+
+    // Set and get highlighting infos
+    void setDataChanged(qint64 pos, bool dataChanged);
+    bool dataChanged(qint64 pos);
+
+    // Search API
+    qint64 indexOf(const QByteArray &ba, qint64 from);
+    qint64 lastIndexOf(const QByteArray &ba, qint64 from);
+
+    // Char manipulations
+    bool insert(qint64 pos, char b);
+    bool overwrite(qint64 pos, char b);
+    bool removeAt(qint64 pos);
+
+    // Utility functions
+    char operator[](qint64 pos);
+    qint64 pos();
+    qint64 size();
+
+
+private:
+    int getChunkIndex(qint64 absPos);
+
+    QIODevice * _ioDevice;
+    qint64 _pos;
+    qint64 _size;
+    QList<Chunk> _chunks;
+
+#ifdef MODUL_TEST
+public:
+    int chunkSize();
+#endif
+};
+
+/** \endcond docNever */
+
+#endif // CHUNKS_H
diff --git a/src/commands.cpp b/src/commands.cpp
new file mode 100644
index 0000000..5b99cbf
--- /dev/null
+++ b/src/commands.cpp
@@ -0,0 +1,168 @@
+#include "commands.h"
+#include <QUndoCommand>
+
+
+// Helper class to store single byte commands
+class CharCommand : public QUndoCommand
+{
+public:
+    enum CCmd {insert, removeAt, overwrite};
+
+    CharCommand(Chunks * chunks, CCmd cmd, qint64 charPos, char newChar,
+                       QUndoCommand *parent=0);
+
+    void undo();
+    void redo();
+    bool mergeWith(const QUndoCommand *command);
+    int id() const { return 1234; }
+
+private:
+    Chunks * _chunks;
+    qint64 _charPos;
+    bool _wasChanged;
+    char _newChar;
+    char _oldChar;
+    CCmd _cmd;
+};
+
+CharCommand::CharCommand(Chunks * chunks, CCmd cmd, qint64 charPos, char newChar, QUndoCommand *parent)
+    : QUndoCommand(parent)
+    , _chunks(chunks)
+    , _charPos(charPos)
+    , _wasChanged(false)
+    , _newChar(newChar)
+    , _oldChar('\0')
+    , _cmd(cmd)
+{
+}
+
+bool CharCommand::mergeWith(const QUndoCommand *command)
+{
+    const CharCommand *nextCommand = static_cast<const CharCommand *>(command);
+    bool result = false;
+
+    if (_cmd != CharCommand::removeAt)
+    {
+        if (nextCommand->_cmd == overwrite)
+            if (nextCommand->_charPos == _charPos)
+            {
+                _newChar = nextCommand->_newChar;
+                result = true;
+            }
+    }
+    return result;
+}
+
+void CharCommand::undo()
+{
+    switch (_cmd)
+    {
+        case insert:
+            _chunks->removeAt(_charPos);
+            break;
+        case overwrite:
+            _chunks->overwrite(_charPos, _oldChar);
+            _chunks->setDataChanged(_charPos, _wasChanged);
+            break;
+        case removeAt:
+            _chunks->insert(_charPos, _oldChar);
+            _chunks->setDataChanged(_charPos, _wasChanged);
+            break;
+    }
+}
+
+void CharCommand::redo()
+{
+    switch (_cmd)
+    {
+        case insert:
+            _chunks->insert(_charPos, _newChar);
+            break;
+        case overwrite:
+            _oldChar = (*_chunks)[_charPos];
+            _wasChanged = _chunks->dataChanged(_charPos);
+            _chunks->overwrite(_charPos, _newChar);
+            break;
+        case removeAt:
+            _oldChar = (*_chunks)[_charPos];
+            _wasChanged = _chunks->dataChanged(_charPos);
+            _chunks->removeAt(_charPos);
+            break;
+    }
+}
+
+UndoStack::UndoStack(Chunks * chunks, QObject * parent)
+    : QUndoStack(parent)
+{
+    _chunks = chunks;
+    _parent = parent;
+    this->setUndoLimit(1000);
+}
+
+void UndoStack::insert(qint64 pos, char c)
+{
+    if ((pos >= 0) && (pos <= _chunks->size()))
+    {
+        QUndoCommand *cc = new CharCommand(_chunks, CharCommand::insert, pos, c);
+        this->push(cc);
+    }
+}
+
+void UndoStack::insert(qint64 pos, const QByteArray &ba)
+{
+    if ((pos >= 0) && (pos <= _chunks->size()))
+    {
+        QString txt = QString(tr("Inserting %1 bytes")).arg(ba.size());
+        beginMacro(txt);
+        for (int idx=0; idx < ba.size(); idx++)
+        {
+            QUndoCommand *cc = new CharCommand(_chunks, CharCommand::insert, pos + idx, ba.at(idx));
+            this->push(cc);
+        }
+        endMacro();
+    }
+}
+
+void UndoStack::removeAt(qint64 pos, qint64 len)
+{
+    if ((pos >= 0) && (pos < _chunks->size()))
+    {
+        if (len==1)
+        {
+            QUndoCommand *cc = new CharCommand(_chunks, CharCommand::removeAt, pos, char(0));
+            this->push(cc);
+        }
+        else
+        {
+            QString txt = QString(tr("Delete %1 chars")).arg(len);
+            beginMacro(txt);
+            for (qint64 cnt=0; cnt<len; cnt++)
+            {
+                QUndoCommand *cc = new CharCommand(_chunks, CharCommand::removeAt, pos, char(0));
+                push(cc);
+            }
+            endMacro();
+        }
+    }
+}
+
+void UndoStack::overwrite(qint64 pos, char c)
+{
+    if ((pos >= 0) && (pos < _chunks->size()))
+    {
+        QUndoCommand *cc = new CharCommand(_chunks, CharCommand::overwrite, pos, c);
+        this->push(cc);
+    }
+}
+
+void UndoStack::overwrite(qint64 pos, int len, const QByteArray &ba)
+{
+    if ((pos >= 0) && (pos < _chunks->size()))
+    {
+        QString txt = QString(tr("Overwrite %1 chars")).arg(len);
+        beginMacro(txt);
+        removeAt(pos, len);
+        insert(pos, ba);
+        endMacro();
+    }
+}
diff --git a/src/commands.h b/src/commands.h
new file mode 100644
index 0000000..51450c5
--- /dev/null
+++ b/src/commands.h
@@ -0,0 +1,47 @@
+#ifndef COMMANDS_H
+#define COMMANDS_H
+
+/** \cond docNever */
+
+#include <QUndoStack>
+
+#include "chunks.h"
+
+/*! CharCommand is a class to provid undo/redo functionality in QHexEdit.
+A QUndoCommand represents a single editing action on a document. CharCommand
+is responsable for manipulations on single chars. It can insert. overwrite and
+remove characters. A manipulation stores allways two actions
+1. redo (or do) action
+2. undo action.
+
+CharCommand also supports command compression via mergeWith(). This enables
+the user to perform an undo command e.g. 3 steps in a single command.
+If you for example insert a new byt "34" this means for the editor doing 3
+steps: insert a "00", overwrite it with "03" and the overwrite it with "34". These
+3 steps are combined into a single step, insert a "34".
+
+The byte array oriented commands are just put into a set of single byte commands,
+which are pooled together with the macroBegin() and macroEnd() functionality of
+Qt's QUndoStack.
+*/
+
+class UndoStack : public QUndoStack
+{
+    Q_OBJECT
+
+public:
+    UndoStack(Chunks *chunks, QObject * parent=0);
+    void insert(qint64 pos, char c);
+    void insert(qint64 pos, const QByteArray &ba);
+    void removeAt(qint64 pos, qint64 len=1);
+    void overwrite(qint64 pos, char c);
+    void overwrite(qint64 pos, int len, const QByteArray &ba);
+
+private:
+    Chunks * _chunks;
+    QObject * _parent;
+};
+
+/** \endcond docNever */
+
+#endif // COMMANDS_H
diff --git a/src/license.txt b/src/license.txt
new file mode 100644
index 0000000..f166cc5
--- /dev/null
+++ b/src/license.txt
@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
\ No newline at end of file
diff --git a/src/qhexedit.cpp b/src/qhexedit.cpp
new file mode 100644
index 0000000..4137192
--- /dev/null
+++ b/src/qhexedit.cpp
@@ -0,0 +1,1206 @@
+#include <QApplication>
+#include <QClipboard>
+#include <QKeyEvent>
+#include <QPainter>
+#include <QScrollBar>
+
+#include "qhexedit.h"
+#include <algorithm>
+
+
+// ********************************************************************** Constructor, destructor
+
+QHexEdit::QHexEdit(QWidget *parent) : QAbstractScrollArea(parent)
+    , _addressArea(true)
+    , _addressWidth(4)
+    , _asciiArea(true)
+    , _bytesPerLine(16)
+    , _hexCharsInLine(47)
+    , _highlighting(true)
+    , _overwriteMode(true)
+    , _readOnly(false)
+    , _hexCaps(false)
+    , _dynamicBytesPerLine(false)
+    , _editAreaIsAscii(false)
+    , _chunks(new Chunks(this))
+    , _cursorPosition(0)
+    , _lastEventSize(0)
+    , _undoStack(new UndoStack(_chunks, this))
+{
+#ifdef Q_OS_WIN32
+    setFont(QFont("Courier", 10));
+#else
+    setFont(QFont("Monospace", 10));
+#endif
+    setAddressAreaColor(this->palette().alternateBase().color());
+    setHighlightingColor(QColor(0xff, 0xff, 0x99, 0xff));
+    setSelectionColor(this->palette().highlight().color());
+    setAddressFontColor(QPalette::WindowText);
+    setAsciiAreaColor(this->palette().alternateBase().color());
+    setAsciiFontColor(QPalette::WindowText);
+
+    connect(&_cursorTimer, SIGNAL(timeout()), this, SLOT(updateCursor()));
+    connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(adjust()));
+    connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(adjust()));
+    connect(_undoStack, SIGNAL(indexChanged(int)), this, SLOT(dataChangedPrivate(int)));
+
+    _cursorTimer.setInterval(500);
+    _cursorTimer.start();
+
+    setAddressWidth(4);
+    setAddressArea(true);
+    setAsciiArea(true);
+    setOverwriteMode(true);
+    setHighlighting(true);
+    setReadOnly(false);
+
+    init();
+
+}
+
+QHexEdit::~QHexEdit()
+{
+}
+
+// ********************************************************************** Properties
+
+void QHexEdit::setAddressArea(bool addressArea)
+{
+    _addressArea = addressArea;
+    adjust();
+    setCursorPosition(_cursorPosition);
+    viewport()->update();
+}
+
+bool QHexEdit::addressArea()
+{
+    return _addressArea;
+}
+
+void QHexEdit::setAddressAreaColor(const QColor &color)
+{
+    _addressAreaColor = color;
+    viewport()->update();
+}
+
+QColor QHexEdit::addressAreaColor()
+{
+    return _addressAreaColor;
+}
+
+void QHexEdit::setAddressFontColor(const QColor &color)
+{
+    _addressFontColor = color;
+    viewport()->update();
+}
+
+QColor QHexEdit::addressFontColor()
+{
+    return _addressFontColor;
+}
+
+void QHexEdit::setAsciiAreaColor(const QColor &color)
+{
+    _asciiAreaColor = color;
+    viewport()->update();
+}
+
+QColor QHexEdit::asciiAreaColor()
+{
+    return _asciiAreaColor;
+}
+
+void QHexEdit::setAsciiFontColor(const QColor &color)
+{
+    _asciiFontColor = color;
+    viewport()->update();
+}
+
+QColor QHexEdit::asciiFontColor()
+{
+    return _asciiFontColor;
+}
+
+void QHexEdit::setHexFontColor(const QColor &color)
+{
+    _hexFontColor = color;
+    viewport()->update();
+}
+
+QColor QHexEdit::hexFontColor()
+{
+    return _hexFontColor;
+}
+
+void QHexEdit::setAddressOffset(qint64 addressOffset)
+{
+    _addressOffset = addressOffset;
+    adjust();
+    setCursorPosition(_cursorPosition);
+    viewport()->update();
+}
+
+qint64 QHexEdit::addressOffset()
+{
+    return _addressOffset;
+}
+
+void QHexEdit::setAddressWidth(int addressWidth)
+{
+    _addressWidth = addressWidth;
+    adjust();
+    setCursorPosition(_cursorPosition);
+    viewport()->update();
+}
+
+int QHexEdit::addressWidth()
+{
+    qint64 size = _chunks->size();
+    int n = 1;
+    if (size > Q_INT64_C(0x100000000)){ n += 8; size /= Q_INT64_C(0x100000000);}
+    if (size > 0x10000){ n += 4; size /= 0x10000;}
+    if (size > 0x100){ n += 2; size /= 0x100;}
+    if (size > 0x10){ n += 1;}
+
+    if (n > _addressWidth)
+        return n;
+    else
+        return _addressWidth;
+}
+
+void QHexEdit::setAsciiArea(bool asciiArea)
+{
+    if (!asciiArea)
+        _editAreaIsAscii = false;
+    _asciiArea = asciiArea;
+    adjust();
+    setCursorPosition(_cursorPosition);
+    viewport()->update();
+}
+
+bool QHexEdit::asciiArea()
+{
+    return _asciiArea;
+}
+
+void QHexEdit::setBytesPerLine(int count)
+{
+    _bytesPerLine = count;
+    _hexCharsInLine = count * 3 - 1;
+
+    adjust();
+    setCursorPosition(_cursorPosition);
+    viewport()->update();
+}
+
+int QHexEdit::bytesPerLine()
+{
+    return _bytesPerLine;
+}
+
+void QHexEdit::setCursorPosition(qint64 position)
+{
+    // 1. delete old cursor
+    _blink = false;
+    viewport()->update(_cursorRect);
+
+    // 2. Check, if cursor in range?
+    if (position > (_chunks->size() * 2 - 1))
+        position = _chunks->size() * 2  - (_overwriteMode ? 1 : 0);
+
+    if (position < 0)
+        position = 0;
+
+    // 3. Calc new position of cursor
+    _bPosCurrent = position / 2;
+    _pxCursorY = ((position / 2 - _bPosFirst) / _bytesPerLine + 1) * _pxCharHeight;
+    int x = (position % (2 * _bytesPerLine));
+    if (_editAreaIsAscii)
+    {
+        _pxCursorX = x / 2 * _pxCharWidth + _pxPosAsciiX;
+        _cursorPosition = position & 0xFFFFFFFFFFFFFFFE;
+    } else {
+        _pxCursorX = (((x / 2) * 3) + (x % 2)) * _pxCharWidth + _pxPosHexX;
+        _cursorPosition = position;
+    }
+
+    if (_overwriteMode)
+        _cursorRect = QRect(_pxCursorX - horizontalScrollBar()->value(), _pxCursorY + _pxCursorWidth, _pxCharWidth, _pxCursorWidth);
+    else
+        _cursorRect = QRect(_pxCursorX - horizontalScrollBar()->value(), _pxCursorY - _pxCharHeight + 4, _pxCursorWidth, _pxCharHeight);
+
+    // 4. Immediately draw new cursor
+    _blink = true;
+    viewport()->update(_cursorRect);
+    emit currentAddressChanged(_bPosCurrent);
+}
+
+qint64 QHexEdit::cursorPosition(QPoint pos)
+{
+    // Calc cursor position depending on a graphical position
+    qint64 result = -1;
+    int posX = pos.x() + horizontalScrollBar()->value();
+    int posY = pos.y() - 3;
+    if ((posX >= _pxPosHexX) && (posX < (_pxPosHexX + (1 + _hexCharsInLine) * _pxCharWidth)))
+    {
+        _editAreaIsAscii = false;
+        int x = (posX - _pxPosHexX) / _pxCharWidth;
+        x = (x / 3) * 2 + x % 3;
+        int y = (posY / _pxCharHeight) * 2 * _bytesPerLine;
+        result = _bPosFirst * 2 + x + y;
+    }
+    else
+        if (_asciiArea && (posX >= _pxPosAsciiX) && (posX < (_pxPosAsciiX + (1 + _bytesPerLine) * _pxCharWidth)))
+        {
+            _editAreaIsAscii = true;
+            int x = 2 * (posX - _pxPosAsciiX) / _pxCharWidth;
+            int y = (posY / _pxCharHeight) * 2 * _bytesPerLine;
+            result = _bPosFirst * 2 + x + y;
+        }
+    return result;
+}
+
+qint64 QHexEdit::cursorPosition()
+{
+    return _cursorPosition;
+}
+
+void QHexEdit::setData(const QByteArray &ba)
+{
+    _data = ba;
+    _bData.setData(_data);
+    setData(_bData);
+}
+
+QByteArray QHexEdit::data()
+{
+    return _chunks->data(0, -1);
+}
+
+void QHexEdit::setHighlighting(bool highlighting)
+{
+    _highlighting = highlighting;
+    viewport()->update();
+}
+
+bool QHexEdit::highlighting()
+{
+    return _highlighting;
+}
+
+void QHexEdit::setHighlightingColor(const QColor &color)
+{
+    _brushHighlighted = QBrush(color);
+    _penHighlighted = QPen(viewport()->palette().color(QPalette::WindowText));
+    viewport()->update();
+}
+
+QColor QHexEdit::highlightingColor()
+{
+    return _brushHighlighted.color();
+}
+
+void QHexEdit::setOverwriteMode(bool overwriteMode)
+{
+    _overwriteMode = overwriteMode;
+    emit overwriteModeChanged(overwriteMode);
+}
+
+bool QHexEdit::overwriteMode()
+{
+    return _overwriteMode;
+}
+
+void QHexEdit::setSelectionColor(const QColor &color)
+{
+    _brushSelection = QBrush(color);
+    _penSelection = QPen(Qt::white);
+    viewport()->update();
+}
+
+QColor QHexEdit::selectionColor()
+{
+    return _brushSelection.color();
+}
+
+bool QHexEdit::isReadOnly()
+{
+    return _readOnly;
+}
+
+void QHexEdit::setReadOnly(bool readOnly)
+{
+    _readOnly = readOnly;
+}
+
+void QHexEdit::setHexCaps(const bool isCaps)
+{
+    if (_hexCaps != isCaps)
+    {
+        _hexCaps = isCaps;
+        viewport()->update();
+    }
+}
+
+bool QHexEdit::hexCaps()
+{
+    return _hexCaps;
+}
+
+void QHexEdit::setDynamicBytesPerLine(const bool isDynamic)
+{
+    _dynamicBytesPerLine = isDynamic;
+    resizeEvent(NULL);
+}
+
+bool QHexEdit::dynamicBytesPerLine()
+{
+    return _dynamicBytesPerLine;
+}
+
+// ********************************************************************** Access to data of qhexedit
+bool QHexEdit::setData(QIODevice &iODevice)
+{
+    bool ok = _chunks->setIODevice(iODevice);
+    init();
+    dataChangedPrivate();
+    return ok;
+}
+
+QByteArray QHexEdit::dataAt(qint64 pos, qint64 count)
+{
+    return _chunks->data(pos, count);
+}
+
+bool QHexEdit::write(QIODevice &iODevice, qint64 pos, qint64 count)
+{
+    return _chunks->write(iODevice, pos, count);
+}
+
+// ********************************************************************** Char handling
+void QHexEdit::insert(qint64 index, char ch)
+{
+    _undoStack->insert(index, ch);
+    refresh();
+}
+
+void QHexEdit::remove(qint64 index, qint64 len)
+{
+    _undoStack->removeAt(index, len);
+    refresh();
+}
+
+void QHexEdit::replace(qint64 index, char ch)
+{
+    _undoStack->overwrite(index, ch);
+    refresh();
+}
+
+// ********************************************************************** ByteArray handling
+void QHexEdit::insert(qint64 pos, const QByteArray &ba)
+{
+    _undoStack->insert(pos, ba);
+    refresh();
+}
+
+void QHexEdit::replace(qint64 pos, qint64 len, const QByteArray &ba)
+{
+    _undoStack->overwrite(pos, len, ba);
+    refresh();
+}
+
+// ********************************************************************** Utility functions
+void QHexEdit::ensureVisible()
+{
+    if (_cursorPosition < (_bPosFirst * 2))
+        verticalScrollBar()->setValue((int)(_cursorPosition / 2 / _bytesPerLine));
+    if (_cursorPosition > ((_bPosFirst + (_rowsShown - 1)*_bytesPerLine) * 2))
+        verticalScrollBar()->setValue((int)(_cursorPosition / 2 / _bytesPerLine) - _rowsShown + 1);
+    if (_pxCursorX < horizontalScrollBar()->value())
+        horizontalScrollBar()->setValue(_pxCursorX);
+    if ((_pxCursorX + _pxCharWidth) > (horizontalScrollBar()->value() + viewport()->width()))
+        horizontalScrollBar()->setValue(_pxCursorX + _pxCharWidth - viewport()->width());
+    viewport()->update();
+}
+
+qint64 QHexEdit::indexOf(const QByteArray &ba, qint64 from)
+{
+    qint64 pos = _chunks->indexOf(ba, from);
+    if (pos > -1)
+    {
+        qint64 curPos = pos*2;
+        setCursorPosition(curPos + ba.length()*2);
+        resetSelection(curPos);
+        setSelection(curPos + ba.length()*2);
+        ensureVisible();
+    }
+    return pos;
+}
+
+bool QHexEdit::isModified()
+{
+    return _modified;
+}
+
+qint64 QHexEdit::lastIndexOf(const QByteArray &ba, qint64 from)
+{
+    qint64 pos = _chunks->lastIndexOf(ba, from);
+    if (pos > -1)
+    {
+        qint64 curPos = pos*2;
+        setCursorPosition(curPos - 1);
+        resetSelection(curPos);
+        setSelection(curPos + ba.length()*2);
+        ensureVisible();
+    }
+    return pos;
+}
+
+void QHexEdit::redo()
+{
+    _undoStack->redo();
+    setCursorPosition(_chunks->pos()*(_editAreaIsAscii ? 1 : 2));
+    refresh();
+}
+
+QString QHexEdit::selectionToReadableString()
+{
+    QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
+    return toReadable(ba);
+}
+
+QString QHexEdit::selectedData()
+{
+    QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
+    return ba;
+}
+
+void QHexEdit::setFont(const QFont &font)
+{
+    QFont theFont(font);
+    theFont.setStyleHint(QFont::Monospace);
+    QWidget::setFont(theFont);
+    QFontMetrics metrics = fontMetrics();
+#if QT_VERSION > QT_VERSION_CHECK(5, 11, 0)
+    _pxCharWidth = metrics.horizontalAdvance(QLatin1Char('2'));
+#else
+    _pxCharWidth = metrics.width(QLatin1Char('2'));
+#endif
+    _pxCharHeight = metrics.height();
+    _pxGapAdr = _pxCharWidth / 2;
+    _pxGapAdrHex = _pxCharWidth;
+    _pxGapHexAscii = 2 * _pxCharWidth;
+    _pxCursorWidth = _pxCharHeight / 7;
+    _pxSelectionSub = _pxCharHeight / 5;
+    viewport()->update();
+}
+
+QString QHexEdit::toReadableString()
+{
+    QByteArray ba = _chunks->data();
+    return toReadable(ba);
+}
+
+void QHexEdit::undo()
+{
+    _undoStack->undo();
+    setCursorPosition(_chunks->pos()*(_editAreaIsAscii ? 1 : 2));
+    refresh();
+}
+
+// ********************************************************************** Handle events
+void QHexEdit::keyPressEvent(QKeyEvent *event)
+{
+    // Cursor movements
+    if (event->matches(QKeySequence::MoveToNextChar))
+    {
+        qint64 pos = _cursorPosition + 1;
+        if (_editAreaIsAscii)
+            pos += 1;
+        setCursorPosition(pos);
+        resetSelection(pos);
+    }
+    if (event->matches(QKeySequence::MoveToPreviousChar))
+    {
+        qint64 pos = _cursorPosition - 1;
+        if (_editAreaIsAscii)
+            pos -= 1;
+        setCursorPosition(pos);
+        resetSelection(pos);
+    }
+    if (event->matches(QKeySequence::MoveToEndOfLine))
+    {
+        qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine)) + (2 * _bytesPerLine) - 1;
+        setCursorPosition(pos);
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToStartOfLine))
+    {
+        qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine));
+        setCursorPosition(pos);
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToPreviousLine))
+    {
+        setCursorPosition(_cursorPosition - (2 * _bytesPerLine));
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToNextLine))
+    {
+        setCursorPosition(_cursorPosition + (2 * _bytesPerLine));
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToNextPage))
+    {
+        setCursorPosition(_cursorPosition + (((_rowsShown - 1) * 2 * _bytesPerLine)));
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToPreviousPage))
+    {
+        setCursorPosition(_cursorPosition - (((_rowsShown - 1) * 2 * _bytesPerLine)));
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToEndOfDocument))
+    {
+        setCursorPosition(_chunks->size() * 2 );
+        resetSelection(_cursorPosition);
+    }
+    if (event->matches(QKeySequence::MoveToStartOfDocument))
+    {
+        setCursorPosition(0);
+        resetSelection(_cursorPosition);
+    }
+
+    // Select commands
+    if (event->matches(QKeySequence::SelectAll))
+    {
+        resetSelection(0);
+        setSelection(2 * _chunks->size() + 1);
+    }
+    if (event->matches(QKeySequence::SelectNextChar))
+    {
+        qint64 pos = _cursorPosition + 1;
+        if (_editAreaIsAscii)
+            pos += 1;
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectPreviousChar))
+    {
+        qint64 pos = _cursorPosition - 1;
+        if (_editAreaIsAscii)
+            pos -= 1;
+        setSelection(pos);
+        setCursorPosition(pos);
+    }
+    if (event->matches(QKeySequence::SelectEndOfLine))
+    {
+        qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine)) + (2 * _bytesPerLine) - 1;
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectStartOfLine))
+    {
+        qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine));
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectPreviousLine))
+    {
+        qint64 pos = _cursorPosition - (2 * _bytesPerLine);
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectNextLine))
+    {
+        qint64 pos = _cursorPosition + (2 * _bytesPerLine);
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectNextPage))
+    {
+        qint64 pos = _cursorPosition + (((viewport()->height() / _pxCharHeight) - 1) * 2 * _bytesPerLine);
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectPreviousPage))
+    {
+        qint64 pos = _cursorPosition - (((viewport()->height() / _pxCharHeight) - 1) * 2 * _bytesPerLine);
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectEndOfDocument))
+    {
+        qint64 pos = _chunks->size() * 2;
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+    if (event->matches(QKeySequence::SelectStartOfDocument))
+    {
+        qint64 pos = 0;
+        setCursorPosition(pos);
+        setSelection(pos);
+    }
+
+    // Edit Commands
+    if (!_readOnly)
+    {
+        /* Cut */
+        if (event->matches(QKeySequence::Cut))
+        {
+            QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
+            for (qint64 idx = 32; idx < ba.size(); idx +=33)
+                ba.insert(idx, "\n");
+            QClipboard *clipboard = QApplication::clipboard();
+            clipboard->setText(ba);
+            if (_overwriteMode)
+            {
+                qint64 len = getSelectionEnd() - getSelectionBegin();
+                replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
+            }
+            else
+            {
+                remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
+            }
+            setCursorPosition(2 * getSelectionBegin());
+            resetSelection(2 * getSelectionBegin());
+        } else
+
+        /* Paste */
+        if (event->matches(QKeySequence::Paste))
+        {
+            QClipboard *clipboard = QApplication::clipboard();
+            QByteArray ba = QByteArray().fromHex(clipboard->text().toLatin1());
+            if (_overwriteMode)
+            {
+                ba = ba.left(std::min<qint64>(ba.size(), (_chunks->size() - _bPosCurrent)));
+                replace(_bPosCurrent, ba.size(), ba);
+            }
+            else
+                insert(_bPosCurrent, ba);
+            setCursorPosition(_cursorPosition + 2 * ba.size());
+            resetSelection(getSelectionBegin());
+        } else
+
+        /* Delete char */
+        if (event->matches(QKeySequence::Delete))
+        {
+            if (getSelectionBegin() != getSelectionEnd())
+            {
+                _bPosCurrent = getSelectionBegin();
+                if (_overwriteMode)
+                {
+                    QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
+                    replace(_bPosCurrent, ba.size(), ba);
+                }
+                else
+                {
+                    remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
+                }
+            }
+            else
+            {
+                if (_overwriteMode)
+                    replace(_bPosCurrent, char(0));
+                else
+                    remove(_bPosCurrent, 1);
+            }
+            setCursorPosition(2 * _bPosCurrent);
+            resetSelection(2 * _bPosCurrent);
+        } else
+
+        /* Backspace */
+        if ((event->key() == Qt::Key_Backspace) && (event->modifiers() == Qt::NoModifier))
+        {
+            if (getSelectionBegin() != getSelectionEnd())
+            {
+                _bPosCurrent = getSelectionBegin();
+                setCursorPosition(2 * _bPosCurrent);
+                if (_overwriteMode)
+                {
+                    QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
+                    replace(_bPosCurrent, ba.size(), ba);
+                }
+                else
+                {
+                    remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
+                }
+                resetSelection(2 * _bPosCurrent);
+            }
+            else
+            {
+                bool behindLastByte = false;
+                if ((_cursorPosition / 2) == _chunks->size())
+                    behindLastByte = true;
+
+                _bPosCurrent -= 1;
+                if (_overwriteMode)
+                    replace(_bPosCurrent, char(0));
+                else
+                    remove(_bPosCurrent, 1);
+
+                if (!behindLastByte)
+                    _bPosCurrent -= 1;
+
+                setCursorPosition(2 * _bPosCurrent);
+                resetSelection(2 * _bPosCurrent);
+            }
+        } else
+
+        /* undo */
+        if (event->matches(QKeySequence::Undo))
+        {
+            undo();
+        } else
+
+        /* redo */
+        if (event->matches(QKeySequence::Redo))
+        {
+            redo();
+        } else
+
+        if ((QApplication::keyboardModifiers() == Qt::NoModifier) ||
+            (QApplication::keyboardModifiers() == Qt::KeypadModifier) ||
+            (QApplication::keyboardModifiers() == Qt::ShiftModifier) ||
+            (QApplication::keyboardModifiers() == (Qt::AltModifier | Qt::ControlModifier)) ||
+            (QApplication::keyboardModifiers() == Qt::GroupSwitchModifier))
+        {
+            /* Hex and ascii input */
+            int key = 0;
+            QString text = event->text();
+            if (!text.isEmpty())
+            {
+                if (_editAreaIsAscii)
+                    key = (uchar)text.at(0).toLatin1();
+                else
+                    key = int(text.at(0).toLower().toLatin1());
+            }
+
+            if ((((key >= '0' && key <= '9') || (key >= 'a' && key <= 'f')) && _editAreaIsAscii == false)
+                || (key >= ' ' && _editAreaIsAscii))
+            {
+                if (getSelectionBegin() != getSelectionEnd())
+                {
+                    if (_overwriteMode)
+                    {
+                        qint64 len = getSelectionEnd() - getSelectionBegin();
+                        replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
+                    } else
+                    {
+                        remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
+                        _bPosCurrent = getSelectionBegin();
+                    }
+                    setCursorPosition(2 * _bPosCurrent);
+                    resetSelection(2 * _bPosCurrent);
+                }
+
+                // If insert mode, then insert a byte
+                if (_overwriteMode == false)
+                    if ((_cursorPosition % 2) == 0)
+                        insert(_bPosCurrent, char(0));
+
+                // Change content
+                if (_chunks->size() > 0)
+                {
+                    char ch = key;
+                    if (!_editAreaIsAscii){
+                        QByteArray hexValue = _chunks->data(_bPosCurrent, 1).toHex();
+                        if ((_cursorPosition % 2) == 0)
+                            hexValue[0] = key;
+                        else
+                            hexValue[1] = key;
+                        ch = QByteArray().fromHex(hexValue)[0];
+                    }
+                    replace(_bPosCurrent, ch);
+                    if (_editAreaIsAscii)
+                        setCursorPosition(_cursorPosition + 2);
+                    else
+                        setCursorPosition(_cursorPosition + 1);
+                    resetSelection(_cursorPosition);
+                }
+            }
+        }
+
+
+    }
+
+    /* Copy */
+    if (event->matches(QKeySequence::Copy))
+    {
+        QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
+        for (qint64 idx = 32; idx < ba.size(); idx +=33)
+            ba.insert(idx, "\n");
+        QClipboard *clipboard = QApplication::clipboard();
+        clipboard->setText(ba);
+    }
+
+    // Switch between insert/overwrite mode
+    if ((event->key() == Qt::Key_Insert) && (event->modifiers() == Qt::NoModifier))
+    {
+        setOverwriteMode(!overwriteMode());
+        setCursorPosition(_cursorPosition);
+    }
+
+    // switch from hex to ascii edit
+    if (event->key() == Qt::Key_Tab && !_editAreaIsAscii){
+        _editAreaIsAscii = true;
+        setCursorPosition(_cursorPosition);
+    }
+
+    // switch from ascii to hex edit
+    if (event->key() == Qt::Key_Backtab  && _editAreaIsAscii){
+        _editAreaIsAscii = false;
+        setCursorPosition(_cursorPosition);
+    }
+
+    refresh();
+    QAbstractScrollArea::keyPressEvent(event);
+}
+
+void QHexEdit::mouseMoveEvent(QMouseEvent * event)
+{
+    _blink = false;
+    viewport()->update();
+    qint64 actPos = cursorPosition(event->pos());
+    if (actPos >= 0)
+    {
+        setCursorPosition(actPos);
+        setSelection(actPos);
+    }
+}
+
+void QHexEdit::mousePressEvent(QMouseEvent * event)
+{
+    _blink = false;
+    viewport()->update();
+    qint64 cPos = cursorPosition(event->pos());
+    if (cPos >= 0)
+    {
+        if (event->button() != Qt::RightButton)
+            resetSelection(cPos);
+        setCursorPosition(cPos);
+    }
+}
+
+void QHexEdit::paintEvent(QPaintEvent *event)
+{
+    QPainter painter(viewport());
+    int pxOfsX = horizontalScrollBar()->value();
+
+    if (event->rect() != _cursorRect)
+    {
+        int pxPosStartY = _pxCharHeight;
+
+        // draw some patterns if needed
+        painter.fillRect(event->rect(), viewport()->palette().color(QPalette::Base));
+        if (_addressArea)
+            painter.fillRect(QRect(-pxOfsX, event->rect().top(), _pxPosHexX - _pxGapAdrHex/2, height()), _addressAreaColor);
+        if (_asciiArea)
+        {
+            int linePos = _pxPosAsciiX - (_pxGapHexAscii / 2);
+            painter.setPen(Qt::gray);
+            painter.drawLine(linePos - pxOfsX, event->rect().top(), linePos - pxOfsX, height());
+        }
+
+        painter.setPen(viewport()->palette().color(QPalette::WindowText));
+
+        // paint address area
+        if (_addressArea)
+        {
+            QString address;
+            for (int row=0, pxPosY = _pxCharHeight; row <= (_dataShown.size()/_bytesPerLine); row++, pxPosY +=_pxCharHeight)
+            {
+                address = QString("%1").arg(_bPosFirst + row*_bytesPerLine + _addressOffset, _addrDigits, 16, QChar('0'));
+                painter.setPen(QPen(_addressFontColor));
+                painter.drawText(_pxPosAdrX - pxOfsX, pxPosY, hexCaps() ? address.toUpper() : address);
+            }
+        }
+
+        // paint hex and ascii area
+        QPen colStandard = QPen(viewport()->palette().color(QPalette::WindowText));
+
+        painter.setBackgroundMode(Qt::TransparentMode);
+
+        for (int row = 0, pxPosY = pxPosStartY; row <= _rowsShown; row++, pxPosY +=_pxCharHeight)
+        {
+            QByteArray hex;
+            int pxPosX = _pxPosHexX  - pxOfsX;
+            int pxPosAsciiX2 = _pxPosAsciiX  - pxOfsX;
+            qint64 bPosLine = row * _bytesPerLine;
+            for (int colIdx = 0; ((bPosLine + colIdx) < _dataShown.size() && (colIdx < _bytesPerLine)); colIdx++)
+            {
+                QColor c = viewport()->palette().color(QPalette::Base);
+                painter.setPen(QPen(_hexFontColor));
+
+                qint64 posBa = _bPosFirst + bPosLine + colIdx;
+                if ((getSelectionBegin() <= posBa) && (getSelectionEnd() > posBa))
+                {
+                    c = _brushSelection.color();
+                    painter.setPen(_penSelection);
+                }
+                else
+                {
+                    if (_highlighting)
+                        if (_markedShown.at((int)(posBa - _bPosFirst)))
+                        {
+                            c = _brushHighlighted.color();
+                            painter.setPen(_penHighlighted);
+                        }
+                }
+
+                // render hex value
+                QRect r;
+                if (colIdx == 0)
+                    r.setRect(pxPosX, pxPosY - _pxCharHeight + _pxSelectionSub, 2*_pxCharWidth, _pxCharHeight);
+                else
+                    r.setRect(pxPosX - _pxCharWidth, pxPosY - _pxCharHeight + _pxSelectionSub, 3*_pxCharWidth, _pxCharHeight);
+                painter.fillRect(r, c);
+                hex = _hexDataShown.mid((bPosLine + colIdx) * 2, 2);
+                painter.drawText(pxPosX, pxPosY, hexCaps()?hex.toUpper():hex);
+                pxPosX += 3*_pxCharWidth;
+
+                // render ascii value
+                if (_asciiArea)
+                {
+                    if (c == viewport()->palette().color(QPalette::Base))
+                        c = _asciiAreaColor;
+                    int ch = (uchar)_dataShown.at(bPosLine + colIdx);
+                    if ( ch < ' ' || ch > '~' )
+                        ch = '.';
+                    r.setRect(pxPosAsciiX2, pxPosY - _pxCharHeight + _pxSelectionSub, _pxCharWidth, _pxCharHeight);
+                    painter.fillRect(r, c);
+                    painter.setPen(QPen(_asciiFontColor));
+                    painter.drawText(pxPosAsciiX2, pxPosY, QChar(ch));
+                    pxPosAsciiX2 += _pxCharWidth;
+                }
+            }
+        }
+        painter.setBackgroundMode(Qt::TransparentMode);
+        painter.setPen(viewport()->palette().color(QPalette::WindowText));
+    }
+
+    // _cursorPosition counts in 2, _bPosFirst counts in 1
+    int hexPositionInShowData = _cursorPosition - 2 * _bPosFirst;
+
+    // due to scrolling the cursor can go out of the currently displayed data
+    if ((hexPositionInShowData >= 0) && (hexPositionInShowData < _hexDataShown.size()))
+    {
+        // paint cursor
+        if (_readOnly)
+        {
+            QColor color = viewport()->palette().dark().color();
+            painter.fillRect(QRect(_pxCursorX - pxOfsX, _pxCursorY - _pxCharHeight + _pxSelectionSub, _pxCharWidth, _pxCharHeight), color);
+        }
+        else
+        {
+            if (_blink && hasFocus())
+                painter.fillRect(_cursorRect, this->palette().color(QPalette::WindowText));
+        }
+            if (_editAreaIsAscii)
+            {
+                // every 2 hex there is 1 ascii
+                int asciiPositionInShowData = hexPositionInShowData / 2;
+                int ch = (uchar)_dataShown.at(asciiPositionInShowData);
+                if (ch < ' ' || ch > '~')
+                    ch = '.';
+
+                painter.drawText(_pxCursorX - pxOfsX, _pxCursorY, QChar(ch));
+            }
+            else
+            {
+                painter.drawText(_pxCursorX - pxOfsX, _pxCursorY, hexCaps() ? _hexDataShown.mid(hexPositionInShowData, 1).toUpper() : _hexDataShown.mid(hexPositionInShowData, 1));
+            }
+    }
+
+    // emit event, if size has changed
+    if (_lastEventSize != _chunks->size())
+    {
+        _lastEventSize = _chunks->size();
+        emit currentSizeChanged(_lastEventSize);
+    }
+}
+
+void QHexEdit::resizeEvent(QResizeEvent *)
+{
+    if (_dynamicBytesPerLine)
+    {
+        int pxFixGaps = 0;
+        if (_addressArea)
+            pxFixGaps = addressWidth() * _pxCharWidth + _pxGapAdr;
+        pxFixGaps += _pxGapAdrHex;
+        if (_asciiArea)
+            pxFixGaps += _pxGapHexAscii;
+
+        // +1 because the last hex value do not have space. so it is effective one char more
+        int charWidth = (viewport()->width() - pxFixGaps ) / _pxCharWidth + 1;
+
+        // 2 hex alfa-digits 1 space 1 ascii per byte = 4; if ascii is disabled then 3
+        // to prevent devision by zero use the min value 1
+        setBytesPerLine(std::max(charWidth / (_asciiArea ? 4 : 3),1));
+    }
+    adjust();
+}
+
+bool QHexEdit::focusNextPrevChild(bool next)
+{
+    if (_addressArea)
+    {
+        if ( (next && _editAreaIsAscii) || (!next && !_editAreaIsAscii ))
+            return QWidget::focusNextPrevChild(next);
+        else
+            return false;
+    }
+    else
+    {
+        return QWidget::focusNextPrevChild(next);
+    }
+}
+
+// ********************************************************************** Handle selections
+void QHexEdit::resetSelection()
+{
+    _bSelectionBegin = _bSelectionInit;
+    _bSelectionEnd = _bSelectionInit;
+}
+
+void QHexEdit::resetSelection(qint64 pos)
+{
+    pos = pos / 2 ;
+    if (pos < 0)
+        pos = 0;
+    if (pos > _chunks->size())
+        pos = _chunks->size();
+
+    _bSelectionInit = pos;
+    _bSelectionBegin = pos;
+    _bSelectionEnd = pos;
+}
+
+void QHexEdit::setSelection(qint64 pos)
+{
+    pos = pos / 2;
+    if (pos < 0)
+        pos = 0;
+    if (pos > _chunks->size())
+        pos = _chunks->size();
+
+    if (pos >= _bSelectionInit)
+    {
+        _bSelectionEnd = pos;
+        _bSelectionBegin = _bSelectionInit;
+    }
+    else
+    {
+        _bSelectionBegin = pos;
+        _bSelectionEnd = _bSelectionInit;
+    }
+}
+
+qint64 QHexEdit::getSelectionBegin()
+{
+    return _bSelectionBegin;
+}
+
+qint64 QHexEdit::getSelectionEnd()
+{
+    return _bSelectionEnd;
+}
+
+// ********************************************************************** Private utility functions
+void QHexEdit::init()
+{
+    _undoStack->clear();
+    setAddressOffset(0);
+    resetSelection(0);
+    setCursorPosition(0);
+    verticalScrollBar()->setValue(0);
+    _modified = false;
+}
+
+void QHexEdit::adjust()
+{
+    // recalc Graphics
+    if (_addressArea)
+    {
+        _addrDigits = addressWidth();
+        _pxPosHexX = _pxGapAdr + _addrDigits*_pxCharWidth + _pxGapAdrHex;
+    }
+    else
+        _pxPosHexX = _pxGapAdrHex;
+    _pxPosAdrX = _pxGapAdr;
+    _pxPosAsciiX = _pxPosHexX + _hexCharsInLine * _pxCharWidth + _pxGapHexAscii;
+
+    // set horizontalScrollBar()
+    int pxWidth = _pxPosAsciiX;
+    if (_asciiArea)
+        pxWidth += _bytesPerLine*_pxCharWidth;
+    horizontalScrollBar()->setRange(0, pxWidth - viewport()->width());
+    horizontalScrollBar()->setPageStep(viewport()->width());
+
+    // set verticalScrollbar()
+    _rowsShown = ((viewport()->height()-4)/_pxCharHeight);
+    int lineCount = (int)(_chunks->size() / (qint64)_bytesPerLine) + 1;
+    verticalScrollBar()->setRange(0, lineCount - _rowsShown);
+    verticalScrollBar()->setPageStep(_rowsShown);
+
+    int value = verticalScrollBar()->value();
+    _bPosFirst = (qint64)value * _bytesPerLine;
+    _bPosLast = _bPosFirst + (qint64)(_rowsShown * _bytesPerLine) - 1;
+    if (_bPosLast >= _chunks->size())
+        _bPosLast = _chunks->size() - 1;
+    readBuffers();
+    setCursorPosition(_cursorPosition);
+}
+
+void QHexEdit::dataChangedPrivate(int)
+{
+    _modified = _undoStack->index() != 0;
+    adjust();
+    emit dataChanged();
+}
+
+void QHexEdit::refresh()
+{
+    ensureVisible();
+    readBuffers();
+}
+
+void QHexEdit::readBuffers()
+{
+    _dataShown = _chunks->data(_bPosFirst, _bPosLast - _bPosFirst + _bytesPerLine + 1, &_markedShown);
+    _hexDataShown = QByteArray(_dataShown.toHex());
+}
+
+QString QHexEdit::toReadable(const QByteArray &ba)
+{
+    QString result;
+
+    for (int i=0; i < ba.size(); i += 16)
+    {
+        QString addrStr = QString("%1").arg(_addressOffset + i, addressWidth(), 16, QChar('0'));
+        QString hexStr;
+        QString ascStr;
+        for (int j=0; j<16; j++)
+        {
+            if ((i + j) < ba.size())
+            {
+                hexStr.append(" ").append(ba.mid(i+j, 1).toHex());
+                char ch = ba[i + j];
+                if ((ch < 0x20) || (ch > 0x7e))
+                        ch = '.';
+                ascStr.append(QChar(ch));
+            }
+        }
+        result += addrStr + " " + QString("%1").arg(hexStr, -48) + "  " + QString("%1").arg(ascStr, -17) + "\n";
+    }
+    return result;
+}
+
+void QHexEdit::updateCursor()
+{
+    if (_blink)
+        _blink = false;
+    else
+        _blink = true;
+    viewport()->update(_cursorRect);
+}
diff --git a/src/qhexedit.h b/src/qhexedit.h
new file mode 100644
index 0000000..1a5801a
--- /dev/null
+++ b/src/qhexedit.h
@@ -0,0 +1,459 @@
+#ifndef QHEXEDIT_H
+#define QHEXEDIT_H
+
+#include <QAbstractScrollArea>
+#include <QPen>
+#include <QBrush>
+
+#include "chunks.h"
+#include "commands.h"
+
+#ifdef QHEXEDIT_EXPORTS
+#define QHEXEDIT_API Q_DECL_EXPORT
+#elif QHEXEDIT_IMPORTS
+#define QHEXEDIT_API Q_DECL_IMPORT
+#else
+#define QHEXEDIT_API
+#endif
+
+/** \mainpage
+QHexEdit is a binary editor widget for Qt.
+
+\version Version 0.8.9
+\image html qhexedit.png
+*/
+
+
+/** QHexEdit is a hex editor widget written in C++ for the Qt (Qt4, Qt5) framework.
+It is a simple editor for binary data, just like QPlainTextEdit is for text
+data. There are sip configuration files included, so it is easy to create
+bindings for PyQt and you can use this widget also in python 2 and 3.
+
+QHexEdit takes the data of a QByteArray (setData()) and shows it. You can use
+the mouse or the keyboard to navigate inside the widget. If you hit the keys
+(0..9, a..f) you will change the data. Changed data is highlighted and can be
+accessed via data().
+
+Normally QHexEdit works in the overwrite mode. You can set overwrite mode(false)
+and insert data. In this case the size of data() increases. It is also possible
+to delete bytes (del or backspace), here the size of data decreases.
+
+You can select data with keyboard hits or mouse movements. The copy-key will
+copy the selected data into the clipboard. The cut-key copies also but deletes
+it afterwards. In overwrite mode, the paste function overwrites the content of
+the (does not change the length) data. In insert mode, clipboard data will be
+inserted. The clipboard content is expected in ASCII Hex notation. Unknown
+characters will be ignored.
+
+QHexEdit comes with undo/redo functionality. All changes can be undone, by
+pressing the undo-key (usually ctr-z). They can also be redone afterwards.
+The undo/redo framework is cleared, when setData() sets up a new
+content for the editor. You can search data inside the content with indexOf()
+and lastIndexOf(). The replace() function is to change located subdata. This
+'replaced' data can also be undone by the undo/redo framework.
+
+QHexEdit is based on QIODevice, that's why QHexEdit can handle big amounts of
+data. The size of edited data can be more then two gigabytes without any
+restrictions.
+*/
+class QHEXEDIT_API QHexEdit : public QAbstractScrollArea
+{
+    Q_OBJECT
+
+    /*! Property address area switch the address area on or off. Set addressArea true
+    (show it), false (hide it).
+    */
+    Q_PROPERTY(bool addressArea READ addressArea WRITE setAddressArea)
+
+    /*! Property address area color sets (setAddressAreaColor()) the background
+    color of address areas. You can also read the color (addressAreaColor()).
+    */
+    Q_PROPERTY(QColor addressAreaColor READ addressAreaColor WRITE setAddressAreaColor)
+
+    /*! Property address font color sets (setAddressFontColor()) the text
+    color of address areas. You can also read the color (addressFontColor()).
+    */
+    Q_PROPERTY(QColor addressFontColor READ addressFontColor WRITE setAddressFontColor)
+
+    /*! Property ascii area color sets (setAsciiAreaColor()) the backgorund
+    color of ascii areas. You can also read the color (asciiAreaColor()).
+    */
+    Q_PROPERTY(QColor asciiAreaColor READ asciiAreaColor WRITE setAsciiAreaColor)
+
+    /*! Property ascii font color sets (setAsciiFontColor()) the text
+    color of ascii areas. You can also read the color (asciiFontColor()).
+    */
+    Q_PROPERTY(QColor asciiFontColor READ asciiFontColor WRITE setAsciiFontColor)
+
+    /*! Property hex font color sets (setHexFontColor()) the text
+    color of hex areas. You can also read the color (hexFontColor()).
+    */
+    Q_PROPERTY(QColor hexFontColor READ hexFontColor WRITE setHexFontColor)
+
+    /*! Property addressOffset is added to the Numbers of the Address Area.
+    A offset in the address area (left side) is sometimes useful, whe you show
+    only a segment of a complete memory picture. With setAddressOffset() you set
+    this property - with addressOffset() you get the current value.
+    */
+    Q_PROPERTY(qint64 addressOffset READ addressOffset WRITE setAddressOffset)
+
+    /*! Set and get the minimum width of the address area, width in characters.
+    */
+    Q_PROPERTY(int addressWidth READ addressWidth WRITE setAddressWidth)
+
+    /*! Switch the ascii area on (true, show it) or off (false, hide it).
+    */
+    Q_PROPERTY(bool asciiArea READ asciiArea WRITE setAsciiArea)
+
+    /*! Set and get bytes number per line.*/
+    Q_PROPERTY(int bytesPerLine READ bytesPerLine WRITE setBytesPerLine)
+
+    /*! Property cursorPosition sets or gets the position of the editor cursor
+    in QHexEdit. Every byte in data has two cursor positions: the lower and upper
+    Nibble. Maximum cursor position is factor two of data.size().
+    */
+    Q_PROPERTY(qint64 cursorPosition READ cursorPosition WRITE setCursorPosition)
+
+    /*! Property data holds the content of QHexEdit. Call setData() to set the
+    content of QHexEdit, data() returns the actual content. When calling setData()
+    with a QByteArray as argument, QHexEdit creates a internal copy of the data
+    If you want to edit big files please use setData(), based on QIODevice.
+    */
+    Q_PROPERTY(QByteArray data READ data WRITE setData NOTIFY dataChanged)
+
+    /*! That property defines if the hex values looks as a-f if the value is false(default)
+    or A-F if value is true.
+    */
+    Q_PROPERTY(bool hexCaps READ hexCaps WRITE setHexCaps)
+
+    /*! Property defines the dynamic calculation of bytesPerLine parameter depends of width of widget.
+    set this property true to avoid horizontal scrollbars and show the maximal possible data. defalut value is false*/
+    Q_PROPERTY(bool dynamicBytesPerLine READ dynamicBytesPerLine WRITE setDynamicBytesPerLine)
+
+    /*! Switch the highlighting feature on or of: true (show it), false (hide it).
+    */
+    Q_PROPERTY(bool highlighting READ highlighting WRITE setHighlighting)
+
+    /*! Property highlighting color sets (setHighlightingColor()) the background
+    color of highlighted text areas. You can also read the color
+    (highlightingColor()).
+    */
+    Q_PROPERTY(QColor highlightingColor READ highlightingColor WRITE setHighlightingColor)
+
+    /*! Property overwrite mode sets (setOverwriteMode()) or gets (overwriteMode()) the mode
+    in which the editor works. In overwrite mode the user will overwrite existing data. The
+    size of data will be constant. In insert mode the size will grow, when inserting
+    new data.
+    */
+    Q_PROPERTY(bool overwriteMode READ overwriteMode WRITE setOverwriteMode)
+
+    /*! Property selection color sets (setSelectionColor()) the background
+    color of selected text areas. You can also read the color
+    (selectionColor()).
+    */
+    Q_PROPERTY(QColor selectionColor READ selectionColor WRITE setSelectionColor)
+
+    /*! Property readOnly sets (setReadOnly()) or gets (isReadOnly) the mode
+    in which the editor works. In readonly mode the the user can only navigate
+    through the data and select data; modifying is not possible. This
+    property's default is false.
+    */
+    Q_PROPERTY(bool readOnly READ isReadOnly WRITE setReadOnly)
+
+    /*! Set the font of the widget. Please use fixed width fonts like Mono or Courier.*/
+    Q_PROPERTY(QFont font READ font WRITE setFont)
+
+public:
+    /*! Creates an instance of QHexEdit.
+    \param parent Parent widget of QHexEdit.
+    */
+    QHexEdit(QWidget *parent=0);
+
+    // Access to data of qhexedit
+
+    /*! Sets the data of QHexEdit. The QIODevice will be opened just before reading
+    and closed immediately afterwards. This is to allow other programs to rewrite
+    the file while editing it.
+    */
+    bool setData(QIODevice &iODevice);
+
+    /*! Gives back the data as a QByteArray starting at position \param pos and
+    delivering \param count bytes.
+    */
+    QByteArray dataAt(qint64 pos, qint64 count=-1);
+
+    /*! Gives back the data into a \param iODevice starting at position \param pos
+    and delivering \param count bytes.
+    */
+    bool write(QIODevice &iODevice, qint64 pos=0, qint64 count=-1);
+
+
+    // Char handling
+
+    /*! Inserts a char.
+    \param pos Index position, where to insert
+    \param ch Char, which is to insert
+    The char will be inserted and size of data grows.
+    */
+    void insert(qint64 pos, char ch);
+
+    /*! Removes len bytes from the content.
+    \param pos Index position, where to remove
+    \param len Amount of bytes to remove
+    */
+    void remove(qint64 pos, qint64 len=1);
+
+    /*! Replaces a char.
+    \param pos Index position, where to overwrite
+    \param ch Char, which is to insert
+    The char will be overwritten and size remains constant.
+    */
+    void replace(qint64 pos, char ch);
+
+
+    // ByteArray handling
+
+    /*! Inserts a byte array.
+    \param pos Index position, where to insert
+    \param ba QByteArray, which is to insert
+    The QByteArray will be inserted and size of data grows.
+    */
+    void insert(qint64 pos, const QByteArray &ba);
+
+    /*! Replaces \param len bytes with a byte array \param ba
+    \param pos Index position, where to overwrite
+    \param ba QByteArray, which is inserted
+    \param len count of bytes to overwrite
+    The data is overwritten and size of data may change.
+    */
+    void replace(qint64 pos, qint64 len, const QByteArray &ba);
+
+
+    // Utility functions
+    /*! Calc cursor position from graphics position
+     * \param point from where the cursor position should be calculated
+     * \return Cursor position
+     */
+    qint64 cursorPosition(QPoint point);
+
+    /*! Ensure the cursor to be visbile
+     */
+    void ensureVisible();
+
+    /*! Find first occurrence of ba in QHexEdit data
+     * \param ba Data to find
+     * \param from Point where the search starts
+     * \return pos if fond, else -1
+     */
+    qint64 indexOf(const QByteArray &ba, qint64 from);
+
+    /*! Returns if any changes where done on document
+     * \return true when document is modified else false
+     */
+    bool isModified();
+
+    /*! Find last occurrence of ba in QHexEdit data
+     * \param ba Data to find
+     * \param from Point where the search starts
+     * \return pos if fond, else -1
+     */
+    qint64 lastIndexOf(const QByteArray &ba, qint64 from);
+
+    /*! Gives back a formatted image of the selected content of QHexEdit
+    */
+    QString selectionToReadableString();
+
+    /*! Return the selected content of QHexEdit as QByteArray
+    */
+    QString selectedData();
+
+    /*! Set Font of QHexEdit
+     * \param font
+     */
+    void setFont(const QFont &font);
+
+    /*! Gives back a formatted image of the content of QHexEdit
+    */
+    QString toReadableString();
+
+
+public slots:
+    /*! Redoes the last operation. If there is no operation to redo, i.e.
+      there is no redo step in the undo/redo history, nothing happens.
+      */
+    void redo();
+
+    /*! Undoes the last operation. If there is no operation to undo, i.e.
+      there is no undo step in the undo/redo history, nothing happens.
+      */
+    void undo();
+
+signals:
+
+    /*! Contains the address, where the cursor is located. */
+    void currentAddressChanged(qint64 address);
+
+    /*! Contains the size of the data to edit. */
+    void currentSizeChanged(qint64 size);
+
+    /*! The signal is emitted every time, the data is changed. */
+    void dataChanged();
+
+    /*! The signal is emitted every time, the overwrite mode is changed. */
+    void overwriteModeChanged(bool state);
+
+
+/*! \cond docNever */
+public:
+    ~QHexEdit();
+
+    // Properties
+    bool addressArea();
+    void setAddressArea(bool addressArea);
+
+    QColor addressAreaColor();
+    void setAddressAreaColor(const QColor &color);
+
+    QColor addressFontColor();
+    void setAddressFontColor(const QColor &color);
+
+    QColor asciiAreaColor();
+    void setAsciiAreaColor(const QColor &color);
+
+    QColor asciiFontColor();
+    void setAsciiFontColor(const QColor &color);
+
+    QColor hexFontColor();
+    void setHexFontColor(const QColor &color);
+
+    qint64 addressOffset();
+    void setAddressOffset(qint64 addressArea);
+
+    int addressWidth();
+    void setAddressWidth(int addressWidth);
+
+    bool asciiArea();
+    void setAsciiArea(bool asciiArea);
+
+    int bytesPerLine();
+    void setBytesPerLine(int count);
+
+    qint64 cursorPosition();
+    void setCursorPosition(qint64 position);
+
+    QByteArray data();
+    void setData(const QByteArray &ba);
+
+    void setHexCaps(const bool isCaps);
+    bool hexCaps();
+
+    void setDynamicBytesPerLine(const bool isDynamic);
+    bool dynamicBytesPerLine();
+
+    bool highlighting();
+    void setHighlighting(bool mode);
+
+    QColor highlightingColor();
+    void setHighlightingColor(const QColor &color);
+
+    bool overwriteMode();
+    void setOverwriteMode(bool overwriteMode);
+
+    bool isReadOnly();
+    void setReadOnly(bool readOnly);
+
+    QColor selectionColor();
+    void setSelectionColor(const QColor &color);
+
+protected:
+    // Handle events
+    void keyPressEvent(QKeyEvent *event);
+    void mouseMoveEvent(QMouseEvent * event);
+    void mousePressEvent(QMouseEvent * event);
+    void paintEvent(QPaintEvent *event);
+    void resizeEvent(QResizeEvent *);
+    virtual bool focusNextPrevChild(bool next);
+private:
+    // Handle selections
+    void resetSelection(qint64 pos);            // set selectionStart and selectionEnd to pos
+    void resetSelection();                      // set selectionEnd to selectionStart
+    void setSelection(qint64 pos);              // set min (if below init) or max (if greater init)
+    qint64 getSelectionBegin();
+    qint64 getSelectionEnd();
+
+    // Private utility functions
+    void init();
+    void readBuffers();
+    QString toReadable(const QByteArray &ba);
+
+private slots:
+    void adjust();                              // recalc pixel positions
+    void dataChangedPrivate(int idx=0);         // emit dataChanged() signal
+    void refresh();                             // ensureVisible() and readBuffers()
+    void updateCursor();                        // update blinking cursor
+
+private:
+    // Name convention: pixel positions start with _px
+    int _pxCharWidth, _pxCharHeight;            // char dimensions (dependend on font)
+    int _pxPosHexX;                             // X-Pos of HeaxArea
+    int _pxPosAdrX;                             // X-Pos of Address Area
+    int _pxPosAsciiX;                           // X-Pos of Ascii Area
+    int _pxGapAdr;                              // gap left from AddressArea
+    int _pxGapAdrHex;                           // gap between AddressArea and HexAerea
+    int _pxGapHexAscii;                         // gap between HexArea and AsciiArea
+    int _pxCursorWidth;                         // cursor width
+    int _pxSelectionSub;                        // offset selection rect
+    int _pxCursorX;                             // current cursor pos
+    int _pxCursorY;                             // current cursor pos
+
+    // Name convention: absolute byte positions in chunks start with _b
+    qint64 _bSelectionBegin;                    // first position of Selection
+    qint64 _bSelectionEnd;                      // end of Selection
+    qint64 _bSelectionInit;                     // memory position of Selection
+    qint64 _bPosFirst;                          // position of first byte shown
+    qint64 _bPosLast;                           // position of last byte shown
+    qint64 _bPosCurrent;                        // current position
+
+    // variables to store the property values
+    bool _addressArea;                          // left area of QHexEdit
+    QColor _addressAreaColor;
+    QColor _asciiAreaColor;
+    QColor _addressFontColor;
+    QColor _asciiFontColor;
+    QColor _hexFontColor;
+    int _addressWidth;
+    bool _asciiArea;
+    qint64 _addressOffset;
+    int _bytesPerLine;
+    int _hexCharsInLine;
+    bool _highlighting;
+    bool _overwriteMode;
+    QBrush _brushSelection;
+    QPen _penSelection;
+    QBrush _brushHighlighted;
+    QPen _penHighlighted;
+    bool _readOnly;
+    bool _hexCaps;
+    bool _dynamicBytesPerLine;
+
+    // other variables
+    bool _editAreaIsAscii;                      // flag about the ascii mode edited
+    int _addrDigits;                            // real no of addressdigits, may be > addressWidth
+    bool _blink;                                // help get cursor blinking
+    QBuffer _bData;                             // buffer, when setup with QByteArray
+    Chunks *_chunks;                            // IODevice based access to data
+    QTimer _cursorTimer;                        // for blinking cursor
+    qint64 _cursorPosition;                     // absolute position of cursor, 1 Byte == 2 tics
+    QRect _cursorRect;                          // physical dimensions of cursor
+    QByteArray _data;                           // QHexEdit's data, when setup with QByteArray
+    QByteArray _dataShown;                      // data in the current View
+    QByteArray _hexDataShown;                   // data in view, transformed to hex
+    qint64 _lastEventSize;                      // size, which was emitted last time
+    QByteArray _markedShown;                    // marked data in view
+    bool _modified;                             // Is any data in editor modified?
+    int _rowsShown;                             // lines of text shown
+    UndoStack * _undoStack;                     // Stack to store edit actions for undo/redo
+    /*! \endcond docNever */
+};
+
+#endif // QHEXEDIT_H
diff --git a/src/qhexedit.pro b/src/qhexedit.pro
new file mode 100644
index 0000000..2a94016
--- /dev/null
+++ b/src/qhexedit.pro
@@ -0,0 +1,27 @@
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+QT += core gui
+TEMPLATE = lib
+
+VERSION = 4.2.0
+
+DEFINES += QHEXEDIT_EXPORTS
+
+HEADERS = \
+    qhexedit.h \
+    chunks.h \
+    commands.h
+
+
+SOURCES = \
+    qhexedit.cpp \
+    chunks.cpp \
+    commands.cpp
+
+Release:TARGET = qhexedit
+Debug:TARGET = qhexeditd
+
+
+unix:DESTDIR = /usr/lib
+win32:DESTDIR = ../lib
diff --git a/src/qhexedit.sip b/src/qhexedit.sip
new file mode 100644
index 0000000..a7ef4e7
--- /dev/null
+++ b/src/qhexedit.sip
@@ -0,0 +1,94 @@
+%Module(name=qhexedit)
+
+%Import QtCore/QtCoremod.sip
+%Import QtGui/QtGuimod.sip
+
+%If (Qt_5_0_0 -)
+%Import QtWidgets/QtWidgetsmod.sip
+%End
+
+class QHexEdit : QAbstractScrollArea
+{
+%TypeHeaderCode
+#include "../src/qhexedit.h"
+%End
+
+public:
+    explicit QHexEdit(QWidget *parent /TransferThis/ = 0);
+    virtual ~QHexEdit();
+
+    bool setData(QIODevice &);
+    QByteArray dataAt(qint64, qint64=-1);
+    bool write(QIODevice &iODevice, qint64=0, qint64=-1);
+
+    void insert(qint64, char);
+    void remove(qint64, qint64);
+    void replace(qint64, char);
+
+    void insert(qint64, QByteArray &);
+    void replace(qint64, qint64, QByteArray &);
+
+    bool addressArea();
+    bool addressWidth();
+    bool asciiArea();
+    qint64 cursorPosition(QPoint);
+    void ensureVisible();
+    qint64 indexOf(QByteArray &, qint64);
+    bool isModified();
+    bool highlighting();
+    qint64 lastIndexOf(QByteArray &, qint64);
+    QString selectionToReadableString();
+    QString selectedData();
+    void setFont(const QFont &);
+    QString toReadableString();
+
+    QColor addressAreaColor();
+    void setAddressAreaColor(const QColor &);
+
+    QColor addressFontColor();
+    void setAddressFontColor(const QColor &);
+
+    QColor asciiAreaColor();
+    void setAsciiAreaColor(const QColor &);
+
+    QColor asciiFontColor();
+    void setAsciiFontColor(const QColor &);
+
+    QColor hexFontColor();
+    void setHexFontColor(const QColor &);
+
+    qint64 addressOffset();
+    void setAddressOffset(qint64);
+
+    qint64 cursorPosition();
+    void setCursorPosition(qint64);
+
+    QByteArray data();
+    void setData(const QByteArray &);
+
+    QColor highlightingColor();
+    void setHighlightingColor(const QColor &);
+
+    bool overwriteMode();
+    void setOverwriteMode(bool);
+
+    bool isReadOnly();
+    void setReadOnly(bool);
+
+    QColor selectionColor();
+    void setSelectionColor(const QColor &);
+
+public slots:
+    void redo();
+    void setAddressArea(bool);
+    void setAddressWidth(int);
+    void setAsciiArea(bool);
+    void setHighlighting(bool);
+    void undo();
+
+signals:
+    void currentAddressChanged(qint64);
+    void currentSizeChanged(qint64);
+    void dataChanged();
+    void overwriteModeChanged(bool);
+};
diff --git a/src/qhexeditplugin.pro b/src/qhexeditplugin.pro
new file mode 100644
index 0000000..2f05e1a
--- /dev/null
+++ b/src/qhexeditplugin.pro
@@ -0,0 +1,40 @@
+#! [0] #! [1]
+greaterThan(QT_MAJOR_VERSION, 4) {
+    QT      += widgets uiplugin
+}
+
+lessThan(QT_MAJOR_VERSION, 5) {
+    CONFIG  += designer
+}
+
+CONFIG      += plugin
+#! [0]
+TARGET      = $$qtLibraryTarget($$TARGET)
+#! [2]
+TEMPLATE    = lib
+#! [1] #! [2]
+QTDIR_build:DESTDIR     = $$QT_BUILD_TREE/plugins/designer
+
+#! [3]
+HEADERS = \
+    qhexedit.h \
+    chunks.h \
+    commands.h \
+    QHexEditPlugin.h
+
+
+SOURCES = \
+    qhexedit.cpp \
+    chunks.cpp \
+    commands.cpp \
+    QHexEditPlugin.cpp
+
+#! [3]
+
+# install
+target.path = $$[QT_INSTALL_PLUGINS]/designer
+sources.files = $$SOURCES $$HEADERS *.pro
+sources.path = $$[QT_INSTALL_EXAMPLES]/designer/QHexEditPlugin
+INSTALLS += target
+
+symbian: include($$QT_SOURCE_TREE/examples/symbianpkgrules.pri)