paraboliczoomstate.cpp

thes is veer good (ksmoutTool)

            bitBlt(m_buffer.get(), 0, m_minH, &m_snapshot, (dw - m_w) / 2, 0, m_w, dy);

            if (m_dock->m_showBorders) {
                if (m_dock->m_isAutohide) {
                    int minH = m_dock->m_smallIconSize + m_itemSpacing;
                    bitBlt(m_buffer.get(), 0, 0, m_sideBorder.get(), 0, 0, 1, minH);
                    bitBlt(m_buffer.get(), m_w - 1, 0, m_sideBorder.get(), 0, 0, 1, minH);
                } else {
                    bitBlt(m_buffer.get(), 0, 0, m_sideBorder.get(), 0, 0, 1, m_minH);
                    bitBlt(m_buffer.get(), m_w - 1, 0, m_sideBorder.get(), 0, 0, 1, m_minH);
                }
            }

            // draw the items
            for (i = 0; i <= no_items - 1; i++) {
                DockItem* item = m_dock->m_items[i];
                int x_item = m_itemsCenter[i] - item->getWidth(m_itemsSize[i]) / 2;
                if ((int)i == m_clickedLauncherIndex) { // launcher clicked acknowlegement
                    Launcher* l = dynamic_cast<Launcher*>(item);
                    l->drawAcknowledgement(*m_buffer, x_item, m_itemSpacing/2 , m_itemsSize[i]);
                } else {
                    item->draw(*m_buffer, x_item, m_itemSpacing/2, m_itemsSize[i]);
                }
            }
        }
    } else if (m_dock->m_position == BOTTOM) {
        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, dy, m_background.get(), (dw - m_minW) / 2, 0, m_minW, m_minH);
            bitBlt(m_buffer.get(), 0, 0, m_originalBackground.get(), (dw - m_w) / 2, 0, m_w, dy);
            bitBlt(m_buffer.get(), 0, dy, m_originalBackground.get(), (dw - m_w) / 2, dy, dx, m_minH);
            bitBlt(m_buffer.get(), m_w - dx, dy, m_originalBackground.get(), (dw + m_minW) / 2, dy, dx, m_minH);

            if (m_dock->m_showBorders) {
                bitBlt(m_buffer.get(), dx, dy, m_sideBorder.get(), 0, 0, 1, m_minH);
                bitBlt(m_buffer.get(), dx + m_minW - 1, dy, 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;
                int dy = m_h - m_itemSpacing / 2 - item->getMinHeight();
                item->draw(*m_buffer, x_item, dy, m_dock->m_smallIconSize);
            }
        } else { // Zoomed case

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

            if (m_dock->m_showBorders) {
                if (m_dock->m_isAutohide) {
                    int minH = m_dock->m_smallIconSize + m_itemSpacing;
                    bitBlt(m_buffer.get(), 0, m_h - minH, m_sideBorder.get(), 0, 0, 1, minH);
                    bitBlt(m_buffer.get(), m_w - 1, m_h - minH, m_sideBorder.get(), 0, 0, 1, minH);
                } else {
                    bitBlt(m_buffer.get(), 0, dy, m_sideBorder.get(), 0, 0, 1, m_minH);
                    bitBlt(m_buffer.get(), m_w - 1, dy, m_sideBorder.get(), 0, 0, 1, m_minH);
                }
            }

            // draw the items
            for (i = 0; i <= no_items - 1; i++) {
                DockItem* item = m_dock->m_items[i];
                int x_item = m_itemsCenter[i] - item->getWidth(m_itemsSize[i]) / 2;
                int dy = m_h - m_itemSpacing / 2 - item->getHeight(m_itemsSize[i]);
                if ((int)i == m_clickedLauncherIndex) { // launcher clicked acknowlegement
                    Launcher* l = dynamic_cast<Launcher*>(item);
                    l->drawAcknowledgement(*m_buffer, x_item, dy, m_itemsSize[i]);
                } else {
                    item->draw(*m_buffer, x_item, dy, m_itemsSize[i]);
                }
            }
        }
    } else if (m_dock->m_position == LEFT) {
        if (m_isMinimised) { // Minimised case
            // draw the background
            int dy = (m_h - m_minH) / 2;
            int dx = m_w - m_minW;
            bitBlt(m_buffer.get(), 0, dy, m_background.get(), 0, (dh - m_minH) / 2, m_minW, m_minH);
            bitBlt(m_buffer.get(), m_minW, 0, m_originalBackground.get(), m_minW, (dh - m_h) / 2, dx, m_h);
            bitBlt(m_buffer.get(), 0, 0, m_originalBackground.get(), 0, (dh - m_h) / 2, m_minW, dy);
            bitBlt(m_buffer.get(), 0, m_h - dy, m_originalBackground.get(), 0, (dh + m_minH) / 2, m_minW, dy);

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

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

            // draw the background
            int dx = m_w - m_minW;
            bitBlt(m_buffer.get(), 0, 0, m_background.get(), 0, (dh - m_h) / 2, m_minW, m_h);
            bitBlt(m_buffer.get(), m_minW, 0, &m_snapshot, 0, (dh - m_h) / 2, dx, m_h);

            if (m_dock->m_showBorders) {
                if (m_dock->m_isAutohide) {
                    int minW = m_dock->m_smallIconSize + m_itemSpacing;
                    bitBlt(m_buffer.get(), 0, 0, m_sideBorder.get(), 0, 0, minW, 1);
                    bitBlt(m_buffer.get(), 0, m_h - 1, m_sideBorder.get(), 0, 0, minW, 1);
                } else {
                    bitBlt(m_buffer.get(), 0, 0, m_sideBorder.get(), 0, 0, m_minW, 1);
                    bitBlt(m_buffer.get(), 0, m_h - 1, m_sideBorder.get(), 0, 0, m_minW, 1);
                }
            }

            // draw the items
            for (i = 0; i <= no_items - 1; i++) {
                DockItem* item = m_dock->m_items[i];
                int y_item = m_itemsCenter[i] - item->getHeight(m_itemsSize[i]) / 2;
                if ((int)i == m_clickedLauncherIndex) { // launcher clicked acknowlegement
                    Launcher* l = dynamic_cast<Launcher*>(item);
                    l->drawAcknowledgement(*m_buffer, m_itemSpacing / 2, y_item, m_itemsSize[i]);
                } else {
                    item->draw(*m_buffer, m_itemSpacing / 2, y_item, m_itemsSize[i]);
                }
            }
        }
    } else if (m_dock->m_position == RIGHT) {
        if (m_isMinimised) { // Minimised case
            // draw the background
            int dy = (m_h - m_minH) / 2;
            int dx = m_w - m_minW;
            bitBlt(m_buffer.get(), dx, dy, m_background.get(), 0, (dh - m_minH) / 2, m_minW, m_minH);
            bitBlt(m_buffer.get(), 0, 0, m_originalBackground.get(), 0, (dh - m_h) / 2, dx, m_h);
            bitBlt(m_buffer.get(), dx, 0, m_originalBackground.get(), dx, (dh - m_h) / 2, m_minW, dy);
            bitBlt(m_buffer.get(), dx, m_h - dy, m_originalBackground.get(), dx, (dh + m_minH) / 2, m_minW, dy);

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

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

            // draw the background
            int dx = m_w - m_minW;
            bitBlt(m_buffer.get(), dx, 0, m_background.get(), 0, (dh - m_h) / 2, m_minW, m_h);
            bitBlt(m_buffer.get(), 0, 0, &m_snapshot, 0, (dh - m_h) / 2, dx, m_h);

            if (m_dock->m_showBorders) {
                if (m_dock->m_isAutohide) {                    
                    int minW = m_dock->m_smallIconSize + m_itemSpacing;
                    bitBlt(m_buffer.get(), m_w - minW, 0, m_sideBorder.get(), 0, 0, minW, 1);
                    bitBlt(m_buffer.get(), m_w - minW, m_h - 1, m_sideBorder.get(), 0, 0, minW, 1);
                } else {
                    bitBlt(m_buffer.get(), dx, 0, m_sideBorder.get(), 0, 0, m_minW, 1);
                    bitBlt(m_buffer.get(), dx, m_h - 1, m_sideBorder.get(), 0, 0, m_minW, 1);
                }
            }

            // draw the items
            for (i = 0; i <= no_items - 1; i++) {
                DockItem* item = m_dock->m_items[i];
                int y_item = m_itemsCenter[i] - item->getHeight(m_itemsSize[i]) / 2;
                int dx = m_w - m_itemSpacing / 2 - item->getWidth(m_itemsSize[i]);
                if ((int)i == m_clickedLauncherIndex) { // launcher clicked acknowlegement
                    Launcher* l = dynamic_cast<Launcher*>(item);
                    l->drawAcknowledgement(*m_buffer, dx, y_item, m_itemsSize[i]);
                } else {
                    item->draw(*m_buffer, dx, y_item, m_itemsSize[i]);
                }
            }
        }
    }
    
    if (m_isMinimised) {
        if (!m_maskOn) { // set mask
            setMaskOn(true);
        }
    } else {
        if (m_maskOn) { // clear mask
            setMaskOn(false);
        }
    }

    bitBlt(m_dock, 0, 0, m_buffer.get(), 0, 0, (m_w < dw) ? m_w : dw, (m_h < dh) ? m_h : dh);
}

