• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdenetwork

• Sitemap
• Contact Us

 

kopete/kopete

chatwindowconfig.cpp

Go to the documentation of this file.

/*
    chatwindowconfig.cpp  -  Kopete Look Feel Config

    Copyright (c) 2005-2006 by Michaël Larouche       <larouche@kde.org>
    Copyright (c) 2005-2006 by Olivier Goffart         <ogoffart at kde.org>
    Copyright (c) 2007      by Gustavo Pichorim Boiko  <gustavo.boiko@kdemail.net>

    Kopete    (c) 2005-2007 by the Kopete developers  <kopete-devel@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.                                   *
    *                                                                       *
    *************************************************************************
*/

#include "chatwindowconfig.h"
#include "emoticonthemedelegate.h"
#include "emoticonthemeitem.h"

#include <QCheckBox>
#include <QDir>
#include <QLayout>
#include <QSpinBox>
#include <QSlider>
#include <QLabel>
#include <QPixmap>
#include <QVBoxLayout>

#include <kdeversion.h>
#include <kinputdialog.h>

#include <kcolorcombo.h>
#include <kcolorbutton.h>
#include <kdebug.h>
#include <kfontrequester.h>
#include <kpluginfactory.h>
#include <kio/netaccess.h>
#include <khtmlview.h>
#include <klineedit.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kpushbutton.h>
#include <kstandarddirs.h>
#include <kurlrequesterdialog.h>
#include <krun.h>
#include <kfiledialog.h>
#include <kurl.h>
#include <kemoticons.h>
#include <KCMultiDialog>

// KNewStuff
#include <knewstuff2/engine.h>

// For Kopete Chat Window Style configuration and preview.
#include <kopetechatwindowstylemanager.h>
#include <kopetechatwindowstyle.h>
#include <chatmessagepart.h>


// Things we fake to get the message preview to work
#include <kopeteprotocol.h>
#include <kopetemetacontact.h>
#include <kopeteaccount.h>
#include <kopeteidentity.h>
#include <kopetecontact.h>
#include <kopetemessage.h>
#include <kopetechatsession.h>
#include <kopetechatsessionmanager.h>
#include <kopetestatusmessage.h>
#include <kopeteappearancesettings.h>

#include "kopeteemoticons.h"

#include "kopeteglobal.h"

#include "kopetechatwindowsettings.h"

K_PLUGIN_FACTORY( KopeteChatWindowConfigFactory,
        registerPlugin<ChatWindowConfig>(); )
K_EXPORT_PLUGIN( KopeteChatWindowConfigFactory("kcm_kopete_chatwindowconfig") )

// Reimplement Kopete::Contact and its abstract method
// This is for style preview.
class FakeContact : public Kopete::Contact
{
public:
    FakeContact (Kopete::Account *account, const QString &id, Kopete::MetaContact *mc ) : Kopete::Contact( account, id, mc ) {}
    virtual Kopete::ChatSession *manager(Kopete::Contact::CanCreateFlags /*c*/) { return 0L; }
    virtual void slotUserInfo() {}
};

// This is for style preview.
class FakeProtocol : public Kopete::Protocol
{
public:
FakeProtocol( const KComponentData &instance, QObject *parent ) : Kopete::Protocol(instance, parent){}
Kopete::Account* createNewAccount( const QString &/*accountId*/ ){return 0L;}
AddContactPage* createAddContactWidget( QWidget */*parent*/, Kopete::Account */*account*/){return 0L;}
KopeteEditAccountWidget* createEditAccountWidget( Kopete::Account */*account*/, QWidget */*parent */){return 0L;}
};

// This is for style preview.
class FakeIdentity : public Kopete::Identity
{
    public:
        FakeIdentity() : Kopete::Identity("Preview Identity") {};
};

// This is for style preview.
class FakeAccount : public Kopete::Account
{
public:
    FakeAccount(Kopete::Protocol *parent, const QString &accountID) : Kopete::Account(parent, accountID)
    {
        m_identity = new FakeIdentity();
        setIdentity(m_identity);
    }

    void setMyself(Kopete::Contact *myself)
    {
        Kopete::Account::setMyself(myself);
    }

