source: psi/trunk/src/proxy.cpp@ 5

/*
 * proxy.cpp - classes for handling proxy profiles
 * Copyright (C) 2003  Justin Karneges
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include"proxy.h"

#include<qlabel.h>
#include<qlineedit.h>
#include<qcheckbox.h>
#include<qvgroupbox.h>
#include<qlayout.h>
#include<qgrid.h>
#include<qhbox.h>
#include<qvbox.h>
#include<qcombobox.h>
#include<qpushbutton.h>
#include<qlistbox.h>
#include<qdom.h>
#include<qguardedptr.h>
#include<qwhatsthis.h>
#include<qapplication.h>
#include"common.h"
#include"iconwidget.h"

static QDomElement textTag(QDomDocument &doc, const QString &name, const QString &content)
{
        QDomElement tag = doc.createElement(name);
        QDomText text = doc.createTextNode(content);
        tag.appendChild(text);

        return tag;
}

static QDomElement textTag(QDomDocument &doc, const QString &name, bool content)
{
        QDomElement tag = doc.createElement(name);
        QDomText text = doc.createTextNode(content ? "true" : "false");
        tag.appendChild(text);

        return tag;
}

static QDomElement findSubTag(const QDomElement &e, const QString &name)
{
        for(QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
                QDomElement i = n.toElement();
                if(i.isNull())
                        continue;
                if(i.tagName() == name)
                        return i;
        }

        return QDomElement();
}

//----------------------------------------------------------------------------
// HostPortEdit
//----------------------------------------------------------------------------
class HostPortEdit::Private
{
public:
        Private() {}

        QLineEdit *le_host, *le_port;
};

HostPortEdit::HostPortEdit(QWidget *parent, const char *name)
:QWidget(parent, name)
{
        d = new Private;

        QLabel *l;
        QHBoxLayout *hb = new QHBoxLayout(this, 0, 4);
        l = new QLabel(tr("Host:"), this);
        hb->addWidget(l);
        d->le_host = new QLineEdit(this);
        d->le_host->setMinimumWidth(128);
        hb->addWidget(d->le_host);
        l = new QLabel(tr("Port:"), this);
        hb->addWidget(l);
        d->le_port = new QLineEdit(this);
        d->le_port->setFixedWidth(64);
        hb->addWidget(d->le_port);
        setPort(0);
}

HostPortEdit::~HostPortEdit()
{
        delete d;
}

QString HostPortEdit::host() const
{
        return d->le_host->text();
}

int HostPortEdit::port() const
{
        return d->le_port->text().toInt();
}

void HostPortEdit::setHost(const QString &s)
{
        d->le_host->setText(s);
}

void HostPortEdit::setPort(int x)
{
        d->le_port->setText(QString::number(x));
}

void HostPortEdit::fixTabbing(QWidget *a, QWidget *b)
{
        setTabOrder(a, d->le_host);
        setTabOrder(d->le_host, d->le_port);
        setTabOrder(d->le_port, b);
}


//----------------------------------------------------------------------------
// ProxySettings
//----------------------------------------------------------------------------
ProxySettings::ProxySettings()
{
        port = 0;
        useAuth = false;
}

QDomElement ProxySettings::toXml(QDomDocument *doc) const
{
        QDomElement e = doc->createElement("proxySettings");
        e.appendChild(textTag(*doc, "host", host));
        e.appendChild(textTag(*doc, "port", QString::number(port)));
        e.appendChild(textTag(*doc, "url", url));
        e.appendChild(textTag(*doc, "useAuth", useAuth));
        e.appendChild(textTag(*doc, "user", user));
        e.appendChild(textTag(*doc, "pass", pass));
        return e;
}

bool ProxySettings::fromXml(const QDomElement &e)
{
        host = findSubTag(e, "host").text();
        port = findSubTag(e, "port").text().toInt();
        url = findSubTag(e, "url").text();
        useAuth = (findSubTag(e, "useAuth").text() == "true") ? true: false;
        user = findSubTag(e, "user").text();
        pass = findSubTag(e, "pass").text();
        return true;
}


//----------------------------------------------------------------------------
// ProxyEdit
//----------------------------------------------------------------------------
class ProxyEdit::Private
{
public:
        Private() {}

        HostPortEdit *hp_host;
        QCheckBox *ck_auth;
        QLabel *lb_url;
        QLineEdit *le_url, *le_user, *le_pass;
        QGrid *gr_auth;
};

ProxyEdit::ProxyEdit(QWidget *parent, const char *name)
:QGroupBox(1, Horizontal, tr("Settings"), parent, name)
{
        d = new Private;

        //QVBoxLayout *vb = new QVBoxLayout(this);
        //QVBox *gb = new QVBox(this);
        //gb->setSpacing(4);
        //vb->addWidget(gb);

        QLabel *l;

        d->hp_host = new HostPortEdit(this);

        QHBox *hb = new QHBox(this);
        d->lb_url = new QLabel(tr("Polling URL:"), hb);
        d->le_url = new QLineEdit(hb);

        d->ck_auth = new QCheckBox(tr("Use authentication"), this);
        connect(d->ck_auth, SIGNAL(toggled(bool)), SLOT(ck_toggled(bool)));

        d->gr_auth = new QGrid(2, Horizontal, this);
        d->gr_auth->setSpacing(4);
        l = new QLabel(tr("Username:"), d->gr_auth);
        d->le_user = new QLineEdit(d->gr_auth);
        l = new QLabel(tr("Password:"), d->gr_auth);
        d->le_pass = new QLineEdit(d->gr_auth);
        d->le_pass->setEchoMode(QLineEdit::Password);
        d->gr_auth->setEnabled(false);

        QWhatsThis::add(d->hp_host,
                tr("Enter the hostname and port of your proxy server.") + "  " +
                tr("Consult your network administrator if necessary."));
        QWhatsThis::add(d->le_user,
                tr("Enter your proxy server login (username) "
                "or leave this field blank if the proxy server does not require it.") + "  " +
                tr("Consult your network administrator if necessary."));
        QWhatsThis::add(d->le_pass,
                tr("Enter your proxy server password "
                "or leave this field blank if the proxy server does not require it.") + "  " +
                tr("Consult your network administrator if necessary."));
}

ProxyEdit::~ProxyEdit()
{
        delete d;
}

void ProxyEdit::reset()
{
        d->hp_host->setHost("");
        d->hp_host->setPort(0);
        d->le_url->setText("");
        d->ck_auth->setChecked(false);
        d->le_user->setText("");
        d->le_pass->setText("");
}

void ProxyEdit::setType(const QString &s)
{
        if(s == "poll") {
                d->lb_url->setEnabled(true);
                d->le_url->setEnabled(true);
        }
        else {
                d->lb_url->setEnabled(false);
                d->le_url->setEnabled(false);
        }
}

ProxySettings ProxyEdit::proxySettings() const
{
        ProxySettings s;
        s.host = d->hp_host->host();
        s.port = d->hp_host->port();
        if(d->le_url->isEnabled())
                s.url = d->le_url->text();
        s.useAuth = d->ck_auth->isChecked();
        s.user = d->le_user->text();
        s.pass = d->le_pass->text();
        return s;
}

void ProxyEdit::setProxySettings(const ProxySettings &s)
{
        d->hp_host->setHost(s.host);
        d->hp_host->setPort(s.port);
        d->le_url->setText(s.url);
        d->ck_auth->setChecked(s.useAuth);
        d->le_user->setText(s.user);
        d->le_pass->setText(s.pass);
}

void ProxyEdit::ck_toggled(bool b)
{
        d->gr_auth->setEnabled(b);
}

void ProxyEdit::fixTabbing(QWidget *a, QWidget *b)
{
        d->hp_host->fixTabbing(a, d->le_url);
        setTabOrder(d->le_url, d->ck_auth);
        setTabOrder(d->ck_auth, d->le_user);
        setTabOrder(d->le_user, d->le_pass);
        setTabOrder(d->le_pass, b);
}


//----------------------------------------------------------------------------
// ProxyDlg
//----------------------------------------------------------------------------
class ProxyDlg::Private
{
public:
        Private() {}

        ProxyEdit *pe_settings;
        ProxyItemList list;
        int last;
};

ProxyDlg::ProxyDlg(const ProxyItemList &list, const QStringList &methods, int def, QWidget *parent, const char *name)
:ProxyUI(parent, name, QApplication::activeModalWidget() ? true: false, WDestructiveClose)
{
        d = new Private;
        setCaption(CAP(caption()));

        d->list = list;
        d->last = -1;
        d->pe_settings = new ProxyEdit(gb_prop);
        replaceWidget(lb_proxyedit, d->pe_settings);
        d->pe_settings->fixTabbing(cb_type, pb_close);

        hookEdit();

        connect(pb_new, SIGNAL(clicked()), SLOT(proxy_new()));
        connect(pb_remove, SIGNAL(clicked()), SLOT(proxy_remove()));
        connect(pb_save, SIGNAL(clicked()), SLOT(doSave()));
        connect(pb_close, SIGNAL(clicked()), SLOT(reject()));
        gb_prop->setEnabled(false);
        pb_remove->setEnabled(false);
        pb_save->setDefault(true);

        cb_type->insertStringList(methods);
        connect(cb_type, SIGNAL(activated(int)), SLOT(cb_activated(int)));

        for(ProxyItemList::ConstIterator it = d->list.begin(); it != d->list.end(); ++it)
                lbx_proxy->insertItem((*it).name);
        if(!list.isEmpty()) {
                if(def < 0)
                        def = 0;
                lbx_proxy->setCurrentItem(def);
                selectCurrent();
        }

        QWhatsThis::add(cb_type,
                tr("If you require a proxy server to connect, select the type of proxy here.") + "  " +
                tr("Consult your network administrator if necessary."));
        // TODO: whatsthis for name
}

ProxyDlg::~ProxyDlg()
{
        delete d;
}

void ProxyDlg::proxy_new()
{
        ProxyItem s;
        s.id = -1; // id of -1 means 'new'
        s.name = getUniqueName();
        d->list += s;

        lbx_proxy->insertItem(s.name);
        lbx_proxy->setCurrentItem(lbx_proxy->count()-1);
        selectCurrent();
}

void ProxyDlg::proxy_remove()
{
        int x = lbx_proxy->currentItem();
        if(x != -1) {
                ProxyItemList::Iterator it = d->list.begin();
                for(int n = 0; n < x; ++n)
                        ++it;
                d->list.remove(it);

                d->last = -1;
                lbx_proxy->removeItem(x);
                selectCurrent();
        }
}

void ProxyDlg::cb_activated(int x)
{
        if(x == 0)
                d->pe_settings->setType("http");
        else if(x == 1)
                d->pe_settings->setType("socks");
        else if(x == 2)
                d->pe_settings->setType("poll");
}

void ProxyDlg::selectCurrent()
{
        int x = lbx_proxy->currentItem();
        if(x != -1)
                lbx_proxy->setSelected(x, true);
}

QString ProxyDlg::getUniqueName() const
{
        QString str;
        int x = 0;
        bool found;
        do {
                str = QString("Proxy %1").arg(++x);
                found = false;
                for(ProxyItemList::ConstIterator it = d->list.begin(); it != d->list.end(); ++it) {
                        if(str == (*it).name) {
                                found = true;
                                break;
                        }
                }
        } while(found);
        return str;
}

void ProxyDlg::saveIntoItem(int x)
{
        ProxyItem &s = d->list[x];
        s.name = le_name->text();
        int i = cb_type->currentItem();
        s.type = "http";
        if(i == 0)
                s.type = "http";
        else if(i == 1)
                s.type = "socks";
        else if(i == 2)
                s.type = "poll";
        s.settings = d->pe_settings->proxySettings();
}

void ProxyDlg::qlbx_highlighted(int x)
{
        // if we are moving off of another item, save its content
        if(d->last != -1)
                saveIntoItem(d->last);
        d->last = x;

        // display the new item's content
        if(x == -1) {
                le_name->setText("");
                cb_type->setCurrentItem(0);
                d->pe_settings->reset();
                gb_prop->setEnabled(false);
                pb_remove->setEnabled(false);
        }
        else {
                ProxyItem &s = d->list[x];
                le_name->setText(s.name);
                int i = 0;
                if(s.type == "http")
                        i = 0;
                else if(s.type == "socks")
                        i = 1;
                else if(s.type == "poll")
                        i = 2;
                cb_type->setCurrentItem(i);
                d->pe_settings->setProxySettings(s.settings);
                cb_activated(i);
                gb_prop->setEnabled(true);
                pb_remove->setEnabled(true);
        }
}

void ProxyDlg::qle_textChanged(const QString &s)
{
        int x = lbx_proxy->currentItem();
        if(x != -1) {
                unhookEdit();
                lbx_proxy->changeItem(s, x);
                hookEdit();
        }
}

// hookEdit / unhookEdit - disconnect some signals to prevent recursion
void ProxyDlg::hookEdit()
{
        connect(lbx_proxy, SIGNAL(highlighted(int)), this, SLOT(qlbx_highlighted(int)));
        connect(le_name, SIGNAL(textChanged(const QString &)), this, SLOT(qle_textChanged(const QString &)));
}

void ProxyDlg::unhookEdit()
{
        disconnect(lbx_proxy, SIGNAL(highlighted(int)), this, SLOT(qlbx_highlighted(int)));
        disconnect(le_name, SIGNAL(textChanged(const QString &)), this, SLOT(qle_textChanged(const QString &)));
}

void ProxyDlg::doSave()
{
        int x = lbx_proxy->currentItem();
        if(x != -1)
                saveIntoItem(x);
        applyList(d->list, x);
        accept();
}


//----------------------------------------------------------------------------
// ProxyChooser
//----------------------------------------------------------------------------
class ProxyChooser::Private
{
public:
        Private() {}

        QComboBox *cb_proxy;
        QPushButton *pb_edit;
        ProxyManager *m;
};

ProxyChooser::ProxyChooser(ProxyManager *m, QWidget *parent, const char *name)
:QWidget(parent, name)
{
        d = new Private;
        d->m = m;
        connect(m, SIGNAL(settingsChanged()), SLOT(pm_settingsChanged()));
        QHBoxLayout *hb = new QHBoxLayout(this, 0, 4);
        d->cb_proxy = new QComboBox(this);
        QSizePolicy sp = d->cb_proxy->sizePolicy();
        d->cb_proxy->setSizePolicy( QSizePolicy(QSizePolicy::Expanding, sp.verData()) );
        hb->addWidget(d->cb_proxy);
        d->pb_edit = new QPushButton(tr("Edit..."), this);
        connect(d->pb_edit, SIGNAL(clicked()), SLOT(doOpen()));
        hb->addWidget(d->pb_edit);

        buildComboBox();
}

ProxyChooser::~ProxyChooser()
{
        delete d;
}

int ProxyChooser::currentItem() const
{
        return d->cb_proxy->currentItem();
}

void ProxyChooser::setCurrentItem(int x)
{
        d->cb_proxy->setCurrentItem(x);
}

void ProxyChooser::pm_settingsChanged()
{
        int x = d->cb_proxy->currentItem();
        buildComboBox();
        if(x >= 1) {
                x = d->m->findOldIndex(x-1);
                if(x == -1)
                        d->cb_proxy->setCurrentItem(0);
                else
                        d->cb_proxy->setCurrentItem(x+1);
        }
        else {
                x = d->m->lastEdited();
                if(x != -1)
                        d->cb_proxy->setCurrentItem(x+1);
        }
}

void ProxyChooser::buildComboBox()
{
        d->cb_proxy->clear();
        d->cb_proxy->insertItem(tr("None"));
        ProxyItemList list = d->m->itemList();
        for(ProxyItemList::ConstIterator it = list.begin(); it != list.end(); ++it)
                d->cb_proxy->insertItem((*it).name);
}

void ProxyChooser::doOpen()
{
        int x = d->cb_proxy->currentItem();
        if(x < 1)
                x = -1;
        else
                --x;
        d->m->openDialog(x);
}

void ProxyChooser::fixTabbing(QWidget *a, QWidget *b)
{
        setTabOrder(a, d->cb_proxy);
        setTabOrder(d->cb_proxy, d->pb_edit);
        setTabOrder(d->pb_edit, b);
}


//----------------------------------------------------------------------------
// ProxyManager
//----------------------------------------------------------------------------
class ProxyManager::Private
{
public:
        Private() {}

        ProxyItemList list;
        QGuardedPtr<ProxyDlg> pd;
        QValueList<int> prevMap;
        int lastEdited;
};

ProxyManager::ProxyManager(QObject *parent)
:QObject(parent)
{
        d = new Private;
}

ProxyManager::~ProxyManager()
{
        delete d;
}

ProxyChooser *ProxyManager::createProxyChooser(QWidget *parent)
{
        return new ProxyChooser(this, parent);
}

ProxyItemList ProxyManager::itemList() const
{
        return d->list;
}

const ProxyItem & ProxyManager::getItem(int x) const
{
        return d->list[x];
}

int ProxyManager::lastEdited() const
{
        return d->lastEdited;
}

void ProxyManager::setItemList(const ProxyItemList &list)
{
        d->list = list;
        assignIds();
}

QStringList ProxyManager::methodList() const
{
        QStringList list;
        list += "HTTP \"Connect\"";
        list += "SOCKS Version 5";
        list += "HTTP Polling";
        return list;
}

void ProxyManager::openDialog(int def)
{
        if(d->pd)
                bringToFront(d->pd);
        else {
                d->pd = new ProxyDlg(d->list, methodList(), def, 0);
                connect(d->pd, SIGNAL(applyList(const ProxyItemList &, int)), SLOT(pd_applyList(const ProxyItemList &, int)));
                d->pd->show();
        }
}

void ProxyManager::pd_applyList(const ProxyItemList &list, int x)
{
        d->list = list;
        d->lastEdited = x;

        // grab old id list
        d->prevMap.clear();
        for(ProxyItemList::ConstIterator it = d->list.begin(); it != d->list.end(); ++it)
                d->prevMap += (*it).id;
        assignIds(); // re-assign proper ids

        settingsChanged();
}

void ProxyManager::assignIds()
{
        int n = 0;
        for(ProxyItemList::Iterator it = d->list.begin(); it != d->list.end(); ++it)
                (*it).id = n++;
}

int ProxyManager::findOldIndex(int x) const
{
        int newPos = 0;
        bool found = false;
        for(QValueList<int>::ConstIterator it = d->prevMap.begin(); it != d->prevMap.end(); ++it) {
                if(*it == x) {
                        found = true;
                        break;
                }
                ++newPos;
        }
        if(found)
                return newPos;
        else
                return -1;
}