NNTPGrab

#include 

#ifdef WIN32

#include 

#endif

#include "nntpgrab_qt.h"

#include "nntpgrab_utils.h"

QNNTPGrabThread::QNNTPGrabThread(NntpgrabCore *core)

{

    this->core = core;

}

QNNTPGrabThread::~QNNTPGrabThread()

{

    if (this->isRunning()) {

        ng_event_handler_loop_quit();

        this->wait();

    }

}

void QNNTPGrabThread::run()

{

    ng_event_handler_loop_run();

}

QNNTPGrab::QNNTPGrab()

{

    core = NULL;

    qRegisterMetaType("QNNTPGrab::NNTPDisconnectType");

    qRegisterMetaType("QNNTPGrab::TaskState");

    qRegisterMetaType("QNNTPGrab::LogLevel");

    qRegisterMetaType("QNNTPGrab::SchedularState");

    qRegisterMetaType >("QList");

}

QNNTPGrab::~QNNTPGrab()

{

    if (core) {

        nntpgrab_core_destroy(core);

        core = NULL;

    }

}

bool QNNTPGrab::init(char **errmsg, char **warnings)

{

    nntpgrab_utils_perform_base_initialization();

    core = nntpgrab_core_new();

    if (!nntpgrab_core_init(core, NNTPGRAB_API_VERSION, errmsg, warnings)) {

        nntpgrab_core_destroy(core);

        core = NULL;

        return false;

    }

    nntpgrab_core_set_emit_log_messages(core, TRUE);

    ng_signal_connect(core, "config_changed", NG_CALLBACK(configChangedWrapper), this);

    ng_signal_connect(core, "all_downloads_completed", NG_CALLBACK(allDownloadsCompletedWrapper), this);

    ng_signal_connect(core, "part_download_start", NG_CALLBACK(partDownloadStartWrapper), this);

    ng_signal_connect(core, "part_done", NG_CALLBACK(partDoneWrapper), this);

    ng_signal_connect(core, "part_failed", NG_CALLBACK(partFailedWrapper), this);

    ng_signal_connect(core, "traffic_monitor_update", NG_CALLBACK(trafficMonitorUpdateWrapper), this);

    ng_signal_connect(core, "part_progress_update", NG_CALLBACK(partProgressUpdateWrapper), this);

    ng_signal_connect(core, "collection_added", NG_CALLBACK(collectionAddedWrapper), this);

    ng_signal_connect(core, "collection_modified", NG_CALLBACK(collectionModifiedWrapper), this);

    ng_signal_connect(core, "collection_removed", NG_CALLBACK(collectionRemovedWrapper), this);

    ng_signal_connect(core, "file_added", NG_CALLBACK(fileAddedWrapper), this);

    ng_signal_connect(core, "file_removed", NG_CALLBACK(fileRemovedWrapper), this);

    ng_signal_connect(core, "file_download_state_update", NG_CALLBACK(fileDownloadStateUpdateWrapper), this);

    ng_signal_connect(core, "file_state_changed", NG_CALLBACK(fileStateChangedWrapper), this);

    ng_signal_connect(core, "connection_connecting", NG_CALLBACK(connectionConnectingWrapper), this);

    ng_signal_connect(core, "connection_connected", NG_CALLBACK(connectionConnectedWrapper), this);

    ng_signal_connect(core, "connection_disconnect", NG_CALLBACK(connectionDisconnectWrapper), this);

    ng_signal_connect(core, "schedular_state_changed", NG_CALLBACK(schedularStateChangedWrapper), this);

    ng_signal_connect(core, "log_message", NG_CALLBACK(logMessageWrapper), this);

    ng_signal_connect(core, "task_moved", NG_CALLBACK(fileMovedWrapper), this);

    ng_signal_connect(core, "collection_moved", NG_CALLBACK(collectionMovedWrapper), this);

    ng_signal_connect(core, "collection_downloaded", NG_CALLBACK(collectionDownloadedWrapper), this);

    ng_signal_connect(core, "plugin_loaded", NG_CALLBACK(pluginLoadedWrapper), this);

    ng_signal_connect(core, "plugin_unloaded", NG_CALLBACK(pluginUnloadedWrapper), this);

    ng_signal_connect(core, "plugin_event", NG_CALLBACK(pluginEventWrapper), this);

    /* If Qt is compiled with GLib support then there's already an GLib main loop active */

    /* If this isn't the case, start one in a seperate thread */

    if (ng_event_handler_loop_depth() == 0) {

        this->callbacks_thread = new QNNTPGrabThread(core);

        this->callbacks_thread->start();

    }

    return true;

}

