paraboliczoomstate.cpp

thes is veer good (ksmoutTool)

        while (i < m_dock->m_items.size() && y > h) {
            h = m_itemsCenter[i] - m_dock->m_items[i]->getHeight(m_itemsSize[i]) / 2;
            i++;
        }
        if (i == no_items && y > h)
            i = no_items - 1;
        else
            i -= 2;
    }

    return i;
}

/**
 * Set isMinimised property given the mouse's x and y position
 */

bool ParabolicZoomState::enableZoom(int x, int y) {
    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();

    int start_x = (m_w - m_minW + m_itemSpacing) / 2;
    int start_y = (m_h - m_minH + m_itemSpacing) / 2;

    switch(m_dock->m_position) {
    case LEFT:
        if (y >= start_y && y < start_y + m_minH - m_itemSpacing) {
            m_snapshot = QPixmap::grabWindow(qt_xrootwin(), m_minW, 0, m_w - m_minW, dh);
            if (m_dock->m_isAutohide) {
                fadeSnapshot();
            }
            m_isMinimised = false;
        }
        break;
    case RIGHT:
        if (y >= start_y && y < start_y + m_minH - m_itemSpacing) {
            m_snapshot = QPixmap::grabWindow(qt_xrootwin(), dw - m_w, 0, m_w - m_minW, dh);
            if (m_dock->m_isAutohide) {
                fadeSnapshot();
            }
            m_isMinimised = false;
        }
        break;
    case TOP:
        if (x >= start_x && x < start_x + m_minW - m_itemSpacing) {
            m_snapshot = QPixmap::grabWindow(qt_xrootwin(), 0, m_minH, dw, m_h - m_minH);
            if (m_dock->m_isAutohide) {
                fadeSnapshot();
            }
            m_isMinimised = false;
        }
        break;
    case BOTTOM:
        if (x >= start_x && x < start_x + m_minW - m_itemSpacing) {
            m_snapshot = QPixmap::grabWindow(qt_xrootwin(), 0, dh - m_h, dw, m_h - m_minH);
            if (m_dock->m_isAutohide) {
                fadeSnapshot();
            }
            m_isMinimised = false;
        }
        break;
    default:
        break;
    }

    return !m_isMinimised;
}

/**
 * Set items' position (and size) given the mouse's x and y position
 * size is a function of position calculated by the parabolic function
 */