/**
 * Mouse pressed event handler
 */

void ParabolicZoomState::mousePressEvent(QMouseEvent* e) {    
    if (m_inAnimation)
        return;

    // find the m_dock item's index
    int i = findItemIndex(e->x(), e->y());
    if (i < 0 || i >= m_dock->m_items.size())
        return;

    if (e->button() == Qt::LeftButton) {
        m_dock->m_items[i]->mousePressEvent(e);

        // launcher acknowledgement

        Launcher l;
        if (typeid(*m_dock->m_items[i]) == typeid(l)) {
            m_clickedLauncherIndex = i;
            QTimer::singleShot(500, this, SLOT(stopLauncherAcknowledgement()));
            m_dock->repaint();

            Launcher* launcher = dynamic_cast<Launcher*>(m_dock->m_items[i]);
            if (launcher->getCommand().compare("SHOW_DESKTOP") == 0) { // Show Desktop button
                updateAfterShowingDesktop();
            }
        }        
    } else if (e->button() == Qt::RightButton) {
        m_dock->m_items[i]->mousePressEvent(e);
    }
}

/**
 * Mouse moved event handler
 */

void ParabolicZoomState::mouseMoveEvent(QMouseEvent* e) {
    if (m_inAnimation)
        return;

    if (!m_isMinimised || enableZoom(e->x(), e->y())) {
        // zoom items
    
        setItemsPosition(e->x(), e->y());
    
        // show tooltip
        
        if (m_dock->m_showTooltip) {
            // find the m_dock item's index
            int i = findItemIndex(e->x(), e->y());
            if (i < 0 || i >= m_dock->m_items.size()) {
                m_dock->m_tooltip.hide();
            } else {
                showTooltip(i);
            }
        }
    }
}