void QNNTPGrab::configChangedWrapper(NntpgrabCore *core, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->configChanged();

}

void QNNTPGrab::allDownloadsCompletedWrapper(NntpgrabCore *core, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->allDownloadsCompleted();

}

void QNNTPGrab::partDownloadStartWrapper(NntpgrabCore *core, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->partDownloadStart(QString(servername), conn_id, QString(collection_name), QString(subject), part_num);

}

void QNNTPGrab::partDoneWrapper(NntpgrabCore *core, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int size, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->partDone(QString(servername), conn_id, QString(collection_name), QString(subject), part_num, size);

}

void QNNTPGrab::partFailedWrapper(NntpgrabCore *core, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num,int size, bool all_servers_tried, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->partFailed(QString(servername), conn_id, QString(collection_name), QString(subject), part_num, size, all_servers_tried);

}

void QNNTPGrab::trafficMonitorUpdateWrapper(NntpgrabCore *core, 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, nguint64 stamp, double average, void *data)

{

    int bytes_received[10];

    Q_UNUSED(core);

    bytes_received[0] = bytes_received1;

    bytes_received[1] = bytes_received2;

    bytes_received[2] = bytes_received3;

    bytes_received[3] = bytes_received4;

    bytes_received[4] = bytes_received5;

    bytes_received[5] = bytes_received6;

    bytes_received[6] = bytes_received7;

    bytes_received[7] = bytes_received8;

    bytes_received[8] = bytes_received9;

    bytes_received[9] = bytes_received10;

    emit ((QNNTPGrab*) data)->trafficMonitorUpdate(bytes_received, stamp, average);

}

void QNNTPGrab::partProgressUpdateWrapper(NntpgrabCore *core, const char *servername, int conn_id, const char *collection_name, const char *subject, int part_num, int bytes_downloaded, int bytes_total, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->partProgressUpdate(QString(servername), conn_id, QString(collection_name), QString(subject), part_num, bytes_downloaded, bytes_total);

}

void QNNTPGrab::collectionAddedWrapper(NntpgrabCore *core, const char *collection_name, const char *poster, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->collectionAdded(QString(collection_name), QString(poster));

}

void QNNTPGrab::collectionModifiedWrapper(NntpgrabCore *core, const char *collection_name, const char *poster, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->collectionModified(QString(collection_name), QString(poster));

}

void QNNTPGrab::collectionRemovedWrapper(NntpgrabCore *core, const char *collection_name, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->collectionRemoved(QString(collection_name));

}

void QNNTPGrab::fileAddedWrapper(NntpgrabCore *core, const char *collection_name, const char *subject, const char *poster, nguint64 stamp, nguint64 file_size, nguint64 total_size, nguint64 total_size_remaining, TaskState state, int num_parts, NGList *groups, void *data)

{

    Q_UNUSED(core);

    /* FIXME: transform groups into a Qt friendly data type */

    emit ((QNNTPGrab*) data)->fileAdded(QString(collection_name), QString(subject), QString(poster), (time_t) stamp, file_size, total_size, total_size_remaining, state, num_parts, groups);

}

void QNNTPGrab::fileRemovedWrapper(NntpgrabCore *core, const char *collection_name, const char *subject, nguint64 total_size, nguint64 total_size_remaining, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->fileRemoved(QString(collection_name), QString(subject), total_size, total_size_remaining);

}

void QNNTPGrab::fileDownloadStateUpdateWrapper(NntpgrabCore *core, 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)

{

    Q_UNUSED(core);

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

}

