NNTPGrab - / - Diff - NNTPGrab

Revision 1776

trunk/client/gui_qt/WidgetConfigDisplay.cpp (revision 1776)
16	16	if (opts.getShowColumnProgress()) {
17	17	ui->chkShowColumnProgress->setChecked(true);
18	18	} else {
19		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_STATE_STR);
	19	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_STATE_STR);
20	20	}
21	21
22	22	if (opts.getShowColumnSubject()) {
23	23	ui->chkShowColumnSubject->setChecked(true);
24	24	} else {
25		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_SUBJECT);
	25	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_SUBJECT);
26	26	}
27	27
28	28	if (opts.getShowColumnPoster()) {
29	29	ui->chkShowColumnPoster->setChecked(true);
30	30	} else {
31		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_POSTER);
	31	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_POSTER);
32	32	}
33	33
34	34	if (opts.getShowColumnNewsgroups()) {
35	35	ui->chkShowColumnNewsgroups->setChecked(true);
36	36	} else {
37		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_GROUPS);
	37	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_GROUPS);
38	38	}
39	39
40	40	if (opts.getShowColumnFilesize()) {
41	41	ui->chkShowColumnFileSize->setChecked(true);
42	42	} else {
43		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_FILE_SIZE_STR);
	43	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_FILE_SIZE_STR);
44	44	}
45	45
46	46	if (opts.getShowColumnFilesizeRemaining()) {
47	47	ui->chkShowColumnFileSizeRemaining->setChecked(true);
48	48	} else {
49		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_FILE_SIZE_REMAINING_STR);
	49	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR);
50	50	}
51	51
52	52	if (opts.getShowColumnStamp()) {
53	53	ui->chkShowColumnStamp->setChecked(true);
54	54	} else {
55		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_STAMP);
	55	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_STAMP);
56	56	}
57	57
58	58	if (opts.getShowColumnTimeRemaining()) {
59	59	ui->chkShowColumnTimeRemaining->setChecked(true);
60	60	} else {
61		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_REMAINING_STR);
	61	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_ESTIMATED_TIME_REMAINING_STR);
62	62	}
63	63
64	64	if (opts.getShowColumnTimeToFinish()) {
65	65	ui->chkShowColumnTimeToFinish->setChecked(true);
66	66	} else {
67		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
	67	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
68	68	}
69	69
70	70	if (opts.getShowTrayIcon()) {
...	...
113	113	{
114	114	opts.setShowColumnProgress(toggled);
115	115	if (toggled) {
116		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_STATE_STR);
	116	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_STATE_STR);
117	117	} else {
118		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_STATE_STR);
	118	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_STATE_STR);
119	119	}
120	120	}
121	121
...	...
123	123	{
124	124	opts.setShowColumnSubject(toggled);
125	125	if (toggled) {
126		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_SUBJECT);
	126	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_SUBJECT);
127	127	} else {
128		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_SUBJECT);
	128	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_SUBJECT);
129	129	}
130	130	}
131	131
...	...
133	133	{
134	134	opts.setShowColumnPoster(toggled);
135	135	if (toggled) {
136		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_POSTER);
	136	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_POSTER);
137	137	} else {
138		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_POSTER);
	138	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_POSTER);
139	139	}
140	140	}
141	141
...	...
143	143	{
144	144	opts.setShowColumnNewsgroups(toggled);
145	145	if (toggled) {
146		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_GROUPS);
	146	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_GROUPS);
147	147	} else {
148		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_GROUPS);
	148	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_GROUPS);
149	149	}
150	150	}
151	151
...	...
153	153	{
154	154	opts.setShowColumnFilesize(toggled);
155	155	if (toggled) {
156		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_FILE_SIZE_STR);
	156	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_FILE_SIZE_STR);
157	157	} else {
158		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_FILE_SIZE_STR);
	158	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_FILE_SIZE_STR);
159	159	}
160	160	}
161	161
...	...
163	163	{
164	164	opts.setShowColumnFilesizeRemaining(toggled);
165	165	if (toggled) {
166		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_FILE_SIZE_REMAINING_STR);
	166	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR);
167	167	} else {
168		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_FILE_SIZE_REMAINING_STR);
	168	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR);
169	169	}
170	170	}
171	171
...	...
173	173	{
174	174	opts.setShowColumnStamp(toggled);
175	175	if (toggled) {
176		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_STAMP);
	176	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_STAMP);
177	177	} else {
178		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_STAMP);
	178	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_STAMP);
179	179	}
180	180	}
181	181
...	...
183	183	{
184	184	opts.setShowColumnTimeRemaining(toggled);
185	185	if (toggled) {
186		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_REMAINING_STR);
	186	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_ESTIMATED_TIME_REMAINING_STR);
