aboutsummaryrefslogtreecommitdiffstats
path: root/SQLiteStudio3/guiSQLiteStudio/qhexedit2
diff options
context:
space:
mode:
Diffstat (limited to 'SQLiteStudio3/guiSQLiteStudio/qhexedit2')
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.cpp115
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.h70
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.cpp180
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.h230
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.cpp883
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.h129
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.cpp167
-rw-r--r--SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.h67
8 files changed, 1841 insertions, 0 deletions
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.cpp b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.cpp
new file mode 100644
index 0000000..303091d
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.cpp
@@ -0,0 +1,115 @@
+#include "commands.h"
+
+CharCommand::CharCommand(XByteArray * xData, Cmd cmd, int charPos, char newChar, QUndoCommand *parent)
+ : QUndoCommand(parent)
+{
+ _xData = xData;
+ _charPos = charPos;
+ _newChar = newChar;
+ _cmd = cmd;
+}
+
+bool CharCommand::mergeWith(const QUndoCommand *command)
+{
+ const CharCommand *nextCommand = static_cast<const CharCommand *>(command);
+ bool result = false;
+
+ if (_cmd != remove)
+ {
+ if (nextCommand->_cmd == replace)
+ if (nextCommand->_charPos == _charPos)
+ {
+ _newChar = nextCommand->_newChar;
+ result = true;
+ }
+ }
+ return result;
+}
+
+void CharCommand::undo()
+{
+ switch (_cmd)
+ {
+ case insert:
+ _xData->remove(_charPos, 1);
+ break;
+ case replace:
+ _xData->replace(_charPos, _oldChar);
+ _xData->setDataChanged(_charPos, _wasChanged);
+ break;
+ case remove:
+ _xData->insert(_charPos, _oldChar);
+ _xData->setDataChanged(_charPos, _wasChanged);
+ break;
+ }
+}
+
+void CharCommand::redo()
+{
+ switch (_cmd)
+ {
+ case insert:
+ _xData->insert(_charPos, _newChar);
+ break;
+ case replace:
+ _oldChar = _xData->data()[_charPos];
+ _wasChanged = _xData->dataChanged(_charPos);
+ _xData->replace(_charPos, _newChar);
+ break;
+ case remove:
+ _oldChar = _xData->data()[_charPos];
+ _wasChanged = _xData->dataChanged(_charPos);
+ _xData->remove(_charPos, 1);
+ break;
+ }
+}
+
+
+
+ArrayCommand::ArrayCommand(XByteArray * xData, Cmd cmd, int baPos, QByteArray newBa, int len, QUndoCommand *parent)
+ : QUndoCommand(parent)
+{
+ _cmd = cmd;
+ _xData = xData;
+ _baPos = baPos;
+ _newBa = newBa;
+ _len = len;
+}
+
+void ArrayCommand::undo()
+{
+ switch (_cmd)
+ {
+ case insert:
+ _xData->remove(_baPos, _newBa.length());
+ break;
+ case replace:
+ _xData->replace(_baPos, _oldBa);
+ _xData->setDataChanged(_baPos, _wasChanged);
+ break;
+ case remove:
+ _xData->insert(_baPos, _oldBa);
+ _xData->setDataChanged(_baPos, _wasChanged);
+ break;
+ }
+}
+
+void ArrayCommand::redo()
+{
+ switch (_cmd)
+ {
+ case insert:
+ _xData->insert(_baPos, _newBa);
+ break;
+ case replace:
+ _oldBa = _xData->data().mid(_baPos, _len);
+ _wasChanged = _xData->dataChanged(_baPos, _len);
+ _xData->replace(_baPos, _newBa);
+ break;
+ case remove:
+ _oldBa = _xData->data().mid(_baPos, _len);
+ _wasChanged = _xData->dataChanged(_baPos, _len);
+ _xData->remove(_baPos, _len);
+ break;
+ }
+}
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.h b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.h
new file mode 100644
index 0000000..b7e4921
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/commands.h
@@ -0,0 +1,70 @@
+#ifndef COMMANDS_H
+#define COMMANDS_H
+
+/** \cond docNever */
+
+#include "guiSQLiteStudio_global.h"
+#include "xbytearray.h"
+#include <QUndoCommand>
+
+/*! CharCommand is a class to prived 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. replace and
+remove characters. A manipulation stores allways to actions
+1. redo (or do) action
+2. undo action.
+
+CharCommand also supports command compression via mergeWidht(). This allows
+the user to execute a undo command contation 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", replace it with "03" and the replace it with "34". These
+3 steps are combined into a single step, insert a "34".
+*/
+class GUI_API_EXPORT CharCommand : public QUndoCommand
+{
+public:
+ enum { Id = 1234 };
+ enum Cmd {insert, remove, replace};
+
+ CharCommand(XByteArray * xData, Cmd cmd, int charPos, char newChar,
+ QUndoCommand *parent=0);
+
+ void undo();
+ void redo();
+ bool mergeWith(const QUndoCommand *command);
+ int id() const { return Id; }
+
+private:
+ XByteArray * _xData;
+ int _charPos;
+ bool _wasChanged;
+ char _newChar;
+ char _oldChar;
+ Cmd _cmd;
+};
+
+/*! ArrayCommand provides undo/redo functionality for handling binary strings. It
+can undo/redo insert, replace and remove binary strins (QByteArrays).
+*/
+class GUI_API_EXPORT ArrayCommand : public QUndoCommand
+{
+public:
+ enum Cmd {insert, remove, replace};
+ ArrayCommand(XByteArray * xData, Cmd cmd, int baPos, QByteArray newBa=QByteArray(), int len=0,
+ QUndoCommand *parent=0);
+ void undo();
+ void redo();
+
+private:
+ Cmd _cmd;
+ XByteArray * _xData;
+ int _baPos;
+ int _len;
+ QByteArray _wasChanged;
+ QByteArray _newBa;
+ QByteArray _oldBa;
+};
+
+/** \endcond docNever */
+
+#endif // COMMANDS_H
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.cpp b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.cpp
new file mode 100644
index 0000000..b12624e
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.cpp
@@ -0,0 +1,180 @@
+#include <QtGui>
+
+#include "qhexedit.h"
+
+
+QHexEdit::QHexEdit(QWidget *parent) : QScrollArea(parent)
+{
+ qHexEdit_p = new QHexEditPrivate(this);
+ setWidget(qHexEdit_p);
+ setWidgetResizable(true);
+
+ connect(qHexEdit_p, SIGNAL(currentAddressChanged(int)), this, SIGNAL(currentAddressChanged(int)));
+ connect(qHexEdit_p, SIGNAL(currentSizeChanged(int)), this, SIGNAL(currentSizeChanged(int)));
+ connect(qHexEdit_p, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));
+ connect(qHexEdit_p, SIGNAL(overwriteModeChanged(bool)), this, SIGNAL(overwriteModeChanged(bool)));
+ setFocusPolicy(Qt::NoFocus);
+}
+
+int QHexEdit::indexOf(const QByteArray & ba, int from) const
+{
+ return qHexEdit_p->indexOf(ba, from);
+}
+
+void QHexEdit::insert(int i, const QByteArray & ba)
+{
+ qHexEdit_p->insert(i, ba);
+}
+
+void QHexEdit::insert(int i, char ch)
+{
+ qHexEdit_p->insert(i, ch);
+}
+
+int QHexEdit::lastIndexOf(const QByteArray & ba, int from) const
+{
+ return qHexEdit_p->lastIndexOf(ba, from);
+}
+
+void QHexEdit::remove(int pos, int len)
+{
+ qHexEdit_p->remove(pos, len);
+}
+
+void QHexEdit::replace( int pos, int len, const QByteArray & after)
+{
+ qHexEdit_p->replace(pos, len, after);
+}
+
+QString QHexEdit::toReadableString()
+{
+ return qHexEdit_p->toRedableString();
+}
+
+QString QHexEdit::selectionToReadableString()
+{
+ return qHexEdit_p->selectionToReadableString();
+}
+
+void QHexEdit::setAddressArea(bool addressArea)
+{
+ qHexEdit_p->setAddressArea(addressArea);
+}
+
+void QHexEdit::redo()
+{
+ qHexEdit_p->redo();
+}
+
+void QHexEdit::undo()
+{
+ qHexEdit_p->undo();
+}
+
+void QHexEdit::setAddressWidth(int addressWidth)
+{
+ qHexEdit_p->setAddressWidth(addressWidth);
+}
+
+void QHexEdit::setAsciiArea(bool asciiArea)
+{
+ qHexEdit_p->setAsciiArea(asciiArea);
+}
+
+void QHexEdit::setHighlighting(bool mode)
+{
+ qHexEdit_p->setHighlighting(mode);
+}
+
+void QHexEdit::setAddressOffset(int offset)
+{
+ qHexEdit_p->setAddressOffset(offset);
+}
+
+int QHexEdit::addressOffset()
+{
+ return qHexEdit_p->addressOffset();
+}
+
+void QHexEdit::setCursorPosition(int cursorPos)
+{
+ // cursorPos in QHexEditPrivate is the position of the textcoursor without
+ // blanks, means bytePos*2
+ qHexEdit_p->setCursorPos(cursorPos*2);
+}
+
+int QHexEdit::cursorPosition()
+{
+ return qHexEdit_p->cursorPos() / 2;
+}
+
+
+void QHexEdit::setData(const QByteArray &data)
+{
+ qHexEdit_p->setData(data);
+}
+
+QByteArray QHexEdit::data()
+{
+ return qHexEdit_p->data();
+}
+
+void QHexEdit::setAddressAreaColor(const QColor &color)
+{
+ qHexEdit_p->setAddressAreaColor(color);
+}
+
+QColor QHexEdit::addressAreaColor()
+{
+ return qHexEdit_p->addressAreaColor();
+}
+
+void QHexEdit::setHighlightingColor(const QColor &color)
+{
+ qHexEdit_p->setHighlightingColor(color);
+}
+
+QColor QHexEdit::highlightingColor()
+{
+ return qHexEdit_p->highlightingColor();
+}
+
+void QHexEdit::setSelectionColor(const QColor &color)
+{
+ qHexEdit_p->setSelectionColor(color);
+}
+
+QColor QHexEdit::selectionColor()
+{
+ return qHexEdit_p->selectionColor();
+}
+
+void QHexEdit::setOverwriteMode(bool overwriteMode)
+{
+ qHexEdit_p->setOverwriteMode(overwriteMode);
+}
+
+bool QHexEdit::overwriteMode()
+{
+ return qHexEdit_p->overwriteMode();
+}
+
+void QHexEdit::setReadOnly(bool readOnly)
+{
+ qHexEdit_p->setReadOnly(readOnly);
+}
+
+bool QHexEdit::isReadOnly()
+{
+ return qHexEdit_p->isReadOnly();
+}
+
+void QHexEdit::setFont(const QFont &font)
+{
+ qHexEdit_p->setFont(font);
+}
+
+const QFont & QHexEdit::font() const
+{
+ return qHexEdit_p->font();
+}
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.h b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.h
new file mode 100644
index 0000000..b2d707c
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit.h
@@ -0,0 +1,230 @@
+#ifndef QHEXEDIT_H
+#define QHEXEDIT_H
+
+#include "guiSQLiteStudio_global.h"
+#include <QtGui>
+#include <QHBoxLayout>
+#include "qhexedit_p.h"
+
+/*! QHexEdit is a hex editor widget written in C++ for the Qt (Qt4) 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.
+
+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().
+
+Normaly QHexEdit works in the overwrite Mode. You can set overwriteMode(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 delets
+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.
+
+This widget can only handle small amounts of data. The size has to be below 10
+megabytes, otherwise the scroll sliders ard not shown and you can't scroll any
+more.
+*/
+class GUI_API_EXPORT QHexEdit : public QScrollArea
+{
+ Q_OBJECT
+ /*! Property data holds the content of QHexEdit. Call setData() to set the
+ content of QHexEdit, data() returns the actual content.
+ */
+ Q_PROPERTY(QByteArray data READ data WRITE setData)
+
+ /*! Property addressOffset is added to the Numbers of the Address Area.
+ A offset in the address area (left side) is sometimes usefull, whe you show
+ only a segment of a complete memory picture. With setAddressOffset() you set
+ this property - with addressOffset() you get the actual value.
+ */
+ Q_PROPERTY(int addressOffset READ addressOffset WRITE setAddressOffset)
+
+ /*! Property address area color sets (setAddressAreaColor()) the backgorund
+ color of address areas. You can also read the color (addressaAreaColor()).
+ */
+ Q_PROPERTY(QColor addressAreaColor READ addressAreaColor WRITE setAddressAreaColor)
+
+ /*! Porperty cursorPosition sets or gets the position of the editor cursor
+ in QHexEdit.
+ */
+ Q_PROPERTY(int cursorPosition READ cursorPosition WRITE setCursorPosition)
+
+ /*! Property highlighting color sets (setHighlightingColor()) the backgorund
+ color of highlighted text areas. You can also read the color
+ (highlightingColor()).
+ */
+ Q_PROPERTY(QColor highlightingColor READ highlightingColor WRITE setHighlightingColor)
+
+ /*! Property selection color sets (setSelectionColor()) the backgorund
+ color of selected text areas. You can also read the color
+ (selectionColor()).
+ */
+ Q_PROPERTY(QColor selectionColor READ selectionColor WRITE setSelectionColor)
+
+ /*! Porperty 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)
+
+ /*! Porperty 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);
+
+ /*! Returns the index position of the first occurrence
+ of the byte array ba in this byte array, searching forward from index position
+ from. Returns -1 if ba could not be found. In addition to this functionality
+ of QByteArray the cursorposition is set to the end of found bytearray and
+ it will be selected.
+
+ */
+ int indexOf(const QByteArray & ba, int from = 0) const;
+
+ /*! Inserts a byte array.
+ \param i Index position, where to insert
+ \param ba byte array, which is to insert
+ In overwrite mode, the existing data will be overwritten, in insertmode ba will be
+ inserted and size of data grows.
+ */
+ void insert(int i, const QByteArray & ba);
+
+ /*! Inserts a char.
+ \param i Index position, where to insert
+ \param ch Char, which is to insert
+ In overwrite mode, the existing data will be overwritten, in insertmode ba will be
+ inserted and size of data grows.
+ */
+ void insert(int i, char ch);
+
+ /*! Returns the index position of the last occurrence
+ of the byte array ba in this byte array, searching backwards from index position
+ from. Returns -1 if ba could not be found. In addition to this functionality
+ of QByteArray the cursorposition is set to the beginning of found bytearray and
+ it will be selected.
+
+ */
+ int lastIndexOf(const QByteArray & ba, int from = 0) const;
+
+ /*! Removes len bytes from the content.
+ \param pos Index position, where to remove
+ \param len Amount of bytes to remove
+ In overwrite mode, the existing bytes will be overwriten with 0x00.
+ */
+ void remove(int pos, int len=1);
+
+ /*! Replaces len bytes from index position pos with the byte array after.
+ */
+ void replace( int pos, int len, const QByteArray & after);
+
+ /*! Gives back a formatted image of the content of QHexEdit
+ */
+ QString toReadableString();
+
+ /*! Gives back a formatted image of the selected content of QHexEdit
+ */
+ QString selectionToReadableString();
+
+ /*! \cond docNever */
+ void setAddressOffset(int offset);
+ int addressOffset();
+ void setCursorPosition(int cusorPos);
+ int cursorPosition();
+ void setData(QByteArray const &data);
+ QByteArray data();
+ void setAddressAreaColor(QColor const &color);
+ QColor addressAreaColor();
+ void setHighlightingColor(QColor const &color);
+ QColor highlightingColor();
+ void setSelectionColor(QColor const &color);
+ QColor selectionColor();
+ void setOverwriteMode(bool);
+ bool overwriteMode();
+ void setReadOnly(bool);
+ bool isReadOnly();
+ const QFont &font() const;
+ void setFont(const QFont &);
+ /*! \endcond docNever */
+
+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();
+
+ /*! Set the minimum width of the address area.
+ \param addressWidth Width in characters.
+ */
+ void setAddressWidth(int addressWidth);
+
+ /*! Switch the address area on or off.
+ \param addressArea true (show it), false (hide it).
+ */
+ void setAddressArea(bool addressArea);
+
+ /*! Switch the ascii area on or off.
+ \param asciiArea true (show it), false (hide it).
+ */
+ void setAsciiArea(bool asciiArea);
+
+ /*! Switch the highlighting feature on or of.
+ \param mode true (show it), false (hide it).
+ */
+ void setHighlighting(bool mode);
+
+ /*! 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(int address);
+
+ /*! Contains the size of the data to edit. */
+ void currentSizeChanged(int size);
+
+ /*! The signal is emited every time, the data is changed. */
+ void dataChanged();
+
+ /*! The signal is emited every time, the overwrite mode is changed. */
+ void overwriteModeChanged(bool state);
+
+private:
+ /*! \cond docNever */
+ QHexEditPrivate *qHexEdit_p;
+ QHBoxLayout *layout;
+ QScrollArea *scrollArea;
+ /*! \endcond docNever */
+};
+
+#endif
+
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.cpp b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.cpp
new file mode 100644
index 0000000..3919c19
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.cpp
@@ -0,0 +1,883 @@
+#include <QtGui>
+#include <QApplication>
+
+#include "qhexedit_p.h"
+#include "commands.h"
+
+const int HEXCHARS_IN_LINE = 47;
+const int GAP_ADR_HEX = 10;
+const int GAP_HEX_ASCII = 16;
+const int BYTES_PER_LINE = 16;
+
+QHexEditPrivate::QHexEditPrivate(QScrollArea *parent) : QWidget(parent)
+{
+ _undoStack = new QUndoStack(this);
+
+ _scrollArea = parent;
+ setAddressWidth(4);
+ setAddressOffset(0);
+ setAddressArea(true);
+ setAsciiArea(true);
+ setHighlighting(true);
+ setOverwriteMode(true);
+ setReadOnly(false);
+ setAddressAreaColor(QColor(0xd4, 0xd4, 0xd4, 0xff));
+ setHighlightingColor(QColor(0xee, 0xee, 0x88, 0xff));
+ setSelectionColor(QColor(0x6d, 0x9e, 0xff, 0xff));
+ setFont(QFont("Courier", 10));
+
+ _size = 0;
+ resetSelection(0);
+
+ setFocusPolicy(Qt::StrongFocus);
+
+ connect(&_cursorTimer, SIGNAL(timeout()), this, SLOT(updateCursor()));
+ _cursorTimer.setInterval(500);
+ _cursorTimer.start();
+}
+
+void QHexEditPrivate::setAddressOffset(int offset)
+{
+ _xData.setAddressOffset(offset);
+ adjust();
+}
+
+int QHexEditPrivate::addressOffset()
+{
+ return _xData.addressOffset();
+}
+
+void QHexEditPrivate::setData(const QByteArray &data)
+{
+ _xData.setData(data);
+ _undoStack->clear();
+ adjust();
+ setCursorPos(0);
+}
+
+QByteArray QHexEditPrivate::data()
+{
+ return _xData.data();
+}
+
+void QHexEditPrivate::setAddressAreaColor(const QColor &color)
+{
+ _addressAreaColor = color;
+ update();
+}
+
+QColor QHexEditPrivate::addressAreaColor()
+{
+ return _addressAreaColor;
+}
+
+void QHexEditPrivate::setHighlightingColor(const QColor &color)
+{
+ _highlightingColor = color;
+ update();
+}
+
+QColor QHexEditPrivate::highlightingColor()
+{
+ return _highlightingColor;
+}
+
+void QHexEditPrivate::setSelectionColor(const QColor &color)
+{
+ _selectionColor = color;
+ update();
+}
+
+QColor QHexEditPrivate::selectionColor()
+{
+ return _selectionColor;
+}
+
+void QHexEditPrivate::setReadOnly(bool readOnly)
+{
+ _readOnly = readOnly;
+}
+
+bool QHexEditPrivate::isReadOnly()
+{
+ return _readOnly;
+}
+
+XByteArray & QHexEditPrivate::xData()
+{
+ return _xData;
+}
+
+int QHexEditPrivate::indexOf(const QByteArray & ba, int from)
+{
+ if (from > (_xData.data().length() - 1))
+ from = _xData.data().length() - 1;
+ int idx = _xData.data().indexOf(ba, from);
+ if (idx > -1)
+ {
+ int curPos = idx*2;
+ setCursorPos(curPos + ba.length()*2);
+ resetSelection(curPos);
+ setSelection(curPos + ba.length()*2);
+ ensureVisible();
+ }
+ return idx;
+}
+
+void QHexEditPrivate::insert(int index, const QByteArray & ba)
+{
+ if (ba.length() > 0)
+ {
+ if (_overwriteMode)
+ {
+ QUndoCommand *arrayCommand= new ArrayCommand(&_xData, ArrayCommand::replace, index, ba, ba.length());
+ _undoStack->push(arrayCommand);
+ emit dataChanged();
+ }
+ else
+ {
+ QUndoCommand *arrayCommand= new ArrayCommand(&_xData, ArrayCommand::insert, index, ba, ba.length());
+ _undoStack->push(arrayCommand);
+ emit dataChanged();
+ }
+ }
+}
+
+void QHexEditPrivate::insert(int index, char ch)
+{
+ QUndoCommand *charCommand = new CharCommand(&_xData, CharCommand::insert, index, ch);
+ _undoStack->push(charCommand);
+ emit dataChanged();
+}
+
+int QHexEditPrivate::lastIndexOf(const QByteArray & ba, int from)
+{
+ from -= ba.length();
+ if (from < 0)
+ from = 0;
+ int idx = _xData.data().lastIndexOf(ba, from);
+ if (idx > -1)
+ {
+ int curPos = idx*2;
+ setCursorPos(curPos);
+ resetSelection(curPos);
+ setSelection(curPos + ba.length()*2);
+ ensureVisible();
+ }
+ return idx;
+}
+
+void QHexEditPrivate::remove(int index, int len)
+{
+ if (len > 0)
+ {
+ if (len == 1)
+ {
+ if (_overwriteMode)
+ {
+ QUndoCommand *charCommand = new CharCommand(&_xData, CharCommand::replace, index, char(0));
+ _undoStack->push(charCommand);
+ emit dataChanged();
+ }
+ else
+ {
+ QUndoCommand *charCommand = new CharCommand(&_xData, CharCommand::remove, index, char(0));
+ _undoStack->push(charCommand);
+ emit dataChanged();
+ }
+ }
+ else
+ {
+ QByteArray ba = QByteArray(len, char(0));
+ if (_overwriteMode)
+ {
+ QUndoCommand *arrayCommand = new ArrayCommand(&_xData, ArrayCommand::replace, index, ba, ba.length());
+ _undoStack->push(arrayCommand);
+ emit dataChanged();
+ }
+ else
+ {
+ QUndoCommand *arrayCommand= new ArrayCommand(&_xData, ArrayCommand::remove, index, ba, len);
+ _undoStack->push(arrayCommand);
+ emit dataChanged();
+ }
+ }
+ }
+}
+
+void QHexEditPrivate::replace(int index, char ch)
+{
+ QUndoCommand *charCommand = new CharCommand(&_xData, CharCommand::replace, index, ch);
+ _undoStack->push(charCommand);
+ resetSelection();
+ emit dataChanged();
+}
+
+void QHexEditPrivate::replace(int index, const QByteArray & ba)
+{
+ QUndoCommand *arrayCommand= new ArrayCommand(&_xData, ArrayCommand::replace, index, ba, ba.length());
+ _undoStack->push(arrayCommand);
+ resetSelection();
+ emit dataChanged();
+}
+
+void QHexEditPrivate::replace(int pos, int len, const QByteArray &after)
+{
+ QUndoCommand *arrayCommand= new ArrayCommand(&_xData, ArrayCommand::replace, pos, after, len);
+ _undoStack->push(arrayCommand);
+ resetSelection();
+ emit dataChanged();
+}
+
+void QHexEditPrivate::setAddressArea(bool addressArea)
+{
+ _addressArea = addressArea;
+ adjust();
+
+ setCursorPos(_cursorPosition);
+}
+
+void QHexEditPrivate::setAddressWidth(int addressWidth)
+{
+ _xData.setAddressWidth(addressWidth);
+
+ setCursorPos(_cursorPosition);
+}
+
+void QHexEditPrivate::setAsciiArea(bool asciiArea)
+{
+ _asciiArea = asciiArea;
+ adjust();
+}
+
+void QHexEditPrivate::setFont(const QFont &font)
+{
+ QWidget::setFont(font);
+ adjust();
+}
+
+void QHexEditPrivate::setHighlighting(bool mode)
+{
+ _highlighting = mode;
+ update();
+}
+
+void QHexEditPrivate::setOverwriteMode(bool overwriteMode)
+{
+ _overwriteMode = overwriteMode;
+}
+
+bool QHexEditPrivate::overwriteMode()
+{
+ return _overwriteMode;
+}
+
+void QHexEditPrivate::redo()
+{
+ _undoStack->redo();
+ emit dataChanged();
+ setCursorPos(_cursorPosition);
+ update();
+}
+
+void QHexEditPrivate::undo()
+{
+ _undoStack->undo();
+ emit dataChanged();
+ setCursorPos(_cursorPosition);
+ update();
+}
+
+QString QHexEditPrivate::toRedableString()
+{
+ return _xData.toRedableString();
+}
+
+
+QString QHexEditPrivate::selectionToReadableString()
+{
+ return _xData.toRedableString(getSelectionBegin(), getSelectionEnd());
+}
+
+void QHexEditPrivate::keyPressEvent(QKeyEvent *event)
+{
+ int charX = (_cursorX - _xPosHex) / _charWidth;
+ int posX = (charX / 3) * 2 + (charX % 3);
+ int posBa = (_cursorY / _charHeight) * BYTES_PER_LINE + posX / 2;
+
+
+/*****************************************************************************/
+/* Cursor movements */
+/*****************************************************************************/
+
+ if (event->matches(QKeySequence::MoveToNextChar))
+ {
+ setCursorPos(_cursorPosition + 1);
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToPreviousChar))
+ {
+ setCursorPos(_cursorPosition - 1);
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToEndOfLine))
+ {
+ setCursorPos(_cursorPosition | (2 * BYTES_PER_LINE -1));
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToStartOfLine))
+ {
+ setCursorPos(_cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)));
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToPreviousLine))
+ {
+ setCursorPos(_cursorPosition - (2 * BYTES_PER_LINE));
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToNextLine))
+ {
+ setCursorPos(_cursorPosition + (2 * BYTES_PER_LINE));
+ resetSelection(_cursorPosition);
+ }
+
+ if (event->matches(QKeySequence::MoveToNextPage))
+ {
+ setCursorPos(_cursorPosition + (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE));
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToPreviousPage))
+ {
+ setCursorPos(_cursorPosition - (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE));
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToEndOfDocument))
+ {
+ setCursorPos(_xData.size() * 2);
+ resetSelection(_cursorPosition);
+ }
+ if (event->matches(QKeySequence::MoveToStartOfDocument))
+ {
+ setCursorPos(0);
+ resetSelection(_cursorPosition);
+ }
+
+/*****************************************************************************/
+/* Select commands */
+/*****************************************************************************/
+ if (event->matches(QKeySequence::SelectAll))
+ {
+ resetSelection(0);
+ setSelection(2*_xData.size() + 1);
+ }
+ if (event->matches(QKeySequence::SelectNextChar))
+ {
+ int pos = _cursorPosition + 1;
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectPreviousChar))
+ {
+ int pos = _cursorPosition - 1;
+ setSelection(pos);
+ setCursorPos(pos);
+ }
+ if (event->matches(QKeySequence::SelectEndOfLine))
+ {
+ int pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)) + (2 * BYTES_PER_LINE);
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectStartOfLine))
+ {
+ int pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE));
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectPreviousLine))
+ {
+ int pos = _cursorPosition - (2 * BYTES_PER_LINE);
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectNextLine))
+ {
+ int pos = _cursorPosition + (2 * BYTES_PER_LINE);
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+
+ if (event->matches(QKeySequence::SelectNextPage))
+ {
+ int pos = _cursorPosition + (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE);
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectPreviousPage))
+ {
+ int pos = _cursorPosition - (((_scrollArea->viewport()->height() / _charHeight) - 1) * 2 * BYTES_PER_LINE);
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectEndOfDocument))
+ {
+ int pos = _xData.size() * 2;
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+ if (event->matches(QKeySequence::SelectStartOfDocument))
+ {
+ int pos = 0;
+ setCursorPos(pos);
+ setSelection(pos);
+ }
+
+/*****************************************************************************/
+/* Edit Commands */
+/*****************************************************************************/
+if (!_readOnly)
+{
+ /* Hex input */
+ int key = int(event->text()[0].toLatin1()); // changed from toAscii() to toLatin() for Qt5 needs
+ if ((key>='0' && key<='9') || (key>='a' && key <= 'f'))
+ {
+ if (getSelectionBegin() != getSelectionEnd())
+ {
+ posBa = getSelectionBegin();
+ remove(posBa, getSelectionEnd() - posBa);
+ setCursorPos(2*posBa);
+ resetSelection(2*posBa);
+ }
+
+ // If insert mode, then insert a byte
+ if (_overwriteMode == false)
+ if ((charX % 3) == 0)
+ {
+ insert(posBa, char(0));
+ }
+
+ // Change content
+ if (_xData.size() > 0)
+ {
+ QByteArray hexValue = _xData.data().mid(posBa, 1).toHex();
+ if ((charX % 3) == 0)
+ hexValue[0] = key;
+ else
+ hexValue[1] = key;
+
+ replace(posBa, QByteArray().fromHex(hexValue)[0]);
+
+ setCursorPos(_cursorPosition + 1);
+ resetSelection(_cursorPosition);
+ }
+ }
+
+ /* Cut & Paste */
+ if (event->matches(QKeySequence::Cut))
+ {
+ QString result = QString();
+ for (int idx = getSelectionBegin(); idx < getSelectionEnd(); idx++)
+ {
+ result += _xData.data().mid(idx, 1).toHex() + " ";
+ if ((idx % 16) == 15)
+ result.append("\n");
+ }
+ remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
+ QClipboard *clipboard = QApplication::clipboard();
+ clipboard->setText(result);
+ setCursorPos(getSelectionBegin());
+ resetSelection(getSelectionBegin());
+ }
+
+ if (event->matches(QKeySequence::Paste))
+ {
+ QClipboard *clipboard = QApplication::clipboard();
+ QByteArray ba = QByteArray().fromHex(clipboard->text().toLatin1());
+ insert(_cursorPosition / 2, ba);
+ setCursorPos(_cursorPosition + 2 * ba.length());
+ resetSelection(getSelectionBegin());
+ }
+
+
+ /* Delete char */
+ if (event->matches(QKeySequence::Delete))
+ {
+ if (getSelectionBegin() != getSelectionEnd())
+ {
+ posBa = getSelectionBegin();
+ remove(posBa, getSelectionEnd() - posBa);
+ setCursorPos(2*posBa);
+ resetSelection(2*posBa);
+ }
+ else
+ {
+ if (_overwriteMode)
+ replace(posBa, char(0));
+ else
+ remove(posBa, 1);
+ }
+ }
+
+ /* Backspace */
+ if ((event->key() == Qt::Key_Backspace) && (event->modifiers() == Qt::NoModifier))
+ {
+ if (getSelectionBegin() != getSelectionEnd())
+ {
+ posBa = getSelectionBegin();
+ remove(posBa, getSelectionEnd() - posBa);
+ setCursorPos(2*posBa);
+ resetSelection(2*posBa);
+ }
+ else
+ {
+ if (posBa > 0)
+ {
+ if (_overwriteMode)
+ replace(posBa - 1, char(0));
+ else
+ remove(posBa - 1, 1);
+ setCursorPos(_cursorPosition - 2);
+ }
+ }
+ }
+
+ /* undo */
+ if (event->matches(QKeySequence::Undo))
+ {
+ undo();
+ }
+
+ /* redo */
+ if (event->matches(QKeySequence::Redo))
+ {
+ redo();
+ }
+
+ }
+
+ if (event->matches(QKeySequence::Copy))
+ {
+ QString result = QString();
+ for (int idx = getSelectionBegin(); idx < getSelectionEnd(); idx++)
+ {
+ result += _xData.data().mid(idx, 1).toHex() + " ";
+ if ((idx % 16) == 15)
+ result.append('\n');
+ }
+ QClipboard *clipboard = QApplication::clipboard();
+ clipboard->setText(result);
+ }
+
+ // Switch between insert/overwrite mode
+ if ((event->key() == Qt::Key_Insert) && (event->modifiers() == Qt::NoModifier))
+ {
+ _overwriteMode = !_overwriteMode;
+ setCursorPos(_cursorPosition);
+ overwriteModeChanged(_overwriteMode);
+ }
+
+ ensureVisible();
+ update();
+}
+
+void QHexEditPrivate::mouseMoveEvent(QMouseEvent * event)
+{
+ _blink = false;
+ update();
+ int actPos = cursorPos(event->pos());
+ setCursorPos(actPos);
+ setSelection(actPos);
+}
+
+void QHexEditPrivate::mousePressEvent(QMouseEvent * event)
+{
+ _blink = false;
+ update();
+ int cPos = cursorPos(event->pos());
+ resetSelection(cPos);
+ setCursorPos(cPos);
+}
+
+void QHexEditPrivate::paintEvent(QPaintEvent *event)
+{
+ QPainter painter(this);
+
+ // draw some patterns if needed
+ painter.fillRect(event->rect(), this->palette().color(QPalette::Base));
+ if (_addressArea)
+ painter.fillRect(QRect(_xPosAdr, event->rect().top(), _xPosHex - GAP_ADR_HEX + 2, height()), _addressAreaColor);
+ if (_asciiArea)
+ {
+ int linePos = _xPosAscii - (GAP_HEX_ASCII / 2);
+ painter.setPen(Qt::gray);
+ painter.drawLine(linePos, event->rect().top(), linePos, height());
+ }
+
+ painter.setPen(this->palette().color(QPalette::WindowText));
+
+ // calc position
+ int firstLineIdx = ((event->rect().top()/ _charHeight) - _charHeight) * BYTES_PER_LINE;
+ if (firstLineIdx < 0)
+ firstLineIdx = 0;
+ int lastLineIdx = ((event->rect().bottom() / _charHeight) + _charHeight) * BYTES_PER_LINE;
+ if (lastLineIdx > _xData.size())
+ lastLineIdx = _xData.size();
+ int yPosStart = ((firstLineIdx) / BYTES_PER_LINE) * _charHeight + _charHeight;
+
+ // paint address area
+ if (_addressArea)
+ {
+ for (int lineIdx = firstLineIdx, yPos = yPosStart; lineIdx < lastLineIdx; lineIdx += BYTES_PER_LINE, yPos +=_charHeight)
+ {
+ QString address = QString("%1")
+ .arg(lineIdx + _xData.addressOffset(), _xData.realAddressNumbers(), 16, QChar('0'));
+ painter.drawText(_xPosAdr, yPos, address);
+ }
+ }
+
+ // paint hex area
+ QByteArray hexBa(_xData.data().mid(firstLineIdx, lastLineIdx - firstLineIdx + 1).toHex());
+ QBrush highLighted = QBrush(_highlightingColor);
+ QPen colHighlighted = QPen(this->palette().color(QPalette::WindowText));
+ QBrush selected = QBrush(_selectionColor);
+ QPen colSelected = QPen(Qt::white);
+ QPen colStandard = QPen(this->palette().color(QPalette::WindowText));
+ painter.setBackgroundMode(Qt::TransparentMode);
+
+ for (int lineIdx = firstLineIdx, yPos = yPosStart; lineIdx < lastLineIdx; lineIdx += BYTES_PER_LINE, yPos +=_charHeight)
+ {
+ QByteArray hex;
+ int xPos = _xPosHex;
+ for (int colIdx = 0; ((lineIdx + colIdx) < _xData.size() and (colIdx < BYTES_PER_LINE)); colIdx++)
+ {
+ int posBa = lineIdx + colIdx;
+ if ((getSelectionBegin() <= posBa) && (getSelectionEnd() > posBa))
+ {
+ painter.setBackground(selected);
+ painter.setBackgroundMode(Qt::OpaqueMode);
+ painter.setPen(colSelected);
+ }
+ else
+ {
+ if (_highlighting)
+ {
+ // hilight diff bytes
+ painter.setBackground(highLighted);
+ if (_xData.dataChanged(posBa))
+ {
+ painter.setPen(colHighlighted);
+ painter.setBackgroundMode(Qt::OpaqueMode);
+ }
+ else
+ {
+ painter.setPen(colStandard);
+ painter.setBackgroundMode(Qt::TransparentMode);
+ }
+ }
+ }
+
+ // render hex value
+ if (colIdx == 0)
+ {
+ hex = hexBa.mid((lineIdx - firstLineIdx) * 2, 2);
+ painter.drawText(xPos, yPos, hex);
+ xPos += 2 * _charWidth;
+ } else {
+ hex = hexBa.mid((lineIdx + colIdx - firstLineIdx) * 2, 2).prepend(" ");
+ painter.drawText(xPos, yPos, hex);
+ xPos += 3 * _charWidth;
+ }
+
+ }
+ }
+ painter.setBackgroundMode(Qt::TransparentMode);
+ painter.setPen(this->palette().color(QPalette::WindowText));
+
+ // paint ascii area
+ if (_asciiArea)
+ {
+ painter.setBackground(highLighted);
+ for (int lineIdx = firstLineIdx, yPos = yPosStart; lineIdx < lastLineIdx; lineIdx += BYTES_PER_LINE, yPos +=_charHeight)
+ {
+ int xPosAscii = _xPosAscii;
+ for (int colIdx = 0; ((lineIdx + colIdx) < _xData.size() and (colIdx < BYTES_PER_LINE)); colIdx++)
+ {
+ if (_cursorPosition/2 == (lineIdx + colIdx))
+ {
+ painter.setBackgroundMode(Qt::OpaqueMode);
+ painter.setPen(colHighlighted);
+ }
+ else
+ {
+ painter.setPen(colStandard);
+ painter.setBackgroundMode(Qt::TransparentMode);
+ }
+
+ painter.drawText(xPosAscii, yPos, _xData.asciiChar(lineIdx + colIdx));
+ xPosAscii += _charWidth;
+ }
+ }
+ }
+ painter.setBackgroundMode(Qt::TransparentMode);
+ painter.setPen(this->palette().color(QPalette::WindowText));
+
+ // paint cursor
+ if (_blink && !_readOnly && hasFocus())
+ {
+ if (_overwriteMode)
+ painter.fillRect(_cursorX, _cursorY + _charHeight - 2, _charWidth, 2, this->palette().color(QPalette::WindowText));
+ else
+ painter.fillRect(_cursorX, _cursorY, 2, _charHeight, this->palette().color(QPalette::WindowText));
+ }
+
+ if (_size != _xData.size())
+ {
+ _size = _xData.size();
+ emit currentSizeChanged(_size);
+ }
+}
+
+void QHexEditPrivate::setCursorPos(int position)
+{
+ // delete cursor
+ _blink = false;
+ update();
+
+ // cursor in range?
+ if (_overwriteMode)
+ {
+ if (position > (_xData.size() * 2 - 1))
+ position = _xData.size() * 2 - 1;
+ } else {
+ if (position > (_xData.size() * 2))
+ position = _xData.size() * 2;
+ }
+
+ if (position < 0)
+ position = 0;
+
+ // calc position
+ _cursorPosition = position;
+ _cursorY = (position / (2 * BYTES_PER_LINE)) * _charHeight + 4;
+ int x = (position % (2 * BYTES_PER_LINE));
+ _cursorX = (((x / 2) * 3) + (x % 2)) * _charWidth + _xPosHex;
+
+ // immiadately draw cursor
+ _blink = true;
+ update();
+ emit currentAddressChanged(_cursorPosition/2);
+}
+
+int QHexEditPrivate::cursorPos(QPoint pos)
+{
+ int result = -1;
+ // find char under cursor
+ if ((pos.x() >= _xPosHex) and (pos.x() < (_xPosHex + HEXCHARS_IN_LINE * _charWidth)))
+ {
+ int x = (pos.x() - _xPosHex) / _charWidth;
+ if ((x % 3) == 0)
+ x = (x / 3) * 2;
+ else
+ x = ((x / 3) * 2) + 1;
+ int y = ((pos.y() - 3) / _charHeight) * 2 * BYTES_PER_LINE;
+ result = x + y;
+ }
+ return result;
+}
+
+int QHexEditPrivate::cursorPos()
+{
+ return _cursorPosition;
+}
+
+void QHexEditPrivate::resetSelection()
+{
+ _selectionBegin = _selectionInit;
+ _selectionEnd = _selectionInit;
+}
+
+void QHexEditPrivate::resetSelection(int pos)
+{
+ if (pos < 0)
+ pos = 0;
+ pos = pos / 2;
+ _selectionInit = pos;
+ _selectionBegin = pos;
+ _selectionEnd = pos;
+}
+
+void QHexEditPrivate::setSelection(int pos)
+{
+ if (pos < 0)
+ pos = 0;
+ pos = pos / 2;
+ if (pos >= _selectionInit)
+ {
+ _selectionEnd = pos;
+ _selectionBegin = _selectionInit;
+ }
+ else
+ {
+ _selectionBegin = pos;
+ _selectionEnd = _selectionInit;
+ }
+}
+
+int QHexEditPrivate::getSelectionBegin()
+{
+ return _selectionBegin;
+}
+
+int QHexEditPrivate::getSelectionEnd()
+{
+ return _selectionEnd;
+}
+
+QSize QHexEditPrivate::sizeHint() const
+{
+ int wd = _xPosAscii + BYTES_PER_LINE * _charWidth;
+ int hg = _charHeight * 8;
+ if (!_asciiArea)
+ wd = _xPosHex + HEXCHARS_IN_LINE * _charWidth;
+
+ return QSize(wd, hg);
+}
+
+
+void QHexEditPrivate::updateCursor()
+{
+ if (_blink)
+ _blink = false;
+ else
+ _blink = true;
+ update(_cursorX, _cursorY, _charWidth, _charHeight);
+}
+
+void QHexEditPrivate::adjust()
+{
+ _charWidth = fontMetrics().width(QLatin1Char('9'));
+ _charHeight = fontMetrics().height();
+
+ _xPosAdr = 0;
+ if (_addressArea)
+ _xPosHex = _xData.realAddressNumbers()*_charWidth + GAP_ADR_HEX;
+ else
+ _xPosHex = 0;
+ _xPosAscii = _xPosHex + HEXCHARS_IN_LINE * _charWidth + GAP_HEX_ASCII;
+
+ // tell QAbstractScollbar, how big we are
+ setMinimumHeight(((_xData.size()/16 + 1) * _charHeight) + 5);
+ if(_asciiArea)
+ setMinimumWidth(_xPosAscii + (BYTES_PER_LINE * _charWidth));
+ else
+ setMinimumWidth(_xPosHex + HEXCHARS_IN_LINE * _charWidth);
+
+ update();
+}
+
+void QHexEditPrivate::ensureVisible()
+{
+ // scrolls to cursorx, cusory (which are set by setCursorPos)
+ // x-margin is 3 pixels, y-margin is half of charHeight
+ _scrollArea->ensureVisible(_cursorX, _cursorY + _charHeight/2, 3, _charHeight/2 + 2);
+}
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.h b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.h
new file mode 100644
index 0000000..b9c17d0
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/qhexedit_p.h
@@ -0,0 +1,129 @@
+#ifndef QHEXEDIT_P_H
+#define QHEXEDIT_P_H
+
+/** \cond docNever */
+
+
+#include <QtGui>
+#include <QScrollArea>
+#include <QUndoStack>
+#include "xbytearray.h"
+
+class QHexEditPrivate : public QWidget
+{
+Q_OBJECT
+
+public:
+ explicit QHexEditPrivate(QScrollArea *parent);
+
+ void setAddressAreaColor(QColor const &color);
+ QColor addressAreaColor();
+
+ void setAddressOffset(int offset);
+ int addressOffset();
+
+ void setCursorPos(int position);
+ int cursorPos();
+
+ void setData(QByteArray const &data);
+ QByteArray data();
+
+ void setHighlightingColor(QColor const &color);
+ QColor highlightingColor();
+
+ void setOverwriteMode(bool overwriteMode);
+ bool overwriteMode();
+
+ void setReadOnly(bool readOnly);
+ bool isReadOnly();
+
+ void setSelectionColor(QColor const &color);
+ QColor selectionColor();
+
+ XByteArray & xData();
+
+ int indexOf(const QByteArray & ba, int from = 0);
+ void insert(int index, const QByteArray & ba);
+ void insert(int index, char ch);
+ int lastIndexOf(const QByteArray & ba, int from = 0);
+ void remove(int index, int len=1);
+ void replace(int index, char ch);
+ void replace(int index, const QByteArray & ba);
+ void replace(int pos, int len, const QByteArray & after);
+
+ void setAddressArea(bool addressArea);
+ void setAddressWidth(int addressWidth);
+ void setAsciiArea(bool asciiArea);
+ void setHighlighting(bool mode);
+ virtual void setFont(const QFont &font);
+
+ void undo();
+ void redo();
+
+ QString toRedableString();
+ QString selectionToReadableString();
+
+ QSize sizeHint() const;
+
+signals:
+ void currentAddressChanged(int address);
+ void currentSizeChanged(int size);
+ void dataChanged();
+ void overwriteModeChanged(bool state);
+
+protected:
+ void keyPressEvent(QKeyEvent * event);
+ void mouseMoveEvent(QMouseEvent * event);
+ void mousePressEvent(QMouseEvent * event);
+
+ void paintEvent(QPaintEvent *event);
+
+ int cursorPos(QPoint pos); // calc cursorpos from graphics position. DOES NOT STORE POSITION
+
+ void resetSelection(int pos); // set selectionStart and selectionEnd to pos
+ void resetSelection(); // set selectionEnd to selectionStart
+ void setSelection(int pos); // set min (if below init) or max (if greater init)
+ int getSelectionBegin();
+ int getSelectionEnd();
+
+
+private slots:
+ void updateCursor();
+
+private:
+ void adjust();
+ void ensureVisible();
+
+ QColor _addressAreaColor;
+ QColor _highlightingColor;
+ QColor _selectionColor;
+ QScrollArea *_scrollArea;
+ QTimer _cursorTimer;
+ QUndoStack *_undoStack;
+
+ XByteArray _xData; // Hält den Inhalt des Hex Editors
+
+ bool _blink; // true: then cursor blinks
+ bool _renderingRequired; // Flag to store that rendering is necessary
+ bool _addressArea; // left area of QHexEdit
+ bool _asciiArea; // medium area
+ bool _highlighting; // highlighting of changed bytes
+ bool _overwriteMode;
+ bool _readOnly; // true: the user can only look and navigate
+
+ int _charWidth, _charHeight; // char dimensions (dpendend on font)
+ int _cursorX, _cursorY; // graphics position of the cursor
+ int _cursorPosition; // character positioin in stream (on byte ends in to steps)
+ int _xPosAdr, _xPosHex, _xPosAscii; // graphics x-position of the areas
+
+ int _selectionBegin; // First selected char
+ int _selectionEnd; // Last selected char
+ int _selectionInit; // That's, where we pressed the mouse button
+
+ int _size;
+};
+
+/** \endcond docNever */
+
+#endif
+
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.cpp b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.cpp
new file mode 100644
index 0000000..ec8bf3d
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.cpp
@@ -0,0 +1,167 @@
+#include "xbytearray.h"
+
+XByteArray::XByteArray()
+{
+ _oldSize = -99;
+ _addressNumbers = 4;
+ _addressOffset = 0;
+
+}
+
+int XByteArray::addressOffset()
+{
+ return _addressOffset;
+}
+
+void XByteArray::setAddressOffset(int offset)
+{
+ _addressOffset = offset;
+}
+
+int XByteArray::addressWidth()
+{
+ return _addressNumbers;
+}
+
+void XByteArray::setAddressWidth(int width)
+{
+ if ((width >= 0) and (width<=6))
+ {
+ _addressNumbers = width;
+ }
+}
+
+QByteArray & XByteArray::data()
+{
+ return _data;
+}
+
+void XByteArray::setData(QByteArray data)
+{
+ _data = data;
+ _changedData = QByteArray(data.length(), char(0));
+}
+
+bool XByteArray::dataChanged(int i)
+{
+ return bool(_changedData[i]);
+}
+
+QByteArray XByteArray::dataChanged(int i, int len)
+{
+ return _changedData.mid(i, len);
+}
+
+void XByteArray::setDataChanged(int i, bool state)
+{
+ _changedData[i] = char(state);
+}
+
+void XByteArray::setDataChanged(int i, const QByteArray & state)
+{
+ int length = state.length();
+ int len;
+ if ((i + length) > _changedData.length())
+ len = _changedData.length() - i;
+ else
+ len = length;
+ _changedData.replace(i, len, state);
+}
+
+int XByteArray::realAddressNumbers()
+{
+ if (_oldSize != _data.size())
+ {
+ // is addressNumbers wide enought?
+ QString test = QString("%1")
+ .arg(_data.size() + _addressOffset, _addressNumbers, 16, QChar('0'));
+ _realAddressNumbers = test.size();
+ }
+ return _realAddressNumbers;
+}
+
+int XByteArray::size()
+{
+ return _data.size();
+}
+
+QByteArray & XByteArray::insert(int i, char ch)
+{
+ _data.insert(i, ch);
+ _changedData.insert(i, char(1));
+ return _data;
+}
+
+QByteArray & XByteArray::insert(int i, const QByteArray & ba)
+{
+ _data.insert(i, ba);
+ _changedData.insert(i, QByteArray(ba.length(), char(1)));
+ return _data;
+}
+
+QByteArray & XByteArray::remove(int i, int len)
+{
+ _data.remove(i, len);
+ _changedData.remove(i, len);
+ return _data;
+}
+
+QByteArray & XByteArray::replace(int index, char ch)
+{
+ _data[index] = ch;
+ _changedData[index] = char(1);
+ return _data;
+}
+
+QByteArray & XByteArray::replace(int index, const QByteArray & ba)
+{
+ int len = ba.length();
+ return replace(index, len, ba);
+}
+
+QByteArray & XByteArray::replace(int index, int length, const QByteArray & ba)
+{
+ int len;
+ if ((index + length) > _data.length())
+ len = _data.length() - index;
+ else
+ len = length;
+ _data.replace(index, len, ba.mid(0, len));
+ _changedData.replace(index, len, QByteArray(len, char(1)));
+ return _data;
+}
+
+QChar XByteArray::asciiChar(int index)
+{
+ char ch = _data[index];
+ if ((ch < 0x20) or (ch > 0x7e))
+ ch = '.';
+ return QChar(ch);
+}
+
+QString XByteArray::toRedableString(int start, int end)
+{
+ int adrWidth = realAddressNumbers();
+ if (_addressNumbers > adrWidth)
+ adrWidth = _addressNumbers;
+ if (end < 0)
+ end = _data.size();
+
+ QString result;
+ for (int i=start; i < end; i += 16)
+ {
+ QString adrStr = QString("%1").arg(_addressOffset + i, adrWidth, 16, QChar('0'));
+ QString hexStr;
+ QString ascStr;
+ for (int j=0; j<16; j++)
+ {
+ if ((i + j) < _data.size())
+ {
+ hexStr.append(" ").append(_data.mid(i+j, 1).toHex());
+ ascStr.append(asciiChar(i+j));
+ }
+ }
+ result += adrStr + " " + QString("%1").arg(hexStr, -48) + " " + QString("%1").arg(ascStr, -17) + "\n";
+ }
+ return result;
+}
diff --git a/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.h b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.h
new file mode 100644
index 0000000..a5cdc11
--- /dev/null
+++ b/SQLiteStudio3/guiSQLiteStudio/qhexedit2/xbytearray.h
@@ -0,0 +1,67 @@
+#ifndef XBYTEARRAY_H
+#define XBYTEARRAY_H
+
+/** \cond docNever */
+
+#include "guiSQLiteStudio_global.h"
+#include <QtCore>
+
+/*! XByteArray represents the content of QHexEcit.
+XByteArray comprehend the data itself and informations to store if it was
+changed. The QHexEdit component uses these informations to perform nice
+rendering of the data
+
+XByteArray also provides some functionality to insert, replace and remove
+single chars and QByteArras. Additionally some functions support rendering
+and converting to readable strings.
+*/
+class GUI_API_EXPORT XByteArray
+{
+public:
+ explicit XByteArray();
+
+ int addressOffset();
+ void setAddressOffset(int offset);
+
+ int addressWidth();
+ void setAddressWidth(int width);
+
+ QByteArray & data();
+ void setData(QByteArray data);
+
+ bool dataChanged(int i);
+ QByteArray dataChanged(int i, int len);
+ void setDataChanged(int i, bool state);
+ void setDataChanged(int i, const QByteArray & state);
+
+ int realAddressNumbers();
+ int size();
+
+ QByteArray & insert(int i, char ch);
+ QByteArray & insert(int i, const QByteArray & ba);
+
+ QByteArray & remove(int pos, int len);
+
+ QByteArray & replace(int index, char ch);
+ QByteArray & replace(int index, const QByteArray & ba);
+ QByteArray & replace(int index, int length, const QByteArray & ba);
+
+ QChar asciiChar(int index);
+ QString toRedableString(int start=0, int end=-1);
+
+signals:
+
+public slots:
+
+private:
+ QByteArray _data;
+ QByteArray _changedData;
+
+ int _addressNumbers; // wanted width of address area
+ int _addressOffset; // will be added to the real addres inside bytearray
+ int _realAddressNumbers; // real width of address area (can be greater then wanted width)
+ int _oldSize; // size of data
+};
+
+/** \endcond docNever */
+#endif // XBYTEARRAY_H
generated by cgit v1.2.3 (git 2.46.0) at 2026-01-26 22:49:38 +0000