void ParabolicZoomState::setItemsPosition(int x, int y) {
    int i = 0;
    unsigned int no_items = m_dock->m_items.size();
    int first_unchanged_index_right = no_items;

    if (m_dock->m_orientation == Qt::Horizontal) {

        // determine the size of the icons

        for (i = 0; i < no_items; i++) {
            int delta_x = abs(m_itemsCenterMin[i] - x);
            if (delta_x < m_functionMaxX) {
                m_itemsSize[i] = function(delta_x);
            } else {
                m_itemsSize[i] = m_dock->m_smallIconSize;
                if (m_itemsCenterMin[i] > x && first_unchanged_index_right == no_items)
                    first_unchanged_index_right = i;
            }
        }

        // determine the position of the icons

        m_itemsCenter[0] = m_itemSpacing / 2 + m_dock->m_items[0]->getWidth(m_itemsSize[0])/2;
        for (i = 1; i < no_items; i++) {
            m_itemsCenter[i] = m_itemsCenter[i-1] + (m_dock->m_items[i]->getWidth(m_itemsSize[i]) + m_dock->m_items[i-1]->getWidth(m_itemsSize[i-1]))/2 + m_itemSpacing;
        }

        if (first_unchanged_index_right < no_items) {
            m_itemsCenter[no_items - 1] = m_w - m_dock->m_items[no_items - 1]->getWidth(m_dock->m_smallIconSize)/2 - m_itemSpacing/2;
            for (i = no_items - 2; i >= first_unchanged_index_right; i--) {
                m_itemsCenter[i] = m_itemsCenter[i+1] - (m_dock->m_items[i]->getWidth(m_itemsSize[i]) + m_dock->m_items[i+1]->getWidth(m_itemsSize[i+1]))/2 - m_itemSpacing;
            }
        }

        if (first_unchanged_index_right <= 5 ) {
             for (i = first_unchanged_index_right - 1; i >= 0; i--) {
                m_itemsCenter[i] = m_itemsCenter[i+1] - (m_dock->m_items[i]->getWidth(m_itemsSize[i]) + m_dock->m_items[i+1]->getWidth(m_itemsSize[i+1]))/2 - m_itemSpacing;
            }
        }
    } else { // Vertical

        // determine the size of the icons

        for (i = 0; i < no_items; i++) {
            int delta_y = abs(m_itemsCenterMin[i] - y);
            if (delta_y < m_functionMaxX) {
                m_itemsSize[i] = function(delta_y);
            } else {
                m_itemsSize[i] = m_dock->m_smallIconSize;
                if (m_itemsCenterMin[i] > y && first_unchanged_index_right == no_items)
                    first_unchanged_index_right = i;
            }
        }

        // determine the position of the icons

        m_itemsCenter[0] = m_itemSpacing / 2 + m_dock->m_items[0]->getHeight(m_itemsSize[0])/2;
        for (i = 1; i < no_items; i++) {
            m_itemsCenter[i] = m_itemsCenter[i-1] + (m_dock->m_items[i]->getHeight(m_itemsSize[i]) + m_dock->m_items[i-1]->getHeight(m_itemsSize[i-1]))/2 + m_itemSpacing;
        }

        if (first_unchanged_index_right < no_items) {
            m_itemsCenter[no_items - 1] = m_h - m_dock->m_items[no_items - 1]->getHeight(m_dock->m_smallIconSize)/2 - m_itemSpacing/2;
            for (i = no_items - 2; i >= first_unchanged_index_right; i--) {
                m_itemsCenter[i] = m_itemsCenter[i+1] - (m_dock->m_items[i]->getHeight(m_itemsSize[i]) + m_dock->m_items[i+1]->getHeight(m_itemsSize[i+1]))/2 - m_itemSpacing;
            }
        }

        if (first_unchanged_index_right <= 5 ) {
             for (i = first_unchanged_index_right - 1; i >= 0; i--) {
                m_itemsCenter[i] = m_itemsCenter[i+1] - (m_dock->m_items[i]->getHeight(m_itemsSize[i]) + m_dock->m_items[i+1]->getHeight(m_itemsSize[i+1]))/2 - m_itemSpacing;
            }
        }
    }

    if (m_justEntered) {
        m_justEntered = false;
        m_inAnimation = true;
        for (i = 0; i < no_items; i++) {
            m_itemsStartSize[i] = m_dock->m_smallIconSize;
            m_itemsEndSize[i] = m_itemsSize[i];
            m_itemsStartCenter[i] = m_itemsCenterMin[i];
            m_itemsEndCenter[i] = m_itemsCenter[i];
        }
        if (!m_timer->isActive()) {
            m_animationCurrentStep = 0;
            m_timer->start(32 - m_dock->m_PzZoomSpeed);
        }
    } else if (!m_inAnimation) {
        m_dock->repaint();
    }
}

/**
 * Show tooltip at item index
 */

void ParabolicZoomState::showTooltip(int index) {
    m_dock->m_tooltip.setText(m_dock->m_items[index]->getDescription());

    int x = m_dock->x();
    int y  = m_dock->y();
    if (m_dock->m_orientation == Qt::Horizontal) {
        x += m_itemSpacing / 2;
        for (int i = 0; i < index; i++) {
            x += m_dock->m_items[i]->getWidth(m_itemsSize[i]) + m_itemSpacing;
        }
        x = x + m_dock->m_items[index]->getWidth(m_itemsSize[index]) / 2 - m_dock->m_tooltip.width() / 2;

        if (m_dock->m_position == TOP)
            y = y + m_dock->height() + TOOLTIP_SPACE;
        else // BOTTOM
            y = y - m_dock->m_tooltip.height() - TOOLTIP_SPACE;
    } else { // Vertical
        y += m_itemSpacing / 2;
        for (int i = 0; i < index; i++) {
            y += m_dock->m_items[i]->getHeight(m_itemsSize[i]) + m_itemSpacing;
        }
        y = y + m_dock->m_items[index]->getHeight(m_itemsSize[index]) / 2 - m_dock->m_tooltip.height() / 2;

        if (m_dock->m_position == LEFT)
            x = x + m_dock->width() + TOOLTIP_SPACE;
        else // RIGHT
            x = x - m_dock->m_tooltip.width() - TOOLTIP_SPACE;
    }

    m_dock->m_tooltip.move(x, y);
    if (!m_dock->m_tooltip.isShown())
        m_dock->m_tooltip.show();
}