187	187	} else {
188		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_REMAINING_STR);
	188	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_ESTIMATED_TIME_REMAINING_STR);
189	189	}
190	190	}
191	191
...	...
193	193	{
194	194	opts.setShowColumnTimeToFinish(toggled);
195	195	if (toggled) {
196		widgetDownloadQueue->showField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
	196	widgetDownloadQueue->showField(DownloadQueueItem::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
197	197	} else {
198		widgetDownloadQueue->hideField(WidgetDownloadQueue::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
	198	widgetDownloadQueue->hideField(DownloadQueueItem::FIELD_ESTIMATED_TIME_TO_FINISH_STR);
199	199	}
200	200	}
201	201

                       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);
+                  }

                   #ifndef DOWNLOADQUEUEMODEL_H
                   #define DOWNLOADQUEUEMODEL_H
                   #include
                   #include "QNNTPGrabGlue.h"
                   #include "DownloadQueueItem.h"
                   class DownloadQueueModel : public QAbstractItemModel
+                  {
                       Q_OBJECT
                   public:
                       DownloadQueueModel(QNNTPGrabGlue *glue, QObject *parent = 0);
                       ~DownloadQueueModel();
                       QVariant data(const QModelIndex &index, int role) const;
                       Qt::ItemFlags flags(const QModelIndex &index) const;
                       QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
                       QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
                       QModelIndex parent(const QModelIndex &index) const;
                       int rowCount(const QModelIndex &parent = QModelIndex()) const;
                       int columnCount(const QModelIndex &parent = QModelIndex()) const;
                   private:
                       void loadDownloadQueue(QNNTPGrabGlue *glue);
                       int calculateProgress(quint64 size, quint64 sizeRemaining);
                       DownloadQueueItem *rootItem;
                   private slots:
                       void 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);
                       void onFileStateChanged(QString collection_name, QString subject, QString real_filename, QNNTPGrabGlue::TaskState old_state, QNNTPGrabGlue::TaskState new_state);
                       void 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);
                       void onFileRemoved(QString collection_name, QString subject, quint64 total_size, quint64 total_size_remaining);
                       void onFileMoved(QString orig_collection_name, QString subject, QString new_collection_name, int old_position, int new_position);
                       void onCollectionAdded(QString collection_name, QString poster);
                       void onCollectionRemoved(QString collection_name);
                       void onCollectionModified(QString collection_name, QString poster);
                       void onCollectionMoved(QString collection_name, int old_position, int new_position);
                       void 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);
                   signals:
                   public slots:
                   };
                   #endif // DOWNLOADQUEUEMODEL_H

                       DialogSetCollectionName.cpp \
                       ConfigGuiOpts.cpp \
                       QNZBCreator.cpp \
                       AutoImport.cpp
                       AutoImport.cpp \
                       DownloadQueueModel.cpp \
                       DownloadQueueItem.cpp
                   HEADERS += mainwindow.h \
                       QNNTPGrabGlue.h \
                       WidgetConfig.h \
-...
                       QNNTPGrabGlue_p.h \
                       ConfigGuiOpts.h \
                       QNZBCreator.h \
                       AutoImport.h
                       AutoImport.h \
                       DownloadQueueModel.h \
                       DownloadQueueItem.h
                   FORMS += mainwindow.ui \
                       WidgetConfig.ui \
                       WidgetDownloadQueue.ui \

                         false
