NNTPGrab

static GTrashStack *signal_data_stack = NULL;

static GStaticMutex mutex = G_STATIC_MUTEX_INIT;

static SignalData *

pop_signal_data(void)

    push_signal_data(signal_data);

    return FALSE;

}

        return;

    }

    data = pop_signal_data();

    strncpy(data->part_progress_data.servername, servername, sizeof(data->part_progress_data.servername) - 1);

    data->part_progress_data.conn_id = conn_id;

    data->part_progress_data.bytes_downloaded = bytes_downloaded;

    data->part_progress_data.bytes_total = bytes_total;

    if (direct) {

        do_emit_part_progress_update(data);

    } else {

    ng_plugin_create_event(plugin_data, "unpack_progress_update", 3);

    ng_plugin_create_event(plugin_data, "unpack_message_received", 3);

    ng_plugin_create_event(plugin_data, "unpack_working_archive_changed", 3);

    /* Add a dependency on the NNTPGrab Core and the PAR2 plugin */

    ng_plugin_set_required_event(plugin_data, "collection_downloaded");

    unpack_data->error_type = error->type;

    unpack_data->error_occured = (error->status != 0 || error->type != 0);

        strncpy(unpack_data->errmsg, error->gerror->message, sizeof(unpack_data->errmsg) - 1);

    } else if (error->status != 0) {

        snprintf(unpack_data->errmsg, sizeof(unpack_data->errmsg) - 1, "Unknown error occured while unpacking, error->status = %i, error->type = %i", error->status, error->type);

    while (list) {

        UnpackFile *file = (UnpackFile*) list->data;

        char *total_filename = g_build_filename(target_directory, file->filename, NULL);

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, _("Now unpacking '%s'"), file->filename);

        if (!unpack_do_unpack(plugin_data, collection_name, total_filename, target_directory, &errmsg)) {

            ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_WARNING, _("Automatic unpack failed due to an error: %s"), errmsg);

            g_free(errmsg);

        }

        ng_plugin_emit_log_msg(plugin_data, NG_LOG_LEVEL_INFO, _("Unpack of '%s' finished"), file->filename);

# void unpack_message_received(NGPlugin *plugin_data, const char *collection_name, const char *filename, const char *message);

# void unpack_working_archive_changed(NGPlugin *plugin_data, const char *collection_name, const char *filename, const char *working_archive);

VOID:STRING,STRING,STRING

            unpack_message_received(glue, values[0], values[1], values[2], data);

        } else if (!strcmp(event_name, "unpack_working_archive_changed")) {

            unpack_working_archive_changed(glue, values[0], values[1], values[2], data);

        } else {

            g_warning("Unknown plugin event received from %s plugin: %s\n", plugin_name, event_name);

        }

        collection_name = ui->entryQuery->text();

    }

    future_import = QtConcurrent::run(this, &WidgetNZBCreator::performImport, file_ids);

    watcher_import.setFuture(future_import);

}

    DialogImportNZB d(glue);

    d.quickImport(collection_name, res.nzb_data, true);

}

void WidgetNZBCreator::btnSelectAll_clicked()

#include "nntpgrab_utils.h"

WidgetDownloadQueue::WidgetDownloadQueue(QNNTPGrabGlue *glue, QAction *actionRemoveSelectedFiles, QWidget *parent) :

        QWidget(parent),

        ui(new Ui::WidgetDownloadQueue)

    ui->setupUi(this);

    this->model = new DownloadQueueModel(glue);

    ui->treeView->setModel(this->model);

    progressbarDelegate = new ProgressBarDelegateDownloadQueue(this);

    connect(ui->treeView, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));

    /* Add custom fields to the list */

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

}

WidgetDownloadQueue::~WidgetDownloadQueue()

    processSelectionAndMoveItems(MOVE_DIRECTION_BOTTOM);

}

void WidgetDownloadQueue::onSelectionChanged(const QItemSelection &newSelection, const QItemSelection &oldSelection)

{

    Q_UNUSED(newSelection);

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

    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:

      true

#endif

private slots:

    void btnQueueMoveToTop_clicked(void);

    void btnQueueMoveUp_clicked(void);

    void btnQueueMoveDown_clicked(void);

int DownloadQueueModel::columnCount(const QModelIndex &parent) const

{

}

QVariant DownloadQueueModel::data(const QModelIndex &index, int role) const

    if (!index.isValid())

        return QModelIndex();

}

int DownloadQueueModel::rowCount(const QModelIndex &parent) const

{

        return 0;

}

void DownloadQueueModel::loadDownloadQueue(QNNTPGrabGlue *glue)

    int ret = (((double)size - sizeRemaining) / size) * 100;

    if (ret < 0 || ret > 100) {

    }

    return qMin(100, ret);

    idx = createIndex(subject_node->row(), (int) DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR, subject_node);

    emit dataChanged(idx, idx);

}

