int MythSecsTo(const QDateTime &from, const QDateTime &to)

{

  return (from.time().secsTo(to.time()) +

	  from.date().daysTo(to.date()) * 60 * 60 * 24);

}

QDateTime MythUTCToLocal(const QDateTime &utc)

{

  QDateTime local = QDateTime(QDate(1970, 1, 1));

  int timesecs = MythSecsTo(local, utc);

  QDateTime localdt;

  localdt.setTime_t(timesecs);

  return localdt;

}

#include <qdatetime.h>

#ifndef UTIL_H_

#define UTIL_H_

#include <qsocket.h>

#include <qstringlist.h>

#include <qdatetime.h>

#include <qcolor.h>

#include <time.h>

class QPixmap;

class QImage;

class QPainter;

class QFont;

QString SocDevErrStr(int error);

// QSockectDevice (frontend)

bool connectSocket(QSocketDevice *socket, const QString &host, int port);

bool WriteStringList(QSocketDevice *socket, QStringList &list);

bool ReadStringList(QSocketDevice *socket, QStringList &list,

                    bool quickTimeout = false);

bool WriteBlock(QSocketDevice *socket, void *data, int len);

// QSockect (backend)

bool WriteStringList(QSocket *socket, QStringList &list);

bool ReadStringList(QSocket *socket, QStringList &list);

bool WriteBlock(QSocket *socket, void *data, int len);

int ReadBlock(QSocket *socket, void *data, int maxlen);

void encodeLongLong(QStringList &list, long long num);

long long decodeLongLong(QStringList &list, int offset);

long long decodeLongLong(QStringList &list, QStringList::iterator &it);

#if defined(Q_WS_X11)

void GetMythTVGeometry(Display *dpy, int screen_num, int *x, int *y, 

                       int *w, int *h);

#endif

QRgb blendColors(QRgb source, QRgb add, int alpha);

#define MYTH_SYSTEM_DONT_BLOCK_LIRC (1)

#define MYTH_SYSTEM_DONT_BLOCK_JOYSTICK_MENU (2)

int myth_system(const QString &command, int flags = 0);

QString cutDownString(QString text, QFont *testFont, int maxwidth);

long long stringToLongLong(const QString &str);

QString longLongToString(long long ll);

bool diskUsage(const char *path, double &total, double &used, double &free);

bool getUptime(time_t &uptime);

bool getMemStats(int &totalMB, int &freeMB, int &totalVM, int &freeVM);

#endif

#include "../libmyth/util.h"

#include "../libmyth/util.h"

#include <qapplication.h>

#include <qdom.h>

#include <qfile.h>

#include <qstring.h>

#include <qregexp.h>

#include <qstringlist.h>

#include <qvaluelist.h>

#include <qmap.h>

#include <qdatetime.h>

#include <qdir.h>

#include <qfile.h>

#include <qsqldatabase.h>

#include <qsqlquery.h>

#include <qurl.h>

#include <unistd.h>

#include <signal.h>

#include <sys/wait.h>

#include <iostream>

#include <fstream>

#include <string>

#include <cstdlib>

#include <cstdio>

#include <ctime>

#include "libmyth/mythcontext.h"

#include "libmythtv/scheduledrecording.h"

#include "libmythtv/datadirect.h"

#include "libmyth/mythdbcon.h"

using namespace std;

static QString SetupIconCacheDirectory();

bool interactive = false;

bool channel_preset = false;

bool non_us_updating = false;

bool from_file = false;

bool quiet = false;

bool no_delete = false;

bool isNorthAmerica = false;

bool isJapan = false;

bool interrupted = false;

bool refresh_today = false;

bool refresh_tomorrow = true;

bool refresh_second = false;

bool refresh_tba = true;

int listing_wrap_offset = 0;

bool dd_grab_all = false;

bool dddataretrieved = false;

bool mark_repeats = true;

bool channel_updates = false;

QString lastdduserid;

DataDirectProcessor ddprocessor;

QString graboptions = "";

class ChanInfo

{

  public:

    ChanInfo() { }

    ChanInfo(const ChanInfo &other) { callsign = other.callsign; 

                                      iconpath = other.iconpath;

                                      chanstr = other.chanstr;

                                      xmltvid = other.xmltvid;

                                      old_xmltvid = other.old_xmltvid;

                                      name = other.name;

                                      freqid = other.freqid;

                                      finetune = other.finetune;

                                      tvformat = other.tvformat;

                                    }

    QString callsign;

    QString iconpath;

    QString chanstr;

    QString xmltvid;

    QString old_xmltvid;

    QString name;

    QString freqid;

    QString finetune;

    QString tvformat;

};

struct ProgRating

{

    QString system;

    QString rating;

};

struct ProgCredit

{

    QString role;

    QString name;

};

class ProgInfo

{

  public:

    ProgInfo() { }

    ProgInfo(const ProgInfo &other) { channel = other.channel;

                                      startts = other.startts;

                                      endts = other.endts;

                                      start = other.start;

                                      end = other.end;

                                      title = other.title;

                                      subtitle = other.subtitle;

                                      desc = other.desc;

                                      category = other.category;

                                      catType = other.catType;

                                      airdate = other.airdate;

                                      stars = other.stars;

                                      previouslyshown = other.previouslyshown;

                                      title_pronounce = other.title_pronounce;

                                      stereo = other.stereo;

                                      subtitled = other.subtitled;

                                      hdtv = other.hdtv;

                                      closecaptioned = other.closecaptioned;

                                      partnumber = other.partnumber;

                                      parttotal = other.parttotal;

                                      seriesid = other.seriesid;

                                      originalairdate = other.originalairdate;

                                      showtype = other.showtype;

                                      colorcode = other.colorcode;

                                      syndicatedepisodenumber = other.syndicatedepisodenumber;

                                      programid = other.programid;

                                      clumpidx = other.clumpidx;

                                      clumpmax = other.clumpmax;

                                      ratings = other.ratings;

                                      credits = other.credits;

                                      content = other.content;

                                    }

    QString channel;

    QString startts;

    QString endts;

    QDateTime start;

    QDateTime end;

    QString title;

    QString subtitle;

    QString desc;

    QString category;

    QString catType;

    QString airdate;

    QString stars;

    bool previouslyshown;

    QString title_pronounce;

    bool stereo;

    bool subtitled;

    bool hdtv;

    bool closecaptioned;

    QString partnumber;

    QString parttotal;

    QString seriesid;                                

    QString originalairdate;

    QString showtype;

    QString colorcode;

    QString syndicatedepisodenumber;

    QString programid;

    QString clumpidx;

    QString clumpmax;

    QValueList<ProgRating> ratings;

    QValueList<ProgCredit> credits;

    QString content;

};

bool operator<(const ProgInfo &a, const ProgInfo &b)