-...
                         true
                         false
                          Progress
                          Subject
                          Poster
                          Newsgroup
                          File size
                          File size remaining
                          Stamp
                          Time remaining
                          Time to finish

                   #include
                   #include
                   #include "ProgressBarDelegateDownloadQueue.h"
                   #include "DownloadQueueModel.h"
                   namespace Ui {
                       class WidgetDownloadQueue;
-...
                       WidgetDownloadQueue(QNNTPGrabGlue *glue, QAction *actionRemoveSelectedFiles, QWidget *parent = 0);
                       ~WidgetDownloadQueue();
                       enum field {
                           FIELD_STATE_STR,
                           FIELD_SUBJECT,
                           FIELD_POSTER,
                           FIELD_GROUPS,
                           FIELD_FILE_SIZE_STR,
                           FIELD_FILE_SIZE_REMAINING_STR,
                           FIELD_STAMP,
                           FIELD_ESTIMATED_TIME_REMAINING_STR,
                           FIELD_ESTIMATED_TIME_TO_FINISH_STR,
                           FIELD_PROGRESS,
                           FIELD_FILE_SIZE,
                           FIELD_FILE_SIZE_REMAINING,
                           FIELD_REAL_FILENAME,
                           NUM_FIELDS
                       };
                       void hideField(DownloadQueueItem::field f);
                       void showField(DownloadQueueItem::field f);
                       void hideField(field f);
                       void showField(field f);
                   protected:
                       void changeEvent(QEvent *e);
-...
                       QNNTPGrabGlue *glue;
                       ProgressBarDelegateDownloadQueue *progressbarDelegate;
                       QAction *actionRemoveSelectedFiles;
                       DownloadQueueModel *model;
                       enum moveDirection {
                           MOVE_DIRECTION_TOP,
-...
                       int calculateNewPosition(int current_position, moveDirection direction);
                       void processSelectionAndMoveItems(moveDirection direction);
                       int calculateProgress(quint64 total_file_size, quint64 file_size_remaining);
                   #if 0
                       QTreeWidgetItem *getTreeWidgetByCollection(QString collection_name);
                       QTreeWidgetItem *getTreeWidgetBySubject(QTreeWidgetItem *collection_node, QString subject);
                   #endif
                   private slots:
                       void btnQueueMoveToTop_clicked(void);
-...
                       void btnQueueMoveDown_clicked(void);
                       void btnQueueMoveToBottom_clicked(void);
                       void 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);
                       void onFileStateChanged(QString collection_name, QString subject, QString real_filename, QNNTPGrabGlue::TaskState old_state, QNNTPGrabGlue::TaskState new_state);
                       void 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);
                       void onFileRemoved(QString collection_name, QString subject, quint64 total_size, quint64 total_size_remaining);
                       void onFileMoved(QString orig_collection_name, QString subject, QString new_collection_name, int old_position, int new_position);
                       void onCollectionAdded(QString collection_name, QString poster);
                       void onCollectionRemoved(QString collection_name);
                       void onCollectionModified(QString collection_name, QString poster);
                       void onCollectionMoved(QString collection_name, int old_position, int new_position);
                       void 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);
                       void onItemSelectionChanged(void);
                       void actionRemoveSelectedFiles_activated(void);

                   #include "DownloadQueueModel.h"
                   DownloadQueueModel::DownloadQueueModel(QNNTPGrabGlue *glue, QObject *parent) :
                       QAbstractItemModel(parent)
+                  {
                       rootItem = new DownloadQueueItem();
                       loadDownloadQueue(glue);
                       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);
+                  }
                   DownloadQueueModel::~DownloadQueueModel()
+                  {
                       delete rootItem;
+                  }
                   int DownloadQueueModel::columnCount(const QModelIndex &parent) const
+                  {
                       if (parent.isValid())
                           return static_cast(parent.internalPointer())->columnCount();
                       else
                           return rootItem->columnCount();
+                  }
                   QVariant DownloadQueueModel::data(const QModelIndex &index, int role) const
+                  {
                       if (!index.isValid())
                           return QVariant();
                       if (role != Qt::DisplayRole)
                           return QVariant();
                       DownloadQueueItem *item = static_cast(index.internalPointer());
                       return item->data(index.column());
+                  }
                   Qt::ItemFlags DownloadQueueModel::flags(const QModelIndex &index) const
+                  {
                       if (!index.isValid())
                           return 0;
                       return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+                  }
                   QVariant DownloadQueueModel::headerData(int section, Qt::Orientation orientation, int role) const
+                  {
                       if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
                           switch (section) {
                               case DownloadQueueItem::FIELD_STATE_STR:
                                   return tr("Progress");
                               case DownloadQueueItem::FIELD_SUBJECT:
                                   return tr("Subject");
                               case DownloadQueueItem::FIELD_POSTER:
                                   return tr("Poster");
                               case DownloadQueueItem::FIELD_GROUPS:
                                   return tr("Groups");
                               case DownloadQueueItem::FIELD_FILE_SIZE_STR:
                                   return tr("File size");
                               case DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR:
                                   return tr("File size remaining");
                               case DownloadQueueItem::FIELD_STAMP:
                                   return tr("Stamp");
                               case DownloadQueueItem::FIELD_ESTIMATED_TIME_REMAINING_STR:
                                   return tr("Estimated time remaining");
                               case DownloadQueueItem::FIELD_ESTIMATED_TIME_TO_FINISH_STR:
                                   return tr("Estimated time to finish");
                               case DownloadQueueItem::FIELD_PROGRESS:
                               case DownloadQueueItem::FIELD_FILE_SIZE:
                               case DownloadQueueItem::FIELD_FILE_SIZE_REMAINING:
                               case DownloadQueueItem::FIELD_REAL_FILENAME:
                               default:
                                   break;
+                          }
+                      }
                       return QVariant();
+                  }
                   QModelIndex DownloadQueueModel::index(int row, int column, const QModelIndex &parent) const
