• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdenetwork

• Sitemap
• Contact Us

 

kopete/kopete

chatview.cpp

Go to the documentation of this file.

/*
    chatview.cpp - Chat View

    Copyright (c) 2002-2004 by Olivier Goffart       <ogoffart@kde.org>
    Copyright (c) 2002-2003 by Martijn Klingens      <klingens@kde.org>

    Kopete    (c) 2002-2004 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 "chatview.h"

#include "chatmessagepart.h"
#include "chattexteditpart.h"
#include "kopetechatwindow.h"
#include "kopetechatsession.h"
#include "kopetemetacontact.h"
#include "kopetepluginmanager.h"
#include "kopeteprotocol.h"
#include "kopeteaccount.h"
#include "kopeteglobal.h"
#include "kopetecontactlist.h"
#include "kopeteviewmanager.h"
#include "kopetebehaviorsettings.h"

#include <kconfig.h>
#include <ktabwidget.h>
#include <kdebug.h>
#include <klocale.h>
#include <kmessagebox.h>
#include <kmenu.h>
#include <kstringhandler.h>
#include <kwindowsystem.h>
#include <kglobalsettings.h>
#include <kgenericfactory.h>
#include <khtmlview.h>

#include <QTimer>
#include <QSplitter>
#include <Q3UriDrag>

K_PLUGIN_FACTORY( ChatWindowPluginFactory, registerPlugin<ChatWindowPlugin>(); )
K_EXPORT_PLUGIN( ChatWindowPluginFactory( "kopete_chatwindow" ) )

ChatWindowPlugin::ChatWindowPlugin(QObject *parent, const QVariantList &) :
    Kopete::ViewPlugin( ChatWindowPluginFactory::componentData(), parent )
{}

KopeteView* ChatWindowPlugin::createView( Kopete::ChatSession *manager )
{
    return new ChatView(manager,this);
}

class KopeteChatViewPrivate
{
public:
    QString captionText;
    QString statusText;
    bool isActive;
    bool sendInProgress;
    bool visibleMembers;
    QSplitter * splitter;
};

ChatView::ChatView( Kopete::ChatSession *mgr, ChatWindowPlugin *parent )
     : KVBox( 0l ), KopeteView( mgr, parent )
         , d(new KopeteChatViewPrivate)
{
    int i;

    d->isActive = false;
    d->visibleMembers = false;
    d->sendInProgress = false;

    KVBox *vbox=this;

    m_mainWindow = 0L;
    m_tabState = Normal;


    //FIXME: don't widgets start off hidden anyway?
    hide();

    d->splitter = new QSplitter( Qt::Vertical, vbox );

    //Create the view dock widget (KHTML Part), and set it to no docking (lock it in place)
    m_messagePart = new ChatMessagePart( mgr , this );

    //Create the bottom dock widget, with the edit area, statusbar and send button
    m_editPart = new ChatTextEditPart( mgr, vbox );

    d->splitter->addWidget(m_messagePart->view());
    d->splitter->addWidget(m_editPart->widget());
    d->splitter->setChildrenCollapsible( false );
    QList<int> sizes;
    sizes << 240 << 40;
    d->splitter->setSizes( sizes );

    // FIXME: is this used these days? it seems totally unnecessary
    connect( editPart(), SIGNAL( toolbarToggled(bool)), this, SLOT(slotToggleRtfToolbar(bool)) );

    connect( editPart(), SIGNAL( messageSent( Kopete::Message & ) ),
             this, SIGNAL( messageSent( Kopete::Message & ) ) );
    connect( editPart(), SIGNAL( canSendChanged( bool ) ),
             this, SIGNAL( canSendChanged(bool) ) );
    connect( editPart(), SIGNAL( typing(bool) ),
         mgr, SLOT( typing(bool) ) );

    //Set the view as the main widget
//  setView(viewDock);

    //It is possible to drag and drop on this widget.
    // I had to disable the acceptDrop in the khtml widget to be able to intercept theses events.
    setAcceptDrops(true);
//  viewDock->setAcceptDrops(false);

    //Manager signals
    connect( mgr, SIGNAL( displayNameChanged() ),
             this, SLOT( slotChatDisplayNameChanged() ) );
    connect( mgr, SIGNAL( contactAdded(const Kopete::Contact*, bool) ),
             this, SLOT( slotContactAdded(const Kopete::Contact*, bool) ) );
    connect( mgr, SIGNAL( contactRemoved(const Kopete::Contact*, const QString&, Qt::TextFormat, bool) ),
             this, SLOT( slotContactRemoved(const Kopete::Contact*, const QString&, Qt::TextFormat, bool) ) );
    connect( mgr, SIGNAL( onlineStatusChanged( Kopete::Contact *, const Kopete::OnlineStatus & , const Kopete::OnlineStatus &) ),
             this, SLOT( slotContactStatusChanged( Kopete::Contact *, const Kopete::OnlineStatus &, const Kopete::OnlineStatus & ) ) );
    connect( mgr, SIGNAL( remoteTyping( const Kopete::Contact *, bool) ),
         this, SLOT( remoteTyping(const Kopete::Contact *, bool) ) );
    connect( mgr, SIGNAL( eventNotification( const QString& ) ),
         this, SLOT( setStatusText( const QString& ) ) );

    //Connections to the manager and the ViewManager that every view should have
    connect( this, SIGNAL( closing( KopeteView * ) ),
         KopeteViewManager::viewManager(), SLOT( slotViewDestroyed( KopeteView * ) ) );
    connect( this, SIGNAL( activated( KopeteView * ) ),
         KopeteViewManager::viewManager(), SLOT( slotViewActivated( KopeteView * ) ) );
    connect( this, SIGNAL( messageSent(Kopete::Message &) ),
         mgr, SLOT( sendMessage(Kopete::Message &) ) );
    connect( mgr, SIGNAL( messageSuccess() ),
         this, SLOT( messageSentSuccessfully() ));

    // add contacts
    slotContactAdded( mgr->myself(), true );
    for ( i = 0; i != mgr->members().size(); i++ )
    {
        slotContactAdded( mgr->members()[i], true );
    }

    setFocusProxy( editPart()->widget() );
    m_messagePart->widget()->setFocusProxy( editPart()->widget() );
    editPart()->widget()->setFocus();

    slotChatDisplayNameChanged();

    // restore docking positions
    readOptions();
}

ChatView::~ChatView()
{
    emit( closing( static_cast<KopeteView*>(this) ) );

    saveOptions();

    delete d;
}

KTextEdit *ChatView::editWidget()
{
    return editPart()->textEdit();
}

QWidget *ChatView::mainWidget()
{
    return this;
}

bool ChatView::canSend()
{
    return editPart()->canSend();
}

Kopete::Message ChatView::currentMessage()
{
    return editPart()->contents();
}

void ChatView::setCurrentMessage( const Kopete::Message &message )
{
    editPart()->setContents( message );
}

void ChatView::cut()
{
    editPart()->textEdit()->cut();
}

void ChatView::copy()
{
    if ( messagePart()->hasSelection() )
        messagePart()->copy();
    else
        editPart()->textEdit()->copy();
}

void ChatView::paste()
{
    editPart()->textEdit()->paste();
}

void ChatView::nickComplete()
{
    return editPart()->complete();
}

void ChatView::addText( const QString &text )
{
    editPart()->addText( text );
}

void ChatView::clear()
{
    messagePart()->clear();
}

void ChatView::setBgColor( const QColor &newColor )
{
    Q_UNUSED(newColor);
//  editPart()->setBackgroundColorColor( newColor );
}

void ChatView::setFont()
{
    editPart()->setFont();
}

QFont ChatView::font()
{
    return editPart()->font();
}

void ChatView::setFont( const QFont &font )
{
    editPart()->setFont( font );
}

void ChatView::setFgColor( const QColor &newColor )
{
    if ( newColor.isValid() )
    {
        editPart()->setTextColor( newColor );
    }
    else
    {
        editPart()->setTextColor();
    }
}

void ChatView::raise( bool activate )
{
    // this shouldn't change the focus. When the window is raised when a new message arrives
    // if i am coding, or talking to someone else, i want to end my sentence before switching to
    // the other chat. i just want to KNOW and SEE the other chat to switch to it later
    // (except if activate==true)

    if ( !m_mainWindow || !m_mainWindow->isActiveWindow() || activate )
        makeVisible();
#ifdef Q_WS_X11
    if ( !KWindowSystem::windowInfo( m_mainWindow->winId(), NET::WMDesktop ).onAllDesktops() )
        if( Kopete::BehaviorSettings::self()->trayflashNotifySetCurrentDesktopToChatView() && activate )
            KWindowSystem::setCurrentDesktop( KWindowSystem::windowInfo( m_mainWindow->winId(), NET::WMDesktop ).desktop() );
        else
            KWindowSystem::setOnDesktop( m_mainWindow->winId(), KWindowSystem::currentDesktop() );
#endif
    if(m_mainWindow->isMinimized())
    {
        KWindowSystem::unminimizeWindow( m_mainWindow->winId());
    }


    m_mainWindow->raise();

    //Will not activate window if user was typing
    if ( activate )
        KWindowSystem::activateWindow( m_mainWindow->winId() );

}

void ChatView::makeVisible()
{
    if ( !m_mainWindow )
    {
        m_mainWindow = KopeteChatWindow::window( m_manager );
        m_mainWindow->setObjectName( QLatin1String("KopeteChatWindow") );
//      if ( root )
//          root->repaint( true );
        emit windowCreated();
    }

    if ( !m_mainWindow->isVisible() )
    {
        m_mainWindow->show();
        // scroll down post show and layout, otherwise the geometry is wrong to scroll to the bottom.
        m_messagePart->keepScrolledDown();
    }



    m_mainWindow->setActiveView( this );
}

bool ChatView::isVisible()
{
    return ( m_mainWindow && m_mainWindow->isVisible() );
}

bool ChatView::sendInProgress()
{
    return d->sendInProgress;
}

bool ChatView::closeView( bool force )
{
    int response = KMessageBox::Continue;

    if ( !force )
    {
        if ( m_manager->members().count() > 1 )
        {
            QString shortCaption = d->captionText;
            shortCaption = KStringHandler::rsqueeze( shortCaption );

            response = KMessageBox::warningContinueCancel( this, i18n("<qt>You are about to leave the groupchat session <b>%1</b>.<br />"
                "You will not receive future messages from this conversation.</qt>", shortCaption ), i18n( "Closing Group Chat" ),
                KGuiItem( i18nc( "@action:button", "Close Chat" ) ), KStandardGuiItem::cancel(), QLatin1String( "AskCloseGroupChat" ) );
        }

        if ( !unreadMessageFrom.isNull() && ( response == KMessageBox::Continue ) )
        {
            response = KMessageBox::warningContinueCancel( this, i18n("<qt>You have received a message from <b>%1</b> in the last "
                "second. Are you sure you want to close this chat?</qt>", unreadMessageFrom ), i18n( "Unread Message" ),
                KGuiItem( i18nc( "@action:button", "Close Chat" ) ), KStandardGuiItem::cancel(), QLatin1String("AskCloseChatRecentMessage" ) );
        }

        if ( d->sendInProgress && ( response == KMessageBox::Continue ) )
        {
            response = KMessageBox::warningContinueCancel( this, i18n( "You have a message send in progress, which will be "
                "aborted if this chat is closed. Are you sure you want to close this chat?" ), i18n( "Message in Transit" ),
                KGuiItem( i18nc( "@action:button", "Close Chat" ) ), KStandardGuiItem::cancel(), QLatin1String( "AskCloseChatMessageInProgress" ) );
        }
    }

    if( response == KMessageBox::Continue )
    {
        // Remove the widget from the window it's attached to
        // and schedule it for deletion
        if( m_mainWindow )
            m_mainWindow->detachChatView( this );
        deleteLater();

        return true;
    }

    return false;
}

ChatView::KopeteTabState ChatView::tabState() const
{
    return m_tabState;
}

void ChatView::updateChatState( KopeteTabState newState )
{
    if ( newState == Undefined )
        newState = m_tabState;
    else if ( newState != Typing && ( newState != Changed || ( m_tabState != Message && m_tabState != Highlighted ) )
        && ( newState != Message ||  m_tabState != Highlighted ) )
    { //if the new state is not a typing state and we don't already have a message or a highlighted message
      //change the tab state
        m_tabState = newState;
    }

    newState = m_remoteTypingMap.isEmpty() ? m_tabState : Typing ;

    emit updateChatState( this, newState );

    if( newState != Typing )
    {
        setStatusText( i18np( "One other person in the chat",
                   "%1 other people in the chat", m_manager->members().count() ) );
    }
}

void ChatView::setMainWindow( KopeteChatWindow* parent )
{
    m_mainWindow = parent;
}

void ChatView::remoteTyping( const Kopete::Contact *contact, bool isTyping )
{
    TypingMap::iterator it = m_remoteTypingMap.find(contact);
    if (it != m_remoteTypingMap.end())
    {
        if (it.value()->isActive())
            it.value()->stop();
        delete it.value();
        m_remoteTypingMap.erase(it);
    }
    if( isTyping )
    {
        m_remoteTypingMap.insert( contact, new QTimer(this) );
        connect( m_remoteTypingMap[ contact ], SIGNAL( timeout() ), SLOT( slotRemoteTypingTimeout() ) );

        m_remoteTypingMap[ contact ]->setSingleShot( true );
        m_remoteTypingMap[ contact ]->start( 6000 );
    }

    // Loop through the map, constructing a string of people typing
    QStringList typingList;

    for( it = m_remoteTypingMap.begin(); it != m_remoteTypingMap.end(); ++it )
    {
        const Kopete::Contact *c = it.key();
        typingList.append( m_messagePart->formatName(c, Qt::PlainText) );
    }

    // Update the status area
    if( !typingList.isEmpty() )
    {
        if ( typingList.count() == 1 )
            setStatusText( i18n( "%1 is typing a message", typingList.first() ) );
        else
        {
            QString statusTyping = typingList.join( QLatin1String( ", " ) );
            setStatusText( i18nc( "%1 is a list of names", "%1 are typing a message", statusTyping ) );
        }
        updateChatState( Typing );
    }
    else
    {
        updateChatState();
    }
}

void ChatView::setStatusText( const QString &status )
{
    d->statusText = status;
    if ( d->isActive )
        m_mainWindow->setStatus( status );
}

const QString& ChatView::statusText()
{
    return d->statusText;
}

void ChatView::slotChatDisplayNameChanged()
{
    // This fires whenever a contact or MC changes displayName, so only
    // update the caption if it changed to avoid unneeded updates that
    // could cause flickering
    QString chatName = m_manager->displayName();

    foreach (const Kopete::Contact *c, msgManager()->members())
    {
        QString contactName = m_messagePart->formatName(c, Qt::PlainText);
        if ( c->metaContact() )
        {
            chatName.replace( c->metaContact()->displayName(), contactName );
        }
        else
        {
            chatName.replace( c->nickName(), contactName );
        }
    }


    if ( chatName != d->captionText )
        setCaption( chatName, true );
}

void ChatView::slotPropertyChanged( Kopete::PropertyContainer*, const QString &key,
        const QVariant& oldValue, const QVariant &newValue  )
{
    if ( key == Kopete::Global::Properties::self()->nickName().key() )
    {
        QString newName=newValue.toString();
        QString oldName=oldValue.toString();

        if(Kopete::BehaviorSettings::self()->showEvents())
            if ( oldName != newName && !oldName.isEmpty())
                sendInternalMessage( i18n( "%1 is now known as %2", oldName, newName ) );
    }
}

void ChatView::slotDisplayNameChanged( const QString &oldValue, const QString &newValue )
{
    if( Kopete::BehaviorSettings::self()->showEvents() )
    {
        if( oldValue != newValue )
            sendInternalMessage( i18n( "%1 is now known as %2", oldValue, newValue ) );
    }
}

void ChatView::slotContactAdded(const Kopete::Contact *contact, bool suppress)
{
    if( contact->metaContact() && contact->metaContact() != Kopete::ContactList::self()->myself() )
    {
        connect( contact->metaContact(), SIGNAL( displayNameChanged(const QString&, const QString&) ),
            this, SLOT( slotDisplayNameChanged(const QString &, const QString &) ) );
    }
    else
    {
        connect( contact, SIGNAL( propertyChanged( Kopete::PropertyContainer *, const QString &, const QVariant &, const QVariant & ) ),
        this, SLOT( slotPropertyChanged( Kopete::PropertyContainer *, const QString &, const QVariant &, const QVariant & ) ) ) ;
    }

    QString contactName = m_messagePart->formatName(contact, Qt::PlainText);
    if( !suppress && m_manager->members().count() > 1 )
        sendInternalMessage(  i18n("%1 has joined the chat.", contactName) );

    updateChatState();
    emit updateStatusIcon( this );
}

void ChatView::slotContactRemoved( const Kopete::Contact *contact, const QString &reason, Qt::TextFormat format, bool suppressNotification )
{
//  kDebug(14000) ;
    if ( contact != m_manager->myself() )
    {
        TypingMap::iterator it = m_remoteTypingMap.find( contact );
        if ( it != m_remoteTypingMap.end() )
        {
            if ((*it)->isActive())
                (*it)->stop();
            delete (*it);
            m_remoteTypingMap.remove( contact );
        }

        // When the last person leaves, don't disconnect the signals, since we're in a one-to-one chat
        if ( m_manager->members().count() > 0 )
        {
            if( contact->metaContact() )
            {
                disconnect( contact->metaContact(), SIGNAL( displayNameChanged(const QString&, const QString&) ),
                this, SLOT( slotDisplayNameChanged(const QString&, const QString&) ) );
            }
            else
            {
                disconnect(contact,SIGNAL(propertyChanged( Kopete::PropertyContainer *, const QString &, const QVariant &, const QVariant & )),
                this, SLOT( slotPropertyChanged( Kopete::PropertyContainer *, const QString &, const QVariant &, const QVariant & ) ) ) ;
            }
        }

        if ( !suppressNotification )
        {
            QString contactName = m_messagePart->formatName(contact, Qt::PlainText);
            if ( reason.isEmpty() )
                sendInternalMessage( i18n( "%1 has left the chat.", contactName ), format ) ;
            else
                sendInternalMessage( i18n( "%1 has left the chat (%2).", contactName, reason ), format);
        }
    }

    updateChatState();
    emit updateStatusIcon( this );
}

QString& ChatView::caption() const
{
     return d->captionText;
}

void ChatView::setCaption( const QString &text, bool modified )
{
//  kDebug(14000) ;
    QString newCaption = text;

    //Save this caption
    d->captionText = text;

    //Turncate if needed
    newCaption = KStringHandler::rsqueeze( d->captionText, 20 );

    //Call the original set caption
    QWidget::setWindowTitle( newCaption );

    emit updateChatTooltip( this, QString::fromLatin1("<qt>%1</qt>").arg( d->captionText ) );
    emit updateChatLabel( this, newCaption );
    //Blink icon if modified and not active
    if( !d->isActive && modified )
        updateChatState( Changed );
    else
        updateChatState();

    //Tell the parent we changed our caption
    emit( captionChanged( d->isActive ) );
}

void ChatView::appendMessage(Kopete::Message &message)
{
    remoteTyping( message.from(), false );

    messagePart()->appendMessage(message);

    if( !d->isActive )
    {
        switch ( message.importance() )
        {
            case Kopete::Message::Highlight:
                updateChatState( Highlighted );
                break;
            case Kopete::Message::Normal:
                if ( message.direction() == Kopete::Message::Inbound )
                {
                    updateChatState( Message );
                    break;
                } // if it's an enternal message or a outgoing, fall thought
            default:
                updateChatState( Changed );
        }
    }

    if( message.direction() == Kopete::Message::Inbound )
    {
        unreadMessageFrom = m_messagePart->formatName ( message.from(), Qt::PlainText );
        QTimer::singleShot( 1000, this, SLOT( slotMarkMessageRead() ) );
    }
    else
        unreadMessageFrom.clear();
}

void ChatView::slotMarkMessageRead()
{
    unreadMessageFrom.clear();
}

void ChatView::slotToggleRtfToolbar( bool enabled )
{
    emit rtfEnabled( this, enabled );
}

void ChatView::slotContactStatusChanged( Kopete::Contact *contact, const Kopete::OnlineStatus &newStatus, const Kopete::OnlineStatus &oldStatus )
{
    kDebug(14000) << contact;
    bool inhibitNotification = ( newStatus.status() == Kopete::OnlineStatus::Unknown ||
                                 oldStatus.status() == Kopete::OnlineStatus::Unknown );
    if ( contact && Kopete::BehaviorSettings::self()->showEvents() && !inhibitNotification )
    {
        if ( contact->account() && contact == contact->account()->myself() )
        {
            // Separate notification for the 'self' contact
            if ( newStatus.status() != Kopete::OnlineStatus::Connecting )
                sendInternalMessage( i18n( "You are now marked as %1.", newStatus.description() ) );
        }
        else if ( !contact->account() || !contact->account()->suppressStatusNotification() )
        {
            QString contactName = m_messagePart->formatName(contact, Qt::PlainText);
            sendInternalMessage( i18n( "%2 is now %1.",
                newStatus.description(), contactName ) );
        }
    }

    // update the windows caption
    slotChatDisplayNameChanged();
    emit updateStatusIcon( this );
}

void ChatView::sendInternalMessage(const QString &msg, Qt::TextFormat format )
{
    // When closing kopete, some internal message may be sent because some contact are deleted
    // these contacts can already be deleted
    Kopete::Message message = Kopete::Message();
    message.setDirection( Kopete::Message::Internal );
    switch(format)
    {
        default:
        case Qt::PlainText:
            message.setPlainBody( msg );
            break;
        case Qt::RichText:
            message.setHtmlBody( msg );
            break;
    }

    // (in many case, this is useless to set myself as contact)
    // TODO: set the contact which initiate the internal message,
    // so we can later show a icon of it (for example, when he join a chat)
    messagePart()->appendMessage( message );
}

void ChatView::sendMessage()
{
    d->sendInProgress = true;
    editPart()->sendMessage();
}

void ChatView::messageSentSuccessfully()
{
    d->sendInProgress = false;
    emit messageSuccess( this );
}

void ChatView::saveOptions()
{
    KSharedConfig::Ptr config = KGlobal::config();
    KConfigGroup kopeteChatWindowMainWinSettings( config, ( msgManager()->form() == Kopete::ChatSession::Chatroom ? QLatin1String( "KopeteChatWindowGroupMode" ) : QLatin1String( "KopeteChatWindowIndividualMode" ) ) );
    kopeteChatWindowMainWinSettings.writeEntry( QLatin1String("ChatViewSplitter"), d->splitter->saveState().toBase64() );
    saveChatSettings();
    config->sync();
}

void ChatView::saveChatSettings()
{
    Kopete::ContactPtrList contacts = msgManager()->members();

    if ( contacts.count() == 0 )
        return;

    Kopete::MetaContact* mc = contacts.first()->metaContact();

    if ( contacts.count() > 1 )
        return; //can't save with more than one person in chatview

    if ( !mc )
        return;

    QString contactListGroup = QLatin1String("chatwindow_") +
                               mc->metaContactId();
    KConfigGroup config = KGlobal::config()->group(contactListGroup);
    config.writeEntry( "EnableRichText", editPart()->isRichTextEnabled() );
    config.writeEntry( "EnableAutoSpellCheck", editPart()->checkSpellingEnabled() );
    config.sync();
}

void ChatView::loadChatSettings()
{
    Kopete::ContactPtrList contacts = msgManager()->members();
    if ( contacts.count() > 1 )
        return; //can't load with more than one other person in the chat

    //read settings for metacontact
    QString contactListGroup = QLatin1String("chatwindow_") +
                               contacts.first()->metaContact()->metaContactId();
    KConfigGroup config(KGlobal::config(), contactListGroup );
    bool enableRichText = config.readEntry( "EnableRichText", true );
    editPart()->setRichTextEnabled( enableRichText );
    emit rtfEnabled( this, editPart()->isRichTextEnabled() );
    bool enableAutoSpell = config.readEntry( "EnableAutoSpellCheck", Kopete::BehaviorSettings::self()->spellCheck() );
    emit autoSpellCheckEnabled( this, enableAutoSpell );
}

void ChatView::readOptions()
{
    KConfigGroup kopeteChatWindowMainWinSettings( KGlobal::config(), ( msgManager()->form() == Kopete::ChatSession::Chatroom ? QLatin1String( "KopeteChatWindowGroupMode" ) : QLatin1String( "KopeteChatWindowIndividualMode" ) ) );
    //kDebug(14000) << "reading splitterpos from key: " << dockKey;
    QByteArray state;
    state = kopeteChatWindowMainWinSettings.readEntry( QLatin1String("ChatViewSplitter"), state );
    d->splitter->restoreState( QByteArray::fromBase64( state ) );
}

void ChatView::setActive( bool value )
{
    d->isActive = value;
    if ( d->isActive )
    {
        updateChatState( Normal );
        emit( activated( static_cast<KopeteView*>(this) ) );
    }
}

void ChatView::slotRemoteTypingTimeout()
{
    // Remove the topmost timer from the list. Why does QPtrDict use void* keys and not typed keys? *sigh*
    // FIXME: should remove the right item, not the topmost
    if ( !m_remoteTypingMap.isEmpty() )
        remoteTyping( m_remoteTypingMap.begin().key(), false );
}

void ChatView::dragEnterEvent ( QDragEnterEvent * event )
{
    if( event->provides( "kopete/x-contact" ) )
    {
        QStringList lst = QString::fromUtf8(event->encodedData ( "kopete/x-contact" )).split( QChar( 0xE000 ) , QString::SkipEmptyParts );
        if(m_manager->mayInvite() && m_manager->protocol()->pluginId() == lst[0] && m_manager->account()->accountId() == lst[1])
        {
            QString contact=lst[2];

            bool found =false;
            foreach(Kopete::Contact * cts, m_manager->members())
            {
                if(cts->contactId() == contact)
                {
                    found=true;
                    break;
                }
            }

            if(!found && contact != m_manager->myself()->contactId())
                event->accept();
        }
    }
    else if( event->provides( "kopete/x-metacontact" ) )
    {
        QString metacontactID=QString::fromUtf8(event->encodedData ( "kopete/x-metacontact" ));
        Kopete::MetaContact *parent = Kopete::ContactList::self()->metaContact(metacontactID);
        if ( parent && m_manager->mayInvite() )
        {
            foreach ( Kopete::Contact * candidate, parent->contacts() )
            {
                if( candidate && candidate->account() == m_manager->account() && candidate->isOnline())
                {
                    if( candidate != m_manager->myself() &&  !m_manager->members().contains( candidate ) )
                        event->accept();
                }
            }
        }
    }
    // make sure it doesn't come from the current chat view - then it's an emoticon
    else if ( event->provides( "text/uri-list" ) && m_manager->members().count() == 1 &&
                 ( event->source() != (QWidget*)m_messagePart->view()->viewport() ) )
    {
        Kopete::ContactPtrList members = m_manager->members();
        Kopete::Contact *contact = members.first();
        if ( contact && contact->canAcceptFiles() )
            event->accept();
    }
    else
        QWidget::dragEnterEvent(event);
}

void ChatView::dropEvent ( QDropEvent * event )
{
    Kopete::ContactPtrList contacts;

    if( event->provides( "kopete/x-contact" ) )
    {
        QStringList lst = QString::fromUtf8(event->encodedData ( "kopete/x-contact" )).split( QChar( 0xE000 ) , QString::SkipEmptyParts );
        if(m_manager->mayInvite() && m_manager->protocol()->pluginId() == lst[0] && m_manager->account()->accountId() == lst[1])
        {
            QString contact=lst[2];

            bool found =false;
            foreach ( Kopete::Contact * candidate, m_manager->members() )
            {
                if(candidate->contactId() == contact)
                {
                    found=true;
                    break;
                }
            }
            if(!found && contact != m_manager->myself()->contactId())
                m_manager->inviteContact(contact);
        }
    }
    else if( event->provides( "kopete/x-metacontact" ) )
    {
        QString metacontactID=QString::fromUtf8(event->encodedData ( "kopete/x-metacontact" ));
        Kopete::MetaContact *parent = Kopete::ContactList::self()->metaContact(metacontactID);
        if ( parent && m_manager->mayInvite() )
        {
            foreach ( Kopete::Contact * candidate, parent->contacts() )
            {
                if( candidate && candidate->account() == m_manager->account() && candidate->isOnline())
                {
                    if( candidate != m_manager->myself() &&  !m_manager->members().contains( candidate ) )
                        m_manager->inviteContact(candidate->contactId());
                }
            }
        }
    }
    else if ( event->provides( "text/uri-list" ) && m_manager->members().count() == 1 )
    {
        Kopete::ContactPtrList members = m_manager->members();
        Kopete::Contact *contact = members.first();

        if ( !contact || !contact->canAcceptFiles() || !Q3UriDrag::canDecode( event ) )
        {
            event->ignore();
            return;
        }

        KUrl::List urlList = KUrl::List::fromMimeData( event->mimeData() );

        for ( KUrl::List::Iterator it = urlList.begin(); it != urlList.end(); ++it )
        {
            if ( (*it).isLocalFile() )
            { //send a file
                contact->sendFile( *it );
            }
            else
            { //this is a URL, send the URL in a message
                addText( (*it).url() );
            }
        }
        event->accept();
        return;
    }
    else
        QWidget::dropEvent(event);

}

void ChatView::registerContextMenuHandler( QObject *target, const char* slot )
{
    connect( m_messagePart,
        SIGNAL( contextMenuEvent( Kopete::Message &, const QString &, KMenu * ) ),
        target,
        slot
    );
}

void ChatView::registerTooltipHandler( QObject *target, const char* slot )
{
    connect( m_messagePart,
        SIGNAL( tooltipEvent( Kopete::Message &, const QString &, QString & ) ),
        target,
        slot
    );
}

#include "chatview.moc"

// vim: set noet ts=4 sts=4 sw=4:

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