mirror of
https://github.com/LongSoft/UEFITool.git
synced 2024-11-24 08:58:23 +08:00
NE Alpha 38
This commit is contained in:
Cr4sh
parent
f410b0f969
commit
0e09dfe1b2
@ -18,8 +18,8 @@ SET(PROJECT_SOURCES
|
||||
../common/LZMA/SDK/C/LzmaDec.c
|
||||
../common/Tiano/EfiTianoDecompress.c
|
||||
../common/ustring.cpp
|
||||
../bstrlib/bstrlib.c
|
||||
../bstrlib/bstrwrap.cpp
|
||||
../common/bstrlib/bstrlib.c
|
||||
../common/bstrlib/bstrwrap.cpp
|
||||
)
|
||||
|
||||
SET(PROJECT_HEADERS
|
||||
@ -43,8 +43,8 @@ SET(PROJECT_HEADERS
|
||||
../common/Tiano/EfiTianoDecompress.h
|
||||
../common/ubytearray.h
|
||||
../common/ustring.h
|
||||
../bstrlib/bstrlib.h
|
||||
../bstrlib/bstrwrap.h
|
||||
../common/bstrlib/bstrlib.h
|
||||
../common/bstrlib/bstrwrap.h
|
||||
)
|
||||
|
||||
ADD_DEFINITIONS(-DU_ENABLE_NVRAM_PARSING_SUPPORT)
|
||||
|
||||
@ -29,7 +29,7 @@ int main(int argc, char *argv[])
|
||||
return (uefidumper.dump(buffer, UString(argv[1])) != U_SUCCESS);
|
||||
}
|
||||
|
||||
std::cout << "UEFIDump 0.1.3" << std::endl << std::endl
|
||||
std::cout << "UEFIDump 0.1.4" << std::endl << std::endl
|
||||
<< "Usage: UEFIDump imagefile" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -121,7 +121,7 @@ int main(int argc, char *argv[])
|
||||
}
|
||||
}
|
||||
// If parameters are different, show version and usage information
|
||||
std::cout << "UEFIExtract 0.13.2" << std::endl << std::endl
|
||||
std::cout << "UEFIExtract 0.13.3" << std::endl << std::endl
|
||||
<< "Usage: UEFIExtract imagefile - generate report and dump only leaf tree items into .dump folder." << std::endl
|
||||
<< " UEFIExtract imagefile all - generate report and dump all tree items." << std::endl
|
||||
<< " UEFIExtract imagefile dump - only generate dump, no report needed." << std::endl
|
||||
|
||||
@ -148,7 +148,7 @@ int main(int argc, char *argv[])
|
||||
return U_SUCCESS;
|
||||
}
|
||||
else {
|
||||
std::cout << "UEFIFind 0.10.6" << std::endl << std::endl <<
|
||||
std::cout << "UEFIFind 0.10.7" << std::endl << std::endl <<
|
||||
"Usage: UEFIFind {header | body | all} {list | count} pattern imagefile" << std::endl <<
|
||||
" or UEFIFind file patternsfile imagefile" << std::endl;
|
||||
return U_INVALID_PARAMETER;
|
||||
|
||||
@ -61,25 +61,13 @@
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QSpinBox" name="hexSpinBox">
|
||||
<widget class="HexSpinBox" name="hexSpinBox">
|
||||
<property name="sizePolicy">
|
||||
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
|
||||
<horstretch>0</horstretch>
|
||||
<verstretch>0</verstretch>
|
||||
</sizepolicy>
|
||||
</property>
|
||||
<property name="suffix">
|
||||
<string/>
|
||||
</property>
|
||||
<property name="prefix">
|
||||
<string>0x</string>
|
||||
</property>
|
||||
<property name="maximum">
|
||||
<number>1000000000</number>
|
||||
</property>
|
||||
<property name="displayIntegerBase">
|
||||
<number>16</number>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
@ -97,6 +85,13 @@
|
||||
</item>
|
||||
</layout>
|
||||
</widget>
|
||||
<customwidgets>
|
||||
<customwidget>
|
||||
<class>HexSpinBox</class>
|
||||
<extends>QSpinBox</extends>
|
||||
<header>hexspinbox.h</header>
|
||||
</customwidget>
|
||||
</customwidgets>
|
||||
<tabstops>
|
||||
<tabstop>buttonBox</tabstop>
|
||||
</tabstops>
|
||||
|
||||
37
UEFITool/hexspinbox.cpp
Normal file
37
UEFITool/hexspinbox.cpp
Normal file
@ -0,0 +1,37 @@
|
||||
/* hexspinbox.cpp
|
||||
|
||||
Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
*/
|
||||
|
||||
#include "hexspinbox.h"
|
||||
#include <QDebug>
|
||||
|
||||
HexSpinBox::HexSpinBox(QWidget *parent) :
|
||||
QSpinBox(parent), validator(QRegExp("0x([0-9a-fA-F]){1,8}"))
|
||||
{
|
||||
this->setRange(0, INT_MAX);
|
||||
this->setPrefix("0x");
|
||||
}
|
||||
|
||||
QValidator::State HexSpinBox::validate(QString &text, int &pos) const
|
||||
{
|
||||
return validator.validate(text, pos);
|
||||
}
|
||||
|
||||
QString HexSpinBox::textFromValue(int val) const
|
||||
{
|
||||
return QString::number(val, 16).toUpper();
|
||||
}
|
||||
|
||||
int HexSpinBox::valueFromText(const QString &text) const
|
||||
{
|
||||
return text.toInt(NULL, 16);
|
||||
}
|
||||
36
UEFITool/hexspinbox.h
Normal file
36
UEFITool/hexspinbox.h
Normal file
@ -0,0 +1,36 @@
|
||||
/* hexspinbox.h
|
||||
|
||||
Copyright (c) 2016, Nikolaj Schlej. All rights reserved.
|
||||
This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef HEXSPINBOX_H
|
||||
#define HEXSPINBOX_H
|
||||
|
||||
#include <QSpinBox>
|
||||
#include <QRegExpValidator>
|
||||
|
||||
class HexSpinBox : public QSpinBox
|
||||
{
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
HexSpinBox(QWidget *parent = 0);
|
||||
|
||||
protected:
|
||||
QValidator::State validate(QString &text, int &pos) const;
|
||||
int valueFromText(const QString &text) const;
|
||||
QString textFromValue(int value) const;
|
||||
|
||||
private:
|
||||
QRegExpValidator validator;
|
||||
};
|
||||
|
||||
#endif // HEXSPINBOX_H
|
||||
@ -16,7 +16,7 @@
|
||||
|
||||
#include <QDialog>
|
||||
#include "../common/treemodel.h"
|
||||
#include "../qhexedit2/qhexedit.h"
|
||||
#include "qhexedit2/qhexedit.h"
|
||||
#include "ui_hexviewdialog.h"
|
||||
|
||||
class HexViewDialog : public QDialog
|
||||
|
||||
323
UEFITool/qhexedit2/chunks.cpp
Normal file
323
UEFITool/qhexedit2/chunks.cpp
Normal file
@ -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)[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
|
||||
77
UEFITool/qhexedit2/chunks.h
Normal file
77
UEFITool/qhexedit2/chunks.h
Normal file
@ -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
|
||||
165
UEFITool/qhexedit2/commands.cpp
Normal file
165
UEFITool/qhexedit2/commands.cpp
Normal file
@ -0,0 +1,165 @@
|
||||
#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;
|
||||
_newChar = newChar;
|
||||
_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;
|
||||
}
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
47
UEFITool/qhexedit2/commands.h
Normal file
47
UEFITool/qhexedit2/commands.h
Normal file
@ -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 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", 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
|
||||
502
UEFITool/qhexedit2/license.txt
Normal file
502
UEFITool/qhexedit2/license.txt
Normal file
@ -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!
|
||||
1085
UEFITool/qhexedit2/qhexedit.cpp
Normal file
1085
UEFITool/qhexedit2/qhexedit.cpp
Normal file
File diff suppressed because it is too large
Load Diff
411
UEFITool/qhexedit2/qhexedit.h
Normal file
411
UEFITool/qhexedit2/qhexedit.h
Normal file
@ -0,0 +1,411 @@
|
||||
#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.2
|
||||
\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().
|
||||
|
||||
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.
|
||||
|
||||
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 backgorund
|
||||
color of address areas. You can also read the color (addressaAreaColor()).
|
||||
*/
|
||||
Q_PROPERTY(QColor addressAreaColor READ addressAreaColor WRITE setAddressAreaColor)
|
||||
|
||||
/*! 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 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)
|
||||
|
||||
/*! Porperty cursorPosition sets or gets the position of the editor cursor
|
||||
in QHexEdit. Every byte in data has to 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)
|
||||
|
||||
/*! 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 backgorund
|
||||
color of highlighted text areas. You can also read the color
|
||||
(highlightingColor()).
|
||||
*/
|
||||
Q_PROPERTY(QColor highlightingColor READ highlightingColor WRITE setHighlightingColor)
|
||||
|
||||
/*! 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)
|
||||
|
||||
/*! 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)
|
||||
|
||||
/*! 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)
|
||||
|
||||
/*! Property upperCase sets (setUpperCase()) or gets (isUpperCase) the case of hex
|
||||
data. Default is lowercase.
|
||||
*/
|
||||
Q_PROPERTY(bool upperCase READ isUpperCase WRITE setUpperCase)
|
||||
|
||||
/*! 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 opend 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 functioins
|
||||
/*! Calc cursor position from graphics position
|
||||
* \param point from where the cursor position should be calculated
|
||||
* \return Cursor postioin
|
||||
*/
|
||||
qint64 cursorPosition(QPoint point);
|
||||
|
||||
/*! Ensure the cursor to be visble
|
||||
*/
|
||||
void ensureVisible();
|
||||
|
||||
/*! Find first occurence 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 occurence 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();
|
||||
|
||||
/*! 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);
|
||||
|
||||
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);
|
||||
|
||||
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);
|
||||
|
||||
bool isUpperCase();
|
||||
void setUpperCase(bool upperCase);
|
||||
|
||||
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)
|
||||
int getSelectionBegin();
|
||||
int 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 (dpendend 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;
|
||||
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 _upperCase;
|
||||
|
||||
// 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
|
||||
@ -18,7 +18,7 @@
|
||||
UEFITool::UEFITool(QWidget *parent) :
|
||||
QMainWindow(parent),
|
||||
ui(new Ui::UEFITool),
|
||||
version(tr("NE Alpha 37"))
|
||||
version(tr("NE Alpha 38"))
|
||||
{
|
||||
clipboard = QApplication::clipboard();
|
||||
|
||||
@ -327,6 +327,8 @@ void UEFITool::bodyHexView()
|
||||
|
||||
void UEFITool::goToOffset()
|
||||
{
|
||||
goToOffsetDialog->ui->hexSpinBox->setFocus();
|
||||
goToOffsetDialog->ui->hexSpinBox->selectAll();
|
||||
if (goToOffsetDialog->exec() != QDialog::Accepted)
|
||||
return;
|
||||
|
||||
@ -810,9 +812,7 @@ void UEFITool::openImageFile(QString path)
|
||||
delete ffsOps;
|
||||
ffsOps = new FfsOperations(model);
|
||||
|
||||
// Set max offset and enable goToOffset
|
||||
// FIXME: doesn't work properly
|
||||
//goToOffsetDialog->ui->hexSpinBox->setMaximum(buffer.size() - 1);
|
||||
// Enable goToOffset
|
||||
ui->actionGoToOffset->setEnabled(true);
|
||||
|
||||
// Enable or disable FIT tab
|
||||
@ -905,7 +905,7 @@ void UEFITool::showParserMessages()
|
||||
std::pair<QString, QModelIndex> msg;
|
||||
foreach (msg, messages) {
|
||||
QListWidgetItem* item = new QListWidgetItem(msg.first, NULL, 0);
|
||||
item->setData(Qt::UserRole, msg.second);
|
||||
item->setData(Qt::UserRole, QByteArray((const char*)&msg.second, sizeof(msg.second)));
|
||||
ui->parserMessagesListWidget->addItem(item);
|
||||
}
|
||||
|
||||
@ -923,7 +923,7 @@ void UEFITool::showFinderMessages()
|
||||
std::pair<QString, QModelIndex> msg;
|
||||
foreach (msg, messages) {
|
||||
QListWidgetItem* item = new QListWidgetItem(msg.first, NULL, 0);
|
||||
item->setData(Qt::UserRole, msg.second);
|
||||
item->setData(Qt::UserRole, QByteArray((const char*)&msg.second, sizeof(msg.second)));;
|
||||
ui->finderMessagesListWidget->addItem(item);
|
||||
}
|
||||
|
||||
@ -941,7 +941,7 @@ void UEFITool::showBuilderMessages()
|
||||
std::pair<QString, QModelIndex> msg;
|
||||
foreach (msg, messages) {
|
||||
QListWidgetItem* item = new QListWidgetItem(msg.first, NULL, 0);
|
||||
item->setData(Qt::UserRole, msg.second);
|
||||
item->setData(Qt::UserRole, QByteArray((const char*)&msg.second, sizeof(msg.second)));
|
||||
ui->builderMessagesListWidget->addItem(item);
|
||||
}
|
||||
|
||||
@ -951,19 +951,21 @@ void UEFITool::showBuilderMessages()
|
||||
|
||||
void UEFITool::scrollTreeView(QListWidgetItem* item)
|
||||
{
|
||||
QModelIndex index = item->data(Qt::UserRole).toModelIndex();
|
||||
if (index.isValid()) {
|
||||
ui->structureTreeView->scrollTo(index, QAbstractItemView::PositionAtCenter);
|
||||
ui->structureTreeView->selectionModel()->select(index, QItemSelectionModel::Select | QItemSelectionModel::Rows | QItemSelectionModel::Clear);
|
||||
QByteArray second = item->data(Qt::UserRole).toByteArray();
|
||||
QModelIndex *index = (QModelIndex *)second.data();
|
||||
if (index && index->isValid()) {
|
||||
ui->structureTreeView->scrollTo(*index, QAbstractItemView::PositionAtCenter);
|
||||
ui->structureTreeView->selectionModel()->select(*index, QItemSelectionModel::Select | QItemSelectionModel::Rows | QItemSelectionModel::Clear);
|
||||
}
|
||||
}
|
||||
|
||||
void UEFITool::scrollTreeView(QTableWidgetItem* item)
|
||||
{
|
||||
QModelIndex index = item->data(Qt::UserRole).toModelIndex();
|
||||
if (index.isValid()) {
|
||||
ui->structureTreeView->scrollTo(index, QAbstractItemView::PositionAtCenter);
|
||||
ui->structureTreeView->selectionModel()->select(index, QItemSelectionModel::Select | QItemSelectionModel::Rows | QItemSelectionModel::Clear);
|
||||
QByteArray second = item->data(Qt::UserRole).toByteArray();
|
||||
QModelIndex *index = (QModelIndex *)second.data();
|
||||
if (index && index->isValid()) {
|
||||
ui->structureTreeView->scrollTo(*index, QAbstractItemView::PositionAtCenter);
|
||||
ui->structureTreeView->selectionModel()->select(*index, QItemSelectionModel::Select | QItemSelectionModel::Rows | QItemSelectionModel::Clear);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1069,7 +1071,7 @@ void UEFITool::showFitTable()
|
||||
for (size_t i = 0; i < fitTable.size(); i++) {
|
||||
for (UINT8 j = 0; j < 6; j++) {
|
||||
QTableWidgetItem* item = new QTableWidgetItem(fitTable[i].first[j]);
|
||||
item->setData(Qt::UserRole, fitTable[i].second);
|
||||
item->setData(Qt::UserRole, QByteArray((const char*)&fitTable[i].second, sizeof(fitTable[i].second)));
|
||||
ui->fitTableWidget->setItem((int)i, j, item);
|
||||
}
|
||||
}
|
||||
|
||||
@ -11,6 +11,7 @@ HEADERS += uefitool.h \
|
||||
gotooffsetdialog.h \
|
||||
guidlineedit.h \
|
||||
ffsfinder.h \
|
||||
hexspinbox.h \
|
||||
../common/nvram.h \
|
||||
../common/nvramparser.h \
|
||||
../common/meparser.h \
|
||||
@ -35,9 +36,9 @@ HEADERS += uefitool.h \
|
||||
../common/Tiano/EfiTianoCompress.h \
|
||||
../common/ustring.h \
|
||||
../common/ubytearray.h \
|
||||
../qhexedit2/qhexedit.h \
|
||||
../qhexedit2/chunks.h \
|
||||
../qhexedit2/commands.h
|
||||
qhexedit2/qhexedit.h \
|
||||
qhexedit2/chunks.h \
|
||||
qhexedit2/commands.h
|
||||
|
||||
SOURCES += uefitool_main.cpp \
|
||||
uefitool.cpp \
|
||||
@ -45,6 +46,7 @@ SOURCES += uefitool_main.cpp \
|
||||
hexviewdialog.cpp \
|
||||
guidlineedit.cpp \
|
||||
ffsfinder.cpp \
|
||||
hexspinbox.cpp \
|
||||
../common/nvram.cpp \
|
||||
../common/nvramparser.cpp \
|
||||
../common/ffsops.cpp \
|
||||
@ -66,9 +68,9 @@ SOURCES += uefitool_main.cpp \
|
||||
../common/Tiano/EfiTianoCompress.c \
|
||||
../common/Tiano/EfiTianoCompressLegacy.c \
|
||||
../common/ustring.cpp \
|
||||
../qhexedit2/qhexedit.cpp \
|
||||
../qhexedit2/chunks.cpp \
|
||||
../qhexedit2/commands.cpp
|
||||
qhexedit2/qhexedit.cpp \
|
||||
qhexedit2/chunks.cpp \
|
||||
qhexedit2/commands.cpp
|
||||
|
||||
FORMS += uefitool.ui \
|
||||
searchdialog.ui \
|
||||
|
||||
28
common/bstrlib/LICENSE
Normal file
28
common/bstrlib/LICENSE
Normal file
@ -0,0 +1,28 @@
|
||||
Copyright (c) 2014, Paul Hsieh
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of bstrlib nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
3137
common/bstrlib/bstrlib.c
Normal file
3137
common/bstrlib/bstrlib.c
Normal file
File diff suppressed because it is too large
Load Diff
321
common/bstrlib/bstrlib.h
Normal file
321
common/bstrlib/bstrlib.h
Normal file
@ -0,0 +1,321 @@
|
||||
/*
|
||||
* This source file is part of the bstring string library. This code was
|
||||
* written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
|
||||
* license and the GPL. Refer to the accompanying documentation for details
|
||||
* on usage and license.
|
||||
*/
|
||||
|
||||
/*
|
||||
* bstrlib.h
|
||||
*
|
||||
* This file is the interface for the core bstring functions.
|
||||
*/
|
||||
|
||||
#ifndef BSTRLIB_INCLUDE
|
||||
#define BSTRLIB_INCLUDE
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <ctype.h>
|
||||
|
||||
#if !defined (BSTRLIB_VSNP_OK) && !defined (BSTRLIB_NOVSNP)
|
||||
# if defined (__TURBOC__) && !defined (__BORLANDC__)
|
||||
# define BSTRLIB_NOVSNP
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#define BSTR_ERR (-1)
|
||||
#define BSTR_OK (0)
|
||||
#define BSTR_BS_BUFF_LENGTH_GET (0)
|
||||
|
||||
typedef struct tagbstring * bstring;
|
||||
typedef const struct tagbstring * const_bstring;
|
||||
|
||||
/* Version */
|
||||
#define BSTR_VER_MAJOR 1
|
||||
#define BSTR_VER_MINOR 0
|
||||
#define BSTR_VER_UPDATE 0
|
||||
|
||||
/* Copy functions */
|
||||
#define cstr2bstr bfromcstr
|
||||
extern bstring bfromcstr (const char * str);
|
||||
extern bstring bfromcstralloc (int mlen, const char * str);
|
||||
extern bstring bfromcstrrangealloc (int minl, int maxl, const char* str);
|
||||
extern bstring blk2bstr (const void * blk, int len);
|
||||
extern char * bstr2cstr (const_bstring s, char z);
|
||||
extern int bcstrfree (char * s);
|
||||
extern bstring bstrcpy (const_bstring b1);
|
||||
extern int bassign (bstring a, const_bstring b);
|
||||
extern int bassignmidstr (bstring a, const_bstring b, int left, int len);
|
||||
extern int bassigncstr (bstring a, const char * str);
|
||||
extern int bassignblk (bstring a, const void * s, int len);
|
||||
|
||||
/* Destroy function */
|
||||
extern int bdestroy (bstring b);
|
||||
|
||||
/* Space allocation hinting functions */
|
||||
extern int balloc (bstring s, int len);
|
||||
extern int ballocmin (bstring b, int len);
|
||||
|
||||
/* Substring extraction */
|
||||
extern bstring bmidstr (const_bstring b, int left, int len);
|
||||
|
||||
/* Various standard manipulations */
|
||||
extern int bconcat (bstring b0, const_bstring b1);
|
||||
extern int bconchar (bstring b0, char c);
|
||||
extern int bcatcstr (bstring b, const char * s);
|
||||
extern int bcatblk (bstring b, const void * s, int len);
|
||||
extern int binsert (bstring s1, int pos, const_bstring s2, unsigned char fill);
|
||||
extern int binsertblk (bstring s1, int pos, const void * s2, int len, unsigned char fill);
|
||||
extern int binsertch (bstring s1, int pos, int len, unsigned char fill);
|
||||
extern int breplace (bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
|
||||
extern int bdelete (bstring s1, int pos, int len);
|
||||
extern int bsetstr (bstring b0, int pos, const_bstring b1, unsigned char fill);
|
||||
extern int btrunc (bstring b, int n);
|
||||
|
||||
/* Scan/search functions */
|
||||
extern int bstricmp (const_bstring b0, const_bstring b1);
|
||||
extern int bstrnicmp (const_bstring b0, const_bstring b1, int n);
|
||||
extern int biseqcaseless (const_bstring b0, const_bstring b1);
|
||||
extern int biseqcaselessblk (const_bstring b, const void * blk, int len);
|
||||
extern int bisstemeqcaselessblk (const_bstring b0, const void * blk, int len);
|
||||
extern int biseq (const_bstring b0, const_bstring b1);
|
||||
extern int biseqblk (const_bstring b, const void * blk, int len);
|
||||
extern int bisstemeqblk (const_bstring b0, const void * blk, int len);
|
||||
extern int biseqcstr (const_bstring b, const char * s);
|
||||
extern int biseqcstrcaseless (const_bstring b, const char * s);
|
||||
extern int bstrcmp (const_bstring b0, const_bstring b1);
|
||||
extern int bstrncmp (const_bstring b0, const_bstring b1, int n);
|
||||
extern int binstr (const_bstring s1, int pos, const_bstring s2);
|
||||
extern int binstrr (const_bstring s1, int pos, const_bstring s2);
|
||||
extern int binstrcaseless (const_bstring s1, int pos, const_bstring s2);
|
||||
extern int binstrrcaseless (const_bstring s1, int pos, const_bstring s2);
|
||||
extern int bstrchrp (const_bstring b, int c, int pos);
|
||||
extern int bstrrchrp (const_bstring b, int c, int pos);
|
||||
#define bstrchr(b,c) bstrchrp ((b), (c), 0)
|
||||
#define bstrrchr(b,c) bstrrchrp ((b), (c), blength(b)-1)
|
||||
extern int binchr (const_bstring b0, int pos, const_bstring b1);
|
||||
extern int binchrr (const_bstring b0, int pos, const_bstring b1);
|
||||
extern int bninchr (const_bstring b0, int pos, const_bstring b1);
|
||||
extern int bninchrr (const_bstring b0, int pos, const_bstring b1);
|
||||
extern int bfindreplace (bstring b, const_bstring find, const_bstring repl, int pos);
|
||||
extern int bfindreplacecaseless (bstring b, const_bstring find, const_bstring repl, int pos);
|
||||
|
||||
/* List of string container functions */
|
||||
struct bstrList {
|
||||
int qty, mlen;
|
||||
bstring * entry;
|
||||
};
|
||||
extern struct bstrList * bstrListCreate (void);
|
||||
extern int bstrListDestroy (struct bstrList * sl);
|
||||
extern int bstrListAlloc (struct bstrList * sl, int msz);
|
||||
extern int bstrListAllocMin (struct bstrList * sl, int msz);
|
||||
|
||||
/* String split and join functions */
|
||||
extern struct bstrList * bsplit (const_bstring str, unsigned char splitChar);
|
||||
extern struct bstrList * bsplits (const_bstring str, const_bstring splitStr);
|
||||
extern struct bstrList * bsplitstr (const_bstring str, const_bstring splitStr);
|
||||
extern bstring bjoin (const struct bstrList * bl, const_bstring sep);
|
||||
extern bstring bjoinblk (const struct bstrList * bl, const void * s, int len);
|
||||
extern int bsplitcb (const_bstring str, unsigned char splitChar, int pos,
|
||||
int (* cb) (void * parm, int ofs, int len), void * parm);
|
||||
extern int bsplitscb (const_bstring str, const_bstring splitStr, int pos,
|
||||
int (* cb) (void * parm, int ofs, int len), void * parm);
|
||||
extern int bsplitstrcb (const_bstring str, const_bstring splitStr, int pos,
|
||||
int (* cb) (void * parm, int ofs, int len), void * parm);
|
||||
|
||||
/* Miscellaneous functions */
|
||||
extern int bpattern (bstring b, int len);
|
||||
extern int btoupper (bstring b);
|
||||
extern int btolower (bstring b);
|
||||
extern int bltrimws (bstring b);
|
||||
extern int brtrimws (bstring b);
|
||||
extern int btrimws (bstring b);
|
||||
|
||||
#if !defined (BSTRLIB_NOVSNP)
|
||||
extern bstring bformat (const char * fmt, ...);
|
||||
extern int bformata (bstring b, const char * fmt, ...);
|
||||
extern int bassignformat (bstring b, const char * fmt, ...);
|
||||
extern int bvcformata (bstring b, int count, const char * fmt, va_list arglist);
|
||||
|
||||
#define bvformata(ret, b, fmt, lastarg) { \
|
||||
bstring bstrtmp_b = (b); \
|
||||
const char * bstrtmp_fmt = (fmt); \
|
||||
int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16; \
|
||||
for (;;) { \
|
||||
va_list bstrtmp_arglist; \
|
||||
va_start (bstrtmp_arglist, lastarg); \
|
||||
bstrtmp_r = bvcformata (bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist); \
|
||||
va_end (bstrtmp_arglist); \
|
||||
if (bstrtmp_r >= 0) { /* Everything went ok */ \
|
||||
bstrtmp_r = BSTR_OK; \
|
||||
break; \
|
||||
} else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */ \
|
||||
bstrtmp_r = BSTR_ERR; \
|
||||
break; \
|
||||
} \
|
||||
bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */ \
|
||||
} \
|
||||
ret = bstrtmp_r; \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
typedef int (*bNgetc) (void *parm);
|
||||
typedef size_t (* bNread) (void *buff, size_t elsize, size_t nelem, void *parm);
|
||||
|
||||
/* Input functions */
|
||||
extern bstring bgets (bNgetc getcPtr, void * parm, char terminator);
|
||||
extern bstring bread (bNread readPtr, void * parm);
|
||||
extern int bgetsa (bstring b, bNgetc getcPtr, void * parm, char terminator);
|
||||
extern int bassigngets (bstring b, bNgetc getcPtr, void * parm, char terminator);
|
||||
extern int breada (bstring b, bNread readPtr, void * parm);
|
||||
|
||||
/* Stream functions */
|
||||
extern struct bStream * bsopen (bNread readPtr, void * parm);
|
||||
extern void * bsclose (struct bStream * s);
|
||||
extern int bsbufflength (struct bStream * s, int sz);
|
||||
extern int bsreadln (bstring b, struct bStream * s, char terminator);
|
||||
extern int bsreadlns (bstring r, struct bStream * s, const_bstring term);
|
||||
extern int bsread (bstring b, struct bStream * s, int n);
|
||||
extern int bsreadlna (bstring b, struct bStream * s, char terminator);
|
||||
extern int bsreadlnsa (bstring r, struct bStream * s, const_bstring term);
|
||||
extern int bsreada (bstring b, struct bStream * s, int n);
|
||||
extern int bsunread (struct bStream * s, const_bstring b);
|
||||
extern int bspeek (bstring r, const struct bStream * s);
|
||||
extern int bssplitscb (struct bStream * s, const_bstring splitStr,
|
||||
int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
|
||||
extern int bssplitstrcb (struct bStream * s, const_bstring splitStr,
|
||||
int (* cb) (void * parm, int ofs, const_bstring entry), void * parm);
|
||||
extern int bseof (const struct bStream * s);
|
||||
|
||||
struct tagbstring {
|
||||
int mlen;
|
||||
int slen;
|
||||
unsigned char * data;
|
||||
};
|
||||
|
||||
/* Accessor macros */
|
||||
#define blengthe(b, e) (((b) == (void *)0 || (b)->slen < 0) ? (int)(e) : ((b)->slen))
|
||||
#define blength(b) (blengthe ((b), 0))
|
||||
#define bdataofse(b, o, e) (((b) == (void *)0 || (b)->data == (void*)0) ? (char *)(e) : ((char *)(b)->data) + (o))
|
||||
#define bdataofs(b, o) (bdataofse ((b), (o), (void *)0))
|
||||
#define bdatae(b, e) (bdataofse (b, 0, e))
|
||||
#define bdata(b) (bdataofs (b, 0))
|
||||
#define bchare(b, p, e) ((((unsigned)(p)) < (unsigned)blength(b)) ? ((b)->data[(p)]) : (e))
|
||||
#define bchar(b, p) bchare ((b), (p), '\0')
|
||||
|
||||
/* Static constant string initialization macro */
|
||||
#define bsStaticMlen(q,m) {(m), (int) sizeof(q)-1, (unsigned char *) ("" q "")}
|
||||
#if defined(_MSC_VER)
|
||||
# define bsStatic(q) bsStaticMlen(q,-32)
|
||||
#endif
|
||||
#ifndef bsStatic
|
||||
# define bsStatic(q) bsStaticMlen(q,-__LINE__)
|
||||
#endif
|
||||
|
||||
/* Static constant block parameter pair */
|
||||
#define bsStaticBlkParms(q) ((void *)("" q "")), ((int) sizeof(q)-1)
|
||||
|
||||
#define bcatStatic(b,s) ((bcatblk)((b), bsStaticBlkParms(s)))
|
||||
#define bfromStatic(s) ((blk2bstr)(bsStaticBlkParms(s)))
|
||||
#define bassignStatic(b,s) ((bassignblk)((b), bsStaticBlkParms(s)))
|
||||
#define binsertStatic(b,p,s,f) ((binsertblk)((b), (p), bsStaticBlkParms(s), (f)))
|
||||
#define bjoinStatic(b,s) ((bjoinblk)((b), bsStaticBlkParms(s)))
|
||||
#define biseqStatic(b,s) ((biseqblk)((b), bsStaticBlkParms(s)))
|
||||
#define bisstemeqStatic(b,s) ((bisstemeqblk)((b), bsStaticBlkParms(s)))
|
||||
#define biseqcaselessStatic(b,s) ((biseqcaselessblk)((b), bsStaticBlkParms(s)))
|
||||
#define bisstemeqcaselessStatic(b,s) ((bisstemeqcaselessblk)((b), bsStaticBlkParms(s)))
|
||||
|
||||
/* Reference building macros */
|
||||
#define cstr2tbstr btfromcstr
|
||||
#define btfromcstr(t,s) { \
|
||||
(t).data = (unsigned char *) (s); \
|
||||
(t).slen = ((t).data) ? ((int) (strlen) ((char *)(t).data)) : 0; \
|
||||
(t).mlen = -1; \
|
||||
}
|
||||
#define blk2tbstr(t,s,l) { \
|
||||
(t).data = (unsigned char *) (s); \
|
||||
(t).slen = l; \
|
||||
(t).mlen = -1; \
|
||||
}
|
||||
#define btfromblk(t,s,l) blk2tbstr(t,s,l)
|
||||
#define bmid2tbstr(t,b,p,l) { \
|
||||
const_bstring bstrtmp_s = (b); \
|
||||
if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) { \
|
||||
int bstrtmp_left = (p); \
|
||||
int bstrtmp_len = (l); \
|
||||
if (bstrtmp_left < 0) { \
|
||||
bstrtmp_len += bstrtmp_left; \
|
||||
bstrtmp_left = 0; \
|
||||
} \
|
||||
if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left) \
|
||||
bstrtmp_len = bstrtmp_s->slen - bstrtmp_left; \
|
||||
if (bstrtmp_len <= 0) { \
|
||||
(t).data = (unsigned char *)""; \
|
||||
(t).slen = 0; \
|
||||
} else { \
|
||||
(t).data = bstrtmp_s->data + bstrtmp_left; \
|
||||
(t).slen = bstrtmp_len; \
|
||||
} \
|
||||
} else { \
|
||||
(t).data = (unsigned char *)""; \
|
||||
(t).slen = 0; \
|
||||
} \
|
||||
(t).mlen = -__LINE__; \
|
||||
}
|
||||
#define btfromblkltrimws(t,s,l) { \
|
||||
int bstrtmp_idx = 0, bstrtmp_len = (l); \
|
||||
unsigned char * bstrtmp_s = (s); \
|
||||
if (bstrtmp_s && bstrtmp_len >= 0) { \
|
||||
for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) { \
|
||||
if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \
|
||||
} \
|
||||
} \
|
||||
(t).data = bstrtmp_s + bstrtmp_idx; \
|
||||
(t).slen = bstrtmp_len - bstrtmp_idx; \
|
||||
(t).mlen = -__LINE__; \
|
||||
}
|
||||
#define btfromblkrtrimws(t,s,l) { \
|
||||
int bstrtmp_len = (l) - 1; \
|
||||
unsigned char * bstrtmp_s = (s); \
|
||||
if (bstrtmp_s && bstrtmp_len >= 0) { \
|
||||
for (; bstrtmp_len >= 0; bstrtmp_len--) { \
|
||||
if (!isspace (bstrtmp_s[bstrtmp_len])) break; \
|
||||
} \
|
||||
} \
|
||||
(t).data = bstrtmp_s; \
|
||||
(t).slen = bstrtmp_len + 1; \
|
||||
(t).mlen = -__LINE__; \
|
||||
}
|
||||
#define btfromblktrimws(t,s,l) { \
|
||||
int bstrtmp_idx = 0, bstrtmp_len = (l) - 1; \
|
||||
unsigned char * bstrtmp_s = (s); \
|
||||
if (bstrtmp_s && bstrtmp_len >= 0) { \
|
||||
for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) { \
|
||||
if (!isspace (bstrtmp_s[bstrtmp_idx])) break; \
|
||||
} \
|
||||
for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) { \
|
||||
if (!isspace (bstrtmp_s[bstrtmp_len])) break; \
|
||||
} \
|
||||
} \
|
||||
(t).data = bstrtmp_s + bstrtmp_idx; \
|
||||
(t).slen = bstrtmp_len + 1 - bstrtmp_idx; \
|
||||
(t).mlen = -__LINE__; \
|
||||
}
|
||||
|
||||
/* Write protection macros */
|
||||
#define bwriteprotect(t) { if ((t).mlen >= 0) (t).mlen = -1; }
|
||||
#define bwriteallow(t) { if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0); }
|
||||
#define biswriteprotected(t) ((t).mlen <= 0)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
1721
common/bstrlib/bstrwrap.cpp
Normal file
1721
common/bstrlib/bstrwrap.cpp
Normal file
File diff suppressed because it is too large
Load Diff
449
common/bstrlib/bstrwrap.h
Normal file
449
common/bstrlib/bstrwrap.h
Normal file
@ -0,0 +1,449 @@
|
||||
/*
|
||||
* This source file is part of the bstring string library. This code was
|
||||
* written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
|
||||
* license and the GPL. Refer to the accompanying documentation for details
|
||||
* on usage and license.
|
||||
*/
|
||||
|
||||
/*
|
||||
* bstrwrap.h
|
||||
*
|
||||
* This file is the C++ wrapper for the bstring functions.
|
||||
*/
|
||||
|
||||
#ifndef BSTRWRAP_INCLUDE
|
||||
#define BSTRWRAP_INCLUDE
|
||||
|
||||
/////////////////// Configuration defines //////////////////////////////
|
||||
|
||||
// WATCOM C/C++ has broken STL and std::iostream support. If you have
|
||||
// ported over STLport, then you can #define BSTRLIB_CAN_USE_STL to use
|
||||
// the CBStringList class.
|
||||
#if defined(__WATCOMC__)
|
||||
# if !defined (BSTRLIB_CAN_USE_STL) && !defined (BSTRLIB_CANNOT_USE_STL)
|
||||
# define BSTRLIB_CANNOT_USE_STL
|
||||
# endif
|
||||
# if !defined (BSTRLIB_CAN_USE_IOSTREAM) && !defined (BSTRLIB_CANNOT_USE_IOSTREAM)
|
||||
# define BSTRLIB_CANNOT_USE_IOSTREAM
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// By default it assumed that STL has been installed and works for your
|
||||
// compiler. If this is not the case, then #define BSTRLIB_CANNOT_USE_STL
|
||||
#if !defined (BSTRLIB_CANNOT_USE_STL) && !defined (BSTRLIB_CAN_USE_STL)
|
||||
#define BSTRLIB_CAN_USE_STL
|
||||
#endif
|
||||
|
||||
// By default it assumed that std::iostream works well with your compiler.
|
||||
// If this is not the case, then #define BSTRLIB_CAN_USE_IOSTREAM
|
||||
#if !defined (BSTRLIB_CANNOT_USE_IOSTREAM) && !defined (BSTRLIB_CAN_USE_IOSTREAM)
|
||||
#define BSTRLIB_CAN_USE_IOSTREAM
|
||||
#endif
|
||||
|
||||
// By default it is assumed that your compiler can deal with and has enabled
|
||||
// exception handlling. If this is not the case then you will need to
|
||||
// #define BSTRLIB_DOESNT_THROW_EXCEPTIONS
|
||||
#if !defined (BSTRLIB_THROWS_EXCEPTIONS) && !defined (BSTRLIB_DOESNT_THROW_EXCEPTIONS)
|
||||
#define BSTRLIB_THROWS_EXCEPTIONS
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "bstrlib.h"
|
||||
#include "../ubytearray.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
#if defined(BSTRLIB_CAN_USE_STL)
|
||||
|
||||
#if defined(__WATCOMC__)
|
||||
#pragma warning 604 10
|
||||
#pragma warning 595 10
|
||||
#pragma warning 594 10
|
||||
#pragma warning 549 10
|
||||
#endif
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#if defined(__WATCOMC__)
|
||||
#pragma warning 604 9
|
||||
#pragma warning 595 9
|
||||
#pragma warning 594 9
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
namespace Bstrlib {
|
||||
|
||||
#ifdef BSTRLIB_THROWS_EXCEPTIONS
|
||||
#if defined(BSTRLIB_CAN_USE_STL)
|
||||
struct CBStringException : public std::exception {
|
||||
private:
|
||||
std::string msg;
|
||||
public:
|
||||
CBStringException (const std::string inmsg) : msg(inmsg) {}
|
||||
virtual ~CBStringException () throw () {}
|
||||
virtual const char *what () const throw () { return msg.c_str(); }
|
||||
};
|
||||
#else
|
||||
struct CBStringException {
|
||||
private:
|
||||
char * msg;
|
||||
int needToFree;
|
||||
public:
|
||||
CBStringException (const char * inmsg) : needToFree(0) {
|
||||
if (inmsg) {
|
||||
msg = (char *) malloc (1 + strlen (inmsg));
|
||||
if (NULL == msg) msg = "Out of memory";
|
||||
else {
|
||||
strcpy (msg, inmsg);
|
||||
needToFree = 1;
|
||||
}
|
||||
} else {
|
||||
msg = "NULL exception message";
|
||||
}
|
||||
}
|
||||
virtual ~CBStringException () throw () {
|
||||
if (needToFree) {
|
||||
free (msg);
|
||||
needToFree = 0;
|
||||
msg = NULL;
|
||||
}
|
||||
}
|
||||
virtual const char *what () const throw () { return msg; }
|
||||
};
|
||||
#endif
|
||||
#define bstringThrow(er) {\
|
||||
CBStringException bstr__cppwrapper_exception ("CBString::" er "");\
|
||||
throw bstr__cppwrapper_exception;\
|
||||
}
|
||||
#else
|
||||
#define bstringThrow(er) {}
|
||||
#endif
|
||||
|
||||
struct CBString;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(disable:4512)
|
||||
#endif
|
||||
|
||||
class CBCharWriteProtected {
|
||||
friend struct CBString;
|
||||
private:
|
||||
const struct tagbstring& s;
|
||||
unsigned int idx;
|
||||
CBCharWriteProtected (const struct tagbstring& c, int i) : s(c), idx((unsigned int)i) {
|
||||
if (idx >= (unsigned) s.slen) {
|
||||
bstringThrow ("character index out of bounds");
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
inline char operator = (char c) {
|
||||
if (s.mlen <= 0) {
|
||||
bstringThrow ("Write protection error");
|
||||
} else {
|
||||
#ifndef BSTRLIB_THROWS_EXCEPTIONS
|
||||
if (idx >= (unsigned) s.slen) return '\0';
|
||||
#endif
|
||||
s.data[idx] = (unsigned char) c;
|
||||
}
|
||||
return (char) s.data[idx];
|
||||
}
|
||||
inline unsigned char operator = (unsigned char c) {
|
||||
if (s.mlen <= 0) {
|
||||
bstringThrow ("Write protection error");
|
||||
} else {
|
||||
#ifndef BSTRLIB_THROWS_EXCEPTIONS
|
||||
if (idx >= (unsigned) s.slen) return '\0';
|
||||
#endif
|
||||
s.data[idx] = c;
|
||||
}
|
||||
return s.data[idx];
|
||||
}
|
||||
inline operator unsigned char () const {
|
||||
#ifndef BSTRLIB_THROWS_EXCEPTIONS
|
||||
if (idx >= (unsigned) s.slen) return (unsigned char) '\0';
|
||||
#endif
|
||||
return s.data[idx];
|
||||
}
|
||||
};
|
||||
|
||||
struct CBString : public tagbstring {
|
||||
|
||||
// Constructors
|
||||
CBString ();
|
||||
CBString (char c);
|
||||
CBString (unsigned char c);
|
||||
CBString (const char *s);
|
||||
CBString (int len, const char *s);
|
||||
CBString (const CBString& b);
|
||||
CBString (const tagbstring& x);
|
||||
CBString (char c, int len);
|
||||
CBString (const void * blk, int len);
|
||||
|
||||
#if defined(BSTRLIB_CAN_USE_STL)
|
||||
CBString (const struct CBStringList& l);
|
||||
CBString (const struct CBStringList& l, const CBString& sep);
|
||||
CBString (const struct CBStringList& l, char sep);
|
||||
CBString (const struct CBStringList& l, unsigned char sep);
|
||||
#endif
|
||||
|
||||
// Destructor
|
||||
#if !defined(BSTRLIB_DONT_USE_VIRTUAL_DESTRUCTOR)
|
||||
virtual
|
||||
#endif
|
||||
~CBString ();
|
||||
|
||||
// = operator
|
||||
const CBString& operator = (char c);
|
||||
const CBString& operator = (unsigned char c);
|
||||
const CBString& operator = (const char *s);
|
||||
const CBString& operator = (const CBString& b);
|
||||
const CBString& operator = (const tagbstring& x);
|
||||
|
||||
// += operator
|
||||
const CBString& operator += (char c);
|
||||
const CBString& operator += (unsigned char c);
|
||||
const CBString& operator += (const char *s);
|
||||
const CBString& operator += (const CBString& b);
|
||||
const CBString& operator += (const tagbstring& x);
|
||||
|
||||
// *= operator
|
||||
inline const CBString& operator *= (int count) {
|
||||
this->repeat (count);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// + operator
|
||||
const CBString operator + (char c) const;
|
||||
const CBString operator + (unsigned char c) const;
|
||||
const CBString operator + (const unsigned char *s) const;
|
||||
const CBString operator + (const char *s) const;
|
||||
const CBString operator + (const CBString& b) const;
|
||||
const CBString operator + (const tagbstring& x) const;
|
||||
|
||||
// * operator
|
||||
inline const CBString operator * (int count) const {
|
||||
CBString retval (*this);
|
||||
retval.repeat (count);
|
||||
return retval;
|
||||
}
|
||||
|
||||
// Comparison operators
|
||||
bool operator == (const CBString& b) const;
|
||||
bool operator == (const char * s) const;
|
||||
bool operator == (const unsigned char * s) const;
|
||||
bool operator != (const CBString& b) const;
|
||||
bool operator != (const char * s) const;
|
||||
bool operator != (const unsigned char * s) const;
|
||||
bool operator < (const CBString& b) const;
|
||||
bool operator < (const char * s) const;
|
||||
bool operator < (const unsigned char * s) const;
|
||||
bool operator <= (const CBString& b) const;
|
||||
bool operator <= (const char * s) const;
|
||||
bool operator <= (const unsigned char * s) const;
|
||||
bool operator > (const CBString& b) const;
|
||||
bool operator > (const char * s) const;
|
||||
bool operator > (const unsigned char * s) const;
|
||||
bool operator >= (const CBString& b) const;
|
||||
bool operator >= (const char * s) const;
|
||||
bool operator >= (const unsigned char * s) const;
|
||||
|
||||
// Casts
|
||||
inline operator const char* () const { return (const char *)data; }
|
||||
inline operator const unsigned char* () const { return (const unsigned char *)data; }
|
||||
operator double () const;
|
||||
operator float () const;
|
||||
operator int () const;
|
||||
operator unsigned int () const;
|
||||
|
||||
// Accessors
|
||||
inline int length () const {return slen;}
|
||||
|
||||
inline unsigned char character (int i) const {
|
||||
if (((unsigned) i) >= (unsigned) slen) {
|
||||
#ifdef BSTRLIB_THROWS_EXCEPTIONS
|
||||
bstringThrow ("character idx out of bounds");
|
||||
#else
|
||||
return '\0';
|
||||
#endif
|
||||
}
|
||||
return data[i];
|
||||
}
|
||||
inline unsigned char operator [] (int i) const { return character(i); }
|
||||
|
||||
inline CBCharWriteProtected character (int i) {
|
||||
return CBCharWriteProtected (*this, i);
|
||||
}
|
||||
inline CBCharWriteProtected operator [] (int i) { return character(i); }
|
||||
|
||||
// Space allocation hint method.
|
||||
void alloc (int length);
|
||||
|
||||
// Search methods.
|
||||
int caselessEqual (const CBString& b) const;
|
||||
int caselessCmp (const CBString& b) const;
|
||||
int find (const CBString& b, int pos = 0) const;
|
||||
int find (const char * b, int pos = 0) const;
|
||||
int caselessfind (const CBString& b, int pos = 0) const;
|
||||
int caselessfind (const char * b, int pos = 0) const;
|
||||
int find (char c, int pos = 0) const;
|
||||
int reversefind (const CBString& b, int pos) const;
|
||||
int reversefind (const char * b, int pos) const;
|
||||
int caselessreversefind (const CBString& b, int pos) const;
|
||||
int caselessreversefind (const char * b, int pos) const;
|
||||
int reversefind (char c, int pos) const;
|
||||
int findchr (const CBString& b, int pos = 0) const;
|
||||
int findchr (const char * s, int pos = 0) const;
|
||||
int reversefindchr (const CBString& b, int pos) const;
|
||||
int reversefindchr (const char * s, int pos) const;
|
||||
int nfindchr (const CBString& b, int pos = 0) const;
|
||||
int nfindchr (const char * b, int pos = 0) const;
|
||||
int nreversefindchr (const CBString& b, int pos) const;
|
||||
int nreversefindchr (const char * b, int pos) const;
|
||||
|
||||
// Search and substitute methods.
|
||||
void findreplace (const CBString& find, const CBString& repl, int pos = 0);
|
||||
void findreplace (const CBString& find, const char * repl, int pos = 0);
|
||||
void findreplace (const char * find, const CBString& repl, int pos = 0);
|
||||
void findreplace (const char * find, const char * repl, int pos = 0);
|
||||
void findreplacecaseless (const CBString& find, const CBString& repl, int pos = 0);
|
||||
void findreplacecaseless (const CBString& find, const char * repl, int pos = 0);
|
||||
void findreplacecaseless (const char * find, const CBString& repl, int pos = 0);
|
||||
void findreplacecaseless (const char * find, const char * repl, int pos = 0);
|
||||
|
||||
// Extraction method.
|
||||
CBString midstr (int left, int len) const;
|
||||
|
||||
// Standard manipulation methods.
|
||||
void setsubstr (int pos, const CBString& b, unsigned char fill = ' ');
|
||||
void setsubstr (int pos, const char * b, unsigned char fill = ' ');
|
||||
void insert (int pos, const CBString& b, unsigned char fill = ' ');
|
||||
void insert (int pos, const char * b, unsigned char fill = ' ');
|
||||
void insertchrs (int pos, int len, unsigned char fill = ' ');
|
||||
void replace (int pos, int len, const CBString& b, unsigned char fill = ' ');
|
||||
void replace (int pos, int len, const char * s, unsigned char fill = ' ');
|
||||
void remove (int pos, int len);
|
||||
void trunc (int len);
|
||||
|
||||
// Miscellaneous methods.
|
||||
void format (const char * fmt, ...);
|
||||
void formata (const char * fmt, ...);
|
||||
void fill (int length, unsigned char fill = ' ');
|
||||
void repeat (int count);
|
||||
void ltrim (const CBString& b = CBString (bsStaticBlkParms (" \t\v\f\r\n")));
|
||||
void rtrim (const CBString& b = CBString (bsStaticBlkParms (" \t\v\f\r\n")));
|
||||
inline void trim (const CBString& b = CBString (bsStaticBlkParms (" \t\v\f\r\n"))) {
|
||||
rtrim (b);
|
||||
ltrim (b);
|
||||
}
|
||||
void toupper ();
|
||||
void tolower ();
|
||||
|
||||
// Write protection methods.
|
||||
void writeprotect ();
|
||||
void writeallow ();
|
||||
inline bool iswriteprotected () const { return mlen <= 0; }
|
||||
|
||||
// Join methods.
|
||||
#if defined(BSTRLIB_CAN_USE_STL)
|
||||
void join (const struct CBStringList& l);
|
||||
void join (const struct CBStringList& l, const CBString& sep);
|
||||
void join (const struct CBStringList& l, char sep);
|
||||
void join (const struct CBStringList& l, unsigned char sep);
|
||||
#endif
|
||||
|
||||
// CBStream methods
|
||||
int gets (bNgetc getcPtr, void * parm, char terminator = '\n');
|
||||
int read (bNread readPtr, void * parm);
|
||||
|
||||
// QString compatibility methods
|
||||
CBString toLocal8Bit() const { return *this; }
|
||||
bool isEmpty() const { return slen == 0; }
|
||||
void clear() { *this = ""; }
|
||||
CBString left(int len) const { return midstr(0, len); }
|
||||
CBString mid(int pos, int len) const { return midstr(pos, len); }
|
||||
static CBString fromUtf16(const unsigned short* str) { // Naive implementation assuming that only ASCII part of UCS2 is used
|
||||
CBString msg; while (*str) { msg += *(char*)str; str++; } return msg;
|
||||
}
|
||||
CBString leftJustified(int length) { if (length > slen) { return *this + CBString(' ', length - slen); } return *this; }
|
||||
};
|
||||
extern const CBString operator + (const char *a, const CBString& b);
|
||||
extern const CBString operator + (const unsigned char *a, const CBString& b);
|
||||
extern const CBString operator + (char c, const CBString& b);
|
||||
extern const CBString operator + (unsigned char c, const CBString& b);
|
||||
extern const CBString operator + (const tagbstring& x, const CBString& b);
|
||||
inline const CBString operator * (int count, const CBString& b) {
|
||||
CBString retval (b);
|
||||
retval.repeat (count);
|
||||
return retval;
|
||||
}
|
||||
|
||||
#if defined(BSTRLIB_CAN_USE_IOSTREAM)
|
||||
extern std::ostream& operator << (std::ostream& sout, CBString b);
|
||||
extern std::istream& operator >> (std::istream& sin, CBString& b);
|
||||
extern std::istream& getline (std::istream& sin, CBString& b, char terminator='\n');
|
||||
#endif
|
||||
|
||||
struct CBStream {
|
||||
friend struct CBStringList;
|
||||
private:
|
||||
struct bStream * m_s;
|
||||
public:
|
||||
CBStream (bNread readPtr, void * parm);
|
||||
~CBStream ();
|
||||
int buffLengthSet (int sz);
|
||||
int buffLengthGet ();
|
||||
int eof () const;
|
||||
|
||||
CBString readLine (char terminator);
|
||||
CBString readLine (const CBString& terminator);
|
||||
void readLine (CBString& s, char terminator);
|
||||
void readLine (CBString& s, const CBString& terminator);
|
||||
void readLineAppend (CBString& s, char terminator);
|
||||
void readLineAppend (CBString& s, const CBString& terminator);
|
||||
|
||||
CBString read ();
|
||||
CBString& operator >> (CBString& s);
|
||||
|
||||
CBString read (int n);
|
||||
void read (CBString& s);
|
||||
void read (CBString& s, int n);
|
||||
void readAppend (CBString& s);
|
||||
void readAppend (CBString& s, int n);
|
||||
|
||||
void unread (const CBString& s);
|
||||
inline CBStream& operator << (const CBString& s) {
|
||||
this->unread (s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
CBString peek () const;
|
||||
void peek (CBString& s) const;
|
||||
void peekAppend (CBString& s) const;
|
||||
};
|
||||
|
||||
#if defined(BSTRLIB_CAN_USE_STL)
|
||||
struct CBStringList : public std::vector<CBString> {
|
||||
// split a string into a vector of strings.
|
||||
void split (const CBString& b, unsigned char splitChar);
|
||||
void split (const CBString& b, const CBString& s);
|
||||
void splitstr (const CBString& b, const CBString& s);
|
||||
void split (const CBStream& b, unsigned char splitChar);
|
||||
void split (const CBStream& b, const CBString& s);
|
||||
void splitstr (const CBStream& b, const CBString& s);
|
||||
};
|
||||
#endif
|
||||
|
||||
} // namespace Bstrlib
|
||||
|
||||
#if !defined (BSTRLIB_DONT_ASSUME_NAMESPACE)
|
||||
using namespace Bstrlib;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif
|
||||
@ -473,7 +473,7 @@ UModelIndex TreeModel::addItem(const UINT32 offset, const UINT8 type, const UINT
|
||||
emit layoutChanged();
|
||||
|
||||
UModelIndex created = createIndex(newItem->row(), parentColumn, newItem);
|
||||
setFixed(created, fixed); // Non-trivial logic requires additional call
|
||||
setFixed(created, (bool)fixed); // Non-trivial logic requires additional call
|
||||
return created;
|
||||
}
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
#else
|
||||
// Use Bstrlib
|
||||
#define BSTRLIB_DOESNT_THROW_EXCEPTIONS
|
||||
#include "../bstrlib/bstrwrap.h"
|
||||
#include "bstrlib/bstrwrap.h"
|
||||
#define UString CBString
|
||||
#endif // QT_CORE_LIB
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user