void QNNTPGrab::fileStateChangedWrapper(NntpgrabCore *core, const char *collection_name, const char *subject, const char *real_filename, TaskState old_state, TaskState new_state, nguint64 file_size_remaining, nguint64 total_size, nguint64 total_size_remaining, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->fileStateChanged(QString(collection_name), QString(subject), QString(real_filename), (QNNTPGrab::TaskState) old_state, (QNNTPGrab::TaskState) new_state, file_size_remaining, total_size, total_size_remaining);

}

void QNNTPGrab::connectionConnectingWrapper(NntpgrabCore *core, const char *servername, int conn_id, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->connectionConnecting(QString(servername), conn_id);

}

void QNNTPGrab::connectionConnectedWrapper(NntpgrabCore *core, const char *servername, int conn_id, const char *welcome_msg, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->connectionConnected(QString(servername), conn_id, welcome_msg);

}

void QNNTPGrab::connectionDisconnectWrapper(NntpgrabCore *core, const char *servername, int conn_id, NNTPDisconnectType disconnect_type, const char *reason, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->connectionDisconnect(QString(servername), conn_id, disconnect_type, QString(reason));

}

void QNNTPGrab::logMessageWrapper(NntpgrabCore *core, const char *component, NGLogLevel log_level, const char *msg, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->logMessage(QString(component), (QNNTPGrab::LogLevel) log_level, QString(msg));

}

void QNNTPGrab::schedularStateChangedWrapper(NntpgrabCore *core, NGSchedularState new_state, const char *reason, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->schedularStateChanged((QNNTPGrab::SchedularState) new_state, QString(reason));

}

void QNNTPGrab::fileMovedWrapper(NntpgrabCore *core, const char *orig_collection_name, const char *subject, const char *new_collection_name, int old_position, int new_position, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->fileMoved(QString(orig_collection_name), QString(subject), QString(new_collection_name), old_position, new_position);

}

void QNNTPGrab::collectionMovedWrapper(NntpgrabCore *core, const char *collection_name, int old_position, int new_position, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->collectionMoved(QString(collection_name), old_position, new_position);

}

void QNNTPGrab::collectionDownloadedWrapper(NntpgrabCore *core, const char *collection_name, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->collectionDownloaded(QString(collection_name));

}

void QNNTPGrab::pluginLoadedWrapper(NntpgrabCore *core, const char *plugin_name, bool is_persistent, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->pluginLoaded(QString(plugin_name), is_persistent);

}

void QNNTPGrab::pluginUnloadedWrapper(NntpgrabCore *core, const char *plugin_name, void *data)

{

    Q_UNUSED(core);

    emit ((QNNTPGrab*) data)->pluginUnloaded(QString(plugin_name));

}

void QNNTPGrab::pluginEventWrapper(NntpgrabCore *core, const char *plugin_name, const char *event_name, const char **values, void *data)

{

    int i;

    QList list_values;

    Q_UNUSED(core);

    i = 0;

    while (values[i]) {

        list_values.append(QString(values[i]));

        i++;

    }

    emit ((QNNTPGrab*) data)->pluginEvent(QString(plugin_name), QString(event_name), list_values);

}

NGConfigOpts QNNTPGrab::configGetOpts()

{

    return nntpgrab_core_config_get_opts(this->core);

}

QNNTPGrab::SchedularState QNNTPGrab::getSchedularState()

{

    return (QNNTPGrab::SchedularState) nntpgrab_core_schedular_get_state(this->core);

}

bool QNNTPGrab::startSchedular()

{

    return nntpgrab_core_schedular_start(this->core);

}

bool QNNTPGrab::stopSchedular(bool wait)

{

    return nntpgrab_core_schedular_stop(this->core, wait);

}

bool QNNTPGrab::loadPlugin(QString plugin_name, QString *errmsg)

{

    bool ret;

    char *errmsg_tmp = NULL;

    ret = nntpgrab_core_plugins_load_plugin(this->core, plugin_name.toAscii(), &errmsg_tmp);

    if (!ret) {

        errmsg->clear();

        errmsg->append(errmsg_tmp);

    }

    return ret;

}

bool QNNTPGrab::startEmbeddedServer(int port, char **errmsg)

{

    return nntpgrab_core_embedded_server_start(this->core, port, errmsg);

}