/** * 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 <tqheader.h> #include <tqvbox.h> #include <tqlayout.h> #include <tqcheckbox.h> #include <tqwhatsthis.h> #include <tqpushbutton.h> #include <tqradiobutton.h> #include <tqtoolbutton.h> #include <tqvbuttongroup.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(TQWidget *parent) :KCModule(parent, "kcmkio") { TQVBoxLayout *mainLayout = new TQVBoxLayout(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(TQApplication::reverseLayout() ? "clear_left" : "locationbar_erase")); dlg->kListViewSearchLine->setListView(dlg->lvDomainPolicy); TQValueList<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 TQString& 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()) { TQString domain = KIDNA::toUnicode(pdlg.domain()); int advice = pdlg.advice(); if ( !handleDuplicate(domain, advice) ) { const char* strAdvice = KCookieAdvice::adviceToStr(advice); TQListViewItem* index = new TQListViewItem (dlg->lvDomainPolicy, domain, i18n(strAdvice)); m_pDomainPolicy.insert (index, strAdvice); configChanged(); } } } void KCookiesPolicies::addPressed() { addNewPolicy (TQString::null); } void KCookiesPolicies::changePressed() { TQListViewItem* index = dlg->lvDomainPolicy->currentItem(); if (!index) return; TQString 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()) { TQString 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 TQString& domain, int advice ) { TQListViewItem* item = dlg->lvDomainPolicy->firstChild(); while ( item != 0 ) { if ( item->text(0) == domain ) { TQString 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() { TQListViewItem* nextItem = 0L; TQListViewItem* 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 TQStringList &domainConfig) { dlg->lvDomainPolicy->clear(); TQStringList::ConstIterator it = domainConfig.begin(); for (; it != domainConfig.end(); ++it) { TQString domain; KCookieAdvice::Value advice = KCookieAdvice::Dunno; splitDomainAdvice(*it, domain, advice); if (!domain.isEmpty()) { TQListViewItem* index = new TQListViewItem( dlg->lvDomainPolicy, KIDNA::toUnicode(domain), i18n(KCookieAdvice::adviceToStr(advice)) ); m_pDomainPolicy[index] = KCookieAdvice::adviceToStr(advice); } } } void KCookiesPolicies::selectionChanged () { TQListViewItem* 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, TQT_SIGNAL( toggled(bool) ), TQT_SLOT( cookiesEnabled(bool) ) ); connect( dlg->cbEnableCookies, TQT_SIGNAL( toggled(bool) ), TQT_SLOT( configChanged() ) ); // Connect the preference check boxes... connect ( dlg->cbRejectCrossDomainCookies, TQT_SIGNAL(clicked()), TQT_SLOT(configChanged())); connect ( dlg->cbAutoAcceptSessionCookies, TQT_SIGNAL(toggled(bool)), TQT_SLOT(configChanged())); connect ( dlg->cbIgnoreCookieExpirationDate, TQT_SIGNAL(toggled(bool)), TQT_SLOT(configChanged())); connect ( dlg->cbAutoAcceptSessionCookies, TQT_SIGNAL(toggled(bool)), TQT_SLOT(autoAcceptSessionCookies(bool))); connect ( dlg->cbIgnoreCookieExpirationDate, TQT_SIGNAL(toggled(bool)), TQT_SLOT(ignoreCookieExpirationDate(bool))); // Connect the default cookie policy radio buttons... connect(dlg->bgDefault, TQT_SIGNAL(clicked(int)), TQT_SLOT(configChanged())); // Connect signals from the domain specific policy listview. connect( dlg->lvDomainPolicy, TQT_SIGNAL(selectionChanged()), TQT_SLOT(selectionChanged()) ); connect( dlg->lvDomainPolicy, TQT_SIGNAL(doubleClicked (TQListViewItem *)), TQT_SLOT(changePressed() ) ); connect( dlg->lvDomainPolicy, TQT_SIGNAL(returnPressed ( TQListViewItem * )), TQT_SLOT(changePressed() ) ); // Connect the buttons... connect( dlg->pbNew, TQT_SIGNAL(clicked()), TQT_SLOT( addPressed() ) ); connect( dlg->pbChange, TQT_SIGNAL( clicked() ), TQT_SLOT( changePressed() ) ); connect( dlg->pbDelete, TQT_SIGNAL( clicked() ), TQT_SLOT( deletePressed() ) ); connect( dlg->pbDeleteAll, TQT_SIGNAL( clicked() ), TQT_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 ); TQString 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); TQStringList domainConfig; TQListViewItem *at = dlg->lvDomainPolicy->firstChild(); while( at ) { domainConfig.append(TQString::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 TQString& cfg, TQString &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 ) ); } TQString 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"