kwin/kcmkwin/kwintabbox/previewhandlerimpl.cpp

/********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.

Copyright (C) 2009 Martin Gräßlin <kde@martin-graesslin.com>

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, see <http://www.gnu.org/licenses/>.
*********************************************************************/

#include "previewhandlerimpl.h"
#include <kephal/screens.h>
#include <klocalizedstring.h>
#include <kwindowsystem.h>
#include <KDebug>

namespace KWin
{
namespace TabBox
{

PreviewClientImpl::PreviewClientImpl(WId id)
    : m_id( id )
    {
    }

PreviewClientImpl::~PreviewClientImpl()
    {
    }

QString PreviewClientImpl::caption() const
    {
    KWindowInfo info = KWindowSystem::windowInfo( m_id, NET::WMVisibleName );
    return info.visibleName();
    }

QPixmap PreviewClientImpl::icon( const QSize& size ) const
    {
    return KWindowSystem::icon( m_id, size.width(), size.height(), true );
    }

bool PreviewClientImpl::isMinimized() const
    {
    KWindowInfo info = KWindowSystem::windowInfo( m_id, NET::WMState | NET::XAWMState );
    return info.isMinimized();
    }

int PreviewClientImpl::width() const
    {
    return 0; // only needed for the outline - not needed in preview
    }

int PreviewClientImpl::height() const
    {
    return 0; // only needed for the outline - not needed in preview
    }

WId PreviewClientImpl::window() const
    {
    return m_id;
    }

int PreviewClientImpl::x() const
    {
    return 0; // only needed for the outline - not needed in preview
    }

int PreviewClientImpl::y() const
    {
    return 0; // only needed for the outline - not needed in preview
    }

/*******************************************************
* PreviewHandlerImpl
*******************************************************/
PreviewHandlerImpl::PreviewHandlerImpl()
    {
    QList< WId > windows = KWindowSystem::stackingOrder();
    foreach( WId w, windows )
        {
        m_stackingOrder.append( new PreviewClientImpl( w ) );
        kDebug( 1212 ) << "Window " << w;
        }
    }

PreviewHandlerImpl::~PreviewHandlerImpl()
    {
    qDeleteAll( m_stackingOrder.begin(), m_stackingOrder.end() );
    m_stackingOrder.clear();
    }

TabBoxClient* PreviewHandlerImpl::clientToAddToList( TabBoxClient* client, int desktop, bool allDesktops ) const
    {
    Q_UNUSED( desktop )
    Q_UNUSED( allDesktops )
    // don't include desktops and panels
    KWindowInfo info = KWindowSystem::windowInfo( client->window(), NET::WMWindowType );
    NET::WindowType wType = info.windowType(NET::NormalMask | NET::DesktopMask | NET::DockMask |
                                            NET::ToolbarMask | NET::MenuMask | NET::DialogMask |
                                            NET::OverrideMask | NET::TopMenuMask |
                                            NET::UtilityMask | NET::SplashMask);

    if (wType != NET::Normal && wType != NET::Override && wType != NET::Unknown &&
        wType != NET::Dialog && wType != NET::Utility)
        {
        return NULL;
        }
    return client;
    }

TabBoxClientList PreviewHandlerImpl::stackingOrder() const
    {
    return m_stackingOrder;
    }

int PreviewHandlerImpl::nextDesktopFocusChain( int desktop ) const
    {
    int ret = desktop + 1;
    if( ret > numberOfDesktops() )
        ret = 1;
    return ret;
    }

int PreviewHandlerImpl::numberOfDesktops() const
    {
    return KWindowSystem::numberOfDesktops();
    }

int PreviewHandlerImpl::currentDesktop() const
    {
    return KWindowSystem::currentDesktop();
    }

QString PreviewHandlerImpl::desktopName( int desktop ) const
    {
    return KWindowSystem::desktopName( desktop );
    }

QString PreviewHandlerImpl::desktopName( TabBoxClient* client ) const
    {
    Q_UNUSED( client )
    return desktopName( 1 );
    }

TabBoxClient* PreviewHandlerImpl::nextClientFocusChain( TabBoxClient* client ) const
    {
    if( m_stackingOrder.isEmpty() )
        return NULL;
    int index = m_stackingOrder.indexOf( client );
    index++;
    if( index >= m_stackingOrder.count() )
        index = 0;
    return m_stackingOrder[ index ];
    }

KWin::TabBox::TabBoxClient* PreviewHandlerImpl::activeClient() const
    {
    if( m_stackingOrder.isEmpty() )
        return NULL;
    return m_stackingOrder[ 0 ];
    }

int PreviewHandlerImpl::activeScreen() const
    {
    return 0;
    }

TabBoxClient* PreviewHandlerImpl::desktopClient() const
    {
    return 0;
    }


} // namespace TabBox
} // namespace KWin