    ~FakeAccount()
    {
        delete m_identity;
    }

bool createContact( const QString &/*contactId*/, Kopete::MetaContact */*parentContact*/ ){return true;}
void connect( const Kopete::OnlineStatus& /*initialStatus*/){}
void disconnect(){}
void setOnlineStatus( const Kopete::OnlineStatus& /*status*/ , const Kopete::StatusMessage &/*reason*/){}
void setStatusMessage(const Kopete::StatusMessage& /*statusMessage*/){}

private:
    FakeIdentity *m_identity;
};

ChatWindowConfig::ChatWindowConfig(QWidget *parent, const QVariantList &args )
    : KCModule( KopeteChatWindowConfigFactory::componentData(), parent, args ),
        m_currentStyle (0L), m_loading(false),
        m_previewProtocol(0L), m_previewAccount(0L), m_myselfMetaContact(0L),
        m_jackMetaContact(0L), m_myself(0L), m_jack(0L)
{
    KConfigGroup config(KGlobal::config(), "ChatWindowSettings");

    QVBoxLayout *layout = new QVBoxLayout(this);
    // since KSetting::Dialog has margins here, we don't need our own.
    layout->setContentsMargins( 0, 0, 0, 0);
    m_tab = new QTabWidget(this);
    layout->addWidget(m_tab);

//--------- style tab ---------------------
    QWidget *styleWidget = new QWidget(m_tab);
    m_styleUi.setupUi(styleWidget);
    m_tab->addTab(styleWidget, i18n("&Style"));
    addConfig( KopeteChatWindowSettings::self(), styleWidget );

    connect(m_styleUi.styleList, SIGNAL(currentTextChanged(const QString &)),
        this, SLOT(slotChatStyleSelected(const QString &)));
    connect(m_styleUi.variantList, SIGNAL(activated(const QString&)),
        this, SLOT(slotChatStyleVariantSelected(const QString &)));
    connect(m_styleUi.deleteButton, SIGNAL(clicked()),
        this, SLOT(slotDeleteChatStyle()));
    connect(m_styleUi.installButton, SIGNAL(clicked()),
        this, SLOT(slotInstallChatStyle()));
    connect(m_styleUi.btnGetStyles, SIGNAL(clicked()),
        this, SLOT(slotGetChatStyles()));

    m_styleUi.deleteButton->setIcon(KIcon("edit-delete"));
    m_styleUi.installButton->setIcon(KIcon("document-import"));
    m_styleUi.btnGetStyles->setIcon(KIcon("get-hot-new-stuff"));

    // Show the available styles when the Manager has finish to load the styles.
    connect(ChatWindowStyleManager::self(), SIGNAL(loadStylesFinished()), this, SLOT(slotLoadChatStyles()));

    // Create the fake Chat Session
    createPreviewChatSession();
    m_preview = new ChatMessagePart(m_previewChatSession, m_styleUi.htmlFrame);
    m_preview->setJScriptEnabled(false);
    m_preview->setJavaEnabled(false);
    m_preview->setPluginsEnabled(false);
    m_preview->setMetaRefreshEnabled(false);
    KHTMLView *htmlWidget = m_preview->view();
    htmlWidget->setMarginWidth(4);
    htmlWidget->setMarginHeight(4);
    htmlWidget->setFocusPolicy(Qt::NoFocus);
    htmlWidget->setSizePolicy(
        QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
    layout = new QVBoxLayout(m_styleUi.htmlFrame);
    layout->setMargin(0);
    layout->addWidget(htmlWidget);
    m_styleUi.htmlFrame->setLayout(layout);
    // Add the preview message to the ChatMessagePart
    createPreviewMessages();


//--------- emoticons tab ---------------------
    QWidget *emoticonsWidget = new QWidget(m_tab);
    m_emoticonsUi.setupUi(emoticonsWidget);
    m_tab->addTab(emoticonsWidget, i18n("&Emoticons"));

    m_emoticonsUi.icon_theme_list->setItemDelegate(new EmoticonThemeDelegate(this));
    addConfig( Kopete::AppearanceSettings::self(), emoticonsWidget );

    connect(m_emoticonsUi.icon_theme_list, SIGNAL(itemSelectionChanged()),
        this, SLOT(emitChanged()));

    connect(m_emoticonsUi.btnManageThemes, SIGNAL(clicked()),
        this, SLOT(slotManageEmoticonThemes()));

//--------- colors tab --------------------------
    QWidget *colorsWidget = new QWidget(m_tab);
    m_colorsUi.setupUi(colorsWidget);
    m_tab->addTab(colorsWidget, i18n("Colors && Fonts"));
    addConfig( Kopete::AppearanceSettings::self(), colorsWidget );

    load();
}

ChatWindowConfig::~ChatWindowConfig()
{
    if (m_previewChatSession)
    {
        Kopete::ChatSessionManager::self()->removeSession(m_previewChatSession);
    }

    // Deleting the account will delete jack and myself
    delete m_previewAccount;

    delete m_myselfMetaContact;
    delete m_jackMetaContact;

    delete m_previewProtocol;
}


void ChatWindowConfig::save()
{
    KCModule::save();
//  kDebug(14000) << "called.";

    KopeteChatWindowSettings *settings = KopeteChatWindowSettings::self();

    // Get the styleName
    if(m_currentStyle)
    {
        kDebug(14000) << m_currentStyle->getStyleName();
        settings->setStyleName( m_currentStyle->getStyleName() );
    }
    // Get and save the styleVariant
    if( !m_currentVariantMap.empty() )
    {
        kDebug(14000) << m_currentVariantMap[ m_styleUi.variantList->currentText()];
        settings->setStyleVariant( m_currentVariantMap[m_styleUi.variantList->currentText()] );
    }

    Kopete::AppearanceSettings *appearanceSettings = Kopete::AppearanceSettings::self();
    QListWidgetItem *item = m_emoticonsUi.icon_theme_list->currentItem();
    
    if (item)
        KEmoticons::setTheme( item->text() );

    // Ugly hacks, this will emit the kcfg signals
    appearanceSettings->setChatTextColor(m_colorsUi.kcfg_chatTextColor->color());
    appearanceSettings->setUseEmoticons(m_emoticonsUi.kcfg_useEmoticons->isChecked());
    settings->setHighlightForegroundColor(m_colorsUi.kcfg_highlightForegroundColor->color());
    settings->setChatBgOverride(m_colorsUi.kcfg_chatBgOverride->isChecked());

    appearanceSettings->writeConfig();
    settings->writeConfig();

    load();
}

void ChatWindowConfig::load()
{
    KCModule::load();

    //we will change the state of somme controls, which will call some signals.
    //so to don't refresh everything several times, we memorize we are loading.
    m_loading=true;

    // Look for available chat window styles.
    slotLoadChatStyles();

    // Look for available emoticons themes
    updateEmoticonList();

    m_loading=false;
    slotUpdateChatPreview();
}

void ChatWindowConfig::slotLoadChatStyles()
{
    m_styleUi.styleList->clear();

    QStringList availableStyles;
    availableStyles = ChatWindowStyleManager::self()->getAvailableStyles();
    if( availableStyles.empty() )
        kDebug(14000) << "Warning, available styles is empty !";

    foreach( const QString& styleName, availableStyles )
    {
        // Insert style name into the listbox
        m_styleUi.styleList->insertItem( 0, styleName );
    }

    m_styleUi.styleList->setSortingEnabled( true );

    QString currentStyle = KopeteChatWindowSettings::self()->styleName();
    QList<QListWidgetItem *> items = m_styleUi.styleList->findItems( currentStyle, Qt::MatchFixedString | Qt::MatchCaseSensitive );
    if( items.count() > 0 )
    {
        kDebug(14000) << "Restoring saved style: " << currentStyle;

        m_styleUi.styleList->setCurrentItem( items[0] );
        m_styleUi.styleList->scrollToItem( items[0] );
    }
}


void ChatWindowConfig::slotChatStyleSelected(const QString &styleName)
{
    if (styleName.isEmpty())
        return;
    // Retrieve variant list.
    m_currentStyle = ChatWindowStyleManager::self()->getStyleFromPool( styleName );

    if(m_currentStyle)
    {
        m_currentVariantMap = m_currentStyle->getVariants();
        kDebug(14000) << "Loading style: " << m_currentStyle->getStyleName();

        // Update the variant list based on current style.
        m_styleUi.variantList->clear();

        // Add the no variant item to the list
        // TODO: Use default name variant from Info.plist
        // TODO: Select default variant from Info.plist
        m_styleUi.variantList->addItem( i18n("(No Variant)") );

        ChatWindowStyle::StyleVariants::ConstIterator it, itEnd = m_currentVariantMap.constEnd();
        int currentIndex = 0;
        for(it = m_currentVariantMap.constBegin(); it != itEnd; ++it)
        {
            // Insert variant name into the combobox.
            m_styleUi.variantList->addItem( it.key() );

            if( it.value() == KopeteChatWindowSettings::self()->styleVariant() )
                m_styleUi.variantList->setCurrentIndex(currentIndex+1);

            currentIndex++;
        }

        // Update the preview
        slotUpdateChatPreview();
        // Get the first variant to preview
        // Check if the current style has variants.
        if( !m_currentVariantMap.empty() ) {
            m_preview->setStyleVariant(m_currentVariantMap[0]);
            m_styleUi.kcfg_useCompact->setEnabled(m_currentStyle->hasCompact( QString() ) );
        }

        emitChanged();
    }
}

void ChatWindowConfig::slotChatStyleVariantSelected(const QString &variantName)
{
//  kDebug(14000) << variantName;
//  kDebug(14000) << m_currentVariantMap[variantName];

    // enable the 'Use compact' checkbox depending on whether the selected variant exists in compact
    // form
    QString styleName = m_styleUi.styleList->currentItem()->text();
    m_currentStyle = ChatWindowStyleManager::self()->getStyleFromPool( styleName );
    if ( m_styleUi.variantList->currentIndex() == 0 ) {
        m_styleUi.kcfg_useCompact->setEnabled(m_currentStyle->hasCompact( "" ) );
    }
    else {
        m_styleUi.kcfg_useCompact->setEnabled(m_currentStyle->hasCompact( variantName ) );
    }
    // Update the preview
    m_preview->setStyleVariant(m_currentVariantMap[variantName]);
    emitChanged();
}

void ChatWindowConfig::slotInstallChatStyle()
{
    KUrl styleUrl = KFileDialog::getOpenUrl( KUrl(), QString::fromUtf8("application/zip application/x-compressed-tar application/x-bzip-compressed-tar"), this, i18n("Choose a Chat Window Style to install") );

    if ( styleUrl.isEmpty() ) // dialog got canceled
        return;

    int styleInstallReturn = installChatStyle( styleUrl );

    switch(styleInstallReturn)
    {
        case ChatWindowStyleManager::StyleCannotOpen:
        {
            KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18n("The specified archive cannot be opened.\nMake sure that the archive is a valid ZIP or TAR archive."), i18n("Cannot open archive") );
            break;
        }
        case ChatWindowStyleManager::StyleNoDirectoryValid:
        {
            KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18n("Could not find a suitable place to install the Chat Window Style."), i18n("Cannot find styles directory") );
            break;
        }
        case ChatWindowStyleManager::StyleNotValid:
            KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18n("The specified archive does not contain a valid Chat Window Style."), i18n("Invalid Style") );
            break;
        case ChatWindowStyleManager::StyleInstallOk:
        {
            KMessageBox::queuedMessageBox( this, KMessageBox::Information, i18n("The Chat Window Style was successfully installed."), i18n("Install successful") );
            break;
        }
        case ChatWindowStyleManager::StyleUnknow:
        default:
        {
            KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18n("An unknown error occurred while trying to install the Chat Window Style."), i18n("Unknown error") );
            break;
        }
    }
}

