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

Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.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 "zoom.h"

#include <QtCore/QDir>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
#include <QtGui/QX11Info>
#include <QtGui/QApplication>
#include <QtGui/QStyle>
#include <QtDBus/QDBusConnection>
#include <kaction.h>
#include <kactioncollection.h>
#include <kstandardaction.h>

#include <kwinglutils.h>
#include <kwinxrenderutils.h>

#include <X11/extensions/Xfixes.h>
#include <X11/Xcursor/Xcursor.h>

#ifdef KWIN_HAVE_OPENGL_COMPOSITING
#include <GL/gl.h>
#endif

namespace KWin
{

static int nominalCursorSize(int iconSize)
    {
    for(int i = 512; i > 8; i /= 2)
        {
        if(i < iconSize)
            return i;
        if((i * .75) < iconSize)
            return int(i * .75);
        }
    return 8;
    }

KWIN_EFFECT( zoom, ZoomEffect )

ZoomEffect::ZoomEffect()
    : QObject()
    , Effect()
    , zoom( 1 )
    , target_zoom( 1 )
    , polling( false )
    , zoomFactor( 1.25 )
    , mouseTracking( MouseTrackingProportional )
    , enableFocusTracking( false )
    , followFocus( true )
    , mousePointer( MousePointerScale )
    , focusDelay( 350 ) // in milliseconds
    , texture( 0 )
    , xrenderPicture( 0 )
    , imageWidth( 0 )
    , imageHeight( 0 )
    , isMouseHidden( false )
    , xMove( 0 )
    , yMove( 0 )
    , moveFactor( 20.0 )
    {
    KActionCollection* actionCollection = new KActionCollection( this );
    KAction* a = 0;
    a = static_cast< KAction* >( actionCollection->addAction( KStandardAction::ZoomIn, this, SLOT( zoomIn())));
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Equal));
    a = static_cast< KAction* >( actionCollection->addAction( KStandardAction::ZoomOut, this, SLOT( zoomOut())));
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Minus));
    a = static_cast< KAction* >( actionCollection->addAction( KStandardAction::ActualSize, this, SLOT( actualSize())));
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_0));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveZoomLeft" ));
    a->setText( i18n("Move Left") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Left));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveZoomLeft() ));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveZoomRight" ));
    a->setText( i18n("Move Right") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Right));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveZoomRight() ));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveZoomUp" ));
    a->setText( i18n("Move Up") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Up));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveZoomUp() ));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveZoomDown" ));
    a->setText( i18n("Move Down") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_Down));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveZoomDown() ));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveMouseToFocus" ));
    a->setText( i18n("Move Mouse to Focus") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_F5));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveMouseToFocus() ));

    a = static_cast< KAction* >( actionCollection->addAction( "MoveMouseToCenter" ));
    a->setText( i18n("Move Mouse to Center") );
    a->setGlobalShortcut(KShortcut(Qt::META + Qt::Key_F6));
    connect( a, SIGNAL( triggered( bool )), this, SLOT( moveMouseToCenter() ));
    
    timeline.setDuration( 350 );
    timeline.setFrameRange( 0, 100 );
    connect(&timeline, SIGNAL(frameChanged(int)), this, SLOT(timelineFrameChanged(int)));

    reconfigure( ReconfigureAll );
    }

ZoomEffect::~ZoomEffect()
    {
    // switch off and free resources
    showCursor();
    }

void ZoomEffect::showCursor()
    {
#if defined(KWIN_HAVE_OPENGL_COMPOSITING) || defined(KWIN_HAVE_XRENDER_COMPOSITING)
    if( isMouseHidden )
        {
        // show the previously hidden mouse-pointer again and free the loaded texture/picture.
        Display* display = QX11Info::display();
        XFixesShowCursor(display, DefaultRootWindow(display));
        delete texture;
        texture = 0;
        delete xrenderPicture;
        xrenderPicture = 0;
        isMouseHidden = false;
        }
#endif
    }

void ZoomEffect::hideCursor()
    {
#if defined(KWIN_HAVE_OPENGL_COMPOSITING) || defined(KWIN_HAVE_XRENDER_COMPOSITING)
    if( !isMouseHidden )
        {
        // try to load the cursor-theme into a OpenGL texture and if successful then hide the mouse-pointer 
        recreateTexture();
        if( texture || xrenderPicture )
            {
            Display* display = QX11Info::display();
            XFixesHideCursor(display, DefaultRootWindow(display));
            isMouseHidden = true;
            }
        }
#endif
    }

