NNTPGrab

        file->now_decoding = TRUE;

        file->status = TASK_STATE_WAITING_FOR_DECODE;

    g_static_mutex_lock(&collection->mutex);

    part->now_downloading = FALSE;

    part->downloaded = success;

    file->file_is_downloading = FALSE;

    g_return_if_fail(collection != NULL);

    g_return_if_fail(file != NULL);

    g_static_mutex_lock(&collection->mutex);

    file->status = TASK_STATE_DECODING;

    }

    file->status = status;

    file->now_decoding = FALSE;

                    collection->total_size_remaining += file->file_size - file->file_size_remaining - filesize_remaining_active;

                    file->file_size_remaining = file->file_size - filesize_remaining_active;

                    file->status = TASK_STATE_WAITING_FOR_DOWNLOAD;

                    if (!restart_flag) {

                        file->file_size_remaining = file->file_size;

                        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, _("File '%s' of collection '%s' was marked optional"), collection_name, subject);

                        collection->total_size_remaining += file->file_size;

                        file->file_size_remaining = file->file_size;

                        ng_plugin_emit_log_msg(NULL, NG_LOG_LEVEL_DEBUG, _("File '%s' of collection '%s' was marked non-optional"), collection_name, subject);

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

    /**

     * NntpgrabCore::connection-connecting:

G_BEGIN_DECLS

typedef enum {

    NNTP_ERROR_NONE,

    char real_filename[256];

    NGTaskState old_state;

    NGTaskState new_state;

};

struct _schedular_data {

                                                 signal_data->file_state_data.subject,

                                                 real_filename,

                                                 signal_data->file_state_data.old_state,

    push_signal_data(signal_data);

}

void

{

    SignalData *data;

    }

    data->file_state_data.old_state = old_state;

    data->file_state_data.new_state = new_state;

    if (direct) {

        do_emit_file_state_changed(data);

void     nntpgrab_core_emit_collection_modified(gboolean direct, const char *collection_name, const char *poster);

void     nntpgrab_core_emit_file_added(gboolean direct, const char *collection_name, const char *subject, const char *poster, guint64 stamp, guint64 file_size, guint64 total_size, guint64 total_size_remaining, NGTaskState status, int num_parts, GList *groups);

void     nntpgrab_core_emit_file_removed(gboolean direct, const char *collection_name, const char *subject, guint64 total_file_size, guint64 total_file_size_remaining);

void     nntpgrab_core_emit_schedular_state_changed(gboolean direct, NGSchedularState state, const char *reason);

void     nntpgrab_core_emit_file_moved(gboolean direct, const char *orig_collection_name, const char *subject, const char *new_collection_name, int old_position, int new_position);

void     nntpgrab_core_emit_collection_moved(gboolean direct, const char *collection_name, int old_position, int new_position);

extern "C" {

#endif

#define NNTPGRAB_TYPE_CORE              (nntpgrab_core_get_type ())

#define NNTPGRAB_CORE(object)           (NG_TYPE_CHECK_INSTANCE_CAST ((object), NNTPGRAB_TYPE_CORE, NntpgrabCore))

VOID:STRING,STRING,UINT64,UINT64

# void (*file_download_state_update) (NNTPGrabCore *core, const char *collection_name, const char *subject, int num_parts_total, int num_parts_done, int num_parts_failed, guint64 file_size, guint64 file_size_remaining, guint64 total_file_size, guint64 total_file_size_remaining);

VOID:STRING,STRING,INT,INT,INT,UINT64,UINT64,UINT64,UINT64

# void (*connection_connecting) (NNTPGrabCore *core, const char *servername, int conn_id);

VOID:STRING,INT

# void (*connection_connected)  (NNTPGrabCore *core, const char *servername, int conn_id, const char *welcome_msg);

}

static void

{

    struct json_object *event = json_object_new_object();

    json_object_object_add(event, "collection_name", json_object_new_string((char*) collection_name));

    json_object_object_add(event, "subject", json_object_new_string((char*) subject));

    json_object_object_add(event, "real_filename", json_object_new_string((char*) (real_filename ? real_filename : "")));

    json_object_object_add(event, "old_state", json_object_new_int(old_state));

    json_object_object_add(event, "new_state", json_object_new_int(new_state));

    emit_event("file_state_changed", event);

    char *real_filename;

    int old_state;

    int new_state;

    get_param(msg, params, "collection_name", "file_state_changed", string, collection_name);

    get_param(msg, params, "subject", "file_state_changed", string, subject);

    get_param(msg, params, "real_filename", "file_state_changed", string, real_filename);

    get_param(msg, params, "old_state", "file_state_changed", int, old_state);

    get_param(msg, params, "new_state", "file_state_changed", int, new_state);

}

static void

                                                        G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,

                                                        0,

                                                        NULL, NULL,

    /**

     * NntpgrabGlue::connection-connecting:

extern "C" {

#endif

#define NNTPGRAB_TYPE_GLUE              (nntpgrab_glue_get_type ())

#define NNTPGRAB_GLUE(object)           (NG_TYPE_CHECK_INSTANCE_CAST ((object), NNTPGRAB_TYPE_GLUE, NntpgrabGlue))

nntpgrab_core/download_queue.h

nntpgrab_core/download_thread.c

nntpgrab_core/download_thread.h

nntpgrab_core/marshalers.c

nntpgrab_core/marshalers.h

nntpgrab_core/nntpconnection.c

#include 

static void

{

    char *msg;

    NotifyNotification *notification;

}

static void

{

    GtkWidget *treeDownloadQueue;

    GtkTreeModel *store;

    GtkTreeIter iter, parent;

    int progress;

    char size[64];

    char size_remaining[64];

    switch(new_state) {

        case TASK_STATE_WAITING_FOR_DOWNLOAD:       // The file was restarted

            // Update the row itself

            memset(size_remaining, 0, sizeof(size_remaining));

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_PARTS_DONE, (int) 0,

                                                                FIELD_PARTS_FAILED, (int) 0,

                                                                FIELD_PROGRESS, (int) 0,

                                                                FIELD_STATE_STR, NULL,

                                                                FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

            // Update the parent

            progress = calculate_progress(total_size, total_size_remaining);

            memset(size, 0, sizeof(size));

            memset(size_remaining, 0, sizeof(size_remaining));

            nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);

            break;

        case TASK_STATE_SKIPPED:

            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,    FIELD_STATE_STR, _("Skipped"),

                                                                FIELD_FILESIZE_REMAINING, (guint64) 0,

                                                                FIELD_FILESIZE_REMAINING_STR, NULL, -1);

            // Update the parent

            progress = calculate_progress(total_size, total_size_remaining);

            memset(size_remaining, 0, sizeof(size_remaining));

            nntpgrab_utils_calculate_file_size(total_size_remaining, size_remaining, sizeof(size_remaining) - 1);

            gtk_tree_store_set(GTK_TREE_STORE(store), &parent,  FIELD_PROGRESS, progress,

                                                                FIELD_FILESIZE_REMAINING, total_size_remaining,

                                                                FIELD_FILESIZE_REMAINING_STR, size_remaining, -1);

    static void fileAddedWrapper(NntpgrabGlue *glue, const char *collection_name, const char *subject, const char *poster, nguint64 stamp, nguint64 file_size, nguint64 total_size, nguint64 total_size_remaining, NGTaskState state, int num_parts, NGList *groups, void *data);

    static void fileRemovedWrapper(NntpgrabGlue *glue, const char *collection_name, const char *subject, nguint64 total_size, nguint64 total_size_remaining, void *data);

    static void fileDownloadStateUpdateWrapper(NntpgrabGlue *glue, const char *collection_name, const char *subject, int num_parts_total, int num_parts_done, int num_parts_failed, nguint64 file_size, nguint64 file_size_remaining, nguint64 total_size, nguint64 total_size_remaining, void *data);

    static void connectionConnectingWrapper(NntpgrabGlue *glue, const char *servername, int conn_id, void *data);

    static void connectionConnectedWrapper(NntpgrabGlue *glue, const char *servername, int conn_id, const char *welcome_msg, void *data);

    static void connectionDisconnectWrapper(NntpgrabGlue *glue, const char *servername, int conn_id, NNTPDisconnectType disconnect_type, const char *reason, void *data);

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

    connect(ui->actionShowDebugWindow, SIGNAL(triggered(void)),

            SLOT(actionShowDebugWindow_activated(void)));

    connect(glue, SIGNAL(schedularStateChanged(QNNTPGrabGlue::SchedularState,QString)),

            SLOT(onSchedularStateChanged(QNNTPGrabGlue::SchedularState,QString)));

    if (!glue->getIsStandalone()) {

    }

}

{

    Q_UNUSED(collection_name);

    Q_UNUSED(real_filename);

        LOG_LEVEL_WARNING,

        LOG_LEVEL_ERROR,

        LOG_LEVEL_FATAL,

    };

    enum SchedularState {

    void fileAdded(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 fileRemoved(QString collection_name, QString subject, quint64 total_size, quint64 total_size_remaining);

    void fileDownloadStateUpdate(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 connectionConnecting(QString servername, int conn_id);

    void connectionConnected(QString servername, int conn_id, QString welcome_msg);

    void connectionDisconnect(QString servername, int conn_id, QNNTPGrabGlue::NNTPDisconnectType disconnect_type, QString reason);

    void pluginEvent(QString plugin_name, QString event_name, QList values);

private:

    QNNTPGrabGluePrivate * const d_ptr;

};

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

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

        qDebug("Invalid progress detected, size = %lli, size_remaining = %lli", size, sizeRemaining);

    }

    return qMin(100, ret);

    emit dataChanged(idx, idx);

}

{

    Q_UNUSED(old_state);

    DownloadQueueItem *collection_node;

    DownloadQueueItem *subject_node;

        return;

    }

    switch(new_state) {

        case QNNTPGrabGlue::TASK_STATE_WAITING_FOR_DOWNLOAD:

            /* The task was restarted */

            /* Update the row itself */

            subject_node->progress = 0;

            subject_node->stateStr = "";

            /* Update the parent */

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

            collection_node->sizeRemaining = total_size_remaining;

            collection_node->sizeRemainingStr = QNNTPGrabGlue::utilsCalculateFileSize(total_size_remaining);

            subject_node->stateStr = "";                /* 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:

            subject_node->progress = 100;

            subject_node->sizeRemaining = 0;

            subject_node->stateStr = tr("Waiting");

            break;

        case QNNTPGrabGlue::TASK_STATE_DECODING:

            subject_node->stateStr = tr("Not available");

            break;

        case QNNTPGrabGlue::TASK_STATE_SKIPPED:

            subject_node->stateStr = tr("Skipped");

            subject_node->sizeRemaining = 0;

            break;

    }

    emit ((QNNTPGrabGlue*) data)->fileDownloadStateUpdate(QString::fromUtf8(collection_name), QString::fromUtf8(subject), num_parts_total, num_parts_done, num_parts_failed, file_size, file_size_remaining, total_size, total_size_remaining);

}

{

    Q_UNUSED(glue);

}

void QNNTPGrabGluePrivate::connectionConnectingWrapper(NntpgrabGlue *glue, const char *servername, int conn_id, void *data)

    void actionShowDebugWindow_activated(void);

    void actionPauseDownloadQueue_activated(void);

    void onSchedularStateChanged(QNNTPGrabGlue::SchedularState state, QString reason);

    void onConnectionLost(QString errmsg);

    void onAllDownloadsCompleted(void);