Made TimeMarker::_view a non-const reference

[pulseview.git] / pv / view / cursorpair.cpp

diff --git a/pv/view/cursorpair.cpp b/pv/view/cursorpair.cpp
index 7fe90c7b6ef11ccb12d3a91d8a3bb05c53334ee9..83e6f7334cbd907a370265f6e18589fe9c572948 100644 (file)
--- a/pv/view/cursorpair.cpp
+++ b/pv/view/cursorpair.cpp
@@ -20,36 +20,132 @@
 
 #include "cursorpair.h"
 
+#include "ruler.h"
 #include "view.h"
 
+#include <algorithm>
+
+using namespace boost;
+using namespace std;
+
 namespace pv {
 namespace view {
 
-CursorPair::CursorPair(const View &view) :
-       _first(view, 0.0),
-       _second(view, 1.0),
+const int CursorPair::DeltaPadding = 8;
+
+CursorPair::CursorPair(View &view) :
+       _first(new Cursor(view, 0.0)),
+       _second(new Cursor(view, 1.0)),
        _view(view)
 {
 }
 
-const Cursor& CursorPair::first() const
+shared_ptr<Cursor> CursorPair::first() const
 {
        return _first;
 }
 
-Cursor& CursorPair::first()
+shared_ptr<Cursor> CursorPair::second() const
 {
-       return _first;
+       return _second;
 }
 
-const Cursor& CursorPair::second() const
+QRectF CursorPair::get_label_rect(const QRect &rect) const
 {
-       return _second;
+       const QSizeF label_size(
+               _text_size.width() + View::LabelPadding.width() * 2,
+               _text_size.height() + View::LabelPadding.height() * 2);
+       const pair<float, float> offsets(get_cursor_offsets());
+       const pair<float, float> normal_offsets(
+               (offsets.first < offsets.second) ? offsets :
+               make_pair(offsets.second, offsets.first));
+
+       const float height = label_size.height();
+       const float left = max(normal_offsets.first + DeltaPadding, -height);
+       const float right = min(normal_offsets.second - DeltaPadding,
+               (float)rect.width() + height);
+
+       return QRectF(left, rect.height() - label_size.height() -
+               Cursor::ArrowSize - Cursor::Offset - 0.5f,
+               right - left, height);
 }
 
-Cursor& CursorPair::second()
+void CursorPair::draw_markers(QPainter &p,
+       const QRect &rect, unsigned int prefix)
 {
-       return _second;
+       assert(_first);
+       assert(_second);
+
+       compute_text_size(p, prefix);
+       QRectF delta_rect(get_label_rect(rect));
+
+       const int radius = delta_rect.height() / 2;
+       const QRectF text_rect(delta_rect.intersected(
+               rect).adjusted(radius, 0, -radius, 0));
+       if(text_rect.width() >= _text_size.width())
+       {
+               const int highlight_radius = delta_rect.height() / 2 - 2;
+
+               p.setBrush(Cursor::FillColour);
+               p.setPen(Cursor::LineColour);
+               p.drawRoundedRect(delta_rect, radius, radius);
+
+               delta_rect.adjust(1, 1, -1, -1);
+               p.setPen(Cursor::HighlightColour);
+               p.drawRoundedRect(delta_rect, highlight_radius, highlight_radius);
+
+               p.setPen(Cursor::TextColour);
+               p.drawText(text_rect, Qt::AlignCenter | Qt::AlignVCenter,
+                       Ruler::format_time(_second->time() - _first->time(), prefix, 2));
+       }
+
+       // Paint the cursor markers
+       _first->paint_label(p, rect, prefix);
+       _second->paint_label(p, rect, prefix);
+}
+
+void CursorPair::draw_viewport_background(QPainter &p,
+       const QRect &rect)
+{
+       p.setPen(Qt::NoPen);
+       p.setBrush(QBrush(View::CursorAreaColour));
+
+       const pair<float, float> offsets(get_cursor_offsets());
+       const int l = (int)max(min(
+               offsets.first, offsets.second), 0.0f);
+       const int r = (int)min(max(
+               offsets.first, offsets.second), (float)rect.width());
+
+       p.drawRect(l, 0, r - l, rect.height());
+}
+
+void CursorPair::draw_viewport_foreground(QPainter &p,
+       const QRect &rect)
+{
+       assert(_first);
+       assert(_second);
+
+       _first->paint(p, rect);
+       _second->paint(p, rect);
+}
+
+void CursorPair::compute_text_size(QPainter &p, unsigned int prefix)
+{
+       assert(_first);
+       assert(_second);
+
+       _text_size = p.boundingRect(QRectF(), 0, Ruler::format_time(
+               _second->time() - _first->time(), prefix, 2)).size();
+}
+
+pair<float, float> CursorPair::get_cursor_offsets() const
+{
+       assert(_first);
+       assert(_second);
+
+       return pair<float, float>(
+               (_first->time() - _view.offset()) / _view.scale(),
+               (_second->time() - _view.offset()) / _view.scale());
 }
 
 } // namespace view