{

    return (a.start < b.start);

}

bool operator>(const ProgInfo &a, const ProgInfo &b)

{

    return (a.start > b.start);

}

bool operator<=(const ProgInfo &a, const ProgInfo &b)

{

    return (a.start <= b.start);

}

struct Source

{

    int id;

    QString name;

    QString xmltvgrabber;

    QString userid;

    QString password;

    QString lineupid;

};

unsigned int ELFHash(const char *s)

{

    /* ELF hash uses unsigned chars and unsigned arithmetic for portability */

    const unsigned char *name = (const unsigned char *)s;

    unsigned long h = 0, g;

    while (*name)

    { /* do some fancy bitwanking on the string */

        h = (h << 4) + (unsigned long)(*name++);

        if ((g = (h & 0xF0000000UL))!=0)

            h ^= (g >> 24);

        h &= ~g;

    }

    return (int)h;

}

void clearDataByChannel(int chanid, QDateTime from, QDateTime to) 

{

    MSqlQuery query;

    QString querystr;

    querystr.sprintf("DELETE FROM program "

                     "WHERE starttime >= '%s' AND starttime < '%s' "

                     "AND chanid = %d;",

                     from.toString("yyyyMMddhhmmss").ascii(),

                     to.toString("yyyyMMddhhmmss").ascii(),

                     chanid);

    query.exec(querystr);

    querystr.sprintf("DELETE FROM programrating WHERE starttime >= '%s' "

                     " AND starttime < '%s' AND chanid = %d;",

                     from.toString("yyyyMMddhhmmss").ascii(),

                     to.toString("yyyyMMddhhmmss").ascii(),

                     chanid);

    query.exec(querystr);

    querystr.sprintf("DELETE FROM credits WHERE starttime >= '%s' "

                     "AND starttime < '%s' AND chanid = %d;",

                     from.toString("yyyyMMddhhmmss").ascii(),

                     to.toString("yyyyMMddhhmmss").ascii(),

                     chanid);

    query.exec(querystr);

    querystr.sprintf("DELETE FROM programgenres WHERE starttime >= '%s' "

                     "AND starttime < '%s' AND chanid = %d;",

                     from.toString("yyyyMMddhhmmss").ascii(),

                     to.toString("yyyyMMddhhmmss").ascii(),

                     chanid);

    query.exec(querystr);

}

void clearDataBySource(int sourceid, QDateTime from, QDateTime to) 

{

    QString querystr= QString("SELECT chanid FROM channel WHERE "

                              "sourceid = \"%0\";").arg(sourceid);

    MSqlQuery query;

    if (!query.exec(querystr))

        MythContext::DBError("Selecting channels per source", query);

    if (query.isActive() && query.numRowsAffected() > 0)

    {

        while (query.next())

        {

            int chanid = query.value(0).toInt();

            clearDataByChannel(chanid, from, to);

        }

    }

}

// icon mapping stuff

namespace {

const char * const IM_DOC_TAG = "iconmappings";

const char * const IM_CS_TO_NET_TAG = "callsigntonetwork";

const char * const IM_CS_TAG = "callsign";

const char * const IM_NET_TAG = "network";

const char * const IM_NET_TO_URL_TAG = "networktourl";

const char * const IM_NET_URL_TAG = "url";

const char * const BASEURLMAP_START = "mythfilldatabase.urlmap.";

const char * const IM_BASEURL_TAG = "baseurl";

const char * const IM_BASE_STUB_TAG = "stub";

QString expandURLString(const QString &url)

{

    QRegExp expandtarget("\\[([^\\]]+)\\]");

    QString retval = url;

    int found_at = 0;

    int start_index = 0;

    while (found_at != -1)

    {

        found_at = expandtarget.search(retval, start_index);

        if (found_at != -1)

        {

            QString no_mapping("no_URL_mapping");

            QString search_string = expandtarget.cap(1);

            QString expanded_text = gContext->GetSetting(

                    QString(BASEURLMAP_START) + search_string, no_mapping);

            if (expanded_text != no_mapping)

            {

                retval.replace(found_at, expandtarget.matchedLength(),

                        expanded_text);

            }

            else

            {

                start_index = found_at + expandtarget.matchedLength();

            }

        }

    }

    return retval;

}

void UpdateSourceIcons(int sourceid)

{

    if (!quiet)

        cout << QString("Updating icons for sourceid: %1").arg(sourceid) << endl;

    QString fileprefix = SetupIconCacheDirectory();

    MSqlQuery query;

    query.prepare("SELECT ch.chanid, nim.url "

            "FROM channel ch, callsignnetworkmap csm "

            "RIGHT JOIN networkiconmap nim ON csm.network = nim.network "

            "WHERE ch.callsign = csm.callsign AND "

            "(icon = :NOICON OR icon = '') AND ch.sourceid = :SOURCEID");

    query.bindValue(":SOURCEID", sourceid);

    query.bindValue(":NOICON", "none");

    if (!query.exec())

        MythContext::DBError("Looking for icons to fetch", query);

    if (query.isActive() && query.numRowsAffected() > 0)

    {

        while (query.next())

        {

            QString icon_url = expandURLString(query.value(1).toString());

            QFileInfo qfi(icon_url);

            QFile localfile(fileprefix + "/" + qfi.fileName());

            if (!localfile.exists())

            {

                QString icon_get_command = QString("wget --timestamping "

                        "--directory-prefix=") + fileprefix + " " + icon_url;

                if (!quiet)

                    cout << QString("Attempting to fetch icon with: %1").arg(icon_get_command) << endl;

                system(icon_get_command);

            }

            if (localfile.exists())

            {

                int chanid = query.value(0).toInt();

                if (!quiet)

                {

                    QString m = QString("Updating channel icon for chanid: %1")

                        .arg(chanid);

                    cout << m << endl;

                }

                MSqlQuery icon_update_query;

                icon_update_query.prepare("UPDATE channel SET icon = :ICON "

                        "WHERE chanid = :CHANID AND sourceid = :SOURCEID");

                icon_update_query.bindValue(":ICON", localfile.name());

                icon_update_query.bindValue(":CHANID", query.value(0).toInt());

                icon_update_query.bindValue(":SOURCEID", sourceid);

                if (!icon_update_query.exec())

                    MythContext::DBError("Setting the icon file name",

                            icon_update_query);

            }

            else

            {

                cerr << QString(

                        "Error retrieving icon from '%1' to file '%2'")

                        .arg(icon_url)

                        .arg(localfile.name())

                     << endl;

            }

        }

    }

}

bool dash_open(QFile &file, const QString &filename, int m, FILE *handle = NULL)

{

    bool retval = false;

    if (filename == "-")

    {

        if (handle == NULL)

        {

            handle = stdout;

            if (m & IO_ReadOnly)

            {

                handle = stdin;

            }

        }

        retval = file.open(m, handle);

    }

    else

    {

        file.setName(filename);

        retval = file.open(m);

    }

    return retval;

}

class DOMException

{