+                  {
                       if (!hasIndex(row, column, parent))
                           return QModelIndex();
                       DownloadQueueItem *parentItem;
                       if (!parent.isValid())
                           parentItem = rootItem;
                       else
                           parentItem = static_cast(parent.internalPointer());
                       DownloadQueueItem *childItem = parentItem->child(row);
                       if (childItem)
                           return createIndex(row, column, childItem);
                       else
                           return QModelIndex();
+                  }
                   QModelIndex DownloadQueueModel::parent(const QModelIndex &index) const
+                  {
                       if (!index.isValid())
                           return QModelIndex();
                       DownloadQueueItem *childItem = static_cast(index.internalPointer());
                       DownloadQueueItem *parentItem = childItem->parent();
                       if (parentItem == rootItem || !parentItem)
                           return QModelIndex();
                       return createIndex(parentItem->row(), 0, parentItem);
+                  }
                   int DownloadQueueModel::rowCount(const QModelIndex &parent) const
+                  {
                       DownloadQueueItem *parentItem;
                       if (parent.column() > 0)
                           return 0;
                       if (!parent.isValid())
                           parentItem = rootItem;
                       else
                           parentItem = static_cast(parent.internalPointer());
                       return parentItem->childCount();
+                  }
                   void DownloadQueueModel::loadDownloadQueue(QNNTPGrabGlue *glue)
+                  {
                       Q_ASSERT(glue != NULL);
                       QList collections = glue->schedularGetAllTasks();
                       for (int i = 0; i < collections.count(); i++) {
                           QNNTPGrabGlue::Collection collection = collections[i];
                           DownloadQueueItem *collection_item = new DownloadQueueItem();
                           for (int j = 0; j < collection.files.count(); j++) {
                               QNNTPGrabGlue::File file = collection.files[j];
                               DownloadQueueItem *file_item = new DownloadQueueItem(collection_item);
                               file_item->subject = file.subject;
                               file_item->poster = file.poster;
                               file_item->size = file.file_size;
                               file_item->sizeRemaining = file.file_size_remaining;
                               file_item->stamp = file.stamp;
                               file_item->state = file.status;
                               file_item->realFilename = file.filename;
                               for (int k = 0; k < file.groups.count(); k++) {
                                   if (file_item->groups.isEmpty()) {
                                       file_item->groups = file.groups[k];
                                   } else {
                                       file_item->groups += QString(",") + file.groups[k];
+                                  }
+                              }
                               if (file.status == QNNTPGrabGlue::TASK_STATE_SKIPPED) {
                                   file_item->progress = 0;
                               } else {
                                   file_item->progress = calculateProgress(file.file_size, file.file_size_remaining);
+                              }
                               switch(file.status) {
                                   case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DOWNLOAD:
                                   case QNNTPGrabGlue::TASK_STATE_DOWNLOADING:
                                       file_item->stateStr = "";
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DECODE:
                                       file_item->stateStr = tr("Waiting");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_DECODING:
                                       file_item->stateStr = tr("Decoding");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_COMPLETE:
                                       file_item->stateStr = tr("Done");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_INCOMPLETE:
                                       file_item->stateStr = tr("Incomplete");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_FINISHED_NO_PARTS_AVAIL:
                                       file_item->stateStr = tr("Not available");
                                       break;
                                   case QNNTPGrabGlue::TASK_STATE_SKIPPED:
                                       file_item->stateStr = tr("Skipped");
                                       break;
                                   default:
                                       file_item->stateStr = "";
                                       break;
                               };
                               collection_item->appendChild(file_item);
+                          }
                           collection_item->progress = calculateProgress(collection.total_size, collection.total_size_remaining);
                           collection_item->subject = collection.collection_name;
                           collection_item->poster = collection.poster;
                           collection_item->size = collection.total_size;
                           collection_item->sizeRemaining = collection.total_size_remaining;
                           rootItem->appendChild(collection_item);
+                      }
+                  }
                   int DownloadQueueModel::calculateProgress(quint64 size, quint64 sizeRemaining)
+                  {
                       if (size == 0) {        /* Prevent a divide by zero */
                           return 0;
+                      }
                       int ret = (((double)size - sizeRemaining) / size) * 100;
                       if (ret < 0 || ret > 100) {
                           qWarning("Invalid progress detected, size = %lli, size_remaining = %lli", size, sizeRemaining);
+                      }
                       return qMin(100, ret);
+                  }
                   void DownloadQueueModel::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);
                   #if 0
                       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));
                   #endif
+                  }
                   void DownloadQueueModel::onFileStateChanged(QString collection_name, QString subject, QString real_filename, QNNTPGrabGlue::TaskState old_state, QNNTPGrabGlue::TaskState new_state)
+                  {
                       Q_UNUSED(old_state);
                   #if 0
                       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;

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff