paraboliczoomstate.cpp~

thes is veer good (ksmoutTool)

/***************************************************************************
 *   Copyright (C) 2006 by the KSmoothDock team   *
 *   [e-mail]   *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "paraboliczoomstate.h"

#include <iostream>
#include <unistd.h>

#include <qapplication.h>
#include <qbitmap.h>
#include <qcursor.h>
#include <qpainter.h>

#include <kpixmapeffect.h>
#include <kwin.h>

#include "desktopselector.h"
#include "ksmoothdock.h"
#include "launcher.h"
#include "showdesktop.h"

/// PUBLIC ///

/**
 * Constructors
 */

ParabolicZoomState::ParabolicZoomState(KSmoothDock* dock)
 : DockState(dock) {
    m_w = 0;
    m_h = 0;
    m_timer = new QTimer(this);
    connect(m_timer, SIGNAL(timeout()), this, SLOT(updateZoom()));
    m_animationNumSteps = 20;
    // m_animationStepDelay = 32 - m_dock->m_PzZoomSpeed;
    m_isMinimised = true;
    m_maskOn = false;
    m_justEntered = false;
    m_justLeft = false;
    m_inAnimation = false;
}

/**
 * Dock created event
 */

void ParabolicZoomState::dockCreatedEvent() {
    m_dock->setDockBelow();
}

/**
 * Update the layout
 */

