Revision 1849
| trunk/nntpgrab_core/download_queue.c (revision 1849) | ||
|---|---|---|
| 1755 | 1755 | 
                                              g_print("file->file_size_remaining = %"G_GUINT64_FORMAT"\n", file->file_size_remaining);
                 | 
              
| 1756 | 1756 | 
                  collection->total_size_remaining = 0;  | 
              
| 1757 | 1757 | 
                                          } else {
                 | 
              
| 1758 | 
                  collection->total_size -= file->file_size;  | 
              |
| 1758 | 1759 | 
                  collection->total_size_remaining -= file->file_size_remaining;  | 
              
| 1759 | 1760 | 
                  }  | 
              
| 1760 | 1761 | 
                   | 
              
| ... | ... | |
| 1768 | 1769 | 
                                      } else if (!is_optional && file->status == TASK_STATE_SKIPPED) {
                 | 
              
| 1769 | 1770 | 
                  file->status = TASK_STATE_WAITING_FOR_DOWNLOAD;  | 
              
| 1770 | 1771 | 
                   | 
              
| 1772 | 
                  collection->total_size += file->file_size;  | 
              |
| 1771 | 1773 | 
                  collection->total_size_remaining += file->file_size;  | 
              
| 1772 | 1774 | 
                  file->file_size_remaining = file->file_size;  | 
              
| 1773 | 1775 | 
                   | 
              
| trunk/nntpgrab_core/queue_rawfile.c (revision 1849) | ||
|---|---|---|
| 255 | 255 | 
                  active_file->file_size_remaining += part->size;  | 
              
| 256 | 256 | 
                                  if (active_file->status != TASK_STATE_SKIPPED) {
                 | 
              
| 257 | 257 | 
                  active_collection->total_size_remaining += part->size;  | 
              
| 258 | 
                                  } else {
                 | 
              |
| 259 | 
                  active_collection->total_size -= part->size;  | 
              |
| 258 | 260 | 
                  }  | 
              
| 259 | 261 | 
                  }  | 
              
| 260 | 262 | 
                   | 
              
| trunk/client/gui/queue.c (revision 1849) | ||
|---|---|---|
| 1229 | 1229 | 
                  guint64 file_size_remaining;  | 
              
| 1230 | 1230 | 
                  guint64 total_size;  | 
              
| 1231 | 1231 | 
                  guint64 total_size_remaining;  | 
              
| 1232 | 
                  char size[64];  | 
              |
| 1232 | 1233 | 
                  char size_remaining[64];  | 
              
| 1233 | 1234 | 
                   | 
              
| 1234 | 1235 | 
                      treeDownloadQueue = nntpgrab_gui_base_get_widget("treeDownloadQueue");
                 | 
              
| ... | ... | |
| 1257 | 1258 | 
                  gtk_tree_model_get(GTK_TREE_MODEL(store), &parent, FIELD_FILESIZE, &total_size,  | 
              
| 1258 | 1259 | 
                  FIELD_FILESIZE_REMAINING, &total_size_remaining, -1);  | 
              
| 1259 | 1260 | 
                   | 
              
| 1261 | 
                              if (old_state == TASK_STATE_SKIPPED) {
                 | 
              |
| 1262 | 
                  total_size += file_size - file_size_remaining;  | 
              |
| 1263 | 
                  }  | 
              |
| 1264 | 
                   | 
              |
| 1260 | 1265 | 
                  total_size_remaining += file_size - file_size_remaining;  | 
              
| 1261 | 1266 | 
                  progress = calculate_progress(total_size, total_size_remaining);  | 
              
| 1267 | 
                   | 
              |
| 1268 | 
                  memset(size, 0, sizeof(size));  | 
              |
| 1269 | 
                  nntpgrab_utils_calculate_file_size(total_size_remaining, size, sizeof(size) - 1);  | 
              |
| 1270 | 
                   | 
              |
| 1262 | 1271 | 
                  memset(size_remaining, 0, sizeof(size_remaining));  | 
              
| 1263 | 1272 | 
                  nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);  | 
              
| 1264 | 1273 | 
                   | 
              
| 1265 | 1274 | 
                  gtk_tree_store_set(GTK_TREE_STORE(store), &parent, FIELD_PROGRESS, progress,  | 
              
| 1275 | 
                  FIELD_FILESIZE, total_size,  | 
              |
| 1276 | 
                  FIELD_FILESIZE_STR, size,  | 
              |
| 1266 | 1277 | 
                  FIELD_FILESIZE_REMAINING, total_size_remaining,  | 
              
| 1267 | 1278 | 
                  FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);  | 
              
| 1268 | 1279 | 
                   | 
              
| ... | ... | |
| 1305 | 1316 | 
                  break;  | 
              
| 1306 | 1317 | 
                   | 
              
| 1307 | 1318 | 
                  case TASK_STATE_SKIPPED:  | 
              
| 1319 | 
                  gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, FIELD_FILESIZE, &file_size,  | 
              |
| 1320 | 
                  FIELD_FILESIZE_REMAINING, &file_size_remaining, -1);  | 
              |
| 1321 | 
                   | 
              |
| 1308 | 1322 | 
                              gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Skipped"),
                 | 
              
| 1309 | 1323 | 
                  FIELD_FILESIZE_REMAINING, (guint64) 0,  | 
              
| 1310 | 1324 | 
                  FIELD_FILESIZE_REMAINING_STR, NULL, -1);  | 
              
| 1325 | 
                   | 
              |
| 1326 | 
                  // Update the parent  | 
              |
| 1327 | 
                  gtk_tree_model_get(GTK_TREE_MODEL(store), &parent, FIELD_FILESIZE, &total_size,  | 
              |
| 1328 | 
                  FIELD_FILESIZE_REMAINING, &total_size_remaining, -1);  | 
              |
| 1329 | 
                   | 
              |
| 1330 | 
                  total_size -= file_size_remaining;  | 
              |
| 1331 | 
                  total_size_remaining -= file_size_remaining;  | 
              |
| 1332 | 
                  progress = calculate_progress(total_size, total_size_remaining);  | 
              |
| 1333 | 
                  memset(size_remaining, 0, sizeof(size_remaining));  | 
              |
| 1334 | 
                  nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);  | 
              |
| 1335 | 
                   | 
              |
| 1336 | 
                  gtk_tree_store_set(GTK_TREE_STORE(store), &parent, FIELD_PROGRESS, progress,  | 
              |
| 1337 | 
                  FIELD_FILESIZE_REMAINING, total_size_remaining,  | 
              |
| 1338 | 
                  FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);  | 
              |
| 1339 | 
                   | 
              |
| 1311 | 1340 | 
                  break;  | 
              
| 1312 | 1341 | 
                  };  | 
              
| 1313 | 1342 | 
                  }  | 
              
Also available in: Unified diff
NNTPGrab

