void thread () { while (!mKillThread) { auto nextTimePoint = std::chrono::steady_clock::now() + tickInterval(); // If an octet is available from the write buffer, load it into the // intermediate buffer. Otherwise, push nothing to keep the pipe // flowing. uint8_t octet; //printf("%s moving an octet from write buffer to intermediate buffer\n", mDebugName.c_str()); mMedium.push(mWriteQueue.try_pop(octet) ? Quantum(octet) : Quantum(boost::none)); // Feed the deliver callback if there's an octet available. auto quantum = mMedium.front(); mMedium.pop(); if (quantum) { //printf("%s outputing an octet\n", mDebugName.c_str()); output(*quantum); } //printf("%s cycle complete\n", mDebugName.c_str()); if (nextTimePoint < std::chrono::steady_clock::now()) { //fprintf(stderr, "Process is too slow to simulate this baud rate.\n"); } else { std::this_thread::sleep_until(nextTimePoint); } } }
// Function copied from qslider.cpp and modified to make it compile void Slider::initStyleOption_Qt430( QStyleOptionSlider *option ) const { if (!option) return; option->initFrom( this ); option->subControls = QStyle::SC_None; option->activeSubControls = QStyle::SC_None; option->orientation = orientation(); option->maximum = maximum(); option->minimum = minimum(); option->tickPosition = (QSlider::TickPosition) tickPosition(); option->tickInterval = tickInterval(); option->upsideDown = (orientation() == Qt::Horizontal) ? (invertedAppearance() != (option->direction == Qt::RightToLeft)) : (!invertedAppearance()); option->direction = Qt::LeftToRight; // we use the upsideDown option instead option->sliderPosition = sliderPosition(); option->sliderValue = value(); option->singleStep = singleStep(); option->pageStep = pageStep(); if (orientation() == Qt::Horizontal) option->state |= QStyle::State_Horizontal; }
void TickSlider::addDefaultTickLabels() { int interval = tickInterval(); if (interval == 0) { interval = pageStep(); } for (int i = minimum(); i <= maximum(); i += interval) { m_tick_labels[i] = QString::number(i); } }
QSize TickSlider::sizeHint() const { QSize size = QSlider::sizeHint(); bool using_labels = tickLabelPosition() != NoTicks; QSize label = using_labels ? biggestLabel() : QSize(); bool using_ticks = tickPosition() != NoTicks; int n_potential_labels = (maximum() - minimum()) / tickInterval(); if (orientation() == Qt::Horizontal) { // Horizontal if (using_labels) { size.rheight() += 2 * label.height(); size = size.expandedTo(QSize( n_potential_labels * label.width() + (n_potential_labels - 1) * m_min_interlabel_gap, 0)); } if (using_ticks) { size.rheight() += 2 * m_tick_length; } if (using_labels && using_ticks) { size.rheight() += 2 * m_tick_label_gap; } if (using_labels || using_ticks) { size.rheight() += 2 * m_gap_to_slider; } } else { // Vertical if (using_labels) { size.rwidth() += 2 * label.width(); size = size.expandedTo(QSize( 0, n_potential_labels * label.height() + (n_potential_labels - 1) * m_min_interlabel_gap)); } if (using_ticks) { size.rwidth() += 2 * m_tick_length; } if (using_labels && using_ticks) { size.rwidth() += 2 * m_tick_label_gap; } if (using_labels || using_ticks) { size.rwidth() += 2 * m_gap_to_slider; } } return size; }
int QSlider::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QAbstractSlider::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 2) qt_static_metacall(this, _c, _id, _a); _id -= 2; } #ifndef QT_NO_PROPERTIES else if (_c == QMetaObject::ReadProperty) { void *_v = _a[0]; switch (_id) { case 0: *reinterpret_cast< TickPosition*>(_v) = tickPosition(); break; case 1: *reinterpret_cast< int*>(_v) = tickInterval(); break; } _id -= 2; } else if (_c == QMetaObject::WriteProperty) { void *_v = _a[0]; switch (_id) { case 0: setTickPosition(*reinterpret_cast< TickPosition*>(_v)); break; case 1: setTickInterval(*reinterpret_cast< int*>(_v)); break; } _id -= 2; } else if (_c == QMetaObject::ResetProperty) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyDesignable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyScriptable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyStored) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyEditable) { _id -= 2; } else if (_c == QMetaObject::QueryPropertyUser) { _id -= 2; } #endif // QT_NO_PROPERTIES return _id; }
void TickSlider::paintEvent(QPaintEvent *ev) { Q_UNUSED(ev) QStylePainter p(this); QStyleOptionSlider opt; initStyleOption(&opt); QRect handle = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this); // Draw the slider first opt.subControls = QStyle::SC_SliderGroove | QStyle::SC_SliderHandle; opt.activeSubControls = getHoverControl(); // addition here p.drawComplexControl(QStyle::CC_Slider, opt); // draw tick marks // do this manually because they are very badly behaved with style sheets int interval = tickInterval(); if (interval == 0) { interval = pageStep(); } // see http://doc.qt.io/qt-5.7/coordsys.html // ... positive is right and down bool using_ticks = tickPosition() != NoTicks; bool using_labels = tickLabelPosition() != NoTicks; if (!using_ticks && !using_labels) { return; } QPen pen; pen.setColor(m_tick_colour); pen.setWidth(m_tick_thickness); p.setPen(pen); bool horizontal = orientation() == Qt::Horizontal; QSize biggest_label = biggestLabel(); int max_label_height = using_labels ? biggest_label.height() : 0; int max_label_width = using_labels ? biggest_label.width() : 0; if (horizontal) { // -------------------------------------------------------------------- // HORIZONTAL // -------------------------------------------------------------------- int move_tick_vertically_by = (max_label_height > 0) ? (max_label_height + m_tick_label_gap) : 0; // Top int bounding_box_top = this->rect().top(); int top_label_top = bounding_box_top; int top_tick_top = bounding_box_top + move_tick_vertically_by; int top_tick_bottom = top_tick_top + m_tick_length; // Bottom, working up int bounding_box_bottom = this->rect().bottom(); int bottom_label_bottom = bounding_box_bottom; int bottom_tick_bottom = bounding_box_bottom - move_tick_vertically_by; int bottom_tick_top = bottom_tick_bottom - m_tick_length; // OK: for (int i = minimum(); i <= maximum(); i += interval) { Qt::Alignment halign = Qt::AlignHCenter; if (m_edge_in_extreme_labels) { bool leftmost = i == minimum(); bool rightmost = i == maximum(); if (leftmost) { halign = Qt::AlignLeft; } else if (rightmost) { halign = Qt::AlignRight; } } int q = m_reverse_horizontal_labels ? (maximum() - i) : i; int x = round( (double)( (double)( (double)(q - this->minimum()) / (double)(this->maximum() - this->minimum()) ) * (double)(this->width() - handle.width()) + (double)(handle.width() / 2.0) ) ) - 1; bool has_label = m_tick_labels.contains(i); QString label_text; if (has_label) { label_text = m_tick_labels[i]; } if (tickPosition() == TicksBothSides || tickPosition() == TicksAbove) { p.drawLine(x, top_tick_top, x, top_tick_bottom); } if (has_label && (tickLabelPosition() == TicksBothSides || tickLabelPosition() == TicksAbove)) { UiFunc::drawText(p, x, top_label_top, halign | Qt::AlignTop, label_text); } if (tickPosition() == TicksBothSides || tickPosition() == TicksBelow) { p.drawLine(x, bottom_tick_top, x, bottom_tick_bottom); } if (has_label && (tickLabelPosition() == TicksBothSides || tickLabelPosition() == TicksBelow)) { UiFunc::drawText(p, x, bottom_label_bottom, halign | Qt::AlignBottom, label_text); } } } else { // -------------------------------------------------------------------- // VERTICAL // -------------------------------------------------------------------- int move_tick_horizontally_by = (max_label_width > 0) ? (max_label_width + m_tick_label_gap) : 0; // Left int bounding_box_left = this->rect().left(); int left_label_right = bounding_box_left + max_label_width; int left_tick_left = bounding_box_left + move_tick_horizontally_by; int left_tick_right = left_tick_left + m_tick_length; // Right, working leftwards int bounding_box_right = this->rect().right(); int right_label_left = bounding_box_right - max_label_width; int right_tick_right = bounding_box_right - move_tick_horizontally_by; int right_tick_left = right_tick_right - m_tick_length; // OK: for (int i = minimum(); i <= maximum(); i += interval) { Qt::Alignment valign = Qt::AlignVCenter; int q = m_reverse_vertical_labels ? (maximum() - i) : i; int y = round( (double)( (double)( (double)(q - this->minimum()) / (double)(this->maximum() - this->minimum()) ) * (double)(this->height() - handle.height()) + (double)(handle.height() / 2.0) ) ) - 1; bool has_label = m_tick_labels.contains(i); QString label_text; if (has_label) { label_text = m_tick_labels[i]; } if (tickPosition() == TicksBothSides || tickPosition() == TicksLeft) { p.drawLine(left_tick_left, y, left_tick_right, y); } if (has_label && (tickLabelPosition() == TicksBothSides || tickLabelPosition() == TicksLeft)) { UiFunc::drawText(p, left_label_right, y, Qt::AlignRight | valign, label_text); } if (tickPosition() == TicksBothSides || tickPosition() == TicksRight) { p.drawLine(right_tick_left, y, right_tick_right, y); } if (has_label && (tickLabelPosition() == TicksBothSides || tickLabelPosition() == TicksRight)) { UiFunc::drawText(p, right_label_left, y, Qt::AlignLeft | valign, label_text); } } } }