NNTPGrab - /trunk/client/gui_qt/WidgetDownloadQueue.cpp - Diff - NNTPGrab

Revision 1776 trunk/client/gui_qt/WidgetDownloadQueue.cpp

                       ui->setupUi(this);
                       ui->treeWidget->header()->setResizeMode(QHeaderView::ResizeToContents);
                       ui->treeView->header()->setResizeMode(QHeaderView::ResizeToContents);
                       this->model = new DownloadQueueModel(glue);
                       ui->treeView->setModel(this->model);
                       progressbarDelegate = new ProgressBarDelegateDownloadQueue(this);
                       ui->treeWidget->setItemDelegateForColumn(FIELD_STATE_STR, progressbarDelegate);
                       ui->treeView->setItemDelegateForColumn(DownloadQueueItem::FIELD_STATE_STR, progressbarDelegate);
                       /* Connect the signal handlers for the download queue widgets */
                       connect(ui->actionMoveSelectedItemsToTheTop, SIGNAL(triggered(void)), SLOT(btnQueueMoveToTop_clicked(void)));
-...
                       connect(ui->actionMoveSelectedItemsDown, SIGNAL(triggered(void)), SLOT(btnQueueMoveDown_clicked(void)));
                       connect(ui->actionMoveSelectedItemsToTheBottom, SIGNAL(triggered(void)), SLOT(btnQueueMoveToBottom_clicked(void)));
                       connect(ui->treeWidget, SIGNAL(itemSelectionChanged(void)), SLOT(onItemSelectionChanged(void)));
                       connect(ui->treeView, SIGNAL(itemSelectionChanged(void)), SLOT(onItemSelectionChanged(void)));
                       connect(glue, SIGNAL(fileDownloadStateUpdate(QString,QString,int,int,int,quint64,quint64,quint64,quint64)), SLOT(onFileDownloadStateUpdate(QString,QString,int,int,int,quint64,quint64,quint64,quint64)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(fileStateChanged(QString,QString,QString,QNNTPGrabGlue::TaskState,QNNTPGrabGlue::TaskState)), SLOT(onFileStateChanged(QString,QString,QString,QNNTPGrabGlue::TaskState,QNNTPGrabGlue::TaskState)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(fileAdded(QString,QString,QString,QDateTime,quint64,quint64,quint64,QNNTPGrabGlue::TaskState,int,QList)), SLOT(onFileAdded(QString,QString,QString,QDateTime,quint64,quint64,quint64,QNNTPGrabGlue::TaskState,int,QList)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(fileRemoved(QString,QString,quint64,quint64)), SLOT(onFileRemoved(QString,QString,quint64,quint64)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(fileMoved(QString,QString,QString,int,int)), SLOT(onFileMoved(QString,QString,QString,int,int)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(collectionAdded(QString,QString)), SLOT(onCollectionAdded(QString,QString)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(collectionRemoved(QString)), SLOT(onCollectionRemoved(QString)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(collectionModified(QString,QString)), SLOT(onCollectionModified(QString,QString)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(collectionMoved(QString,int,int)), SLOT(onCollectionMoved(QString,int,int)), Qt::QueuedConnection);
                       connect(glue, SIGNAL(trafficMonitorUpdate(int,int,int,int,int,int,int,int,int,int,QDateTime,double)), SLOT(onTrafficMonitorUpdate(int,int,int,int,int,int,int,int,int,int,QDateTime,double)), Qt::QueuedConnection);
                       connect(ui->actionMarkItemOptional, SIGNAL(triggered()), SLOT(actionMarkItemOptional_activated()));
                       connect(ui->actionRestartSelectedItems, SIGNAL(triggered()), SLOT(actionRestartSelectedItems_activated()));
                       connect(actionRemoveSelectedFiles, SIGNAL(triggered()), SLOT(actionRemoveSelectedFiles_activated()));
                       connect(ui->actionOpenDownloadFolder, SIGNAL(triggered()), SLOT(actionOpenDownloadFolder_activated()));
                       connect(ui->actionExecuteSelectedItem, SIGNAL(triggered()), SLOT(actionExecuteSelectedItem_activated()));
                       ui->treeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
                       connect(ui->treeWidget, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
                       ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
                       connect(ui->treeView, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
                       /* Add custom fields to the list */
                       ui->treeWidget->setColumnCount(NUM_FIELDS);
                       ui->treeWidget->setColumnHidden(FIELD_PROGRESS, true);
                       ui->treeWidget->setColumnHidden(FIELD_FILE_SIZE, true);
                       ui->treeWidget->setColumnHidden(FIELD_FILE_SIZE_REMAINING, true);
                       ui->treeWidget->setColumnHidden(FIELD_REAL_FILENAME, true);
                       //ui->treeView->setColumnCount(DownloadQueueItem::NUM_FIELDS);
                       ui->treeView->setColumnHidden(DownloadQueueItem::FIELD_PROGRESS, true);
                       ui->treeView->setColumnHidden(DownloadQueueItem::FIELD_FILE_SIZE, true);
                       ui->treeView->setColumnHidden(DownloadQueueItem::FIELD_FILE_SIZE_REMAINING, true);
                       ui->treeView->setColumnHidden(DownloadQueueItem::FIELD_REAL_FILENAME, true);
                       /* Retrieve the download queue */
                       QList collections = glue->schedularGetAllTasks();
                       int i;
                       for (i = 0; i < collections.count(); i++) {
                           QNNTPGrabGlue::Collection collection = collections[i];
                           QTreeWidgetItem *collection_item = new QTreeWidgetItem();
                           int j;
                           for (j = 0; j < collection.files.count(); j++) {
                               QNNTPGrabGlue::File file = collection.files[j];
                               QTreeWidgetItem *file_item = new QTreeWidgetItem(collection_item);
                               file_item->setText(FIELD_SUBJECT, file.subject);
                               file_item->setText(FIELD_POSTER, file.poster);
                               file_item->setData(FIELD_FILE_SIZE, Qt::UserRole, QVariant(file.file_size));
                               file_item->setText(FIELD_FILE_SIZE_STR, glue->utilsCalculateFileSize(file.file_size));
                               file_item->setData(FIELD_FILE_SIZE_REMAINING, Qt::UserRole, QVariant(file.file_size_remaining));
                               file_item->setText(FIELD_FILE_SIZE_REMAINING_STR, glue->utilsCalculateFileSize(file.file_size_remaining));
                               file_item->setText(FIELD_STAMP, file.stamp.toString());
                               file_item->setText(FIELD_REAL_FILENAME, file.filename);
                               int k;
                               QString groups;
                               for (k = 0; k < file.groups.count(); k++) {
                                   if (groups.isEmpty()) {
                                       groups = file.groups[k];
                                   } else {
                                       groups += QString(",") + file.groups[k];
+                                  }
+                              }
                               file_item->setText(FIELD_GROUPS, groups);
                               int progress;
                               QString state_str;
                               if (file.status == QNNTPGrabGlue::TASK_STATE_SKIPPED) {
                                   progress = 0;
                               } else {
                                   progress = calculateProgress(file.file_size, file.file_size_remaining);
+                              }
                               switch(file.status) {
                                   case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DOWNLOAD:
                                   case QNNTPGrabGlue::TASK_STATE_DOWNLOADING:
                                       state_str = "";
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DECODE:
                                       state_str = tr("Waiting");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_DECODING:
                                       state_str = tr("Decoding");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_COMPLETE:
                                       state_str = tr("Done");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_INCOMPLETE:
                                       state_str = tr("Incomplete");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_NO_PARTS_AVAIL:
                                       state_str = tr("Not available");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_SKIPPED:
                                       state_str = tr("Skipped");
                                       break;
                                   default:
                                       state_str = "";
                                       break;
                               };
                               file_item->setText(FIELD_PROGRESS, QString("%1").arg(progress));
                               file_item->setText(FIELD_STATE_STR, state_str);
+                          }
                           collection_item->setText(FIELD_PROGRESS, QString("%1").arg(calculateProgress(collection.total_size, collection.total_size_remaining)));
                           collection_item->setText(FIELD_SUBJECT, collection.collection_name);
                           collection_item->setText(FIELD_POSTER, collection.poster);
                           collection_item->setData(FIELD_FILE_SIZE, Qt::UserRole, collection.total_size);
                           collection_item->setText(FIELD_FILE_SIZE_STR, glue->utilsCalculateFileSize(collection.total_size));
                           collection_item->setData(FIELD_FILE_SIZE_REMAINING, Qt::UserRole, collection.total_size_remaining);
                           collection_item->setText(FIELD_FILE_SIZE_REMAINING_STR, glue->utilsCalculateFileSize(collection.total_size_remaining));
                           ui->treeWidget->addTopLevelItem(collection_item);
+                      }
                       ui->treeWidget->resizeColumnToContents(FIELD_PROGRESS);
                       //ui->treeWidget->resizeColumnToContents(FIELD_PROGRESS);
+                  }
                   WidgetDownloadQueue::~WidgetDownloadQueue()
-...
                       QList list_collections;
                       MoveItemData move_data;
                       for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
                           collection_item = ui->treeWidget->topLevelItem(i);
                   #if 0
                       for (int i = 0; i < ui->treeView->topLevelItemCount(); i++) {
                           collection_item = ui->treeView->topLevelItem(i);
                           if (collection_item->isSelected()) {
                               if (i == ui->treeWidget->topLevelItemCount() - 1 && direction == MOVE_DIRECTION_DOWN) {
-...
+                              }
+                          }
+                      }
                   #endif
                       if (list_collections.count() > 0) {
                           Q_FOREACH(move_data, list_collections) {
                               doMoveItem(move_data.item->data(FIELD_SUBJECT, 0).toString(), NULL, calculateNewPosition(move_data.position, direction));
                               doMoveItem(move_data.item->data(DownloadQueueItem::FIELD_SUBJECT, 0).toString(), NULL, calculateNewPosition(move_data.position, direction));
+                          }
+                      }
+                  }
-...
                       processSelectionAndMoveItems(MOVE_DIRECTION_BOTTOM);
+                  }
                   int WidgetDownloadQueue::calculateProgress(quint64 size, quint64 size_remaining)
+                  {
                       if (size == 0) {        /* Prevent a divide by zero */
                           return 0;
+                      }
                       int ret = (((double)size - size_remaining) / size) * 100;
                       if (ret < 0 || ret > 100) {
                           qWarning("Invalid progress detected, size = %lli, size_remaining = %lli", size, size_remaining);
+                      }
                       return qMin(100, ret);
+                  }
                   void WidgetDownloadQueue::onFileDownloadStateUpdate(QString collection_name, QString subject, int num_parts_total, int num_parts_done,
                                                                       int num_parts_failed, quint64 file_size, quint64 file_size_remaining,
                                                                       quint64 total_size, quint64 total_size_remaining)
+                  {
                       Q_UNUSED(num_parts_total);
                       Q_UNUSED(num_parts_done);
                       Q_UNUSED(num_parts_failed);
                       QTreeWidgetItem *collection_node;
                       QTreeWidgetItem *subject_node;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       subject_node = getTreeWidgetBySubject(collection_node, subject);
                       if (subject_node == NULL) {
                           qWarning("onFileDownloadStateUpdate: Subject '%s' from collection '%s' could not found", collection_name.toUtf8().data(), subject.toUtf8().data());
                           return;
+                      }
                       collection_node->setText(FIELD_PROGRESS, QString("%1").arg(calculateProgress(total_size, total_size_remaining)));
                       collection_node->setText(FIELD_STATE_STR, collection_node->text(FIELD_STATE_STR));    /* Force redraw */
                       collection_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(total_size_remaining));
                       collection_node->setText(FIELD_FILE_SIZE_REMAINING_STR, glue->utilsCalculateFileSize(total_size_remaining));
                       subject_node->setText(FIELD_PROGRESS, QString("%1").arg(calculateProgress(file_size, file_size_remaining)));
                       subject_node->setText(FIELD_STATE_STR, subject_node->text(FIELD_STATE_STR));    /* Force redraw */
                       subject_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(file_size_remaining));
                       subject_node->setText(FIELD_FILE_SIZE_REMAINING_STR, glue->utilsCalculateFileSize(file_size_remaining));
+                  }
                   void WidgetDownloadQueue::onFileStateChanged(QString collection_name, QString subject, QString real_filename, QNNTPGrabGlue::TaskState old_state, QNNTPGrabGlue::TaskState new_state)
+                  {
                       Q_UNUSED(old_state);
                       QTreeWidgetItem *collection_node;
                       QTreeWidgetItem *subject_node;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       subject_node = getTreeWidgetBySubject(collection_node, subject);
                       if (!subject_node) {
                           qWarning("onFileStateChanged: Subject '%s' from collection '%s' could not be found", subject.toUtf8().data(), collection_name.toUtf8().data());
                           return;
+                      }
                       quint64 file_size;
                       quint64 file_size_remaining;
                       QString size_remaining;
                       quint64 total_size;
                       quint64 total_size_remaining;
                       int progress;
                       switch(new_state) {
                           case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DOWNLOAD:
                               /* The task was restarted */
                               /* Update the row itself */
                               file_size = subject_node->data(FIELD_FILE_SIZE, Qt::DisplayRole).toLongLong();
                               file_size_remaining = subject_node->data(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole).toLongLong();
                               size_remaining = glue->utilsCalculateFileSize(file_size);
                               subject_node->setText(FIELD_PROGRESS, "0");
                               subject_node->setText(FIELD_STATE_STR, "");
                               subject_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(file_size));
                               subject_node->setText(FIELD_FILE_SIZE_REMAINING_STR, size_remaining);
                               /* Update the parent */
                               total_size = collection_node->data(FIELD_FILE_SIZE, Qt::DisplayRole).toLongLong();
                               total_size_remaining = collection_node->data(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole).toLongLong();
                               total_size_remaining += file_size - file_size_remaining;
                               progress = calculateProgress(total_size, total_size_remaining);
                               size_remaining = glue->utilsCalculateFileSize(total_size_remaining);
                               collection_node->setText(FIELD_PROGRESS, QString("%1").arg(progress));
                               collection_node->setText(FIELD_STATE_STR, collection_node->text(FIELD_STATE_STR));    /* Force redraw */
                               collection_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(total_size_remaining));
                               collection_node->setText(FIELD_FILE_SIZE_REMAINING_STR, size_remaining);
                               break;
                           case QNNTPGrabGlue::TASK_STATE_DOWNLOADING:
                               subject_node->setText(FIELD_PROGRESS, "0");
                               subject_node->setText(FIELD_STATE_STR, "");     /* The state message should be empty. In that case the value of the progress bar will be shown */
                               break;
                           case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DECODE:
                               size_remaining = glue->utilsCalculateFileSize(0);
                               subject_node->setText(FIELD_PROGRESS, "100");
                               subject_node->setText(FIELD_FILE_SIZE_REMAINING_STR, size_remaining);
                               subject_node->setText(FIELD_STATE_STR, tr("Waiting"));
                               break;
                           case QNNTPGrabGlue::TASK_STATE_DECODING:
                               subject_node->setText(FIELD_PROGRESS, "100");
                               subject_node->setText(FIELD_STATE_STR, tr("Decoding"));
                               break;
                           case QNNTPGrabGlue::TASK_STATE_FINISHED_COMPLETE:
                               Q_ASSERT(real_filename != NULL);
                               subject_node->setText(FIELD_STATE_STR, tr("Done"));
                               subject_node->setText(FIELD_REAL_FILENAME, real_filename);
                               break;
                           case QNNTPGrabGlue::TASK_STATE_FINISHED_INCOMPLETE:
                               Q_ASSERT(real_filename != NULL);
                               subject_node->setText(FIELD_STATE_STR, tr("Incomplete"));
                               subject_node->setText(FIELD_REAL_FILENAME, real_filename);
                               break;
                           case QNNTPGrabGlue::TASK_STATE_FINISHED_NO_PARTS_AVAIL:
                               subject_node->setText(FIELD_STATE_STR, tr("Not available"));
                               break;
                           case QNNTPGrabGlue::TASK_STATE_SKIPPED:
                               subject_node->setText(FIELD_STATE_STR, tr("Skipped"));
                               subject_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayPropertyRole, QVariant(0));
                               subject_node->setText(FIELD_FILE_SIZE_REMAINING_STR, "");
                               break;
+                      }
                       ui->treeWidget->resizeColumnToContents(FIELD_PROGRESS);
+                  }
                   void WidgetDownloadQueue::onFileAdded(QString collection_name, QString subject, QString poster, QDateTime stamp, quint64 file_size, quint64 total_size, quint64 total_size_remaining, QNNTPGrabGlue::TaskState state, int num_parts, QList groups)
+                  {
                       Q_UNUSED(num_parts);
                       QTreeWidgetItem *collection_node =  NULL;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       if (collection_node == NULL) {
                           qWarning("file added: Collection %s could not be found", collection_name.toUtf8().data());
                           return;
+                      }
                       QTreeWidgetItem *file_node =  new QTreeWidgetItem();
                       file_node->setText(FIELD_SUBJECT, subject);
                       file_node->setText(FIELD_POSTER, poster);
                       file_node->setData(FIELD_FILE_SIZE, Qt::DisplayRole, QVariant(file_size));
                       file_node->setText(FIELD_FILE_SIZE_STR, glue->utilsCalculateFileSize(file_size));
                       file_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayPropertyRole, QVariant(file_size));
                       file_node->setText(FIELD_FILE_SIZE_REMAINING_STR, glue->utilsCalculateFileSize(file_size));
                       file_node->setText(FIELD_STAMP, stamp.toString());
                       int i;
                       QString groups_str;
                       for (i = 0; i < groups.count(); i++) {
                           if (groups_str.isEmpty()) {
                               groups_str = groups[i];
                           } else {
                               groups_str += QString(",") + groups[i];
+                          }
+                      }
                       file_node->setText(FIELD_GROUPS, groups_str);
                       if (state == QNNTPGrabGlue::TASK_STATE_SKIPPED) {
                           file_node->setText(FIELD_STATE_STR, tr("Skipped"));
                           file_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(0));
                           file_node->setText(FIELD_FILE_SIZE_REMAINING_STR, "");
+                      }
                       /* Update the parent */
                       collection_node->addChild(file_node);
                       QString size = glue->utilsCalculateFileSize(total_size);
                       QString size_remaining = glue->utilsCalculateFileSize(total_size_remaining);
                       int progress = calculateProgress(total_size, total_size_remaining);
                       collection_node->setData(FIELD_FILE_SIZE, Qt::DisplayRole, QVariant(total_size));
                       collection_node->setText(FIELD_FILE_SIZE_STR, size);
                       collection_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(total_size_remaining));
                       collection_node->setText(FIELD_FILE_SIZE_REMAINING_STR, size_remaining);
                       collection_node->setText(FIELD_PROGRESS, QString("%1").arg(progress));
                       collection_node->setText(FIELD_STATE_STR, collection_node->text(FIELD_STATE_STR));    /* Force redraw */