/**
 * Fade and draw a border on the snapshot (in autohide mode)
 */

void ParabolicZoomState::fadeSnapshot() {
    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();
    int minW = m_dock->m_smallIconSize + m_itemSpacing;
    int minH = m_dock->m_smallIconSize + m_itemSpacing;
    KPixmap pix;

    switch(m_dock->m_position) {
    case LEFT:
        pix = QPixmap(minW, m_h);
        bitBlt(&pix, 0, 0, &m_snapshot, 0, (dh - m_h) / 2, minW, m_h);
        KPixmapEffect::fade(pix, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
        bitBlt(&m_snapshot, 0, (dh - m_h) / 2, &pix, 0, 0, minW, m_h);
        break;
    case RIGHT:
        pix = QPixmap(minW, m_h);
        bitBlt(&pix, 0, 0, &m_snapshot, m_w - minW, (dh - m_h) / 2, minW, m_h);
        KPixmapEffect::fade(pix, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
        bitBlt(&m_snapshot, m_w - minW, (dh - m_h) / 2, &pix, 0, 0, minW, m_h);
        break;
    case TOP:
        pix = QPixmap(m_w, minH);
        bitBlt(&pix, 0, 0, &m_snapshot, (dw - m_w) / 2, 0, m_w, minH);
        KPixmapEffect::fade(pix, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
        bitBlt(&m_snapshot, (dw - m_w) / 2, 0, &pix, 0, 0, m_w, minH);
        break;
    case BOTTOM:
        pix = QPixmap(m_w, minH);
        bitBlt(&pix, 0, 0, &m_snapshot, (dw - m_w) / 2, m_h - minH, m_w, minH);
        KPixmapEffect::fade(pix, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
        bitBlt(&m_snapshot, (dw - m_w) / 2, m_h - minH, &pix, 0, 0, m_w, minH);
        break;
    default:
        break;
    }

    // draw borders
    if (m_dock->m_showBorders) {       
        QPainter p(&m_snapshot);

        p.setPen(m_dock->m_borderColor);

        switch(m_dock->m_position) {
        case LEFT:
            p.drawLine(minW - 1, 0, minW - 1, dh - 1);            
            break;
        case RIGHT:
            p.drawLine(m_w - minW, 0, m_w - minW, dh - 1);
            break;
        case TOP:
            p.drawLine(0, minH - 1, dw - 1, minH - 1);
            break;
        case BOTTOM:
            p.drawLine(0, m_h - minH, dw - 1, m_h - minH);
            break;
        default:
            break;
        }
    }
}

/**
 * Pause execution
 */

void ParabolicZoomState::pauseExecution() {
    usleep(100000); // pause for 100 miliseconds    
}

/**
 * Set mask on/off
 */

void ParabolicZoomState::setMaskOn(bool maskOn) {
    if (maskOn) { // set mask
        QBitmap mask(m_dock->size());
        QPainter pm;
        pm.begin(&mask);
        pm.fillRect(m_dock->rect(), Qt::color0);
        
        int rx = 0;
        int ry = 0;

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

        QRect rect(rx, ry, m_minW, m_minH);
        pm.fillRect(rect, Qt::color1);
        pm.end();
        m_dock->setMask(mask);
        m_maskOn = true;
    } else {

        // for some reason, clearMask does not work anymore
        //m_dock->clearMask();

        QBitmap mask(m_dock->size());
        QPainter pm;
        pm.begin(&mask);
        pm.fillRect(m_dock->rect(), Qt::color1);
        pm.end();
        m_dock->setMask(mask);
        m_maskOn = false;
    }
}

/**
 * Parabolic function
 * @param x the distant from the center of the icon to the mouse position
 * @return the icon size
 */

int ParabolicZoomState::function(int x) {
    if ( (x < -m_functionMaxX) || (x > m_functionMaxX) )
        return m_dock->m_smallIconSize;
    else
        return (m_dock->m_bigIconSize - (x * x * (m_dock->m_bigIconSize - m_dock->m_smallIconSize)) / (m_functionMaxX * m_functionMaxX));
}

#include "paraboliczoomstate.moc"