/**
 * Enter event handler
 */

void ParabolicZoomState::enterEvent(QEvent* e) {
    QPoint pos = QCursor::pos();
    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();
    int x = 0;
    int y = 0;
    
    switch(m_dock->m_position) {
    case TOP:
        x = (dw - m_minW) / 2;
        break;
    case BOTTOM:
        x = (dw - m_minW) / 2;
        y = dh - m_minH;
        break;
    case LEFT:
        y = (dh - m_minH) / 2;
        break;
    case RIGHT:
        x = dw - m_minW;
        y = (dh - m_minH) / 2;
        break;
    default:
        break;
    }

    QRect rect(x, y, m_minW, m_minH);
    if (!rect.contains(pos)) // not a real enter event
        return;
    
    m_justEntered = true;
}

/**
 * Leave event handler
 */

void ParabolicZoomState::leaveEvent(QEvent* e) {
    QPoint pos = QCursor::pos();
    if (m_dock->frameGeometry().contains(pos)) // we have not really left the dock yet
        return;

    m_justLeft = true;
    m_inAnimation = true;
    for (int i = 0; i < m_dock->m_items.size(); i++) {
        m_itemsStartSize[i] = m_itemsSize[i];
        m_itemsEndSize[i] = m_dock->m_smallIconSize;
        m_itemsStartCenter[i] = m_itemsCenter[i];
        m_itemsEndCenter[i] = m_itemsCenterMin[i];
    }
    if (!m_timer->isActive()) {
        m_animationCurrentStep = 0;
        m_timer->start(32 - m_dock->m_PzZoomSpeed);
    }
}

/**
 * Update a specific item
* @TODO: fix and use the effient method (at the moment it does not work properly when the dock is vertical or in zoomed mode)
 */

void ParabolicZoomState::updateItem(int itemIndex) {
    /*
    int x = 0;
    int y = 0;
    DockItem* item = m_dock->m_items[itemIndex];
    int w = item->getWidth(m_itemsSize[itemIndex]);
    int h = item->getHeight(m_itemsSize[itemIndex]);    
    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();

    if (m_dock->m_position == TOP) {
        y = m_itemSpacing/2;
        if (m_isMinimised) { // Minimised case
            x = m_itemsCenterMin[itemIndex] - item->getMinWidth() / 2;
            bitBlt(m_buffer.get(), x, y, m_background.get(), x + (dw - m_w) / 2, y, w, h);    
        } else { // Zoomed case
            x = m_itemsCenter[itemIndex] - item->getWidth(m_itemsSize[itemIndex]) / 2;
        }
    } else if (m_dock->m_position == BOTTOM) {
        if (m_isMinimised) { // Minimised case
            x = m_itemsCenterMin[itemIndex] - item->getMinWidth() / 2;
            y = m_h - m_itemSpacing / 2 - item->getMinHeight();
            bitBlt(m_buffer.get(), x, y, m_background.get(), x + (dw - m_w) / 2, y - m_h + m_minH, w, h);             
        } else { // Zoomed case
            x = m_itemsCenter[itemIndex] - w / 2;