  private:

    QString message;

  protected:

    void setMessage(const QString &mes)

    {

        message = mes;

    }

  public:

    DOMException() : message("Unknown DOMException") {}

    virtual ~DOMException() {}

    DOMException(const QString &mes) : message(mes) {}

    QString getMessage()

    {

        return message;

    }

};

class DOMBadElementConversion : public DOMException

{

  public:

    DOMBadElementConversion()

    {

        setMessage("Unknown DOMBadElementConversion");

    }

    DOMBadElementConversion(const QString &mes) : DOMException(mes) {}

    DOMBadElementConversion(const QDomNode &node)

    {

        setMessage(QString("Unable to convert node: '%1' to QDomElement.")

                .arg(node.nodeName()));

    }

};

class DOMUnknownChildElement : public DOMException

{

  public:

    DOMUnknownChildElement()

    {

        setMessage("Unknown DOMUnknownChildElement");

    }

    DOMUnknownChildElement(const QString &mes) : DOMException(mes) {}

    DOMUnknownChildElement(const QDomElement &e, QString child_name)

    {

        setMessage(QString("Unknown child element '%1' of: '%2'")

                .arg(child_name)

                .arg(e.tagName()));

    }

};

QDomElement nodeToElement(QDomNode &node)

{

    QDomElement retval = node.toElement();

    if (retval.isNull())

    {

        throw DOMBadElementConversion(node);

    }

    return retval;

}

QString getNamedElementText(const QDomElement &e,

        const QString &child_element_name)

{

    QDomNode child_node = e.namedItem(child_element_name);

    if (child_node.isNull())

    {

        throw DOMUnknownChildElement(e, child_element_name);

    }

    QDomElement element = nodeToElement(child_node);

    return element.text();

}

void ImportIconMap(const QString &filename)

{

    if (!quiet)

    {

        QString msg = QString("Importing icon mapping from %1...")

                .arg(filename);

        cout << msg << endl;

    }

    QFile xml_file;

    if (dash_open(xml_file, filename, IO_ReadOnly))

    {

        QDomDocument doc;

        QString de_msg;

        int de_ln = 0;

        int de_column = 0;

        if (doc.setContent(&xml_file, false, &de_msg, &de_ln, &de_column))

        {

            MSqlQuery nm_query;

            nm_query.prepare("REPLACE INTO networkiconmap(network, url) "

                    "VALUES(:NETWORK, :URL)");

            MSqlQuery cm_query;

            cm_query.prepare("REPLACE INTO callsignnetworkmap(callsign, "

                    "network) VALUES(:CALLSIGN, :NETWORK)");

            MSqlQuery su_query;

            su_query.prepare("UPDATE settings SET data = :URL "

                    "WHERE value = :STUBNAME");

            MSqlQuery si_query;

            si_query.prepare("INSERT INTO settings(value, data) "

                    "VALUES(:STUBNAME, :URL)");

            QDomElement element = doc.documentElement();

            QDomNode node = element.firstChild();

            while (!node.isNull())

            {

                try

                {

                    QDomElement e = nodeToElement(node);

                    if (e.tagName() == IM_NET_TO_URL_TAG)

                    {

                        QString net = getNamedElementText(e, IM_NET_TAG);

                        QString u = getNamedElementText(e, IM_NET_URL_TAG);

                        nm_query.bindValue(":NETWORK", net.stripWhiteSpace());

                        nm_query.bindValue(":URL", u.stripWhiteSpace());

                        if (!nm_query.exec())

                            MythContext::DBError(

                                    "Inserting network->url mapping", nm_query);

                    }

                    else if (e.tagName() == IM_CS_TO_NET_TAG)

                    {

                        QString cs = getNamedElementText(e, IM_CS_TAG);

                        QString net = getNamedElementText(e, IM_NET_TAG);

                        cm_query.bindValue(":CALLSIGN", cs.stripWhiteSpace());

                        cm_query.bindValue(":NETWORK", net.stripWhiteSpace());

                        if (!cm_query.exec())

                            MythContext::DBError("Inserting callsign->network "

                                    "mapping", cm_query);

                    }

                    else if (e.tagName() == IM_BASEURL_TAG)

                    {

                        MSqlQuery *qr = &si_query;

                        QString st(BASEURLMAP_START);

                        st += getNamedElementText(e, IM_BASE_STUB_TAG);

                        QString u = getNamedElementText(e, IM_NET_URL_TAG);

                        MSqlQuery qc;

                        qc.prepare("SELECT COUNT(*) FROM settings "

                                "WHERE value = :STUBNAME");

                        qc.bindValue(":STUBNAME", st);

                        qc.exec();

                        if (qc.isActive() && qc.numRowsAffected() > 0)

                        {

                            qc.first();

                            if (qc.value(0).toInt() != 0)

                            {

                                qr = &su_query;

                            }

                        }

                        qr->bindValue(":STUBNAME", st);

                        qr->bindValue(":URL", u);

                        if (!qr->exec())

                            MythContext::DBError(

                                    "Inserting callsign->network mapping", *qr);

                    }

                }

                catch (DOMException &e)

                {

                    cerr << QString("Error while processing %1: %2")

                            .arg(node.nodeName())

                            .arg(e.getMessage())

                         << endl;

                }

                node = node.nextSibling();

            }

        }

        else

        {

            cerr << QString(

                    "Error unable to set document content: %1:%2c%3 %4")

                    .arg(filename)

                    .arg(de_ln)

                    .arg(de_column)

                    .arg(de_msg)

                 << endl;

        }

    }

    else

    {

        cerr << QString("Error unable to open '%1' for reading.")

                .arg(filename)

             << endl;

    }

}

void ExportIconMap(const QString &filename)

{

    if (!quiet)

    {

        cout << QString("Exporting icon mapping to %1...").arg(filename)

             << endl;

    }

    QFile xml_file(filename);

    if (dash_open(xml_file, filename, IO_WriteOnly))

    {

        QTextStream os(&xml_file);

        os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";

        os << "<!-- generated by mythfilldatabase -->\n";

        QDomDocument iconmap;

        QDomElement roote = iconmap.createElement(IM_DOC_TAG);

        MSqlQuery query;

        query.exec("SELECT * FROM callsignnetworkmap ORDER BY callsign");

        if (query.isActive() && query.numRowsAffected() > 0)

        {

            while (query.next())

            {

                QDomElement cs2nettag = iconmap.createElement(IM_CS_TO_NET_TAG);

                QDomElement cstag = iconmap.createElement(IM_CS_TAG);

                QDomElement nettag = iconmap.createElement(IM_NET_TAG);

                QDomText cs_text = iconmap.createTextNode(

                        query.value(1).toString());

                QDomText net_text = iconmap.createTextNode(

                        query.value(2).toString());

                cstag.appendChild(cs_text);

                nettag.appendChild(net_text);

                cs2nettag.appendChild(cstag);

                cs2nettag.appendChild(nettag);

                roote.appendChild(cs2nettag);

            }

        }

        query.exec("SELECT * FROM networkiconmap ORDER BY network");

        if (query.isActive() && query.numRowsAffected() > 0)

        {

            while (query.next())

            {

                QDomElement net2urltag = iconmap.createElement(

                        IM_NET_TO_URL_TAG);

                QDomElement nettag = iconmap.createElement(IM_NET_TAG);

                QDomElement urltag = iconmap.createElement(IM_NET_URL_TAG);

                QDomText net_text = iconmap.createTextNode(

                        query.value(1).toString());

                QDomText url_text = iconmap.createTextNode(

                        query.value(2).toString());

                nettag.appendChild(net_text);

                urltag.appendChild(url_text);

                net2urltag.appendChild(nettag);

                net2urltag.appendChild(urltag);

                roote.appendChild(net2urltag);

            }

        }

        query.prepare("SELECT value,data FROM settings WHERE value "

                "LIKE :URLMAP");

        query.bindValue(":URLMAP", QString(BASEURLMAP_START) + "%");

        query.exec();

        if (query.isActive() && query.numRowsAffected() > 0)

        {

            QRegExp baseax("\\.([^\\.]+)$");

            while (query.next())

            {

                QString base_stub = query.value(0).toString();

                if (baseax.search(base_stub) != -1)

                {

                    base_stub = baseax.cap(1);

                }

                QDomElement baseurltag = iconmap.createElement(IM_BASEURL_TAG);

                QDomElement stubtag = iconmap.createElement(

                        IM_BASE_STUB_TAG);

                QDomElement urltag = iconmap.createElement(IM_NET_URL_TAG);

                QDomText base_text = iconmap.createTextNode(base_stub);

                QDomText url_text = iconmap.createTextNode(

                        query.value(1).toString());

                stubtag.appendChild(base_text);

                urltag.appendChild(url_text);

                baseurltag.appendChild(stubtag);

                baseurltag.appendChild(urltag);

                roote.appendChild(baseurltag);

            }

        }

        iconmap.appendChild(roote);

        iconmap.save(os, 4);

    }

    else

    {

        cerr << QString("Error unable to open '%1' for writing.") << endl;

    }

}

void RunSimpleQuery(const QString &query)

{

    MSqlQuery q;

    if (!q.exec(query))

        MythContext::DBError("RunSimpleQuery ", q);

}

void ResetIconMap(bool reset_icons)

{

    MSqlQuery query;

    query.prepare("DELETE FROM settings WHERE value LIKE :URLMAPLIKE");

    query.bindValue(":URLMAPLIKE", QString(BASEURLMAP_START) + '%');

    if (!query.exec())

        MythContext::DBError("ResetIconMap", query);

    RunSimpleQuery("TRUNCATE TABLE callsignnetworkmap;");

    RunSimpleQuery("TRUNCATE TABLE networkiconmap");

    if (reset_icons)

    {

        RunSimpleQuery("UPDATE channel SET icon = 'none'");

    }

}

} // namespace