+                  }
                   void WidgetDownloadQueue::onFileRemoved(QString collection_name, QString subject, quint64 total_size, quint64 total_size_remaining)
+                  {
                       QTreeWidgetItem *collection_node;
                       QTreeWidgetItem *subject_node;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       subject_node = getTreeWidgetBySubject(collection_node, subject);
                       if (subject_node == NULL) {
                           qWarning("onFileRemoved: Subject '%s' in collection '%s' could not be found", subject.toUtf8().data(), collection_name.toUtf8().data());
                           return;
+                      }
                       QString size = glue->utilsCalculateFileSize(total_size);
                       QString size_remaining = glue->utilsCalculateFileSize(total_size_remaining);
                       collection_node->setData(FIELD_FILE_SIZE, Qt::DisplayRole, QVariant(total_size));
                       collection_node->setText(FIELD_FILE_SIZE_STR, size);
                       collection_node->setData(FIELD_FILE_SIZE_REMAINING, Qt::DisplayRole, QVariant(total_size_remaining));
                       collection_node->setText(FIELD_FILE_SIZE_REMAINING_STR, size_remaining);
                       collection_node->setText(FIELD_PROGRESS, QString("%1").arg(calculateProgress(total_size, total_size_remaining)));
                       collection_node->setText(FIELD_STATE_STR, collection_node->text(FIELD_STATE_STR));    /* Force redraw */
                       delete subject_node;
+                  }
                   void WidgetDownloadQueue::onFileMoved(QString orig_collection_name, QString subject, QString new_collection_name, int old_position, int new_position)