void ZoomEffect::recreateTexture()
    {
    // read details about the mouse-cursor theme define per default
    KConfigGroup mousecfg(KSharedConfig::openConfig( "kcminputrc" ), "Mouse" );
    QString theme = mousecfg.readEntry("cursorTheme", QString());
    QString size  = mousecfg.readEntry("cursorSize", QString());

    // try to find the to the theme-name matching cursor-directory.
    QByteArray themePath;
    foreach (const QString &baseDir, QString(XcursorLibraryPath()).split(':', QString::SkipEmptyParts))
        {
        QDir dir(baseDir);
        if(!dir.exists()) continue;
        if(!theme.isEmpty() && dir.cd(theme))
            {
            themePath = QFile::encodeName(dir.absolutePath());
            break; // theme found, job is done and we can abort the search now
            }
        if(dir.cd("default")) // default is better then nothing, so keep it as backup
            themePath = QFile::encodeName(dir.absolutePath());
        }

    // fetch a reasonable size for the cursor-theme image
    bool ok;
    int iconSize = size.toInt(&ok);
    if(!ok)
        iconSize = QApplication::style()->pixelMetric(QStyle::PM_LargeIconSize);

    // load the cursor-theme image from the Xcursor-library
    XcursorImage *ximg = XcursorLibraryLoadImage("left_ptr", themePath, nominalCursorSize(iconSize));
    if (ximg)
        {
        // turn the XcursorImage into a QImage that will be used to create the GLTexture/XRenderPicture.
        imageWidth = ximg->width;
        imageHeight = ximg->height;
        QImage img((uchar*)ximg->pixels, imageWidth, imageHeight, QImage::Format_ARGB32_Premultiplied);
#ifdef KWIN_HAVE_OPENGL_COMPOSITING
        if( effects->compositingType() == OpenGLCompositing )
            texture = new GLTexture(img);
#endif
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
        if( effects->compositingType() == XRenderCompositing )
            xrenderPicture = new XRenderPicture(QPixmap::fromImage(img));
#endif
        XcursorImageDestroy(ximg);
        }
    }

void ZoomEffect::reconfigure( ReconfigureFlags )
    {
    KConfigGroup conf = EffectsHandler::effectConfig("Zoom");
    // On zoom-in and zoom-out change the zoom by the defined zoom-factor.
    zoomFactor = qMax(0.1, conf.readEntry("ZoomFactor", zoomFactor));
    // Visibility of the mouse-pointer.
    mousePointer = MousePointerType(conf.readEntry("MousePointer", int(mousePointer)));
    // Track moving of the mouse.
    mouseTracking = MouseTrackingType(conf.readEntry("MouseTracking", int(mouseTracking)));
    // Enable tracking of the focused location.
    bool _enableFocusTracking = conf.readEntry("EnableFocusTracking", enableFocusTracking);
    if(enableFocusTracking != _enableFocusTracking)
        {
        enableFocusTracking = _enableFocusTracking;
        if(QDBusConnection::sessionBus().isConnected())
            {
            if(enableFocusTracking)
                QDBusConnection::sessionBus().connect("org.kde.kaccessibleapp", "/Adaptor", "org.kde.kaccessibleapp.Adaptor", "focusChanged", this, SLOT(focusChanged(int,int,int,int,int,int)));
            else
                QDBusConnection::sessionBus().disconnect("org.kde.kaccessibleapp", "/Adaptor", "org.kde.kaccessibleapp.Adaptor", "focusChanged", this, SLOT(focusChanged(int,int,int,int,int,int)));
            }
        }
    // When the focus changes, move the zoom area to the focused location.
    followFocus = conf.readEntry("EnableFollowFocus", followFocus);
    // The time in milliseconds to wait before a focus-event takes away a mouse-move.
    focusDelay = qMax(0, conf.readEntry("FocusDelay", focusDelay));
    // The factor the zoom-area will be moved on touching an edge on push-mode or using the navigation KAction's.
    moveFactor = qMax(0.1, conf.readEntry("MoveFactor", moveFactor));
    }

void ZoomEffect::prePaintScreen( ScreenPrePaintData& data, int time )
    {
    if( zoom != target_zoom )
        {
        double diff = time / animationTime( 500.0 );
        if( target_zoom > zoom )
            zoom = qMin( zoom * qMax( 1 + diff, 1.2 ), target_zoom );
        else
            zoom = qMax( zoom * qMin( 1 - diff, 0.8 ), target_zoom );
        }

    if( zoom == 1.0 )
        {
        showCursor();
        }
    else
        {
        hideCursor();
        data.mask |= PAINT_SCREEN_TRANSFORMED;
        }

    effects->prePaintScreen( data, time );
    }

