kwin/effects/_test/kicker/kicker.cpp

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

 Copyright (C) 2010 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 "kicker.h"

#include <QtCore/QTimer>
#include <QtCore/QUrl>
#include <QtWebKit/QWebElement>
#include <QtWebKit/QWebElementCollection>
#include <QtWebKit/QWebFrame>
#include <QtWebKit/QWebPage>

namespace KWin
{

KWIN_EFFECT(kicker, KickerEffect)

KickerEffect::KickerEffect()
    : m_page(new QWebPage(this))
    , m_timer(new QTimer(this))
    , m_goalTimer(new QTimer(this))
    , m_goalActive(false)
    , m_ascending(false)
{
    connect(m_page, SIGNAL(loadFinished(bool)), this, SLOT(slotLoadFinished(bool)));
    connect(m_timer, SIGNAL(timeout()), this, SLOT(timeout()));
    connect(m_goalTimer, SIGNAL(timeout()), this, SLOT(goalTimeout()));

    reconfigure(ReconfigureAll);
    // reload the webpage each half a minute
    m_timer->start(30 * 1000);
    // goal animation should end after seven seconds
    m_goalTimer->setInterval(7 * 1000);
    m_goalTimer->setSingleShot(true);
    // the animations should have a duration of half a second with an
    // ease in out curve
    m_timeLine.setCurveShape(TimeLine::EaseInOutCurve);
    m_timeLine.setDuration(500);
    // let's download the webpage immediatelly
    timeout();
}

KickerEffect::~KickerEffect()
{
    while (!m_frames.isEmpty()) {
        delete m_frames.first();
        m_frames.removeFirst();
    }
    while (!m_goalFrames.isEmpty()) {
        delete m_goalFrames.first();
        m_goalFrames.removeFirst();
    }
}

void KickerEffect::reconfigure(ReconfigureFlags)
{
}

void KickerEffect::prePaintScreen(ScreenPrePaintData& data, int time)
{
    // the goal animation uses a KWin::TimeLine to modify the opacity values
    // as long as the goal timer has not timed out m_goalActive is true
    // after the timeout an animation might still be running, so we continue
    // till progress reaches 0.0 again
    if (m_goalActive ||  m_timeLine.progress() != 0.0) {
        // the animation might either be ascending (increasing opacity) or
        // descending (decreasing opacity). In case of ascending we add time
        // to the timeline till progress reaches 1.0. There we switch direction
        // to descending. In descending case of course vice versa.
        if (m_ascending) {
            m_timeLine.addTime(time);
            if (m_timeLine.progress() == 1.0) {
                m_ascending = false;
            }
        } else {
            m_timeLine.removeTime(time);
            // it is possible that this is the last animation. Therefore the
            // anding with goalActive. If it has been the last animation we
            // do not need to keep the goal EffectFrame around any more, so
            // we delete them.
            if (m_timeLine.progress() == 0.0 && m_goalActive) {
                m_ascending = true;
            } else if (m_timeLine.progress() == 0.0) {
                // goal animation finshed, let's delete the EffectFrames
                while (!m_goalFrames.isEmpty()) {
                    delete m_goalFrames.first();
                    m_goalFrames.removeFirst();
                }
                m_goalFrames.clear();
            }
        }
    }
    effects->prePaintScreen(data, time);
}

void KickerEffect::paintScreen(int mask, QRegion region, ScreenPaintData &data)
{
    effects->paintScreen(mask, region, data);

    if (m_size.isValid()) {
        // let's paint the score EffectFrame with unmodified opacity. As it
        // uses Plasma styled textures it's still translucent, but the text
        // is fully opaque.
        foreach (EffectFrame * frame, m_frames)
        frame->render(region, 1.0);
    }
    if (m_goalActive || m_timeLine.progress() != 0.0) {
        // the goal animation changes the opacity. Therefore we modify the
        // opacity by multiplying with the timeline's progress.
        // The text should be fully opaque (1.0), while the background should
        // be translucent (0.75)
        foreach (EffectFrame * frame, m_goalFrames)
        frame->render(region, 1.0 * m_timeLine.progress(), 0.75 * m_timeLine.progress());
        // we are animating: need a new frame
        effects->addRepaintFull();
    }
}

void KickerEffect::slotLoadFinished(bool ok)
{
    // if connection failed let's keep the last score
    if (!ok)
        return;

    QWebElement doc = m_page->mainFrame()->documentElement();
    // CSS selector for the teams
    QWebElementCollection teams = doc.findAll("td.lttabver h1 a");
    if (teams.count() != 2)
        return;
    QString firstTeam = teams[0].toPlainText();
    QString secondTeam = teams[1].toPlainText();

    // CSS selector for the current score
    QString result = doc.findFirst("td.lttaberg h1").toPlainText();
    if (m_score != result) {
        // the score changed, a goal might have been scored
        bool activate = true;
        // but not if the web page has been loaded for the first time
        if (m_score.isNull())
            activate = false;
        // not if we entered extra time
        if (!m_score.contains("i.V.") && result.contains("i.V."))
            activate = false;
        // not if extra time ended
        if (!m_score.contains("n.V.") && result.contains("n.V."))
            activate = false;
        // not if penality shootout begins
        if (!m_score.contains("i.E.") && result.contains("i.E."))
            activate = false;
        // not if first or second half starts.
        if (m_score.count('-') > result.count('-'))
            activate = false;
        // yeah it's a goal - generate the EffectFrame and start the animation
        if (activate) {
            generateGoalImage();
            m_goalActive = true;
            m_ascending = true;
            m_goalTimer->start();
        }
        m_score = result;
    }

    QString text = firstTeam + ' ' + result + ' ' + secondTeam;
    QFont font;
    font.setBold(true);
    QFontMetrics fm(font);
    m_size = fm.boundingRect(text).adjusted(-10, -10, 10, 10).size();
    // we don't want to reposition the EffectFrames, therefore we delete the
    // old ones. Normally you wouldn't do that, but as we only update once in
    // half a minute and it's easier to code...
    while (!m_frames.isEmpty()) {
        delete m_frames.first();
        m_frames.removeFirst();
    }
    m_frames.clear();
    // and properly position the frame on each screen
    for (int i = 0; i < effects->numScreens(); i++) {
        QRect area = effects->clientArea(ScreenArea, i, effects->currentDesktop());
        QRect geometry = QRect(area.x() + area.width() - m_size.width() - 20, area.y() + 20, m_size.width(), m_size.height());
        EffectFrame *frame = new EffectFrame(EffectFrame::Styled);
        frame->setText(text);
        frame->setFont(font);
        frame->setGeometry(geometry);
        m_frames.append(frame);
    }
    // effect frame changed and animation might have started - we need a full repaint
    effects->addRepaintFull();
}

void KickerEffect::timeout()
{
    // hard coded URL to the liveticker of the match Argentina vs Germany at World Cup 2010.
    // If this URL is not valid anymore you can find newer examples on the referrenced web site.
    m_page->mainFrame()->load(QUrl("http://www.kicker.de/news/fussball/wm/spielplan/weltmeisterschaft/2010/5/833353/livematch_argentinien_deutschland.html"));
}

void KickerEffect::generateGoalImage()
{
    QFont font("FreeMono", 172);
    QString goal("GOAL");
    QFontMetrics fm(font);
    QSize size = fm.boundingRect(goal).adjusted(-10, -10, 10, 10).size();
    for (int i = 0; i < effects->numScreens(); i++) {
        // place one frame on the center of each screen
        QRect area = effects->clientArea(ScreenArea, i, effects->currentDesktop());
        QRect geometry = QRect(area.x() + (area.width() - size.width()) / 2,
                               area.y() + (area.height() - size.height()) / 2,
                               size.width(), size.height());
        EffectFrame *frame = new EffectFrame(EffectFrame::Unstyled, false);
        frame->setText(goal);
        frame->setFont(font);
        frame->setGeometry(geometry);
        m_goalFrames.append(frame);
    }
}

void KickerEffect::goalTimeout()
{
    // stop the animation
    m_goalActive = false;
    effects->addRepaintFull();
}

} // namespace