+                  {
                       Q_UNUSED(subject);
                       Q_UNUSED(new_collection_name);
                       bool was_selected;
                       QTreeWidgetItem *subject_node;
                       QTreeWidgetItem *collection_node = getTreeWidgetByCollection(orig_collection_name);
                       qDebug("file moved: old_position: %i, new position: %i", old_position, new_position);
                       if (collection_node == NULL) {
                           qWarning("onFileMoved: Collection '%s' not found", orig_collection_name.toUtf8().data());
                           return;
+                      }
                       was_selected = collection_node->child(old_position)->isSelected();
                       subject_node = collection_node->takeChild(old_position);
                       if (new_position == -1) {
                           collection_node->addChild(subject_node);
                       } else {
                           collection_node->insertChild(new_position, subject_node);
+                      }
                       if (was_selected) {
                           subject_node->setSelected(true);
+                      }
+                  }
                   void WidgetDownloadQueue::onCollectionAdded(QString collection_name, QString poster)
+                  {
                       qDebug("Collection added");
                       QTreeWidgetItem *collection_node =  new QTreeWidgetItem();
                       collection_node->setText(FIELD_SUBJECT, collection_name);
                       collection_node->setText(FIELD_POSTER, poster);
                       ui->treeWidget->addTopLevelItem(collection_node);
+                  }
                   void WidgetDownloadQueue::onCollectionRemoved(QString collection_name)