// DataDirect stuff

void DataDirectStationUpdate(Source source)

{

    MSqlQuery query;

    QString querystr;

    int chanid;

    ddprocessor.updateStationViewTable();

    MSqlQuery query1;

    query1.prepare("SELECT dd_v_station.stationid,dd_v_station.callsign,"

               "dd_v_station.stationname,dd_v_station.channel,"

               "dd_v_station.fccchannelnumber,dd_v_station.channelMinor "

               "FROM dd_v_station LEFT JOIN channel ON "

               "dd_v_station.stationid = channel.xmltvid "

               "AND channel.sourceid = :SOURCEID "

               "WHERE channel.chanid IS NULL;");

    query1.bindValue(":SOURCEID", source.id);

    if (!query1.exec())

        MythContext::DBError("Selecting new channels", query1);

    if (query1.isActive() && query1.numRowsAffected() > 0)

    {

        while (query1.next())

        {

            chanid = source.id * 1000 + query1.value(3).toString().toInt();

            while(1)

            {

                querystr.sprintf("SELECT channum FROM channel WHERE "

                                 "chanid = %d;", chanid);

                if (!query.exec(querystr))

                    break;

                if (query.isActive() && query.numRowsAffected() > 0)

                    chanid++;

                else

                    break;

            }

            QString xmltvid = query1.value(0).toString();

            QString callsign = query1.value(1).toString();

            if (callsign == "")

                callsign = QString::number(chanid);

            QString name = query1.value(2).toString();

            QString channel = query1.value(3).toString();

            QString freqid = query1.value(4).toString();

            QString minor = query1.value(5).toString();

            if (minor != "") 

            {

                freqid += "-" + minor;

                channel += "_" + minor; // default channel number

            }

            else

                freqid = channel;

            query.prepare("INSERT INTO channel (chanid,channum,sourceid,"

                          "callsign, name, xmltvid, freqid, tvformat) "

                          "VALUES (:CHANID,:CHANNUM,:SOURCEID,:CALLSIGN,"

                          ":NAME,:XMLTVID,:FREQID,:TVFORMAT);");

            query.bindValue(":CHANID", chanid);

            query.bindValue(":CHANNUM", channel);

            query.bindValue(":SOURCEID", source.id);

            query.bindValue(":CALLSIGN", callsign);

            query.bindValue(":NAME", name);

            query.bindValue(":XMLTVID", xmltvid);

            query.bindValue(":FREQID", freqid);

            query.bindValue(":TVFORMAT", "Default");

            if (!query.exec())

                MythContext::DBError("Inserting new channel", query);

        }

    }

    if(channel_updates)

    {

        //

        //  User must pass "--do_channel_update" for this block of code to

        //  execute

        //

        MSqlQuery dd_station_info("SELECT callsign, stationname, stationid,"

                "channel, fccchannelnumber, channelMinor FROM dd_v_station;");

        if (dd_station_info.first())

        {

            MSqlQuery dd_update;

            dd_update.prepare("UPDATE channel SET callsign = :CALLSIGN,"

                    " name = :NAME, channum = :CHANNEL, freqid = :FREQID "

                    " WHERE xmltvid = :STATIONID AND sourceid = :SOURCEID;");

            do

            {

                QString channel = dd_station_info.value(3).toString();

                QString freqid = dd_station_info.value(4).toString();

                QString minor = dd_station_info.value(5).toString();

                if (minor != "")

                {

                    freqid += "-" + minor;

                    channel += "_" + minor; // default channel number

                }

                else

                {

                    freqid = channel;

                }

                dd_update.bindValue(":CALLSIGN", dd_station_info.value(0));

                dd_update.bindValue(":NAME", dd_station_info.value(1));

                dd_update.bindValue(":STATIONID", dd_station_info.value(2));

                dd_update.bindValue(":CHANNEL", channel);

                dd_update.bindValue(":SOURCEID", source.id);

                dd_update.bindValue(":FREQID", freqid);

                if (!dd_update.exec())

                {

                    MythContext::DBError("Updating channel table",

                            dd_update.lastQuery());

                }

            } 

            while (dd_station_info.next());

        }

    }

    UpdateSourceIcons(source.id);

    // Now, delete any channels which no longer exist

    // (Not currently done in standard program -- need to verify if required)

}