void ParabolicZoomState::updateLayout(bool reset) {
    m_clickedLauncherIndex = -1;
    
    m_itemsSize.clear();
    m_itemsStartSize.clear();
    m_itemsEndSize.clear();
    m_itemsCenterMin.clear();
    m_itemsCenter.clear();
    m_itemsStartCenter.clear();
    m_itemsEndCenter.clear();
    for (unsigned int i = 0; i < m_dock->m_items.size() + 1; i++) {
        m_itemsSize.push_back(m_dock->m_smallIconSize);
        m_itemsStartSize.push_back(m_dock->m_smallIconSize);
        m_itemsEndSize.push_back(m_dock->m_smallIconSize);

        m_itemsCenterMin.push_back(0);
        m_itemsCenter.push_back(0);
        m_itemsStartCenter.push_back(0);
        m_itemsEndCenter.push_back(0);
    }

    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();

    int old_min_w = m_minW;
    int old_min_h = m_minH;
    int old_w = m_w;
    int old_h = m_h;

    m_itemSpacing = m_dock->m_smallIconSize / 2;
    m_functionMaxX = (int) (2.5 * (m_dock->m_smallIconSize + m_itemSpacing));

    m_minW = m_minH = 0;
    if (m_dock->m_orientation == Qt::Horizontal) {
        // calculate w and h

        for (unsigned int i = 0; i < m_dock->m_items.size(); i++) {
            int item_min_w = m_dock->m_items[i]->getMinWidth();
            m_minW += item_min_w;
        }
        m_minW += m_dock->m_items.size() * m_itemSpacing;
        if (m_dock->m_isAutohide) {
            m_minH = 1;
        } else {
            m_minH = m_dock->m_smallIconSize + m_itemSpacing;
        }

        int distance = m_dock->m_smallIconSize + m_itemSpacing;

        if (m_dock->m_items.size() >= 5) {
            m_w = function(0) + 2*function(distance) + 2*function(2*distance) - 5*m_dock->m_smallIconSize + m_minW;
        } else if (m_dock->m_items.size() == 4) {
            m_w = function(0) + 2*function(distance) + function(2*distance) - 4*m_dock->m_smallIconSize + m_minW;
        } else if (m_dock->m_items.size() == 3) {
            m_w = function(0) + 2*function(distance) - 3*m_dock->m_smallIconSize + m_minW;
        } else if (m_dock->m_items.size() == 2) {
            m_w = function(0) + function(distance) - 2*m_dock->m_smallIconSize + m_minW;
        } else if (m_dock->m_items.size() == 1) {
            m_w = function(0) - m_dock->m_smallIconSize + m_minW;
        }

        m_h = m_dock->m_bigIconSize + m_itemSpacing;

        // calculate items center

        m_itemsCenterMin[0] = m_itemSpacing / 2 + (m_w - m_minW) / 2 + m_dock->m_items[0]->getMinWidth() / 2;
        for (unsigned int i = 1; i < m_dock->m_items.size(); i++) {
            m_itemsCenterMin[i] = m_itemsCenterMin[i-1] + m_dock->m_items[i-1]->getMinWidth() / 2 + m_itemSpacing + m_dock->m_items[i]->getMinWidth() / 2;
        }
    } else { // Vertical
        // calculate w and h

        for (unsigned int i = 0; i < m_dock->m_items.size(); i++) {
            int item_min_h = m_dock->m_items[i]->getMinHeight();
            m_minH += item_min_h;
        }
        m_minH += m_dock->m_items.size() * m_itemSpacing;
        if (m_dock->m_isAutohide) {
            m_minW = 1;
        } else {
            m_minW = m_dock->m_smallIconSize + m_itemSpacing;
        }

        int distance = m_dock->m_smallIconSize + m_itemSpacing;

        if (m_dock->m_items.size() >= 5) {
            m_h = function(0) + 2*function(distance) + 2*function(2*distance) - 5*m_dock->m_smallIconSize + m_minH;
        } else if (m_dock->m_items.size() == 4) {
            m_h = function(0) + 2*function(distance) + function(2*distance) - 4*m_dock->m_smallIconSize + m_minH;
        } else if (m_dock->m_items.size() == 3) {
            m_h = function(0) + 2*function(distance) - 3*m_dock->m_smallIconSize + m_minH;
        } else if (m_dock->m_items.size() == 2) {
            m_h = function(0) + function(distance) - 2*m_dock->m_smallIconSize + m_minH;
        } else if (m_dock->m_items.size() == 1) {
            m_h = function(0) - m_dock->m_smallIconSize + m_minH;
        }

        m_w = m_dock->m_bigIconSize + m_itemSpacing;

        // calculate items center

        m_itemsCenterMin[0] = m_itemSpacing / 2 + (m_h - m_minH) / 2 + m_dock->m_items[0]->getMinHeight() / 2;
        for (unsigned int i = 1; i < m_dock->m_items.size(); i++) {
            m_itemsCenterMin[i] = m_itemsCenterMin[i-1] + m_dock->m_items[i-1]->getMinHeight() / 2 + m_itemSpacing + m_dock->m_items[i]->getMinHeight() / 2;
        }
    }

    for (unsigned int i = 0; i < m_dock->m_items.size(); i++) {
        m_itemsCenter[i] = m_itemsCenterMin[i];
        m_itemsStartCenter[i] = m_itemsCenterMin[i];
        m_itemsEndCenter[i] = m_itemsCenterMin[i];
    }

    // resize pixmaps

    if (m_dock->m_orientation == Qt::Horizontal && (m_minH != old_min_h || m_h != old_h)) {
        m_buffer.reset(new QPixmap(dw, m_h));
        QPixmap pix(dw, m_minH);
        m_background.reset(new KPixmap(pix));
        m_originalBackground.reset(new QPixmap(dw, m_h));
        if (m_dock->m_isAutohide) {
            m_sideBorder.reset(new QPixmap(1, m_dock->m_smallIconSize + m_itemSpacing));
        } else {
            m_sideBorder.reset(new QPixmap(1, m_minH));
        }
        
        // update background
        updateBackgroundImage();
    } else if (m_dock->m_orientation == Qt::Vertical && (m_minW != old_min_w || m_w != old_w)) {
        m_buffer.reset(new QPixmap(m_w, dh));
        QPixmap pix(m_minW, dh);
        m_background.reset(new KPixmap(pix));
        m_originalBackground.reset(new QPixmap(m_w, dh));
        if (m_dock->m_isAutohide) {
            m_sideBorder.reset(new QPixmap(m_dock->m_smallIconSize + m_itemSpacing, 1));
        } else {
            m_sideBorder.reset(new QPixmap(m_minW, 1));
        }
        
        // update background
        updateBackgroundImage();
    }

    int x = (dw - m_w) / 2;
    int y = (dh - m_h) / 2;    

    // set strut of the dock and move it

    switch(m_dock->m_position) {
    case LEFT:
        m_dock->move(0, y);
        KWin::setExtendedStrut(m_dock->winId(), m_minW, 0, dh, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        KSmoothDock::setDesktopIconsArea(m_minW, 0, dw - m_minW, dh);
        break;
    case RIGHT:
        m_dock->move(dw - m_w, y);
        KWin::setExtendedStrut(m_dock->winId(), 0, 0, 0, m_minW, 0, dh, 0, 0, 0, 0, 0, 0);
        KSmoothDock::setDesktopIconsArea(0, 0, dw - m_minW, dh);
        break;
    case TOP:
        m_dock->move(x, 0);
        KWin::setExtendedStrut(m_dock->winId(), 0, 0, 0, 0, 0, 0, m_minH, 0, dw, 0, 0, 0);
        KSmoothDock::setDesktopIconsArea(0, m_minH, dw, dh - m_minH);
        break;
    case BOTTOM:
        m_dock->move(x, dh - m_h);
        KWin::setExtendedStrut(m_dock->winId(), 0, 0, 0, 0, 0, 0, 0, 0, 0, m_minH, 0, dw);
        KSmoothDock::setDesktopIconsArea(0, 0, dw, dh - m_minH);
        break;
    default:
        break;
    }

    if (!reset) {
        if (!m_isMinimised) { // zoom case

            // the dock has not been resized yet, so we have to do mouse position's translation ourselves

            int rx = 0;
            int ry = 0;

            switch(m_dock->m_position) {
            case LEFT:
                rx = 0; // for the sake of clarity
                ry = y;
                break;
            case RIGHT:
                rx = dw - m_w;
                ry = y;
                break;
            case TOP:
                rx = x;
                ry = 0;
                break;
            case BOTTOM:
                rx = x;
                ry = dh - m_h;
                break;
            default:
                break;
            }

            QRect rect(rx, ry, m_w, m_h);
            QPoint mouse_pos = QCursor::pos();
            if (rect.contains(mouse_pos)) {                
                mouse_pos.setX(mouse_pos.x() - rx);
                mouse_pos.setY(mouse_pos.y() - ry);
                setItemsPosition(mouse_pos.x(), mouse_pos.y());
            } else {
                leaveEvent(NULL);
            }            
        } else {        
            m_dock->setDockBelow();
        }
    } else {
        m_isMinimised = true;
        m_dock->setDockBelow();
    }

    // reset the mask
    if (m_isMinimised) {
        setMaskOn(true);
    } else {
        setMaskOn(false);
    }

    // resize the dock
    m_dock->resize(m_w, m_h);

    m_dock->repaint();    
}

/**
 * Update the background
 */

void ParabolicZoomState::updateBackground() {
    updateBackgroundImage();
    m_dock->repaint();
}

/**
 * Paint event handler    
 */

void ParabolicZoomState::paintEvent(QPaintEvent* e) {
    unsigned int i = 0;
    unsigned int no_items = m_dock->m_items.size();

    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();

    if (m_dock->m_position == TOP) {
        if (m_isMinimised) { // Minimised case
            // draw the background
            int dx = (m_w - m_minW) / 2;
            int dy = m_h - m_minH;
            bitBlt(m_buffer.get(), dx, 0, m_background.get(), (dw - m_minW) / 2, 0, m_minW, m_minH);
            bitBlt(m_buffer.get(), 0, m_minH, m_originalBackground.get(), (dw - m_w) / 2, m_minH, m_w, dy);
            bitBlt(m_buffer.get(), 0, 0, m_originalBackground.get(), (dw - m_w) / 2, 0, dx, m_minH);
            bitBlt(m_buffer.get(), m_w - dx, 0, m_originalBackground.get(), (dw + m_minW) / 2, 0, dx, m_minH);

            if (m_dock->m_showBorders) {
                bitBlt(m_buffer.get(), dx, 0, m_sideBorder.get(), 0, 0, 1, m_minH);
                bitBlt(m_buffer.get(), dx + m_minW - 1, 0, m_sideBorder.get(), 0, 0, 1, m_minH);
            }

            // draw the items
            for (i = 0; i < no_items; i++) {
                DockItem* item = m_dock->m_items[i];
                int x_item = m_itemsCenterMin[i] - item->getMinWidth() / 2;
                item->draw(*m_buffer, x_item, m_itemSpacing/2, m_dock->m_smallIconSize);
            }
        } else { // Zoomed case

            // draw the background
            int dy = m_h - m_minH;
            bitBlt(m_buffer.get(), 0, 0, m_background.get(), (dw - m_w) / 2, 0, m_w, m_minH);