+                  {
                       qDebug("collection removed: %s", collection_name.toUtf8().data());
                       QTreeWidgetItem *collection_node =  NULL;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       if (collection_node == NULL) {
                           qWarning("collectionmodified: Collection %s not found", collection_name.toUtf8().data());
                           return;
+                      }
                       delete collection_node;
+                  }
                   void WidgetDownloadQueue::onCollectionModified(QString collection_name, QString poster)
+                  {
                       qDebug("Collection modified");
                       QTreeWidgetItem *collection_node =  NULL;
                       collection_node = getTreeWidgetByCollection(collection_name);
                       if (collection_node == NULL) {
                           qWarning("collectionmodified: Collection %s not found", collection_name.toUtf8().data());
                           return;
+                      }
                       collection_node->setText(FIELD_POSTER, poster);
+                  }
                   void WidgetDownloadQueue::onCollectionMoved(QString collection_name, int old_position, int new_position)
+                  {
                       qDebug("collection moved: old_position: %i, new position: %i", old_position, new_position);
                       bool was_selected;
                       bool was_expanded;
                       QTreeWidgetItem *collection_node;
                       was_selected = ui->treeWidget->topLevelItem(old_position)->isSelected();
                       was_expanded = ui->treeWidget->topLevelItem(old_position)->isExpanded();
                       collection_node = ui->treeWidget->takeTopLevelItem(old_position);
                       if (collection_node->text(FIELD_SUBJECT).compare(collection_name) != 0) {
                           qWarning("onCollectionMoved: %s != %s", collection_name.toUtf8().data(), collection_node->text(FIELD_SUBJECT).toUtf8().data());
                           return;
+                      }
                       if (new_position == -1) { // To bottom
                           ui->treeWidget->addTopLevelItem(collection_node);
                       } else {
                           ui->treeWidget->insertTopLevelItem(new_position, collection_node);
+                      }
                       if (was_selected) {
                           collection_node->setSelected(true);
+                      }
                       if (was_expanded) {
                           collection_node->setExpanded(true);
+                      }
+                  }
                   void WidgetDownloadQueue::onTrafficMonitorUpdate(int bytes_received1, int bytes_received2, int bytes_received3, int bytes_received4, int bytes_received5, int bytes_received6, int bytes_received7, int bytes_received8, int bytes_received9, int bytes_received10, QDateTime stamp, double average)
