src/qtui/chatview.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2019 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "chatview.h"
  22
  23 #include <algorithm>
  24
  25 #include <QGraphicsTextItem>
  26 #include <QKeyEvent>
  27 #include <QMenu>
  28 #include <QScrollBar>
  29
  30 #include "bufferwidget.h"
  31 #include "chatline.h"
  32 #include "chatscene.h"
  33 #include "client.h"
  34 #include "clientignorelistmanager.h"
  35 #include "messagefilter.h"
  36 #include "qtui.h"
  37 #include "qtuistyle.h"
  38
  39 ChatView::ChatView(BufferId bufferId, QWidget* parent)
  40     : QGraphicsView(parent)
  41     , AbstractChatView()
  42 {
  43     QList<BufferId> filterList;
  44     filterList.append(bufferId);
  45     auto* filter = new MessageFilter(Client::messageModel(), filterList, this);
  46     init(filter);
  47 }
  48
  49 ChatView::ChatView(MessageFilter* filter, QWidget* parent)
  50     : QGraphicsView(parent)
  51     , AbstractChatView()
  52 {
  53     init(filter);
  54 }
  55
  56 void ChatView::init(MessageFilter* filter)
  57 {
  58     _bufferContainer = nullptr;
  59     _currentScaleFactor = 1;
  60     _invalidateFilter = false;
  61
  62     setAttribute(Qt::WA_AcceptTouchEvents);
  63     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
  64     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
  65     setAlignment(Qt::AlignLeft | Qt::AlignBottom);
  66     setInteractive(true);
  67     // setOptimizationFlags(QGraphicsView::DontClipPainter | QGraphicsView::DontAdjustForAntialiasing);
  68     // setOptimizationFlags(QGraphicsView::DontAdjustForAntialiasing);
  69     setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
  70     // setTransformationAnchor(QGraphicsView::NoAnchor);
  71     setTransformationAnchor(QGraphicsView::AnchorViewCenter);
  72
  73     _scrollTimer.setInterval(100);
  74     _scrollTimer.setSingleShot(true);
  75     connect(&_scrollTimer, &QTimer::timeout, this, &ChatView::scrollTimerTimeout);
  76
  77     _scene = new ChatScene(filter, filter->idString(), viewport()->width(), this);
  78     connect(_scene, &QGraphicsScene::sceneRectChanged, this, &ChatView::adjustSceneRect);
  79     connect(_scene, &ChatScene::lastLineChanged, this, &ChatView::lastLineChanged);
  80     connect(_scene, &ChatScene::mouseMoveWhileSelecting, this, &ChatView::mouseMoveWhileSelecting);
  81     setScene(_scene);
  82
  83     connect(verticalScrollBar(), &QAbstractSlider::valueChanged, this, &ChatView::verticalScrollbarChanged);
  84     _lastScrollbarPos = verticalScrollBar()->maximum();
  85
  86     connect(Client::networkModel(), &NetworkModel::markerLineSet, this, &ChatView::markerLineSet);
  87
  88     // only connect if client is synched with a core
  89     if (Client::isConnected())
  90         connect(Client::ignoreListManager(), &ClientIgnoreListManager::ignoreListChanged, this, &ChatView::invalidateFilter);
  91 }
  92
  93 bool ChatView::event(QEvent* event)
  94 {
  95     if (event->type() == QEvent::KeyPress) {
  96         auto* keyEvent = static_cast<QKeyEvent*>(event);
  97         switch (keyEvent->key()) {
  98         case Qt::Key_Up:
  99         case Qt::Key_Down:
 100         case Qt::Key_PageUp:
 101         case Qt::Key_PageDown:
 102             if (!verticalScrollBar()->isVisible()) {
 103                 scene()->requestBacklog();
 104                 return true;
 105             }
 106         default:
 107             break;
 108         }
 109     }
 110
 111     if (event->type() == QEvent::TouchBegin && ((QTouchEvent*)event)->device()->type() == QTouchDevice::TouchScreen) {
 112         // Enable scrolling by draging, disable selecting/clicking content
 113         setDragMode(QGraphicsView::ScrollHandDrag);
 114         setInteractive(false);
 115         // if scrollbar is not visible we need to request backlog below else we need to accept
 116         // the event now (return true) so that we will receive TouchUpdate and TouchEnd/TouchCancel
 117         if (verticalScrollBar()->isVisible())
 118             return true;
 119     }
 120
 121     if (event->type() == QEvent::TouchEnd || event->type() == QEvent::TouchCancel) {
 122         // End scroll and reset settings to default
 123         setDragMode(QGraphicsView::NoDrag);
 124         setInteractive(true);
 125         _firstTouchUpdateHappened = false;
 126         return true;
 127     }
 128
 129     if (event->type() == QEvent::TouchUpdate) {
 130         if (!_firstTouchUpdateHappened) {
 131             // After the first movement of a Touch-Point, calculate the distance in both axis
 132             // and if the point moved more horizontally abort scroll.
 133             QTouchEvent::TouchPoint p = ((QTouchEvent*)event)->touchPoints().at(0);
 134             double dx = qAbs(p.lastPos().x() - p.pos().x());
 135             double dy = qAbs(p.lastPos().y() - p.pos().y());
 136             if (dx > dy) {
 137                 setDragMode(QGraphicsView::NoDrag);
 138                 setInteractive(true);
 139             }
 140             _firstTouchUpdateHappened = true;
 141         }
 142         // Applying the movement happens automatically by the drag-mode
 143     }
 144     if (event->type() == QEvent::Wheel
 145         || (event->type() == QEvent::TouchBegin && ((QTouchEvent*)event)->device()->type() == QTouchDevice::TouchScreen)
 146         || event->type() == QEvent::TouchUpdate) {
 147         if (!verticalScrollBar()->isVisible()) {
 148             scene()->requestBacklog();
 149             return true;
 150         }
 151     }
 152
 153     if (event->type() == QEvent::Show) {
 154         if (_invalidateFilter)
 155             invalidateFilter();
 156     }
 157
 158     return QGraphicsView::event(event);
 159 }
 160
 161 void ChatView::resizeEvent(QResizeEvent* event)
 162 {
 163     // if view is currently scrolled to bottom, we want it that way after resizing
 164     bool atBottom = (_lastScrollbarPos == verticalScrollBar()->maximum());
 165
 166     QGraphicsView::resizeEvent(event);
 167
 168     // if scrolling to bottom, do it immediately.
 169     if (atBottom) {
 170         // we can reduce viewport updates if we scroll to the bottom allready at the beginning
 171         verticalScrollBar()->setValue(verticalScrollBar()->maximum());
 172     }
 173
 174     scene()->updateForViewport(viewport()->width(), viewport()->height());
 175     adjustSceneRect();
 176
 177     if (atBottom) {
 178         _lastScrollbarPos = verticalScrollBar()->maximum();
 179         verticalScrollBar()->setValue(verticalScrollBar()->maximum());
 180     }
 181     checkChatLineCaches();
 182 }
 183
 184 void ChatView::adjustSceneRect()
 185 {
 186     // Workaround for QTBUG-6322
 187     // If the viewport's sceneRect() is (almost) as wide as as the viewport itself,
 188     // Qt wants to reserve space for scrollbars even if they're turned off, resulting in
 189     // an ugly white space at the bottom of the ChatView.
 190     // Since the view's scene's width actually doesn't matter at all, we just adjust it
 191     // by some hopefully large enough value to avoid this problem.
 192
 193     setSceneRect(scene()->sceneRect().adjusted(0, 0, -25, 0));
 194 }
 195
 196 void ChatView::mouseMoveWhileSelecting(const QPointF& scenePos)
 197 {
 198     int y = (int)mapFromScene(scenePos).y();
 199     _scrollOffset = 0;
 200     if (y < 0)
 201         _scrollOffset = y;
 202     else if (y > height())
 203         _scrollOffset = y - height();
 204
 205     if (_scrollOffset && !_scrollTimer.isActive())
 206         _scrollTimer.start();
 207 }
 208
 209 void ChatView::scrollTimerTimeout()
 210 {
 211     // scroll view
 212     QAbstractSlider* vbar = verticalScrollBar();
 213     if (_scrollOffset < 0 && vbar->value() > 0)
 214         vbar->setValue(qMax(vbar->value() + _scrollOffset, 0));
 215     else if (_scrollOffset > 0 && vbar->value() < vbar->maximum())
 216         vbar->setValue(qMin(vbar->value() + _scrollOffset, vbar->maximum()));
 217 }
 218
 219 void ChatView::lastLineChanged(QGraphicsItem* chatLine, qreal offset)
 220 {
 221     Q_UNUSED(chatLine)
 222     // disabled until further testing/discussion
 223     // if(!scene()->isScrollingAllowed())
 224     //  return;
 225
 226     QAbstractSlider* vbar = verticalScrollBar();
 227     Q_ASSERT(vbar);
 228     if (vbar->maximum() - vbar->value() <= (offset + 5) * _currentScaleFactor) {  // 5px grace area
 229         vbar->setValue(vbar->maximum());
 230     }
 231 }
 232
 233 void ChatView::verticalScrollbarChanged(int newPos)
 234 {
 235     QAbstractSlider* vbar = verticalScrollBar();
 236     Q_ASSERT(vbar);
 237
 238     // check for backlog request
 239     if (newPos < _lastScrollbarPos) {
 240         int relativePos = 100;
 241         if (vbar->maximum() - vbar->minimum() != 0)
 242             relativePos = (newPos - vbar->minimum()) * 100 / (vbar->maximum() - vbar->minimum());
 243
 244         if (relativePos < 20) {
 245             scene()->requestBacklog();
 246         }
 247     }
 248     _lastScrollbarPos = newPos;
 249
 250     // FIXME: Fugly workaround for the ChatView scrolling up 1px on buffer switch
 251     if (vbar->maximum() - newPos <= 2)
 252         vbar->setValue(vbar->maximum());
 253 }
 254
 255 MsgId ChatView::lastMsgId() const
 256 {
 257     if (!scene())
 258         return {};
 259
 260     QAbstractItemModel* model = scene()->model();
 261     if (!model || model->rowCount() == 0)
 262         return {};
 263
 264     return model->index(model->rowCount() - 1, 0).data(MessageModel::MsgIdRole).value<MsgId>();
 265 }
 266
 267 MsgId ChatView::lastVisibleMsgId() const
 268 {
 269     ChatLine* line = lastVisibleChatLine();
 270
 271     if (line)
 272         return line->msgId();
 273
 274     return {};
 275 }
 276
 277 bool chatLinePtrLessThan(ChatLine* one, ChatLine* other)
 278 {
 279     return one->row() < other->row();
 280 }
 281
 282 // TODO: figure out if it's cheaper to use a cached list (that we'd need to keep updated)
 283 QSet<ChatLine*> ChatView::visibleChatLines(Qt::ItemSelectionMode mode) const
 284 {
 285     QSet<ChatLine*> result;
 286     foreach (QGraphicsItem* item, items(viewport()->rect().adjusted(-1, -1, 1, 1), mode)) {
 287         auto* line = qgraphicsitem_cast<ChatLine*>(item);
 288         if (line)
 289             result.insert(line);
 290     }
 291     return result;
 292 }
 293
 294 QList<ChatLine*> ChatView::visibleChatLinesSorted(Qt::ItemSelectionMode mode) const
 295 {
 296     QList<ChatLine*> result = visibleChatLines(mode).toList();
 297     std::sort(result.begin(), result.end(), chatLinePtrLessThan);
 298     return result;
 299 }
 300
 301 ChatLine* ChatView::lastVisibleChatLine(bool ignoreDayChange) const
 302 {
 303     if (!scene())
 304         return nullptr;
 305
 306     QAbstractItemModel* model = scene()->model();
 307     if (!model || model->rowCount() == 0)
 308         return nullptr;
 309
 310     int row = -1;
 311
 312     QSet<ChatLine*> visibleLines = visibleChatLines(Qt::ContainsItemBoundingRect);
 313     foreach (ChatLine* line, visibleLines) {
 314         if (line->row() > row && (ignoreDayChange ? line->msgType() != Message::DayChange : true))
 315             row = line->row();
 316     }
 317
 318     if (row >= 0)
 319         return scene()->chatLine(row);
 320
 321     return nullptr;
 322 }
 323
 324 void ChatView::setMarkerLineVisible(bool visible)
 325 {
 326     scene()->setMarkerLineVisible(visible);
 327 }
 328
 329 void ChatView::setMarkerLine(MsgId msgId)
 330 {
 331     if (!scene()->isSingleBufferScene())
 332         return;
 333
 334     BufferId bufId = scene()->singleBufferId();
 335     Client::setMarkerLine(bufId, msgId);
 336 }
 337
 338 void ChatView::markerLineSet(BufferId buffer, MsgId msgId)
 339 {
 340     if (!scene()->isSingleBufferScene() || scene()->singleBufferId() != buffer)
 341         return;
 342
 343     scene()->setMarkerLine(msgId);
 344     scene()->setMarkerLineVisible(true);
 345 }
 346
 347 void ChatView::jumpToMarkerLine(bool requestBacklog)
 348 {
 349     scene()->jumpToMarkerLine(requestBacklog);
 350 }
 351
 352 void ChatView::addActionsToMenu(QMenu* menu, const QPointF& pos)
 353 {
 354     // zoom actions
 355     auto* bw = qobject_cast<BufferWidget*>(bufferContainer());
 356     if (bw) {
 357         bw->addActionsToMenu(menu, pos);
 358         menu->addSeparator();
 359     }
 360 }
 361
 362 void ChatView::zoomIn()
 363 {
 364     _currentScaleFactor *= 1.2;
 365     scale(1.2, 1.2);
 366     scene()->setWidth(viewport()->width() / _currentScaleFactor - 2);
 367 }
 368
 369 void ChatView::zoomOut()
 370 {
 371     _currentScaleFactor /= 1.2;
 372     scale(1 / 1.2, 1 / 1.2);
 373     scene()->setWidth(viewport()->width() / _currentScaleFactor - 2);
 374 }
 375
 376 void ChatView::zoomOriginal()
 377 {
 378     scale(1 / _currentScaleFactor, 1 / _currentScaleFactor);
 379     _currentScaleFactor = 1;
 380     scene()->setWidth(viewport()->width() - 2);
 381 }
 382
 383 void ChatView::invalidateFilter()
 384 {
 385     // if this is the currently selected chatview
 386     // invalidate immediately
 387     if (isVisible()) {
 388         _scene->filter()->invalidateFilter();
 389         _invalidateFilter = false;
 390     }
 391     // otherwise invalidate whenever the view is shown
 392     else {
 393         _invalidateFilter = true;
 394     }
 395 }
 396
 397 void ChatView::scrollContentsBy(int dx, int dy)
 398 {
 399     QGraphicsView::scrollContentsBy(dx, dy);
 400     checkChatLineCaches();
 401 }
 402
 403 void ChatView::setHasCache(ChatLine* line, bool hasCache)
 404 {
 405     if (hasCache)
 406         _linesWithCache.insert(line);
 407     else
 408         _linesWithCache.remove(line);
 409 }
 410
 411 void ChatView::checkChatLineCaches()
 412 {
 413     qreal top = mapToScene(viewport()->rect().topLeft()).y() - 10;  // some grace area to avoid premature cleaning
 414     qreal bottom = mapToScene(viewport()->rect().bottomRight()).y() + 10;
 415     QSet<ChatLine*>::iterator iter = _linesWithCache.begin();
 416     while (iter != _linesWithCache.end()) {
 417         ChatLine* line = *iter;
 418         if (line->pos().y() + line->height() < top || line->pos().y() > bottom) {
 419             line->clearCache();
 420             iter = _linesWithCache.erase(iter);
 421         }
 422         else
 423             ++iter;
 424     }
 425 }