void RPCConsole::scrollToEnd()
{
QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
scrollbar->setValue(scrollbar->maximum());
}
void HighlightScrollBarOverlay::paintEvent(QPaintEvent *paintEvent)
{
QWidget::paintEvent(paintEvent);
updateCache();
if (m_highlightCache.isEmpty())
return;
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing, false);
const QRect &gRect = overlayRect();
const QRect &hRect = handleRect();
const int marginX = 3;
const int marginH = -2 * marginX + 1;
const QRect aboveHandleRect = QRect(gRect.x() + marginX,
gRect.y(),
gRect.width() + marginH,
hRect.y() - gRect.y());
const QRect handleRect = QRect(gRect.x() + marginX,
hRect.y(),
gRect.width() + marginH,
hRect.height());
const QRect belowHandleRect = QRect(gRect.x() + marginX,
hRect.y() + hRect.height(),
gRect.width() + marginH,
gRect.height() - hRect.height() + gRect.y() - hRect.y());
const int aboveValue = m_scrollBar->value();
const int belowValue = m_scrollBar->maximum() - m_scrollBar->value();
const int sizeDocAbove = aboveValue * int(m_highlightController->lineHeight());
const int sizeDocBelow = belowValue * int(m_highlightController->lineHeight());
const int sizeDocVisible = int(m_highlightController->visibleRange());
const int scrollBarBackgroundHeight = aboveHandleRect.height() + belowHandleRect.height();
const int sizeDocInvisible = sizeDocAbove + sizeDocBelow;
const double backgroundRatio = sizeDocInvisible
? ((double)scrollBarBackgroundHeight / sizeDocInvisible) : 0;
if (aboveValue) {
drawHighlights(&painter,
0,
sizeDocAbove,
backgroundRatio,
0,
aboveHandleRect);
}
if (belowValue) {
// This is the hypothetical handle height if the handle would
// be stretched using the background ratio.
const double handleVirtualHeight = sizeDocVisible * backgroundRatio;
// Skip the doc above and visible part.
const int offset = qRound(aboveHandleRect.height() + handleVirtualHeight);
drawHighlights(&painter,
sizeDocAbove + sizeDocVisible,
sizeDocBelow,
backgroundRatio,
offset,
belowHandleRect);
}
const double handleRatio = sizeDocVisible
? ((double)handleRect.height() / sizeDocVisible) : 0;
// This is the hypothetical handle position if the background would
// be stretched using the handle ratio.
const double aboveVirtualHeight = sizeDocAbove * handleRatio;
// This is the accurate handle position (double)
const double accurateHandlePos = sizeDocAbove * backgroundRatio;
// The correction between handle position (int) and accurate position (double)
const double correction = aboveHandleRect.height() - accurateHandlePos;
// Skip the doc above and apply correction
const int offset = qRound(aboveVirtualHeight + correction);
drawHighlights(&painter,
sizeDocAbove,
sizeDocVisible,
handleRatio,
offset,
handleRect);
}
void log_frame::UpdateUI()
{
const auto start = steady_clock::now();
// Check TTY logs
while (const u64 size = std::max<s64>(0, g_tty_size.load() - m_tty_file.pos()))
{
std::string buf;
buf.resize(size);
buf.resize(m_tty_file.read(&buf.front(), buf.size()));
if (buf.find_first_of('\0') != -1)
{
m_tty_file.seek(s64{0} - buf.size(), fs::seek_mode::seek_cur);
break;
}
if (buf.size() && m_TTYAct->isChecked())
{
QTextCursor text_cursor{m_tty->document()};
text_cursor.movePosition(QTextCursor::End);
text_cursor.insertText(qstr(buf));
}
// Limit processing time
if (steady_clock::now() >= start + 4ms || buf.empty()) break;
}
// Check main logs
while (const auto packet = s_gui_listener.read->next.load())
{
// Confirm log level
if (packet->sev <= s_gui_listener.enabled)
{
QString text;
switch (packet->sev)
{
case logs::level::always: break;
case logs::level::fatal: text = "F "; break;
case logs::level::error: text = "E "; break;
case logs::level::todo: text = "U "; break;
case logs::level::success: text = "S "; break;
case logs::level::warning: text = "W "; break;
case logs::level::notice: text = "! "; break;
case logs::level::trace: text = "T "; break;
default: continue;
}
// Print UTF-8 text.
text += qstr(packet->msg);
// save old log state
QScrollBar *sb = m_log->verticalScrollBar();
bool isMax = sb->value() == sb->maximum();
int sb_pos = sb->value();
int sel_pos = m_log->textCursor().position();
int sel_start = m_log->textCursor().selectionStart();
int sel_end = m_log->textCursor().selectionEnd();
// clear selection or else it will get colorized as well
QTextCursor c = m_log->textCursor();
c.clearSelection();
m_log->setTextCursor(c);
// remove the new line because Qt's append adds a new line already.
text.chop(1);
QString suffix;
bool isSame = text == m_old_text;
// create counter suffix and remove recurring line if needed
if (m_stack_log)
{
if (isSame)
{
m_log_counter++;
suffix = QString(" x%1").arg(m_log_counter);
m_log->moveCursor(QTextCursor::End, QTextCursor::MoveAnchor);
m_log->moveCursor(QTextCursor::StartOfBlock, QTextCursor::MoveAnchor);
m_log->moveCursor(QTextCursor::End, QTextCursor::KeepAnchor);
m_log->textCursor().removeSelectedText();
m_log->textCursor().deletePreviousChar();
}
else
{
m_log_counter = 1;
m_old_text = text;
}
}
// add actual log message
m_log->setTextColor(m_color[static_cast<int>(packet->sev)]);
m_log->append(text);
// add counter suffix if needed
if (m_stack_log && isSame)
{
m_log->setTextColor(m_color_stack);
m_log->insertPlainText(suffix);
}
// if we mark text from right to left we need to swap sides (start is always smaller than end)
if (sel_pos < sel_end)
{
std::swap(sel_start, sel_end);
}
// reset old text cursor and selection
c.setPosition(sel_start);
c.setPosition(sel_end, QTextCursor::KeepAnchor);
m_log->setTextCursor(c);
// set scrollbar to max means auto-scroll
sb->setValue(isMax ? sb->maximum() : sb_pos);
}
// Drop packet
s_gui_listener.pop();
// Limit processing time
if (steady_clock::now() >= start + 7ms) break;
}
}
void RKProgressControlDialog::scrollDown () {
RK_TRACE (MISC);
QScrollBar *bar = output_text->verticalScrollBar ();
if (bar) bar->setValue (bar->maximum ());
}
/**
* Resize the scroll bars and center the point clicked.
*
*/
void StatisticsTool::resizeScrollbars() {
QScrollBar *hbar = p_visualScroll->horizontalScrollBar();
QScrollBar *vbar = p_visualScroll->verticalScrollBar();
hbar->setSliderPosition((hbar->maximum() + hbar->minimum()) / 2);
vbar->setSliderPosition((vbar->maximum() + vbar->minimum()) / 2);
}
void LogViewer::addText(const QString &text, int textType)
{
QString typeStr;
QString stringToAdd = "";
moveCursor(QTextCursor::End);
switch (textType)
{
case LogInfo:
setTextColor( Qt::black );
//typeStr = "[info ] ";
typeStr = "";
break;
case LogWarn:
setTextColor( QColor(100,100, 0) );
//typeStr = "[warn] ";
typeStr = "";
break;
case LogErr:
setTextColor( Qt::red );
//typeStr = "[error] ";
typeStr = "";
break;
case LogThreadId:
setTextColor( QColor(100,100,100) );
//typeStr = "[thread ] ";
typeStr = "";
break;
case LogTx:
setTextColor( Qt::blue );
//typeStr = "[tx ] ";
typeStr = "<< ";
break;
case LogRx:
setTextColor( QColor(150,0,255) );
//typeStr = "[rx ] ";
typeStr = ">> ";
break;
default:
setTextColor( Qt::black );
typeStr = "";
}
if ((lastTextType == LogTx) || (lastTextType == LogRx))
{
if (textType != lastTextType)
{
stringToAdd.append("\r");
stringToAdd.append(typeStr);
}
}
else
{
stringToAdd.append(typeStr);
}
stringToAdd.append(text);
if (!((textType == LogTx) || (textType == LogRx)))
stringToAdd.append("\r");
textCursor().insertText(stringToAdd);
lastTextType = textType;
QScrollBar *bar = verticalScrollBar();
bar->setValue(bar->maximum());
}
void ScriptConsoleView::scrollDown()
{
QScrollBar *scroll = m_ui->commandsList->verticalScrollBar();
scroll->setValue(scroll->maximum());
}
void Console::scrollDown() {
QScrollBar *vbar = verticalScrollBar();
vbar->setValue(vbar->maximum());
}
void MainWindow::on_actionGoDowm_triggered()
{
QScrollBar *bar = textBrowser->verticalScrollBar();
bar->setSliderPosition(bar->maximum());
}
void VMdEditor::makeBlockVisible(const QTextBlock &p_block)
{
if (!p_block.isValid() || !p_block.isVisible()) {
return;
}
QScrollBar *vbar = verticalScrollBar();
if (!vbar || (vbar->minimum() == vbar->maximum())) {
// No vertical scrollbar. No need to scroll.
return;
}
int height = rect().height();
QScrollBar *hbar = horizontalScrollBar();
if (hbar && (hbar->minimum() != hbar->maximum())) {
height -= hbar->height();
}
bool moved = false;
QAbstractTextDocumentLayout *layout = document()->documentLayout();
QRectF rect = layout->blockBoundingRect(p_block);
int y = GETVISUALOFFSETY;
int rectHeight = (int)rect.height();
// Handle the case rectHeight >= height.
if (rectHeight >= height) {
if (y < 0) {
// Need to scroll up.
while (y + rectHeight < height && vbar->value() > vbar->minimum()) {
moved = true;
vbar->setValue(vbar->value() - vbar->singleStep());
rect = layout->blockBoundingRect(p_block);
rectHeight = (int)rect.height();
y = GETVISUALOFFSETY;
}
} else if (y > 0) {
// Need to scroll down.
while (y > 0 && vbar->value() < vbar->maximum()) {
moved = true;
vbar->setValue(vbar->value() + vbar->singleStep());
rect = layout->blockBoundingRect(p_block);
rectHeight = (int)rect.height();
y = GETVISUALOFFSETY;
}
if (y < 0) {
// One step back.
moved = true;
vbar->setValue(vbar->value() - vbar->singleStep());
}
}
if (moved) {
qDebug() << "scroll to make huge block visible";
}
return;
}
while (y < 0 && vbar->value() > vbar->minimum()) {
moved = true;
vbar->setValue(vbar->value() - vbar->singleStep());
rect = layout->blockBoundingRect(p_block);
rectHeight = (int)rect.height();
y = GETVISUALOFFSETY;
}
if (moved) {
qDebug() << "scroll page down to make block visible";
return;
}
while (y + rectHeight > height && vbar->value() < vbar->maximum()) {
moved = true;
vbar->setValue(vbar->value() + vbar->singleStep());
rect = layout->blockBoundingRect(p_block);
rectHeight = (int)rect.height();
y = GETVISUALOFFSETY;
}
if (moved) {
qDebug() << "scroll page up to make block visible";
}
}