void ZoomEffect::paintScreen( int mask, QRegion region, ScreenPaintData& data )
    {
    if( zoom != 1.0 )
        {
        data.xScale *= zoom;
        data.yScale *= zoom;

        // mouse-tracking allows navigation of the zoom-area using the mouse.
        switch( mouseTracking )
            {
            case MouseTrackingProportional:
                data.xTranslate = - int( cursorPoint.x() * ( zoom - 1.0 ) );
                data.yTranslate = - int( cursorPoint.y() * ( zoom - 1.0 ) );
                prevPoint = cursorPoint;
                break;
            case MouseTrackingCentred:
                data.xTranslate = qMin(0, qMax( int(displayWidth() - displayWidth() * zoom), int( displayWidth()/2 - cursorPoint.x() * zoom )));
                data.yTranslate = qMin(0, qMax( int(displayHeight() - displayHeight() * zoom), int( displayHeight()/2 - cursorPoint.y() * zoom )));
                prevPoint = cursorPoint;
                break;
            case MouseTrackingPush:
                if( timeline.state() != QTimeLine::Running )
                    {
                    // touching an edge of the screen moves the zoom-area in that direction.
                    int x = cursorPoint.x() * zoom - prevPoint.x() * ( zoom - 1.0 );
                    int y = cursorPoint.y() * zoom - prevPoint.y() * ( zoom - 1.0 );
                    int threshold = 1; //qMax(1, int(10.0 / zoom));
                    xMove = yMove = 0;
                    if( x < threshold )
                        xMove = - qMax(1.0, displayWidth() / zoom / moveFactor);
                    else if( x + threshold > displayWidth() )
                        xMove = qMax(1.0, displayWidth() / zoom / moveFactor);
                    if( y < threshold )
                        yMove = - qMax(1.0, displayHeight() / zoom / moveFactor);
                    else if( y + threshold > displayHeight() )
                        yMove = qMax(1.0, displayHeight() / zoom / moveFactor);
                    if( xMove != 0 || yMove != 0 )
                        {
                        prevPoint.setX( qMax(0, qMin(displayWidth(), prevPoint.x() + xMove)) );
                        prevPoint.setY( qMax(0, qMin(displayHeight(), prevPoint.y() + yMove)) );
                        timeline.start();
                        }
                    }
                // fall through
            case MouseTrackingDisabled:
                data.xTranslate = - int( prevPoint.x() * ( zoom - 1.0 ) );
                data.yTranslate = - int( prevPoint.y() * ( zoom - 1.0 ) );
                break;
            }

        // use the focusPoint if focus tracking is enabled
        if(enableFocusTracking && followFocus)
            {
            bool acceptFocus = true;
            if(mouseTracking != MouseTrackingDisabled && focusDelay > 0)
                {
                // Wait some time for the mouse before doing the switch. This serves as threshold
                // to prevent the focus from jumping around to much while working with the mouse.
                const int msecs = lastMouseEvent.msecsTo(lastFocusEvent);
                acceptFocus = msecs > focusDelay;
                }
            if(acceptFocus)
                {
                data.xTranslate = - int( focusPoint.x() * ( zoom - 1.0 ) );
                data.yTranslate = - int( focusPoint.y() * ( zoom - 1.0 ) );
                prevPoint = focusPoint;
                }
            }
        }

    effects->paintScreen( mask, region, data );

    if( zoom != 1.0 && mousePointer != MousePointerHide )
        {
        // Draw the mouse-texture at the position matching to zoomed-in image of the desktop. Hidding the
        // previous mouse-cursor and drawing our own fake mouse-cursor is needed to be able to scale the
        // mouse-cursor up and to re-position those mouse-cursor to match to the choosen zoom-level.
#ifdef KWIN_HAVE_OPENGL_COMPOSITING
        if( texture )
            {
            glPushAttrib( GL_CURRENT_BIT | GL_ENABLE_BIT );
            texture->bind();
            glEnable( GL_BLEND );
            glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
            int w = imageWidth;
            int h = imageHeight;
            if( mousePointer == MousePointerScale )
                {
                w *= zoom;
                h *= zoom;
                }
            QPoint p = QCursor::pos();
            QRect rect(p.x() * zoom + data.xTranslate, p.y() * zoom + data.yTranslate, w, h);
            texture->render(region, rect);
            texture->unbind();
            glPopAttrib();
            }
#endif
#ifdef KWIN_HAVE_XRENDER_COMPOSITING
        if( xrenderPicture )
            {
            QPoint p = QCursor::pos();
            QRect rect(p.x() * zoom + data.xTranslate, p.y() * zoom + data.yTranslate, imageWidth, imageHeight);
            XRenderComposite( display(), PictOpOver, *xrenderPicture, None, effects->xrenderBufferPicture(), 0, 0, 0, 0, rect.x(), rect.y(), rect.width(), rect.height());
            }
#endif
        }
    }