void DataDirectProgramUpdate(Source source) 

{

    MSqlQuery query;

    //cerr << "Creating program view table...\n";

    ddprocessor.updateProgramViewTable(source.id);

    //cerr <<  "Finished creating program view table...\n";

    //cerr << "Adding rows to main program table from view table..\n";

    if (!query.exec("INSERT IGNORE INTO program (chanid, starttime, endtime, "

                    "title, subtitle, description, "

                    "showtype, category, category_type, "

                    "airdate, stars, previouslyshown, stereo, subtitled, "

                    "hdtv, closecaptioned, partnumber, parttotal, seriesid, "

                    "originalairdate, colorcode, syndicatedepisodenumber, "

                    "programid) "

                    "SELECT chanid, starttime, endtime, "

                    "title, subtitle, description, "

                    "showtype, dd_genre.class, category_type, "

                    "airdate, stars, previouslyshown, stereo, subtitled, "

                    "hdtv, closecaptioned, partnumber, parttotal, seriesid, "

                    "originalairdate, colorcode, syndicatedepisodenumber, "

                    "dd_v_program.programid FROM dd_v_program "

                    "LEFT JOIN dd_genre ON ("

                    "dd_v_program.programid = dd_genre.programid AND "

                    "dd_genre.relevance = '0');"))

        MythContext::DBError("Inserting into program table", query);

    //cerr << "Finished adding rows to main program table...\n";

    //cerr << "Adding program ratings...\n";

    if (!query.exec("INSERT IGNORE INTO programrating (chanid, starttime, "

                    "system, rating) SELECT chanid, starttime, 'MPAA', "

                    "mpaarating FROM dd_v_program WHERE mpaarating != '';"))

        MythContext::DBError("Inserting into programrating table", query);

    if (!query.exec("INSERT IGNORE INTO programrating (chanid, starttime, "

                    "system, rating) SELECT chanid, starttime, 'VCHIP', "

                    "tvrating FROM dd_v_program WHERE tvrating != '';"))

        MythContext::DBError("Inserting into programrating table", query);

    //cerr << "Finished adding program ratings...\n";

    //cerr << "Populating people table from production crew list...\n";

    if (!query.exec("INSERT IGNORE INTO people (name) SELECT fullname "

                    "FROM dd_productioncrew;"))

        MythContext::DBError("Inserting into people table", query);

    //cerr << "Finished adding people...\n";

    //cerr << "Adding credits entries from production crew list...\n";

    if (!query.exec("INSERT IGNORE INTO credits (chanid, starttime, person, "

                    "role) SELECT chanid, starttime, person, role "

                    "FROM dd_productioncrew, dd_v_program, people "

                    "WHERE "

                    "((dd_productioncrew.programid = dd_v_program.programid) "

                    "AND (dd_productioncrew.fullname = people.name));"))

        MythContext::DBError("Inserting into credits table", query);

    //cerr << "Finished inserting credits...\n";

    //cerr << "Adding genres...\n";

    if (!query.exec("INSERT IGNORE INTO programgenres (chanid, starttime, "

                    "relevance, genre) SELECT chanid, starttime, "

                    "relevance, class FROM dd_v_program, dd_genre "

                    "WHERE (dd_v_program.programid = dd_genre.programid);"))

        MythContext::DBError("Inserting into programgenres table",query);

    //cerr << "Done...\n";

}

bool grabDDData(Source source, int poffset, QDate pdate) 

{

    ddprocessor.setLineup(source.lineupid);

    ddprocessor.setUserID(source.userid);

    ddprocessor.setPassword(source.password);

    bool needtoretrieve = true;

    if (source.userid != lastdduserid)

        dddataretrieved = false;

    if (dd_grab_all && dddataretrieved)

        needtoretrieve = false;

    QDateTime qdtNow = QDateTime::currentDateTime();

    MSqlQuery query;

    QString status = "currently running.";

    query.exec(QString("UPDATE settings SET data ='%1' "

                       "WHERE value='mythfilldatabaseLastRunStart'")

                       .arg(qdtNow.toString("yyyy-MM-dd hh:mm")));

    if (needtoretrieve)

    {

        if (!quiet)

            cout << "Retrieving datadirect data... \n";

        if (dd_grab_all) 

        {

            if (!quiet)

                cout << "Grabbing ALL available data...\n";

            if (!ddprocessor.grabAllData())

            {

                cerr << "Encountered error in grabbing data...\n";

                return false;

            }

        }

        else

        {

            if (!quiet)

                cout << "Grabbing data for " << pdate.toString() 

                     << " offset " << poffset << "\n";

            QDateTime fromdatetime = QDateTime(pdate);

            QDateTime todatetime;

            fromdatetime.setTime_t(QDateTime(pdate).toTime_t(),Qt::UTC);

            fromdatetime = fromdatetime.addDays(poffset);

            todatetime = fromdatetime.addDays(1);

            if (!quiet)

                cout << "From : " << fromdatetime.toString() 

                     << " To : " << todatetime.toString() << " (UTC)\n";

            ddprocessor.grabData(false, fromdatetime, todatetime);

        }

        dddataretrieved = true;

        lastdduserid = source.userid;

    }

    else

    {

        if (!quiet)

            cout << "Using existing grabbed data in temp tables..\n";

    }

    if (!quiet)

        cout << "Grab complete.  Actual data from " 

             << ddprocessor.getActualListingsFrom().toString() << " "

             << "to " << ddprocessor.getActualListingsTo().toString() 

             << " (UTC) \n";

    qdtNow = QDateTime::currentDateTime();

    query.exec(QString("UPDATE settings SET data ='%1' "

                       "WHERE value='mythfilldatabaseLastRunEnd'")

                       .arg(qdtNow.toString("yyyy-MM-dd hh:mm")));

    if (!quiet)

        cout << "Clearing data for source...\n";

    QDateTime fromlocaldt = MythUTCToLocal(ddprocessor.getActualListingFrom());

    QDateTime tolocaldt = MythUTCToLocal(ddprocessor.getActualListingsTo());

    if (!quiet)

        cout << "Clearing from " << fromlocaldt.toString() 

             << " to " << tolocaldt.toString() << " (localtime)\n";

    clearDataBySource(source.id, fromlocaldt,tolocaldt);

    if (!quiet)

        cout << "Data for source cleared...\n";

    if (!quiet)

        cout << "Main temp tables populated.  Updating myth channels...\n";

    DataDirectStationUpdate(source);

    if (!quiet)

        cout << "Channels updated..  Updating programs...\n";

    DataDirectProgramUpdate(source);

    return true;

}