int ChatWindowConfig::installChatStyle(const KUrl &styleToInstall)
{
    int styleInstallReturn = ChatWindowStyleManager::StyleCannotOpen;

    if( !styleToInstall.isEmpty() )
    {
        QString stylePath;
        if( KIO::NetAccess::download( styleToInstall, stylePath, this ) )
        {
            styleInstallReturn = ChatWindowStyleManager::self()->installStyle( stylePath );

            // removeTempFile check if the file is a temp file, so it's ok for local files.
            KIO::NetAccess::removeTempFile( stylePath );
        }
    }

    return styleInstallReturn;
}

void ChatWindowConfig::slotDeleteChatStyle()
{
    if (!m_styleUi.styleList->currentItem())
    {
        return; // nothing selected
    }

    QString styleName = m_styleUi.styleList->currentItem()->text();
    if( ChatWindowStyleManager::self()->removeStyle(styleName) )
    {
        KMessageBox::queuedMessageBox(this, KMessageBox::Information, i18nc("@info", "The Chat Window Style <resource>%1</resource> was successfully deleted.", styleName));
        emitChanged();
    }
    else
    {
        KMessageBox::queuedMessageBox(this, KMessageBox::Sorry, i18nc("@info", "An error occurred while trying to delete the <resource>%1</resource> Chat Window Style. Your account might not have permission to remove it.", styleName));
    }
}

