Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 474 insertions, 0 deletions

diff --git a/kcontrol/kio/kcookiespolicies.cpp b/kcontrol/kio/kcookiespolicies.cpp
new file mode 100644
index 000000000..7ee302ec1
--- /dev/null
+++ b/kcontrol/kio/kcookiespolicies.cpp
@@ -0,0 +1,474 @@
+/**
+ * kcookiespolicies.cpp - Cookies configuration
+ *
+ * Original Authors
+ * Copyright (c) Waldo Bastian <bastian@kde.org>
+ * Copyright (c) 1999 David Faure <faure@kde.org>
+ *
+ * Re-written by:
+ * Copyright (c) 2000- Dawit Alemayehu <adawit@kde.org>
+ *
+ *  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 program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+#include <qheader.h>
+#include <qvbox.h>
+#include <qlayout.h>
+#include <qcheckbox.h>
+#include <qwhatsthis.h>
+#include <qpushbutton.h>
+#include <qradiobutton.h>
+#include <qtoolbutton.h>
+#include <qvbuttongroup.h>
+
+#include <kiconloader.h>
+#include <kidna.h>
+#include <kmessagebox.h>
+#include <klistview.h>
+#include <klistviewsearchline.h>
+#include <klocale.h>
+#include <kconfig.h>
+#include <dcopref.h>
+
+#include "ksaveioconfig.h"
+
+#include "kcookiespolicies.h"
+#include "kcookiespoliciesdlg_ui.h"
+
+KCookiesPolicies::KCookiesPolicies(QWidget *parent)
+                 :KCModule(parent, "kcmkio")
+{
+    QVBoxLayout *mainLayout = new QVBoxLayout(this, 0, 0);
+
+    dlg = new KCookiesPolicyDlgUI (this);
+    dlg->lvDomainPolicy->header()->setStretchEnabled(true, 0);
+    dlg->lvDomainPolicy->setColumnWidthMode(0, KListView::Manual);
+    dlg->lvDomainPolicy->setColumnWidthMode(1, KListView::Maximum);
+    dlg->tbClearSearchLine->setIconSet(SmallIconSet(QApplication::reverseLayout() ? "clear_left" : "locationbar_erase"));
+    dlg->kListViewSearchLine->setListView(dlg->lvDomainPolicy);
+    QValueList<int> columns;
+    columns.append(0);
+    dlg->kListViewSearchLine->setSearchColumns(columns);
+
+    mainLayout->addWidget(dlg);
+
+    load();
+}
+
+KCookiesPolicies::~KCookiesPolicies()
+{
+}
+
+void KCookiesPolicies::configChanged ()
+{
+  //kdDebug() << "KCookiesPolicies::configChanged..." << endl;
+  emit changed((d_configChanged=true));
+}
+
+void KCookiesPolicies::cookiesEnabled( bool enable )
+{
+  dlg->bgDefault->setEnabled( enable );
+  dlg->bgPreferences->setEnabled ( enable );
+  dlg->gbDomainSpecific->setEnabled( enable );
+
+  if (enable)
+  {
+    ignoreCookieExpirationDate ( enable );
+    autoAcceptSessionCookies ( enable );
+  }
+}
+
+void KCookiesPolicies::ignoreCookieExpirationDate ( bool enable )
+{
+  bool isAutoAcceptChecked = dlg->cbAutoAcceptSessionCookies->isChecked();
+  enable = (enable && isAutoAcceptChecked);
+
+  dlg->bgDefault->setEnabled( !enable );
+  dlg->gbDomainSpecific->setEnabled( !enable );
+}
+
+void KCookiesPolicies::autoAcceptSessionCookies ( bool enable )
+{
+  bool isIgnoreExpirationChecked = dlg->cbIgnoreCookieExpirationDate->isChecked();
+  enable = (enable && isIgnoreExpirationChecked);
+
+  dlg->bgDefault->setEnabled( !enable );
+  dlg->gbDomainSpecific->setEnabled( !enable );
+}
+
+void KCookiesPolicies::addNewPolicy(const QString& domain)
+{
+  PolicyDlg pdlg (i18n("New Cookie Policy"), this);
+  pdlg.setEnableHostEdit (true, domain);
+
+  if (dlg->rbPolicyAccept->isChecked())
+    pdlg.setPolicy(KCookieAdvice::Reject);
+  else
+    pdlg.setPolicy(KCookieAdvice::Accept);
+
+  if (pdlg.exec() && !pdlg.domain().isEmpty())
+  {
+    QString domain = KIDNA::toUnicode(pdlg.domain());
+    int advice = pdlg.advice();
+
+    if ( !handleDuplicate(domain, advice) )
+    {
+      const char* strAdvice = KCookieAdvice::adviceToStr(advice);
+      QListViewItem* index = new QListViewItem (dlg->lvDomainPolicy,
+                                                domain, i18n(strAdvice));
+      m_pDomainPolicy.insert (index, strAdvice);
+      configChanged();
+    }
+  }
+}
+
+
+void KCookiesPolicies::addPressed()
+{
+  addNewPolicy (QString::null);
+}
+
+void KCookiesPolicies::changePressed()
+{
+  QListViewItem* index = dlg->lvDomainPolicy->currentItem();
+
+  if (!index)
+    return;
+
+  QString oldDomain = index->text(0);
+
+  PolicyDlg pdlg (i18n("Change Cookie Policy"), this);
+  pdlg.setPolicy (KCookieAdvice::strToAdvice(m_pDomainPolicy[index]));
+  pdlg.setEnableHostEdit (true, oldDomain);
+
+  if( pdlg.exec() && !pdlg.domain().isEmpty())
+  {
+    QString newDomain = KIDNA::toUnicode(pdlg.domain());
+    int advice = pdlg.advice();
+    if (newDomain == oldDomain || !handleDuplicate(newDomain, advice))
+    {
+      m_pDomainPolicy[index] = KCookieAdvice::adviceToStr(advice);
+      index->setText(0, newDomain);
+      index->setText(1, i18n(m_pDomainPolicy[index]) );
+      configChanged();
+    }
+  }
+}
+
+bool KCookiesPolicies::handleDuplicate( const QString& domain, int advice )
+{
+  QListViewItem* item = dlg->lvDomainPolicy->firstChild();
+  while ( item != 0 )
+  {
+    if ( item->text(0) == domain )
+    {
+      QString msg = i18n("<qt>A policy already exists for"
+                         "<center><b>%1</b></center>"
+                         "Do you want to replace it?</qt>").arg(domain);
+      int res = KMessageBox::warningContinueCancel(this, msg,
+                                          i18n("Duplicate Policy"),
+                                          i18n("Replace"));
+      if ( res == KMessageBox::Continue )
+      {
+        m_pDomainPolicy[item]= KCookieAdvice::adviceToStr(advice);
+        item->setText(0, domain);
+        item->setText(1, i18n(m_pDomainPolicy[item]));
+        configChanged();
+        return true;
+      }
+      else
+        return true;  // User Cancelled!!
+    }
+    item = item->nextSibling();
+  }
+  return false;
+}
+
+void KCookiesPolicies::deletePressed()
+{
+  QListViewItem* nextItem = 0L;
+  QListViewItem* item = dlg->lvDomainPolicy->firstChild ();
+
+  while (item != 0L)
+  {
+    if (dlg->lvDomainPolicy->isSelected (item))
+    {
+      nextItem = item->itemBelow();
+      if ( !nextItem )
+        nextItem = item->itemAbove();
+
+      delete item;
+      item = nextItem;
+    }
+    else
+    {
+      item = item->itemBelow();
+    }
+  }
+
+  if (nextItem)
+    dlg->lvDomainPolicy->setSelected (nextItem, true);
+
+  updateButtons();
+  configChanged();
+}
+
+void KCookiesPolicies::deleteAllPressed()
+{
+  m_pDomainPolicy.clear();
+  dlg->lvDomainPolicy->clear();
+  updateButtons();
+  configChanged();
+}
+
+void KCookiesPolicies::updateButtons()
+{
+  bool hasItems = dlg->lvDomainPolicy->childCount() > 0;
+
+  dlg->pbChange->setEnabled ((hasItems && d_itemsSelected == 1));
+  dlg->pbDelete->setEnabled ((hasItems && d_itemsSelected > 0));
+  dlg->pbDeleteAll->setEnabled ( hasItems );
+}
+
+void KCookiesPolicies::updateDomainList(const QStringList &domainConfig)
+{
+  dlg->lvDomainPolicy->clear();
+
+  QStringList::ConstIterator it = domainConfig.begin();
+  for (; it != domainConfig.end(); ++it)
+  {
+    QString domain;
+    KCookieAdvice::Value advice = KCookieAdvice::Dunno;
+
+    splitDomainAdvice(*it, domain, advice);
+
+    if (!domain.isEmpty())
+    {
+        QListViewItem* index = new QListViewItem( dlg->lvDomainPolicy, KIDNA::toUnicode(domain),
+                                                  i18n(KCookieAdvice::adviceToStr(advice)) );
+        m_pDomainPolicy[index] = KCookieAdvice::adviceToStr(advice);
+    }
+  }
+}
+
+void KCookiesPolicies::selectionChanged ()
+{
+  QListViewItem* item = dlg->lvDomainPolicy->firstChild ();
+
+  d_itemsSelected = 0;
+
+  while (item != 0L)
+  {
+    if (dlg->lvDomainPolicy->isSelected (item))
+      d_itemsSelected++;
+    item = item->nextSibling ();
+  }
+
+  updateButtons ();
+}
+
+void KCookiesPolicies::load()
+{
+  d_itemsSelected = 0;
+  d_configChanged = false;
+
+  KConfig cfg ("kcookiejarrc", true);
+  cfg.setGroup ("Cookie Policy");
+
+  bool enableCookies = cfg.readBoolEntry("Cookies", true);
+  dlg->cbEnableCookies->setChecked (enableCookies);
+  cookiesEnabled( enableCookies );
+
+  KCookieAdvice::Value advice = KCookieAdvice::strToAdvice (cfg.readEntry(
+                                               "CookieGlobalAdvice", "Ask"));
+  switch (advice)
+  {
+    case KCookieAdvice::Accept:
+      dlg->rbPolicyAccept->setChecked (true);
+      break;
+    case KCookieAdvice::Reject:
+      dlg->rbPolicyReject->setChecked (true);
+      break;
+    case KCookieAdvice::Ask:
+    case KCookieAdvice::Dunno:
+    default:
+      dlg->rbPolicyAsk->setChecked (true);
+  }
+
+  bool enable = cfg.readBoolEntry("RejectCrossDomainCookies", true);
+  dlg->cbRejectCrossDomainCookies->setChecked (enable);
+
+  bool sessionCookies = cfg.readBoolEntry("AcceptSessionCookies", true);
+  dlg->cbAutoAcceptSessionCookies->setChecked (sessionCookies);
+  bool cookieExpiration = cfg.readBoolEntry("IgnoreExpirationDate", false);
+  dlg->cbIgnoreCookieExpirationDate->setChecked (cookieExpiration);
+  updateDomainList(cfg.readListEntry("CookieDomainAdvice"));
+
+  if (enableCookies)
+  {
+    ignoreCookieExpirationDate( cookieExpiration );
+    autoAcceptSessionCookies( sessionCookies );
+    updateButtons();
+  }
+
+  // Connect the main swicth :) Enable/disable cookie support
+  connect( dlg->cbEnableCookies, SIGNAL( toggled(bool) ),
+           SLOT( cookiesEnabled(bool) ) );
+  connect( dlg->cbEnableCookies, SIGNAL( toggled(bool) ),
+           SLOT( configChanged() ) );
+
+  // Connect the preference check boxes...
+  connect ( dlg->cbRejectCrossDomainCookies, SIGNAL(clicked()),
+            SLOT(configChanged()));
+  connect ( dlg->cbAutoAcceptSessionCookies, SIGNAL(toggled(bool)),
+            SLOT(configChanged()));
+  connect ( dlg->cbIgnoreCookieExpirationDate, SIGNAL(toggled(bool)),
+            SLOT(configChanged()));
+
+  connect ( dlg->cbAutoAcceptSessionCookies, SIGNAL(toggled(bool)),
+            SLOT(autoAcceptSessionCookies(bool)));
+  connect ( dlg->cbIgnoreCookieExpirationDate, SIGNAL(toggled(bool)),
+            SLOT(ignoreCookieExpirationDate(bool)));
+
+  // Connect the default cookie policy radio buttons...
+  connect(dlg->bgDefault, SIGNAL(clicked(int)), SLOT(configChanged()));
+
+  // Connect signals from the domain specific policy listview.
+  connect( dlg->lvDomainPolicy, SIGNAL(selectionChanged()),
+           SLOT(selectionChanged()) );
+  connect( dlg->lvDomainPolicy, SIGNAL(doubleClicked (QListViewItem *)),
+           SLOT(changePressed() ) );
+  connect( dlg->lvDomainPolicy, SIGNAL(returnPressed ( QListViewItem * )),
+           SLOT(changePressed() ) );
+
+  // Connect the buttons...
+  connect( dlg->pbNew, SIGNAL(clicked()), SLOT( addPressed() ) );
+  connect( dlg->pbChange, SIGNAL( clicked() ), SLOT( changePressed() ) );
+  connect( dlg->pbDelete, SIGNAL( clicked() ), SLOT( deletePressed() ) );
+  connect( dlg->pbDeleteAll, SIGNAL( clicked() ), SLOT( deleteAllPressed() ) );
+}
+
+void KCookiesPolicies::save()
+{
+  // If nothing changed, ignore the save request.
+  if (!d_configChanged)
+    return;
+
+  KConfig cfg ( "kcookiejarrc" );
+  cfg.setGroup( "Cookie Policy" );
+
+  bool state = dlg->cbEnableCookies->isChecked();
+  cfg.writeEntry( "Cookies", state );
+  state = dlg->cbRejectCrossDomainCookies->isChecked();
+  cfg.writeEntry( "RejectCrossDomainCookies", state );
+  state = dlg->cbAutoAcceptSessionCookies->isChecked();
+  cfg.writeEntry( "AcceptSessionCookies", state );
+  state = dlg->cbIgnoreCookieExpirationDate->isChecked();
+  cfg.writeEntry( "IgnoreExpirationDate", state );
+
+  QString advice;
+  if (dlg->rbPolicyAccept->isChecked())
+      advice = KCookieAdvice::adviceToStr(KCookieAdvice::Accept);
+  else if (dlg->rbPolicyReject->isChecked())
+      advice = KCookieAdvice::adviceToStr(KCookieAdvice::Reject);
+  else
+      advice = KCookieAdvice::adviceToStr(KCookieAdvice::Ask);
+
+  cfg.writeEntry("CookieGlobalAdvice", advice);
+
+  QStringList domainConfig;
+  QListViewItem *at = dlg->lvDomainPolicy->firstChild();
+
+  while( at )
+  {
+    domainConfig.append(QString::fromLatin1("%1:%2").arg(KIDNA::toAscii(at->text(0))).arg(m_pDomainPolicy[at]));
+    at = at->nextSibling();
+  }
+
+  cfg.writeEntry("CookieDomainAdvice", domainConfig);
+  cfg.sync();
+
+  // Update the cookiejar...
+  if (!dlg->cbEnableCookies->isChecked())
+    (void)DCOPRef("kded", "kcookiejar").send("shutdown");
+  else
+  {
+    if (!DCOPRef("kded", "kcookiejar").send("reloadPolicy"))
+      KMessageBox::sorry(0, i18n("Unable to communicate with the cookie handler service.\n"
+                                 "Any changes you made will not take effect until the service "
+                                 "is restarted."));
+  }
+
+  // Force running io-slave to reload configurations...
+  KSaveIOConfig::updateRunningIOSlaves (this);
+  emit changed( false );
+}
+
+
+void KCookiesPolicies::defaults()
+{
+  dlg->cbEnableCookies->setChecked( true );
+  dlg->rbPolicyAsk->setChecked( true );
+  dlg->rbPolicyAccept->setChecked( false );
+  dlg->rbPolicyReject->setChecked( false );
+  dlg->cbRejectCrossDomainCookies->setChecked( true );
+  dlg->cbAutoAcceptSessionCookies->setChecked( true );
+  dlg->cbIgnoreCookieExpirationDate->setChecked( false );
+  dlg->lvDomainPolicy->clear();
+
+  cookiesEnabled( dlg->cbEnableCookies->isChecked() );
+  updateButtons();
+}
+
+void KCookiesPolicies::splitDomainAdvice (const QString& cfg, QString &domain,
+                                          KCookieAdvice::Value &advice)
+{
+  int sepPos = cfg.findRev(':');
+
+  // Ignore any policy that does not contain a domain...
+  if ( sepPos <= 0 )
+    return;
+
+  domain = cfg.left(sepPos);
+  advice = KCookieAdvice::strToAdvice( cfg.mid( sepPos+1 ) );
+}
+
+QString KCookiesPolicies::quickHelp() const
+{
+  return i18n("<h1>Cookies</h1> Cookies contain information that Konqueror"
+              " (or any other KDE application using the HTTP protocol) stores"
+              " on your computer from a remote Internet server. This means"
+              " that a web server can store information about you and your"
+              " browsing activities on your machine for later use. You might"
+              " consider this an invasion of privacy.<p>However, cookies are"
+              " useful in certain situations. For example, they are often used"
+              " by Internet shops, so you can 'put things into a shopping"
+              " basket'. Some sites require you have a browser that supports"
+              " cookies.<p>Because most people want a compromise between privacy"
+              " and the benefits cookies offer, KDE offers you the ability to"
+              " customize the way it handles cookies. You might, for example"
+              " want to set KDE's default policy to ask you whenever a server"
+              " wants to set a cookie or simply reject or accept everything."
+              " For example, you might choose to accept all cookies from your"
+              " favorite shopping web site. For this all you have to do is"
+              " either browse to that particular site and when you are presented"
+              " with the cookie dialog box, click on <i> This domain </i> under"
+              " the 'apply to' tab and choose accept or simply specify the name"
+              " of the site in the <i> Domain Specific Policy </i> tab and set"
+              " it to accept. This enables you to receive cookies from trusted"
+              " web sites without being asked every time KDE receives a cookie."
+             );
+}
+
+#include "kcookiespolicies.moc"