// XMLTV stuff

QDateTime fromXMLTVDate(QString &text)

{

    int year, month, day, hour, min, sec;

    QDate ldate;

    QTime ltime;

    QDateTime dt;

    if (text == QString::null)

        return dt;

    if (text.find(QRegExp("^\\d{12}")) != 0)

        return dt;

    year = atoi(text.mid(0, 4).ascii());

    month = atoi(text.mid(4, 2).ascii());

    day = atoi(text.mid(6, 2).ascii());

    hour = atoi(text.mid(8, 2).ascii());

    min = atoi(text.mid(10, 2).ascii());

    if (text.find(QRegExp("^\\d\\d"), 12) == 0)

        sec = atoi(text.mid(12, 2).ascii());

    else

        sec = 0;

    ldate = QDate(year, month, day);

    ltime = QTime(hour, min, sec);

    dt = QDateTime(ldate, ltime);

    return dt; 

}

QString getFirstText(QDomElement element)

{

    for (QDomNode dname = element.firstChild(); !dname.isNull();

         dname = dname.nextSibling())

    {

        QDomText t = dname.toText();

        if (!t.isNull())

            return t.data();

    }

    return "";

}

ChanInfo *parseChannel(QDomElement &element, QUrl baseUrl) 

{

    ChanInfo *chaninfo = new ChanInfo;

    QString xmltvid = element.attribute("id", "");

    QStringList split = QStringList::split(" ", xmltvid);

    bool xmltvisjunk = false;

    if (isNorthAmerica)

    {

        if (xmltvid.contains("zap2it"))

        {

            xmltvisjunk = true;

            chaninfo->chanstr = "";

            chaninfo->xmltvid = xmltvid;

            chaninfo->callsign = "";

        }

        else

        {

            chaninfo->xmltvid = split[0];

            chaninfo->chanstr = split[0];

            if (split.size() > 1)

                chaninfo->callsign = split[1];

            else

                chaninfo->callsign = "";

        }

    }

    else

    {

        chaninfo->callsign = "";

        chaninfo->chanstr = "";

        chaninfo->xmltvid = xmltvid;

    }

    chaninfo->iconpath = "";

    chaninfo->name = "";

    chaninfo->finetune = "";

    chaninfo->tvformat = "Default";

    for (QDomNode child = element.firstChild(); !child.isNull();

         child = child.nextSibling())

    {

        QDomElement info = child.toElement();

        if (!info.isNull())

        {

            if (info.tagName() == "icon")

            {

                QUrl iconUrl(baseUrl, info.attribute("src", ""), true);

                chaninfo->iconpath = iconUrl.toString();

            }

            else if (info.tagName() == "display-name")

            {

                if (chaninfo->name.length() == 0)

                {

                    chaninfo->name = info.text();

                    if (xmltvisjunk)

                    {

                        QStringList split = QStringList::split(" ", 

                                                               chaninfo->name);

                        if (split[0] == "Channel")

                        { 

                            chaninfo->old_xmltvid = split[1];

                            chaninfo->chanstr = split[1];

                            if (split.size() > 2)

                                chaninfo->callsign = split[2];

                        }

                        else

                        {

                            chaninfo->old_xmltvid = split[0];

                            chaninfo->chanstr = split[0];

                            if (split.size() > 1)

                                chaninfo->callsign = split[1];

                        }

                    }

                }

                else if (isJapan && chaninfo->callsign.length() == 0)

                {

                    chaninfo->callsign = info.text();

                }

                else if (chaninfo->chanstr.length() == 0)

                {

                    chaninfo->chanstr = info.text();

                }

            }

        }

    }

    chaninfo->freqid = chaninfo->chanstr;

    return chaninfo;

}

int TimezoneToInt (QString timezone)

{

    // we signal an error by setting it invalid (> 840min = 14hr)

    int result = 841;

    if (timezone.length() == 5)

    {

        bool ok;

        result = timezone.mid(1,2).toInt(&ok, 10);

        if (!ok)

            result = 841;

        else

        {

            result *= 60;

            int min = timezone.right(2).toInt(&ok, 10);

            if (!ok)

                result = 841;

            else

            {

                result += min;

                if (timezone.left(1) == "-")

                    result *= -1;

            }

        }

    }

    return result;

}

void addTimeOffset(QString &timestr, int localTimezoneOffset)

{

    if (timestr.isEmpty() || abs(localTimezoneOffset) > 840)

        return;

    QStringList split = QStringList::split(" ", timestr);

    QString ts = split[0];

    int ts_offset = localTimezoneOffset;

    if (split.size() > 1)

    {

        QString tmp = split[1];

        tmp.stripWhiteSpace();

        ts_offset = TimezoneToInt(tmp);

        if (abs(ts_offset) > 840)

            ts_offset = localTimezoneOffset;

    }

    int diff = localTimezoneOffset - ts_offset;

    int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;

    if (diff != 0)

    {

        bool ok;

            if (ts.length() == 14)

            {

                year  = ts.left(4).toInt(&ok, 10);

                month = ts.mid(4,2).toInt(&ok, 10);

                day   = ts.mid(6,2).toInt(&ok, 10);

                hour  = ts.mid(8,2).toInt(&ok, 10);

                min   = ts.mid(10,2).toInt(&ok, 10);

                sec   = ts.mid(12,2).toInt(&ok, 10);

            }

            else if (ts.length() == 12)

            {

                year  = ts.left(4).toInt(&ok, 10);

                month = ts.mid(4,2).toInt(&ok, 10);

                day   = ts.mid(6,2).toInt(&ok, 10);

                hour  = ts.mid(8,2).toInt(&ok, 10);

                min   = ts.mid(10,2).toInt(&ok, 10);

                sec   = 0;

            }

            else

            {

                diff = 0;

                cerr << "Ignoring unknown timestamp format: " << ts << endl;

            }

    }

    if (diff != 0)

    {

        QDateTime dt = QDateTime(QDate(year, month, day),QTime(hour, min, sec));

        dt = dt.addSecs(diff * 60 );

        timestr = dt.toString("yyyyMMddhhmmss");

    }

}