void ChatWindowConfig::slotGetChatStyles()
{
    KConfigGroup configGrp(KGlobal::config(), "KNewStuff2");
    configGrp.writeEntry("ProvidersUrl", "http://download.kde.org/khotnewstuff/kopetestyles12-providers.xml");
    configGrp.writeEntry("TargetDir", "kopete_chatstyles");
    configGrp.sync();
    
    KNS::Engine *engine = new KNS::Engine();
    engine->init(configGrp.config()->name());
    
    // FIXME: Upon closing the Settings KCMultiDialog all KCMs are deleted and when reopening
    // the settings dialog there is no active valid KComponentData, which KNS2 relies on.
    // Forcing an active one below works around bug 163382, but the problem is somewhere else.
    KGlobal::setActiveComponent(KopeteChatWindowConfigFactory::componentData());

    KNS::Entry::List entries = engine->downloadDialogModal(this);

    if ( entries.size() > 0 )
    {
        int correctlyInstalled(0);
        foreach( KNS::Entry* entry, entries )
        {
            if ( entry->status() == KNS::Entry::Installed && entry->installedFiles().size() > 0 )
            {
                KUrl styleFile( entry->installedFiles().at(0) );
                int result = installChatStyle( styleFile );

                QString packageName(entry->name().representation());
                QString errorTitle = i18nc("@title:window", "Chat Window Style <resource>%1</resource> installation", packageName);
                switch(result)
                {
                    case ChatWindowStyleManager::StyleCannotOpen:
                    {
                        KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18nc("@info", "The specified archive <filename>%1</filename> cannot be opened.\nMake sure that the archive is a valid ZIP or TAR archive.", styleFile.pathOrUrl()), errorTitle);
                        break;
                    }
                    case ChatWindowStyleManager::StyleNoDirectoryValid:
                    {
                        KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18nc("@info", "Could not find a suitable place to install the Chat Window Style <resource>%1</resource>.", packageName), errorTitle );
                        break;
                    }
                    case ChatWindowStyleManager::StyleNotValid:
                        KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18nc("@info", "The specified archive <filename>%1</filename> does not contain a valid Chat Window Style.", styleFile.pathOrUrl()), errorTitle );
                        break;
                    case ChatWindowStyleManager::StyleInstallOk:
                    {
                        ++correctlyInstalled;
                        break;
                    }
                    case ChatWindowStyleManager::StyleUnknow:
                    default:
                    {
                        KMessageBox::queuedMessageBox( this, KMessageBox::Error, i18nc("@info", "An unknown error occurred while trying to install the Chat Window Style <resource>%1</resource>.", packageName), errorTitle );
                        break;
                    }
                }
            }
        }

        if ( correctlyInstalled > 0)
        {
            KMessageBox::queuedMessageBox(this, KMessageBox::Information, i18np("One Chat Window Style package has been installed.", "%1 Chat Window Style packages have been installed.", correctlyInstalled));
        }
    }

    delete engine;
}