void ZoomEffect::postPaintScreen()
    {
    if( zoom != target_zoom )
        effects->addRepaintFull();
    effects->postPaintScreen();
    }

void ZoomEffect::zoomIn()
    {
    target_zoom *= zoomFactor;
    if( !polling )
        {
        polling = true;
        effects->startMousePolling();
        }
    effects->addRepaintFull();
    }

void ZoomEffect::zoomOut()
    {
    target_zoom /= zoomFactor;
    if( target_zoom < 1 )
        {
        target_zoom = 1;
        if( polling )
            {
            polling = false;
            effects->stopMousePolling();
            }
        }
    effects->addRepaintFull();
    }

void ZoomEffect::actualSize()
    {
    target_zoom = 1;
    if( polling )
        {
        polling = false;
        effects->stopMousePolling();
        }
    effects->addRepaintFull();
    }

void ZoomEffect::timelineFrameChanged(int /* frame */)
    {
    prevPoint.setX( qMax(0, qMin(displayWidth(), prevPoint.x() + xMove)) );
    prevPoint.setY( qMax(0, qMin(displayHeight(), prevPoint.y() + yMove)) );
    cursorPoint = prevPoint;
    effects->addRepaintFull();
    }

void ZoomEffect::moveZoom(int x, int y)
    {
    if( timeline.state() == QTimeLine::Running )
        timeline.stop();

    if( x < 0 )
        xMove = - qMax(1.0, displayWidth() / zoom / moveFactor);
    else if( x > 0 )
        xMove = qMax(1.0, displayWidth() / zoom  / moveFactor);
    else
        xMove = 0;

    if( y < 0 )
        yMove = - qMax(1.0, displayHeight() / zoom / moveFactor);
    else if( y > 0 )
        yMove = qMax(1.0, displayHeight() / zoom / moveFactor);
    else
        yMove = 0;
                
    timeline.start();
    }

void ZoomEffect::moveZoomLeft()
    {
    moveZoom(-1, 0);
    }

void ZoomEffect::moveZoomRight()
    {
    moveZoom(1, 0);
    }

void ZoomEffect::moveZoomUp()
    {
    moveZoom(0, -1);
    }

void ZoomEffect::moveZoomDown()
    {
    moveZoom(0, 1);
    }

void ZoomEffect::moveMouseToFocus()
    {
    QCursor::setPos(focusPoint.x(), focusPoint.y());
    }

void ZoomEffect::moveMouseToCenter()
    {
    //QRect r = effects->clientArea(KWin::ScreenArea, effects->activeScreen(), effects->currentDesktop());
    QRect r(0, 0, displayWidth(), displayHeight());
    QCursor::setPos(r.x() + r.width() / 2, r.y() + r.height() / 2);
    }

void ZoomEffect::mouseChanged( const QPoint& pos, const QPoint& old, Qt::MouseButtons,
    Qt::MouseButtons, Qt::KeyboardModifiers, Qt::KeyboardModifiers )
    {
    cursorPoint = pos;
    if( pos != old )
        {
        lastMouseEvent = QTime::currentTime();
        effects->addRepaintFull();
        }
    }

void ZoomEffect::focusChanged(int px, int py, int rx, int ry, int rwidth, int rheight)
    {
    focusPoint = (px >= 0 && py >= 0) ? QPoint(px, py) : QPoint( rx + qMax(0, (qMin(displayWidth(), rwidth)/2)-60), ry + qMax(0, (qMin(displayHeight(), rheight)/2)-60) );
    if( enableFocusTracking )
        {
        lastFocusEvent = QTime::currentTime();
        effects->addRepaintFull();
        }
    }

} // namespace

#include "zoom.moc"