ThrottleableWidget(parent)

{

this->background = SYMVIEW_DEFAULT_BG_COLOR;

this->lowSym = SYMVIEW_DEFAULT_LO_COLOR;

this->highSym = SYMVIEW_DEFAULT_HI_COLOR;

this->setFocusPolicy(Qt::StrongFocus);

this->setMouseTracking(true);

this->invalidate();

{

if (this->viewPort.width() != this->width()

|| this->viewPort.height() != this->height()) {

if (this->autoStride)

this->setStride(static_cast<unsigned int>(this->width()));

this->viewPort = QImage(

this->width(),

this->height(),

QImage::Format_ARGB32);

}

QImage &image,

unsigned int start,

unsigned int end,

unsigned int zoom,

unsigned int lineSize,

unsigned int lineSkip,

unsigned int lineStart,

bool showSelection)

{

unsigned int x = 0;

int y = 0;

int asInt, convD;

unsigned int p = start;

QRgb *scanLine;

QRgb color;

qint64 selStart = 0, selEnd = 0;

// Calculate conversion coefficients

convD = (1 << this->bps) - 1;

scanLine = reinterpret_cast<QRgb *>(image.scanLine(0));

if (lineSize == 0)

lineSize = static_cast<unsigned int>(image.width());

if (showSelection) {

if (this->selStart > this->selEnd) {

selStart = this->selEnd - 1;

selEnd = this->selStart + 1;

} else {

selStart = this->selStart;

selEnd = this->selEnd;

}

}

if (this->zoom == 1) {

bool inSel;

while (p < end) {

inSel = showSelection && selStart <= p && p < selEnd;

asInt = (static_cast<int>(this->buffer[p++]) * 255) / convD;

if (this->reverse)

asInt = ~asInt;

// You like Cobol, right?

if (x++ >= lineStart) {

if (inSel)

color = qRgb(255 - asInt, 255 - asInt, 255);

else

color = qRgb(

(this->lowSym.red() * (255 - asInt) + this->highSym.red() * asInt) / 255,

(this->lowSym.green() * (255 - asInt) + this->highSym.green() * asInt) / 255,

(this->lowSym.blue() * (255 - asInt) + this->highSym.blue() * asInt) / 255);

scanLine[x - 1 - lineStart] = color;

}

if (x >= lineSize) {

x = 0;

scanLine = reinterpret_cast<QRgb *>(image.scanLine(++y));

p += lineSkip; // Skip non visible pixels

}

}

} else {

// If zoom is bigger than one, we decide which pixel belongs to which

// symbol instead. We assume the symbol stream to be divided in

// blocks of lineSize symbols, starting by start. Therefore:

//

// x = i / zoom

// y = j / zoom

//

// if (x >= lineSize) p(x, y) = 0

// p(x, y) = start + x + y * lineSize

//

unsigned int stride = lineSize + lineSkip;

bool highlight = zoom > 2 && this->hoverX > 0 && this->hoverY > 0;

QRgb color;

bool inSel;

int width = static_cast<int>(stride * zoom);

if (width > image.width())

width = image.width();

for (int j = 0; j < image.height(); ++j) {

unsigned int y = static_cast<unsigned>(j) / zoom;

scanLine = reinterpret_cast<QRgb *>(image.scanLine(j));

for (int i = 0; i < width; ++i) {

unsigned x = static_cast<unsigned>(i) / zoom

+ lineStart;

if (x < stride) {

p = start + x + y * stride;

inSel = showSelection && selStart <= p && p < selEnd;

asInt = (static_cast<int>(this->buffer[p]) * 255) / convD;

if (p >= end)

break;

if (this->reverse)

asInt = ~asInt;

if (inSel)

color = qRgb(255 - asInt, 255 - asInt, 255);

else

color = qRgb(

(this->lowSym.red() * (255 - asInt) + this->highSym.red() * asInt) / 255,

(this->lowSym.green() * (255 - asInt) + this->highSym.green() * asInt) / 255,

(this->lowSym.blue() * (255 - asInt) + this->highSym.blue() * asInt) / 255);

scanLine[i] = color;

}

}

if (p > end)

break;

}

if (highlight) {

unsigned int y = static_cast<unsigned>(this->hoverY) / zoom;

unsigned int x = static_cast<unsigned>(this->hoverX) / zoom;

unsigned int highlightPtr = start + x + lineStart + y * stride;

unsigned int uWidth = stride - lineStart;

if (highlightPtr >= start

&& highlightPtr < end

&& x < uWidth) {

x *= zoom;

y *= zoom;

uWidth *= zoom;

emit hoverSymbol(highlightPtr);

for (unsigned int j = 0; j < zoom; ++j)

if (y + j < static_cast<unsigned>(image.height())) {

scanLine = reinterpret_cast<QRgb *>(

image.scanLine(static_cast<int>(y + j)));

if (j == 0 || j == zoom - 1) {

for (unsigned int i = x; i < qBound(0u, x + zoom, uWidth); ++i)

scanLine[i] = qRgb(255, 0, 0);

} else {

scanLine[x] = qRgb(255, 0, 0);

if (x + zoom <= uWidth)

scanLine[x + zoom - 1] = qRgb(255, 0, 0);

}

}

}

}

}

{

unsigned int available;

int width = this->viewPort.width();

int zoom = static_cast<int>(this->zoom);

int limitBar = static_cast<int>(stride * zoom);

if (!this->size().isValid())

return;

// Assert a few things before going on

this->assertImage();

int lineSize = this->stride > width / zoom

? width / zoom

: this->stride;

unsigned int lineSkip = static_cast<unsigned int>(this->stride - lineSize);

unsigned int lineStart = static_cast<unsigned int>(this->hOffset);

// lineSize: Number of visible symbols

// lineSkip: Number of invisible symbols

// If I start beyond the number of visible symbols, I will fall beyond

// the line limits.

if (lineStart > lineSkip)

lineStart = lineSkip;

unsigned int visibleLines =

(static_cast<unsigned>(this->height()) + this->zoom - 1) / this->zoom;

unsigned visible = static_cast<unsigned>(this->stride) * visibleLines;

this->viewPort.fill(this->background); // Fill in black

if (this->bps > 0 && this->buffer.size() > this->offset) {

available = static_cast<unsigned>(this->buffer.size()) - this->offset;

// Calculate how many symbols are visible

if (visible > available)

visible = available;

this->drawToImage(

this->viewPort,

this->offset,

this->offset + visible,

this->zoom,

static_cast<unsigned int>(lineSize) + lineStart, // lineSize

lineSkip - lineStart, // lineSkip

lineStart, // lineStart

true); // drawSelection

}

// Draw limitbar on the right

if (limitBar + zoom <= width) {

int height = this->viewPort.height();

for (auto i = 0; i < zoom; ++i) {

for (auto j = 0; j < height; ++j) {

QRgb *scanLine = reinterpret_cast<QRgb *>(

this->viewPort.scanLine(static_cast<int>(j)));

scanLine[i + limitBar] = qRgb(255, 0, 0);

}

}

}

{

this->buffer.clear();

this->offset = 0;

this->selStart = this->selEnd = 0;

this->invalidate();

{

QFile file(dest);

char b;

QImage img;

file.open(QIODevice::WriteOnly);

if (!file.isOpen())

throw std::ios_base::failure("Failed to save file " + dest.toStdString());

if (format > FILE_FORMAT_C_ARRAY) {

// Initialize image

img = QImage(this->stride, this->getLines(), QImage::Format_ARGB32);

drawToImage(

img,

this->offset % static_cast<unsigned>(this->stride),

static_cast<unsigned>(this->buffer.size()));

}

switch (format) {

case FILE_FORMAT_TEXT:

for (auto p = this->buffer.begin();

p != this->buffer.end();

++p) {

b = '0' + static_cast<char>(*p);

file.write(&b, 1);

}

break;

case FILE_FORMAT_RAW:

for (auto p = this->buffer.begin();

p != this->buffer.end();

++p) {

b = static_cast<char>(*p & ((1 << this->bps) - 1));

file.write(&b, 1);

}

break;

case FILE_FORMAT_C_ARRAY:

char buf[8];

file.write("#include <stdint.h>\n\n");

file.write(

("static uint8_t data[" + QString::number(this->buffer.size()) + "] = {\n")

.toUtf8());

for (unsigned int i = 0; i < this->buffer.size(); ++i) {

if (i % 16 == 0)

file.write(" ");

snprintf(buf, 8, "0x%02x, ", static_cast<unsigned int>(this->buffer[i]));

file.write(buf);

if (i % 16 == 15)

file.write("\n");

}

file.write("};\n");

break;

case FILE_FORMAT_BMP:

img.save(&file, "BMP");

break;

case FILE_FORMAT_PNG:

img.save(&file, "PNG");

break;

case FILE_FORMAT_JPEG:

img.save(&file, "JPEG");

break;

case FILE_FORMAT_PPM:

img.save(&file, "PPM");

break;

}

{

QPainter painter(this);

painter.drawImage(0, 0, this->viewPort);

{

unsigned int new_offset = 0;

int size = static_cast<int>(this->buffer.size());

int lines = (size + this->stride - 1) / this->stride;

if (lines > this->height() / static_cast<int>(this->zoom))

new_offset = static_cast<unsigned int>(

(lines - this->height() / static_cast<int>(this->zoom))

* this->stride);

this->setOffset(new_offset);

{

this->buffer.insert(

this->buffer.end(),

data,

data + length);

if (length > 0) {

if (this->autoScroll)

this->scrollToBottom();

this->invalidate();

}

{

qint64 off = coordToOffset(hoverX, hoverY);

if (off >= 0) {

if (ev->button() == Qt::MouseButton::LeftButton) {

this->selecting = true;

this->selStart = off;

this->selEnd = off;

this->invalidate();

}

}

{

if (this->selecting) {

if (ev->button() == Qt::MouseButton::LeftButton) {

this->selecting = false;

this->invalidate();

}

}

{

qint64 off;

x /= this->zoom;

y /= this->zoom;

if (x >= this->stride)

x = this->stride - 1;

else if (x < 0)

x = 0;

x += this->hOffset;

off = this->offset + SCAST(qint64, x) + SCAST(qint64, y) * this->stride;

if (off < 0)

off = 0;

else if (off >= SCAST(qint64, this->buffer.size()))

off = SCAST(qint64, this->buffer.size()) - 1;

return off;

{

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)

hoverX = event->position().x();

hoverY = event->position().y();

#else

hoverX = event->x();

hoverY = event->y();

#endif

if (this->selecting) {

qint64 end = this->coordToOffset(hoverX, hoverY);

if (end >= 0) {

this->selEnd = end;

this->invalidate();

}

}

if (this->zoom > 2)

this->invalidate();

{

if (this->selStart != this->selEnd) {

qint64 start;

qint64 end;

QClipboard *clipboard = QApplication::clipboard();

QString string;

int p = 0;

if (this->selStart > this->selEnd) {

start = this->selEnd - 1;

end = this->selStart + 1;

} else {

start = this->selStart;

end = this->selEnd;

}

string.resize(SCAST(int, end - start));

for (auto i = start;

i < end;

++i)

string[p++] = QChar('0' + this->buffer[i]);

clipboard->setText(string);

}

{

unsigned int lineSize = static_cast<unsigned>(this->stride);

unsigned int lineCount = static_cast<unsigned>(this->height()) / this->zoom;

unsigned int pageSize = lineSize * lineCount;

unsigned int visible = static_cast<unsigned>(this->width()) / this->zoom;

switch (event->key()) {

case Qt::Key_PageUp:

this->setOffset(

this->offset < pageSize

? 0

: this->offset - pageSize);

break;

case Qt::Key_PageDown:

if (this->getLength() > pageSize) {

this->setOffset(

static_cast<unsigned int>(

this->offset < this->getLength() - pageSize

? this->offset + pageSize

: this->getLength() - pageSize));

}

break;

case Qt::Key_Up:

this->setOffset(

this->offset < lineSize

? 0

: this->offset - lineSize);

break;

case Qt::Key_Down:

if (this->getLength() > pageSize) {

this->setOffset(

static_cast<unsigned int>(

this->offset + lineSize < this->getLength() - pageSize

? this->offset + lineSize

: this->getLength() - pageSize));

}

break;

case Qt::Key_Home:

this->setOffset(0);

break;

case Qt::Key_End:

this->setOffset(static_cast<unsigned int>(this->getLength() - pageSize));

break;

case Qt::Key_Left:

if (this->hOffset > 0)

this->setHOffset(this->hOffset - 1);

break;

case Qt::Key_Right:

if (static_cast<unsigned>(this->hOffset) + visible <= lineSize)

this->setHOffset(this->hOffset + 1);

break;

case Qt::Key_Plus:

if (event->modifiers() & Qt::ControlModifier)

this->setZoom(this->zoom + 1);

break;

case Qt::Key_Minus:

if (event->modifiers() & Qt::ControlModifier && this->zoom > 1)

this->setZoom(this->zoom - 1);

break;

case Qt::Key_Escape:

if (this->selecting) {

this->selStart = this->selEnd = 0;

this->selecting = false;

this->invalidate();

}

break;

case Qt::Key_C:

if (event->modifiers() & Qt::Modifier::CTRL)

this->copyToClipboard();

break;

case Qt::Key_A:

if (event->modifiers() & Qt::Modifier::CTRL) {

this->selStart = 0;

this->selEnd = SCAST(qint64, this->buffer.size());

this->invalidate();

}

break;

}

{

unsigned int lineSize = static_cast<unsigned>(this->stride);

unsigned int lineCount = static_cast<unsigned>(this->height()) / this->zoom;

unsigned int pageSize = lineSize * lineCount;

int count = (event->angleDelta().y() + 119) / 120;

if (event->modifiers() & Qt::ControlModifier) {

if (count <= 0) {

unsigned int delta = static_cast<unsigned>(-count) + 1;

this->setZoom(delta < this->zoom ? this->zoom - delta : 1);

} else {

unsigned int delta = static_cast<unsigned>(count);

this->setZoom(

this->zoom + delta > SYMVIEW_MAX_ZOOM

? SYMVIEW_MAX_ZOOM

: this->zoom + delta);

}

} else {

if (count > 0) {

unsigned int delta = static_cast<unsigned>(count);

unsigned int step = 5 * delta * lineSize * this->zoom;

this->setOffset(

this->offset < step

? 0

: this->offset - step);

} else {

unsigned int delta = static_cast<unsigned>(-count) + 1;

unsigned int step = 5 * delta * lineSize * this->zoom;

if (this->getLength() > pageSize) {

this->setOffset(

static_cast<unsigned int>(

this->offset + step < this->getLength() - pageSize

? this->offset + step

: this->getLength() - pageSize));

}

}

}