void parseCredits(QDomElement &element, ProgInfo *pginfo)

{

    for (QDomNode child = element.firstChild(); !child.isNull();

         child = child.nextSibling())

    {

        QDomElement info = child.toElement();

        if (!info.isNull())

        {

            ProgCredit credit;

            credit.role = info.tagName();

            credit.name = getFirstText(info);

            pginfo->credits.append(credit);

        }

    }

}

ProgInfo *parseProgram(QDomElement &element, int localTimezoneOffset)

{

    QString uniqueid, seriesid, season, episode;

    ProgInfo *pginfo = new ProgInfo;

    pginfo->previouslyshown = pginfo->stereo = pginfo->subtitled =

    pginfo->hdtv = pginfo->closecaptioned = false;

    pginfo->subtitle = pginfo->title = pginfo->desc =

    pginfo->category = pginfo->content = pginfo->catType =

    pginfo->syndicatedepisodenumber =  pginfo->partnumber =

    pginfo->parttotal = pginfo->showtype = pginfo->colorcode =

    pginfo->stars = "";

    QString text = element.attribute("start", "");

    addTimeOffset(text, localTimezoneOffset);

    pginfo->startts = text;

    text = element.attribute("stop", "");

    addTimeOffset(text, localTimezoneOffset);

    pginfo->endts = text;

    text = element.attribute("channel", "");

    QStringList split = QStringList::split(" ", text);   

    pginfo->channel = split[0];

    text = element.attribute("clumpidx", "");

    if (!text.isEmpty()) 

    {

        split = QStringList::split("/", text);

        pginfo->clumpidx = split[0];

        pginfo->clumpmax = split[1];

    }

    pginfo->start = fromXMLTVDate(pginfo->startts);

    pginfo->end = fromXMLTVDate(pginfo->endts);

    for (QDomNode child = element.firstChild(); !child.isNull();

         child = child.nextSibling())

    {

        QDomElement info = child.toElement();

        if (!info.isNull())

        {

            if (info.tagName() == "title")

            {

                if (isJapan)

                {

                    if (info.attribute("lang") == "ja_JP")

                    {

                        pginfo->title = getFirstText(info);

                    }

                    else if (info.attribute("lang") == "ja_JP@kana")

                    {

                        pginfo->title_pronounce = getFirstText(info);

                    }

                }

                else if (pginfo->title == "")

                {

                    pginfo->title = getFirstText(info);

                }

            }

            else if (info.tagName() == "sub-title" && pginfo->subtitle == "")

            {

                pginfo->subtitle = getFirstText(info);

            }

            else if (info.tagName() == "content")

            {

                pginfo->content = getFirstText(info);

            }

            else if (info.tagName() == "desc" && pginfo->desc == "")

            {

                pginfo->desc = getFirstText(info);

            }

            else if (info.tagName() == "category")

            {

                QString cat = getFirstText(info);

                if (cat == "movie" || cat == "series" || 

                    cat == "sports" || cat == "tvshow")

                {

                    if (pginfo->catType.isEmpty())

                        pginfo->catType = cat;

                }

                else if (pginfo->category.isEmpty())

                {

                    pginfo->category = cat;

                }

                if ((cat == "Film" || cat == "film") && !isNorthAmerica)

                {

                    // Hack for tv_grab_uk_rt

                    pginfo->catType = "movie";

                }

            }

            else if (info.tagName() == "date" && pginfo->airdate == "")

            {

                pginfo->airdate = getFirstText(info);

                if (4 != pginfo->airdate.length())

                    pginfo->airdate = "";

            }

            else if (info.tagName() == "star-rating")

            {

                QDomNodeList values = info.elementsByTagName("value");

                QDomElement item;

                QString stars, num, den;

                float avg = 0.0;

                // not sure why the XML suggests multiple ratings,

                // but the following will average them anyway.

                for (unsigned int i = 0; i < values.length(); i++)

                {

                    item = values.item(i).toElement();

                    if (item.isNull())

                        continue;

                    stars = getFirstText(item);

                    num = stars.section('/', 0, 0);

                    den = stars.section('/', 1, 1);

                    if (0.0 >= den.toFloat())

                        continue;

                    avg *= i/(i+1);

                    avg += (num.toFloat()/den.toFloat()) / (i+1);

                }

                pginfo->stars.setNum(avg);

            }

            else if (info.tagName() == "rating")

            {

                // again, the structure of ratings seems poorly represented

                // in the XML.  no idea what we'd do with multiple values.

                QDomNodeList values = info.elementsByTagName("value");

                QDomElement item = values.item(0).toElement();

                if (item.isNull())

                    continue;

                ProgRating rating;

                rating.system = info.attribute("system", "");

                rating.rating = getFirstText(item);

                if ("" != rating.system)

                    pginfo->ratings.append(rating);

            }

            else if (info.tagName() == "previously-shown")

            {

                pginfo->previouslyshown = true;

                QString prevdate = getFirstText(info);

                pginfo->originalairdate = prevdate;

            } 

            else if (info.tagName() == "credits")

            {

                parseCredits(info, pginfo);

            }

            else if (info.tagName() == "episode-num" &&

                     info.attribute("system") == "xmltv_ns")

            {

                int tmp;

                QString episodenum(getFirstText(info));

                episode = episodenum.section('.',1,1);

                episode = episode.section('/',0,0).stripWhiteSpace();

                season = episodenum.section('.',0,0).stripWhiteSpace();

                QString part(episodenum.section('.',2,2));

                QString partnumber(part.section('/',0,0).stripWhiteSpace());

                QString parttotal(part.section('/',1,1).stripWhiteSpace());

                if (!episode.isEmpty())

                {

                    tmp = episode.toInt() + 1;

                    episode = QString::number(tmp);

                    pginfo->syndicatedepisodenumber = QString("E" + episode);

                }

                if (!season.isEmpty())

                {

                    tmp = season.toInt() + 1;

                    season = QString::number(tmp);

                    pginfo->syndicatedepisodenumber.append(QString("S" + season));

                }

                if (!partnumber.isEmpty())

                {                

                    tmp = partnumber.toInt() + 1;

                    partnumber = QString::number(tmp);

                }

                if (partnumber != 0 && parttotal >= partnumber && !parttotal.isEmpty())

                {

                    pginfo->parttotal = parttotal;

                    pginfo->partnumber = partnumber;

                }

            }

            else if (info.tagName() == "episode-num" &&

                     info.attribute("system") == "onscreen" &&

                     pginfo->subtitle.isEmpty())

            {

                 pginfo->subtitle = getFirstText(info);

            }

        }

    }

    if (pginfo->category.isEmpty() && !pginfo->catType.isEmpty())

        pginfo->category = pginfo->catType;

    /* Do what MythWeb does and assume that programmes with

       star-rating in America are movies. This allows us to

       unify app code with grabbers which explicitly deliver that

       info. */

    if (isNorthAmerica && pginfo->catType == "" &&

        pginfo->stars != "" && pginfo->airdate != "")

        pginfo->catType = "movie";

    /* Hack for teveblad grabber to do something with the content tag*/

    if (pginfo->content != "")

    {

        if (pginfo->category == "film")

        {

            pginfo->subtitle = pginfo->desc;

            pginfo->desc = pginfo->content;

        }

        else if (pginfo->desc != "") 

        {

            pginfo->desc = pginfo->desc + " - " + pginfo->content;

        }

        else if (pginfo->desc == "")

        {

            pginfo->desc = pginfo->content;

        }

    }

    if (pginfo->airdate.isEmpty())

        pginfo->airdate = QDate::currentDate().toString("yyyy");

    /* Let's build ourself a programid */

    QString programid;

    if (pginfo->catType == "movie")

        programid = "MV";

    else if (pginfo->catType == "series")

        programid = "EP";

    else if (pginfo->catType == "sports")

        programid = "SP";

    else

        programid = "SH";

    if (!uniqueid.isEmpty()) // we already have a unique id ready for use

        programid.append(uniqueid);

    else

    {

        if (seriesid.isEmpty()) //need to hash ourself a seriesid from the title

        {

            seriesid = QString::number(ELFHash(pginfo->title));

        }

        pginfo->seriesid = seriesid;

        programid.append(seriesid);

        if (!episode.isEmpty() && !season.isEmpty())

        {

            programid.append(episode);

            programid.append(season);

            if (!pginfo->partnumber.isEmpty() && !pginfo->parttotal.isEmpty())

            {

                programid.append(pginfo->partnumber);

                programid.append(pginfo->parttotal);

            }

        }

        else

        {

            /* No ep/season info? Well then remove the programid and rely on

               normal dupchecking methods instead. */

            if (pginfo->catType != "movie")

                programid = "";

        }

    }

    pginfo->programid = programid;

    return pginfo;

}