+                  {
                       Q_UNUSED(stamp);
                       Q_UNUSED(average);
                       static int times_been_here = 10;
                       bool no_data_received = FALSE;
                       quint64 total_estimated_time_remaining;
                       if (ui->treeWidget->children().count() == 0) {
                           return;
+                      }
                       if (bytes_received1 == 0 && bytes_received2 == 0 && bytes_received3 == 0 && bytes_received4 == 0 && bytes_received5 == 0 &&
                           bytes_received6 == 0 && bytes_received7 == 0 && bytes_received8 == 0 && bytes_received9 == 0 && bytes_received10 == 0) {
                               no_data_received = TRUE;
+                      }
                       /* Only update on startup, on every 3 seconds, and when there has no data been received in the last 10 seconds */
                       if (times_been_here < 3 && !no_data_received) {
                           times_been_here += 1;
                           return;
+                      }
                       if (no_data_received) {
                           times_been_here = 3;    /* update the time remaining the next time we get here */
                       } else {
                           times_been_here = 0;    /* perform the next update in 10 seconds */
+                      }
                       total_estimated_time_remaining = 0;
                       for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
                           QTreeWidgetItem *collection_item;
                           int estimated_time_remaining;
                           quint64 file_size;
                           collection_item = ui->treeWidget->topLevelItem(i);
                           file_size = collection_item->data(FIELD_FILE_SIZE_REMAINING, Qt::UserRole).toULongLong();
                           estimated_time_remaining = glue->utilsCalculateEstimatedTimeRemaining(bytes_received1, bytes_received2, bytes_received3, bytes_received4, bytes_received5,
                                                                                                 bytes_received6, bytes_received7, bytes_received8, bytes_received9, bytes_received10, file_size);
                           if (estimated_time_remaining == -1) {
                               /* Not enough data received to make an estimation */
                               return;
+                          }
                           if (estimated_time_remaining == 0) {
                               /* Collection is already downloaded */
                               collection_item->setText(FIELD_ESTIMATED_TIME_REMAINING_STR, "");
                               collection_item->setText(FIELD_ESTIMATED_TIME_TO_FINISH_STR, "");
                           } else {
                               collection_item->setText(FIELD_ESTIMATED_TIME_REMAINING_STR, glue->utilsGetReadableTimeRemaining(total_estimated_time_remaining + estimated_time_remaining));
                               collection_item->setText(FIELD_ESTIMATED_TIME_TO_FINISH_STR, glue->utilsGetReadableFinishedTime(total_estimated_time_remaining + estimated_time_remaining));
+                          }
                           total_estimated_time_remaining += estimated_time_remaining;
                   /* Disabled for now as it causes too much load */
                   #if 0
                           /* Walk through all the children */
                           for (int j = 0; j < collection_item->childCount(); j++) {
                               QTreeWidgetItem *subject_item = collection_item->child(j);
                               file_size = subject_item->data(FIELD_FILE_SIZE_REMAINING, Qt::UserRole).toLongLong();
                               if (file_size == 0) {
                                   /* File is already downloaded */
                                   subject_item->setText(FIELD_ESTIMATED_TIME_REMAINING_STR, "");
                                   subject_item->setText(FIELD_ESTIMATED_TIME_TO_FINISH_STR, "");
                               } else {
                                   estimated_time_remaining = glue->utilsCalculateEstimatedTimeRemaining(bytes_received1, bytes_received2, bytes_received3, bytes_received4, bytes_received5,
                                                                                                         bytes_received6, bytes_received7, bytes_received8, bytes_received9, bytes_received10, file_size);
                                   subject_item->setText(FIELD_ESTIMATED_TIME_REMAINING_STR, glue->utilsGetReadableTimeRemaining(total_estimated_time_remaining));
                                   subject_item->setText(FIELD_ESTIMATED_TIME_TO_FINISH_STR, glue->utilsGetReadableFinishedTime(total_estimated_time_remaining));
+                              }
+                          }
                   #endif
+                      }
                       ui->treeWidget->resizeColumnToContents(FIELD_ESTIMATED_TIME_REMAINING_STR);
                       ui->treeWidget->resizeColumnToContents(FIELD_ESTIMATED_TIME_TO_FINISH_STR);