void ChatWindowConfig::createPreviewChatSession()
{
    m_previewProtocol = new FakeProtocol( KComponentData(QByteArray("kopete-preview-chatwindowstyle")), 0 ); m_previewProtocol->setObjectName( QLatin1String("kopete-preview-chatwindowstyle") );
    m_previewAccount = new FakeAccount(m_previewProtocol, QString("previewaccount"));

    // Create fake meta/contacts
    m_myselfMetaContact = new Kopete::MetaContact();
    m_myselfMetaContact->setTemporary();
    m_myselfMetaContact->setDisplayName(i18n("Myself"));
    m_myselfMetaContact->setDisplayNameSource(Kopete::MetaContact::SourceCustom);

    m_myself = new FakeContact(m_previewAccount, i18nc("This is the myself preview contact id", "myself@preview"), m_myselfMetaContact);
    m_myself->setNickName(i18nc("This is the myself preview contact nickname", "Myself"));

    m_jackMetaContact = new Kopete::MetaContact();
    m_jackMetaContact->setTemporary();
    m_jackMetaContact->setDisplayName(i18n("Jack"));
    m_jackMetaContact->setDisplayNameSource(Kopete::MetaContact::SourceCustom);

    m_jack = new FakeContact(m_previewAccount, i18nc("This is the other preview contact id", "jack@preview"), m_jackMetaContact);
    m_jack->setNickName(i18nc("This is the other preview contact nickname", "Jack"));

    m_previewAccount->setMyself(m_myself);

    Kopete::ContactPtrList contactList;
    contactList.append(m_jack);
    // Create fakeChatSession
    m_previewChatSession = Kopete::ChatSessionManager::self()->create(m_myself, contactList, m_previewProtocol);
    m_previewChatSession->setDisplayName(i18nc("preview of a chat session", "Preview Session"));
}