void DownloadQueueModel::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)

        return;

    }

    DownloadQueueItem *file_node = new DownloadQueueItem(collection_node);

    file_node->subject = subject;

    file_node->poster = poster;

        file_node->sizeRemainingStr = QNNTPGrabGlue::utilsCalculateFileSize(0);

    }

    /* Update the parent */

    collection_node->appendChild(file_node);

    collection_node->size = total_size;

    collection_node->sizeStr = QNNTPGrabGlue::utilsCalculateFileSize(total_size);

    collection_node->sizeRemaining = total_size_remaining;

    idx = createIndex(collection_node->row(), (int) DownloadQueueItem::FIELD_FILE_SIZE_REMAINING_STR, collection_node);

    emit dataChanged(idx, idx);

}

void DownloadQueueModel::onFileRemoved(QString collection_name, QString subject, quint64 total_size, quint64 total_size_remaining)

        return;

    }

    collection_node->size = total_size;

    collection_node->sizeStr = QNNTPGrabGlue::utilsCalculateFileSize(total_size);

    collection_node->sizeRemaining = total_size_remaining;

    collection_node->progress = calculateProgress(total_size, total_size_remaining);

    collection_node->removeChild(subject_node);

    QModelIndex idx = createIndex(collection_node->row(), (int) DownloadQueueItem::FIELD_STATE_STR, collection_node);

    emit dataChanged(idx, idx);

void DownloadQueueModel::onCollectionAdded(QString collection_name, QString poster)

{

    DownloadQueueItem *collection_node = new DownloadQueueItem(rootItem);

    collection_node->subject = collection_name;

    collection_node->poster = poster;

    rootItem->appendChild(collection_node);

}

void DownloadQueueModel::onCollectionRemoved(QString collection_name)

        return;

    }

    rootItem->removeChild(collection_node);

}

void DownloadQueueModel::onCollectionModified(QString collection_name, QString poster)

    QModelIndex parent_idx = createIndex(rootItem->row(), 0, rootItem);

    int new_pos_in_model = qMin(rootItem->childCount(), ((old_position < new_position) ? new_position + 1 : new_position));

        qWarning("beginMoveRows failed\n");

        return;

    }

    void unpackProgressUpdate(QString collection_name, QString filename, double progress);

    void unpackMessageReceived(QString collection_name, QString filename, QString message);

    void unpackWorkingArchiveChanged(QString collection_name, QString filename, QString working_archive);

private slots:

    void configChanged();

    int row() const;

    DownloadQueueItem *parent();

    DownloadQueueItem *lookupSubject(QString subject);

    QString subject;

    QString poster;

    /* Is the current row selected? */

    QModelIndex idx = sourceParent.child(sourceStart, 0);

    if (!idx.isValid()) {

    }

    if (isSelected(idx)) {

        /* Deselect the row and keep track of it so we can re-select it after the move has completed */

        deselectedSourceParent = sourceParent;

        deselectedSourceStart = sourceStart;

        QModelIndex idx = destinationParent.child(destinationRow, 0);

        if (!idx.isValid()) {

        }

        select(idx, Toggle | Rows);

    } else {

void DownloadQueueSelectionModel::onRowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)

{

    Q_UNUSED(sourceEnd);

    /* Was the original row selected? */

    if (deselectedSourceParent != sourceParent ||

        return;

    }

}

    collection_item->setText(FIELD_PROGRESS, "75");

    file_item->setText(FIELD_PROGRESS, QString("%1").arg((int) (progress * 100)));

}

void WidgetRepairAndUnpack::unpackMessageReceived(QString collection_name, QString filename, QString message)

    ui->treeWidget->scrollToBottom();

}

void WidgetRepairAndUnpack::configChanged()

{

    this->opts = glue->configGetOpts();

            unpackMessageReceived(values[0], values[1], values[2]);

        } else if (event_name == "unpack_working_archive_changed") {

            unpackWorkingArchiveChanged(values[0], values[1], values[2]);

        } else {

            qWarning(QString("Unknown plugin event received from plugin '%1': %2").arg(plugin_name, event_name).toUtf8());

        }

    if (txt.isEmpty()) {

        return QSize(60,16);

    } else {

    }

}

#include "DownloadQueueItem.h"

DownloadQueueItem::DownloadQueueItem(DownloadQueueItem *parent)

            return sizeRemainingStr;

        case FIELD_STAMP:

        case FIELD_ESTIMATED_TIME_REMAINING_STR:

            return estimatedTimeRemainingStr;

    return NULL;

}