+                  }
                   QTreeWidgetItem *WidgetDownloadQueue::getTreeWidgetByCollection(QString collection_name)
+                  {
                       QTreeWidgetItem *collection_node =  NULL;
-...
+                      }
                       return subject_node;
+                  }
                   #endif
                   void WidgetDownloadQueue::onItemSelectionChanged(void)
+                  {
                       if (ui->treeWidget->selectedItems().count() == 0) {
                   #if 0
                       if (ui->treeView->selectedItems().count() == 0) {
                           ui->btnQueueMoveToTop->setEnabled(false);
                           ui->btnQueueMoveUp->setEnabled(false);
                           ui->btnQueueMoveDown->setEnabled(false);
-...
                           ui->btnQueueMoveToBottom->setEnabled(true);
                           actionRemoveSelectedFiles->setEnabled(true);
+                      }
                   #endif
+                  }
                   void WidgetDownloadQueue::actionMarkItemOptional_activated(void)
+                  {
                   #if 0
                       bool flag_set = FALSE;
                       bool is_optional = FALSE;
                       for (int i = 0; i < ui->treeWidget->selectedItems().count(); i++) {
                       for (int i = 0; i < ui->treeView->selectedItems().count(); i++) {
                           QString collection_name = "";
                           QString subject = "";
                           QString errmsg = "";
                           QTreeWidgetItem *item = ui->treeWidget->selectedItems().at(i);
                           QTreeWidgetItem *item = ui->treeView->selectedItems().at(i);
                           if (item->childCount() != 0) {
                               /* This is a collection, ignore */
-...
                               qWarning("%s", tr("Unable to change the status of the selected file(s)").toUtf8().data());
+                          }
+                      }
                   #endif
+                  }
                   void WidgetDownloadQueue::actionRemoveSelectedFiles_activated(void)
+                  {
                       for (int i = 0; i < ui->treeWidget->selectedItems().count(); i++) {
                   #if 0
                       for (int i = 0; i < ui->treeView->selectedItems().count(); i++) {
                           QString collection_name = "";
                           QString subject = "";
                           QString errmsg = "";
                           QTreeWidgetItem *item = ui->treeWidget->selectedItems().at(i);
                           QTreeWidgetItem *item = ui->treeView->selectedItems().at(i);
                           if (item->childCount() == 0) {
                               /* This is a subject */
-...
                               qWarning(tr("Error occured while removing file(s):\n%s").toUtf8().data(), errmsg.toUtf8().data());
+                          }
+                      }
                   #endif
+                  }
                   void WidgetDownloadQueue::actionRestartSelectedItems_activated(void)
+                  {
                       for (int i = 0; i < ui->treeWidget->selectedItems().count(); i++) {
                   #if 0
                       for (int i = 0; i < ui->treeView->selectedItems().count(); i++) {
                           QString collection_name = "";
                           QString subject = "";
                           QString errmsg = "";
                           QTreeWidgetItem *item = ui->treeWidget->selectedItems().at(i);
                           QTreeWidgetItem *item = ui->treeView->selectedItems().at(i);
                           if (item->childCount() == 0) {
                               /* This is a subject */
-...
                               qWarning(tr("Error occured while restarting file(s):\n%s").toUtf8().data(), errmsg.toUtf8().data());
+                          }
+                      }
                   #endif
+                  }
                   void WidgetDownloadQueue::actionOpenDownloadFolder_activated(void)
+                  {
                   #if 0
                       QString folder = "";
                       QNNTPGrabGlue::ConfigOpts opts = glue->configGetOpts();
                       if (ui->treeWidget->selectedItems().count() == 1) {
                       if (ui->treeView->selectedItems().count() == 1) {
                           QString collection_name;
                           QTreeWidgetItem *item = ui->treeWidget->selectedItems().at(0);
                           QTreeWidgetItem *item = ui->treeView->selectedItems().at(0);
                           if (item->childCount() == 0) {
                               /* This is a subject */
-...
                   #else
                       QDesktopServices::openUrl(QUrl(QString("file://") + location.absoluteFilePath()));
                   #endif
                   #endif
+                  }
                   void WidgetDownloadQueue::actionExecuteSelectedItem_activated(void)
+                  {
                   #if 0
                       QNNTPGrabGlue::ConfigOpts opts = glue->configGetOpts();
                       if (ui->treeWidget->selectedItems().count() != 1) {
                       if (ui->treeView->selectedItems().count() != 1) {
                           return;
+                      }
                       QTreeWidgetItem *item = ui->treeWidget->selectedItems().at(0);
                       QTreeWidgetItem *item = ui->treeView->selectedItems().at(0);
                       if (item->childCount() != 0) {
                           return;
-...
                   #else
                       QDesktopServices::openUrl(QUrl(QString("file://") + location.absoluteFilePath()));
                   #endif
                   #endif
+                  }
                   void WidgetDownloadQueue::showContextMenu(const QPoint &position)
+                  {
                   #if 0
                       QList actions;
                       QAction *a = new QAction(this);
                       if (!ui->treeWidget->indexAt(position).isValid()) {
                       if (!ui->treeView->indexAt(position).isValid()) {
                           return;
+                      }
                       if (ui->treeWidget->selectedItems().count() == 0) {
                       if (ui->treeView->selectedItems().count() == 0) {
                           return;
+                      }
-...
                       /* Do we have exactly one selected item and is this item already downloaded? */
                       ui->actionExecuteSelectedItem->setEnabled(false);
                       if (glue->getIsStandalone() && ui->treeWidget->selectedItems().count() == 1) {
                           item = ui->treeWidget->selectedItems().at(0);
                       if (glue->getIsStandalone() && ui->treeView->selectedItems().count() == 1) {
                           item = ui->treeView->selectedItems().at(0);
                           if (item->text(FIELD_STATE_STR).compare(tr("Done")) == 0 ||
                               item->text(FIELD_STATE_STR).compare(tr("Incomplete")) == 0) {
-...
+                      }
                       /* Enable the forcefully download / skip option */
                       item = ui->treeWidget->selectedItems().at(0);
                       item = ui->treeView->selectedItems().at(0);
                       if (item->text(FIELD_STATE_STR).compare(tr("Skipped")) == 0) {
                           ui->actionMarkItemOptional->setText(tr("Forcefully download file(s)"));
                           ui->actionMarkItemOptional->setEnabled(true);
-...
                           ui->actionMarkItemOptional->setEnabled(false);
+                      }
                       QMenu::exec(actions, ui->treeWidget->mapToGlobal(position));
                       QMenu::exec(actions, ui->treeView->mapToGlobal(position));
                       delete a;
                   #endif
+                  }
                   void WidgetDownloadQueue::hideField(field f)
                   void WidgetDownloadQueue::hideField(DownloadQueueItem::field f)
+                  {
                       ui->treeWidget->hideColumn(f);
                       ui->treeView->hideColumn(f);
+                  }
                   void WidgetDownloadQueue::showField(field f)
                   void WidgetDownloadQueue::showField(DownloadQueueItem::field f)
+                  {
                       ui->treeWidget->showColumn(f);
                       ui->treeView->showColumn(f);
+                  }

Also available in: Unified diff