void parseFile(QString filename, QValueList<ChanInfo> *chanlist,

               QMap<QString, QValueList<ProgInfo> > *proglist)

{

    QDomDocument doc;

    QFile f;

    if (!dash_open(f, filename, IO_ReadOnly))

    {

        return;

    }

    QString errorMsg = "unknown";

    int errorLine = 0;

    int errorColumn = 0;

    if (!doc.setContent(&f, &errorMsg, &errorLine, &errorColumn))

    {

        cerr << "Error in " << errorLine << ":" << errorColumn << ": "

             << errorMsg << endl;

        f.close();

        return;

    }

    f.close();

    // now we calculate the localTimezoneOffset, so that we can fix

    // the programdata if needed

    QString config_offset = gContext->GetSetting("TimeOffset", "None");

    // we disable this feature by setting it invalid (> 840min = 14hr)

    int localTimezoneOffset = 841;

    if (config_offset == "Auto")

    {

        time_t now = time(NULL);

        struct tm local_tm;

        localtime_r(&now, &local_tm);

        localTimezoneOffset = local_tm.tm_gmtoff / 60;

    }

    else if (config_offset != "None")

    {

        localTimezoneOffset = TimezoneToInt(config_offset);

        if (abs(localTimezoneOffset) > 840)

            cerr << "Ignoring invalid TimeOffset " << config_offset << endl;

    }

    QDomElement docElem = doc.documentElement();

    QUrl baseUrl(docElem.attribute("source-data-url", ""));

    QUrl sourceUrl(docElem.attribute("source-info-url", ""));

    if (sourceUrl.toString() == "http://labs.zap2it.com/")

    {

        cerr << "Don't use tv_grab_na_dd, use the internal datadirect grabber."

             << endl;

        exit(14);

    }

    QString aggregatedTitle;

    QString aggregatedDesc;

    QString groupingTitle;

    QString groupingDesc;

    QDomNode n = docElem.firstChild();

    while (!n.isNull())

    {

        QDomElement e = n.toElement();

        if (!e.isNull()) 

        {

            if (e.tagName() == "channel")

            {

                ChanInfo *chinfo = parseChannel(e, baseUrl);

                chanlist->push_back(*chinfo);

                delete chinfo;

            }

            else if (e.tagName() == "programme")

            {

                ProgInfo *pginfo = parseProgram(e, localTimezoneOffset);

                if (pginfo->startts == pginfo->endts)

                {

                    /* Not a real program : just a grouping marker */

                    if (!pginfo->title.isEmpty())

                        groupingTitle = pginfo->title + " : ";

                    if (!pginfo->desc.isEmpty())

                        groupingDesc = pginfo->desc + " : ";

                }

                else

                {

                    if (pginfo->clumpidx.isEmpty())

                    {

                        if (!groupingTitle.isEmpty())

                        {

                            pginfo->title.prepend(groupingTitle);

                            groupingTitle = "";

                        }

                        if (!groupingDesc.isEmpty())

                        {

                            pginfo->desc.prepend(groupingDesc);

                            groupingDesc = "";

                        }

                        (*proglist)[pginfo->channel].push_back(*pginfo);

                    }

                    else

                    {

                        /* append all titles/descriptions from one clump */

                        if (pginfo->clumpidx.toInt() == 0)

                        {

                            aggregatedTitle = "";

                            aggregatedDesc = "";

                        }

                        if (!pginfo->title.isEmpty())

                        {

                            if (!aggregatedTitle.isEmpty())

                                aggregatedTitle.append(" | ");

                            aggregatedTitle.append(pginfo->title);

                        }

                        if (!pginfo->desc.isEmpty())

                        {

                            if (!aggregatedDesc.isEmpty())

                                aggregatedDesc.append(" | ");

                            aggregatedDesc.append(pginfo->desc);

                        }    

                        if (pginfo->clumpidx.toInt() == 

                            pginfo->clumpmax.toInt() - 1)

                        {

                            pginfo->title = aggregatedTitle;

                            pginfo->desc = aggregatedDesc;

                            (*proglist)[pginfo->channel].push_back(*pginfo);

                        }

                    }

                }

                delete pginfo;

            }

        }

        n = n.nextSibling();

    }

    return;

}

bool conflict(ProgInfo &a, ProgInfo &b)

{

    if ((a.start <= b.start && b.start < a.end) ||

        (b.end <= a.end && a.start < b.end))

        return true;

    return false;

}

void fixProgramList(QValueList<ProgInfo> *fixlist)

{

    qHeapSort(*fixlist);

    QValueList<ProgInfo>::iterator i = fixlist->begin();

    QValueList<ProgInfo>::iterator cur;

    while (1)    

    {

        cur = i;