void ChatWindowConfig::createPreviewMessages()
{
    Kopete::Message msgIn( m_jack,m_myself );
    msgIn.setPlainBody( i18n( "Hello, this is an incoming message :-)" ) );
    msgIn.setDirection( Kopete::Message::Inbound );

    Kopete::Message msgIn2( m_jack, m_myself );
    msgIn2.setPlainBody( i18n( "Hello, this is an incoming consecutive message." ) );
    msgIn2.setDirection( Kopete::Message::Inbound );

    Kopete::Message msgOut( m_myself, m_jack );
    msgOut.setPlainBody( i18n( "Ok, this is an outgoing message" ) );
    msgOut.setDirection( Kopete::Message::Outbound );

    Kopete::Message msgOut2( m_myself, m_jack );
    msgOut2.setPlainBody( i18n( "Ok, an outgoing consecutive message." ) );
    msgOut2.setDirection( Kopete::Message::Outbound );

    Kopete::Message msgOut3( m_myself, m_jack );
    msgOut3.setPlainBody( i18n( "Message that is being sent." ) );
    msgOut3.setDirection( Kopete::Message::Outbound );
    msgOut3.setState( Kopete::Message::StateSending );

    Kopete::Message msgOut4( m_myself, m_jack );
    msgOut4.setPlainBody( i18n( "Delivered message." ) );
    msgOut4.setDirection( Kopete::Message::Outbound );
    msgOut4.setState( Kopete::Message::StateSent );

    Kopete::Message msgOut5( m_myself, m_jack );
    msgOut5.setPlainBody( i18n( "Message that can't be delivered." ) );
    msgOut5.setDirection( Kopete::Message::Outbound );
    msgOut5.setState( Kopete::Message::StateError );

    Kopete::Message msgCol( m_jack, m_myself );
    msgCol.setPlainBody( i18n("Here is an incoming colored message.") );
    msgCol.setDirection( Kopete::Message::Inbound );
    msgCol.setForegroundColor( QColor( "DodgerBlue" ) );
    msgCol.setBackgroundColor( QColor( "LightSteelBlue" ) );

    Kopete::Message msgInt( m_jack, m_myself );
    msgInt.setPlainBody( i18n( "This is an internal message" ) );
    msgInt.setDirection( Kopete::Message::Internal );

    Kopete::Message msgAct( m_jack, m_myself );
    msgAct.setPlainBody( i18n( "performed an action" ) );
    msgAct.setType( Kopete::Message::TypeAction );
    msgAct.setDirection( Kopete::Message::Inbound );

    Kopete::Message msgHigh( m_jack, m_myself );
    msgHigh.setPlainBody( i18n( "This is a highlighted message" ) );
    msgHigh.setDirection( Kopete::Message::Inbound );
    msgHigh.setImportance( Kopete::Message::Highlight );

    Kopete::Message msgFTRequest( m_jack, m_myself );
    msgFTRequest.setPlainBody( i18n( "Hello, this is an incoming file transfer request" ) );
    msgFTRequest.setDirection( Kopete::Message::Inbound );
    msgFTRequest.setType( Kopete::Message::TypeFileTransferRequest );
    msgFTRequest.setFileName( "data.pdf" );
    msgFTRequest.setFileSize( 10000000 );

    Kopete::Message msgFTRequestDisabled( m_jack, m_myself );
    msgFTRequestDisabled.setPlainBody( i18n( "Hello, this is a disabled incoming file transfer request" ) );
    msgFTRequestDisabled.setDirection( Kopete::Message::Inbound );
    msgFTRequestDisabled.setType( Kopete::Message::TypeFileTransferRequest );
    msgFTRequestDisabled.setFileName( "data.pdf" );
    msgFTRequestDisabled.setFileSize( 10000000 );
    msgFTRequestDisabled.setFileTransferDisabled( true );

    // This is a UTF-8 string btw.
    Kopete::Message msgRightToLeft( m_myself, m_jack );
    msgRightToLeft.setPlainBody( i18nc("This special UTF-8 string is to test if the style supports Right-to-Left language display.", "הודעות טקסט") );
    msgRightToLeft.setDirection( Kopete::Message::Outbound );

    Kopete::Message msgBye ( m_myself, m_jack );
    msgBye.setPlainBody( i18n("Bye") );
    msgBye.setDirection( Kopete::Message::Outbound );

    // Add the messages to ChatMessagePart
    m_preview->appendMessage(msgIn);
    m_preview->appendMessage(msgIn2);
    m_preview->appendMessage(msgOut);
    m_preview->appendMessage(msgOut2);
    m_preview->appendMessage(msgOut3);
    m_preview->appendMessage(msgOut4);
    m_preview->appendMessage(msgOut5);
    m_preview->appendMessage(msgCol);
    m_preview->appendMessage(msgInt);
    m_preview->appendMessage(msgAct);
    m_preview->appendMessage(msgHigh);
    m_preview->appendMessage(msgFTRequest);
    m_preview->appendMessage(msgFTRequestDisabled);
    m_preview->appendMessage(msgRightToLeft);
    m_preview->appendMessage(msgBye);
}

