: QObject(parent)
{
}
-
-// void AbstractMessageProcessor::postProcess(Message &msg) {
-// Client::buffer(msg.bufferInfo())->updateActivityLevel(msg);
-// }
class AbstractMessageProcessor : public QObject {
Q_OBJECT
- public:
- AbstractMessageProcessor(QObject *parent);
- virtual void reset() = 0;
+public:
+ AbstractMessageProcessor(QObject *parent);
+ virtual void reset() = 0;
- public slots:
- virtual void process(Message &msg) = 0;
- virtual void process(QList<Message> &msgs) = 0;
-
- signals:
- void progressUpdated(int value, int maximum);
-
- protected:
- inline void postProcess(Message &msg) { Client::networkModel()->updateBufferActivity(msg); }
+public slots:
+ virtual void process(Message &msg) = 0;
+ virtual void process(QList<Message> &msgs) = 0;
+protected:
+ inline void postProcess(Message &msg) { Client::networkModel()->updateBufferActivity(msg); }
};
#endif
BacklogRequester::BacklogRequester(bool buffering, ClientBacklogManager *backlogManager)
: backlogManager(backlogManager),
- _isBuffering(buffering)
+ _isBuffering(buffering),
+ _totalBuffers(0)
{
Q_ASSERT(backlogManager);
}
+void BacklogRequester::setWaitingBuffers(const QSet<BufferId> &buffers) {
+ _buffersWaiting = buffers;
+ _totalBuffers = _buffersWaiting.count();
+}
+
+void BacklogRequester::addWaitingBuffer(BufferId buffer) {
+ _buffersWaiting << buffer;
+ _totalBuffers++;
+}
+
bool BacklogRequester::buffer(BufferId bufferId, const MessageList &messages) {
_bufferedMessages << messages;
_buffersWaiting.remove(bufferId);
inline bool isBuffering() { return _isBuffering; }
inline const QList<Message> &bufferedMessages() { return _bufferedMessages; }
+ inline int buffersWaiting() const { return _buffersWaiting.count(); }
+ inline int totalBuffers() const { return _totalBuffers; }
//! returns false if it was the last missing backlogpart
bool buffer(BufferId bufferId, const MessageList &messages);
protected:
inline QList<BufferId> allBufferIds() const { return Client::networkModel()->allBufferIds(); }
- inline void setWaitingBuffers(const QList<BufferId> &buffers) { _buffersWaiting = buffers.toSet(); }
- inline void setWaitingBuffers(const QSet<BufferId> &buffers) { _buffersWaiting = buffers; }
- inline void addWaitingBuffer(BufferId buffer) { _buffersWaiting << buffer; }
+ inline void setWaitingBuffers(const QList<BufferId> &buffers) { setWaitingBuffers(buffers.toSet()); }
+ void setWaitingBuffers(const QSet<BufferId> &buffers);
+ void addWaitingBuffer(BufferId buffer);
ClientBacklogManager *backlogManager;
private:
bool _isBuffering;
MessageList _bufferedMessages;
+ int _totalBuffers;
QSet<BufferId> _buffersWaiting;
};
}
if(isBuffering()) {
- if(!_requester->buffer(bufferId, msglist)) {
- // this was the last part to buffer
+ bool lastPart = !_requester->buffer(bufferId, msglist);
+ updateProgress(_requester->totalBuffers() - _requester->buffersWaiting(), _requester->totalBuffers());
+ if(lastPart) {
stopBuffering();
reset();
}
};
_requester->requestBacklog();
+ if(_requester->isBuffering()) {
+ updateProgress(0, _requester->totalBuffers());
+ }
}
void ClientBacklogManager::stopBuffering() {
void messagesRequested(const QString &) const;
void messagesProcessed(const QString &) const;
+ void updateProgress(int, int);
+
private:
bool isBuffering();
void stopBuffering();
void MainWin::setupStatusBar() {
// MessageProcessor progress
statusBar()->addPermanentWidget(msgProcessorStatusWidget);
- connect(Client::messageProcessor(), SIGNAL(progressUpdated(int, int)), msgProcessorStatusWidget, SLOT(setProgress(int, int)));
// Core Lag:
updateLagIndicator();
connect(showStatusbar, SIGNAL(toggled(bool)), statusBar(), SLOT(setVisible(bool)));
connect(showStatusbar, SIGNAL(toggled(bool)), this, SLOT(saveStatusBarStatus(bool)));
-
- connect(Client::backlogManager(), SIGNAL(messagesRequested(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
- connect(Client::backlogManager(), SIGNAL(messagesProcessed(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
}
void MainWin::saveStatusBarStatus(bool enabled) {
action->setVisible(!Client::internalCore());
}
+ disconnect(Client::backlogManager(), SIGNAL(updateProgress(int, int)), msgProcessorStatusWidget, SLOT(setProgress(int, int)));
+ disconnect(Client::backlogManager(), SIGNAL(messagesRequested(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ disconnect(Client::backlogManager(), SIGNAL(messagesProcessed(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ if(!Client::internalCore()) {
+ connect(Client::backlogManager(), SIGNAL(updateProgress(int, int)), msgProcessorStatusWidget, SLOT(setProgress(int, int)));
+ connect(Client::backlogManager(), SIGNAL(messagesRequested(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ connect(Client::backlogManager(), SIGNAL(messagesProcessed(const QString &)), this, SLOT(showStatusBarMessage(const QString &)));
+ }
+
// _viewMenu->setEnabled(true);
if(!Client::internalCore())
statusBar()->showMessage(tr("Connected to core."));
#include "msgprocessorstatuswidget.h"
-MsgProcessorStatusWidget::MsgProcessorStatusWidget(QWidget *parent) : QWidget(parent) {
+MsgProcessorStatusWidget::MsgProcessorStatusWidget(QWidget *parent)
+ : QWidget(parent)
+{
ui.setupUi(this);
-
hide();
}
void MsgProcessorStatusWidget::setProgress(int value, int max) {
- if(max <= 0) {
+ if(max <= 0 || value == max) {
hide();
} else {
- if(isHidden()) show();
+ if(isHidden())
+ show();
ui.progressBar->setMaximum(max);
ui.progressBar->setValue(value);
}
class MsgProcessorStatusWidget : public QWidget {
Q_OBJECT
- public:
- MsgProcessorStatusWidget(QWidget *parent = 0);
+public:
+ MsgProcessorStatusWidget(QWidget *parent = 0);
- public slots:
- void setProgress(int value, int max);
-
- private:
- Ui::MsgProcessorStatusWidget ui;
+public slots:
+ void setProgress(int value, int max);
+private:
+ Ui::MsgProcessorStatusWidget ui;
};
#endif
QtUiMessageProcessor::QtUiMessageProcessor(QObject *parent)
: AbstractMessageProcessor(parent),
_processing(false),
- _processMode(TimerBased),
- _msgsProcessed(0),
- _msgCount(0)
+ _processMode(TimerBased)
{
NotificationSettings notificationSettings;
_nicksCaseSensitive = notificationSettings.nicksCaseSensitive();
if(msgs.isEmpty()) return;
_processQueue.append(msgs);
- _msgCount += msgs.count();
- if(!isProcessing()) startProcessing();
- else updateProgress();
+ if(!isProcessing())
+ startProcessing();
}
void QtUiMessageProcessor::startProcessing() {
if(processMode() == TimerBased) {
- if(_currentBatch.isEmpty() && _processQueue.isEmpty()) return;
+ if(_currentBatch.isEmpty() && _processQueue.isEmpty())
+ return;
_processing = true;
- _msgsProcessed = 0;
- _msgCount = _currentBatch.count();
- foreach(QList<Message> msglist, _processQueue) _msgCount += msglist.count();
- updateProgress();
- if(!_processTimer.isActive()) _processTimer.start();
+ if(!_processTimer.isActive())
+ _processTimer.start();
}
}
if(_processQueue.isEmpty()) {
_processTimer.stop();
_processing = false;
- _msgsProcessed = _msgCount = 0;
- updateProgress();
return;
}
_currentBatch = _processQueue.takeFirst();
}
Message msg = _currentBatch.takeFirst();
process(msg);
- _msgsProcessed++;
- updateProgress();
-}
-
-void QtUiMessageProcessor::updateProgress(bool start) {
- if(start) {
- _progressTimer.start();
- emit progressUpdated(_msgsProcessed, _msgCount);
- } else {
- if(_msgCount == 0 || _progressTimer.elapsed() >= progressUpdateDelay) {
- _progressTimer.restart();
- emit progressUpdated(_msgsProcessed, _msgCount);
- }
- }
}
void QtUiMessageProcessor::checkForHighlight(Message &msg) {
private:
void checkForHighlight(Message &msg);
void startProcessing();
- void updateProgress(bool start = false);
QList<QList<Message> > _processQueue;
QList<Message> _currentBatch;
QTimer _processTimer;
bool _processing;
Mode _processMode;
- int _msgsProcessed, _msgCount;
- QTime _progressTimer;
struct HighlightRule {
QString name;
<rect>
<x>0</x>
<y>0</y>
- <width>229</width>
+ <width>251</width>
<height>26</height>
</rect>
</property>
<item>
<widget class="QLabel" name="label" >
<property name="text" >
- <string>Processing Messages</string>
+ <string>Receiving Backlog</string>
</property>
</widget>
</item>