void ChatWindowConfig::slotUpdateChatPreview()
{
    if(m_loading || !m_currentStyle)
        return;

    // Update the preview
    m_preview->setStyle(m_currentStyle);

    emitChanged();
}


void ChatWindowConfig::updateEmoticonList()
{
    KStandardDirs dir;

    m_emoticonsUi.icon_theme_list->clear(); // Wipe out old list
    // Get a list of directories in our icon theme dir
    QStringList themeDirs = KGlobal::dirs()->findDirs("emoticons", "");
    // loop adding themes from all dirs into theme-list
    for( int x = 0;x < themeDirs.count();x++)
    {
        QDir themeQDir(themeDirs[x]);
        themeQDir.setFilter( QDir::Dirs ); // only scan for subdirs
        themeQDir.setSorting( QDir::Name ); // I guess name is as good as any
        for(unsigned int y = 0; y < themeQDir.count(); y++)
        {
            QStringList themes = themeQDir.entryList(QDir::Dirs, QDir::Name);

            // We don't care for '.' and '..'
            if ( themeQDir[y] != "." && themeQDir[y] != ".." )
            {
                // Add ourselves to the list, using our directory name  FIXME:  use the first emoticon of the theme.
                QListWidgetItem *item = new EmoticonThemeItem(themeQDir[y]);
                m_emoticonsUi.icon_theme_list->addItem(item);
            }
        }
    }

    // Where is that theme in our big-list-o-themes?

    QList<QListWidgetItem*> items = m_emoticonsUi.icon_theme_list->findItems( KEmoticons::currentThemeName(), Qt::MatchExactly );

    if (items.count()) // found it... make it the currently selected theme
        m_emoticonsUi.icon_theme_list->setCurrentItem( items.first() );
    else // Er, it's not there... select the current item
        m_emoticonsUi.icon_theme_list->setCurrentItem( 0 );
}


void ChatWindowConfig::slotManageEmoticonThemes()
{
    // FIXME: Upon closing the Settings KCMultiDialog all KCMs are deleted and when reopening
    // the settings dialog there is no active valid KComponentData, which KNS2 relies on.
    // Forcing an active one below works around bug 165919, but the problem is somewhere else.
    KGlobal::setActiveComponent(KopeteChatWindowConfigFactory::componentData());

    KCMultiDialog *kcm = new KCMultiDialog( this );
    kcm->setCaption( i18n( "Configure Emoticon Themes" ) );
    kcm->addModule( "emoticons" );
    kcm->exec();
    updateEmoticonList();
}


void ChatWindowConfig::emitChanged()
{
    emit changed( true );
}

#include "chatwindowconfig.moc"

kopete/kopete

Skip menu "kopete/kopete"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

kdenetwork

Skip menu "kdenetwork"

• kget
• kopete
•   kopete
•   libkopete
•       libpapillon
• krfb

Generated for kdenetwork by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal