normalzoomstate.cpp~

thes is veer good (ksmoutTool)

void NormalZoomState::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 dx = (item->getMaxWidth() - w) / 2;
    int dy = (item->getMaxHeight() - h) / 2;

    for (int i = 0; i < itemIndex; i++) {
        if (m_dock->m_orientation == Qt::Horizontal) {
            x += m_dock->m_items[i]->getMaxWidth();
        } else { // Vertical
            y += m_dock->m_items[i]->getMaxHeight();
        }
    }
    x += dx;
    y += dy;

    bitBlt(m_buffer.get(), x, y, m_background.get(), x, y, w, h);
    item->draw(*m_buffer, x, y, m_itemsSize[itemIndex]);

    bitBlt(m_dock, x, y, m_buffer.get(), x, y, w, h); (
    */
    
    // for now use this inefficient method
    m_dock->repaint();
}

/**
 * Update the dock when the active window has been changed
 */

void NormalZoomState::activeWindowChanged(WId id) {
    if (!m_dock->m_isAutohide)
        return;

    if ( (id == m_dock->winId()) || (id == 0) || ShowDesktop::the()->desktopShowing() )
        return;

    if (!m_isHidden) { // zoom mode
        KWin::WindowInfo info(id, 0, 0);
        QRect windowFrameGeometry = info.frameGeometry();
    
        QRect rect = m_dock->frameGeometry();
        NET::WindowType type = info.windowType(0xffff);
        NET::MappingState mapping_state = info.mappingState();
        if ((mapping_state == NET::Visible) && (type == NET::Normal || type == NET::Dialog || type == NET::Unknown || type == NET::Override) && rect.intersects(windowFrameGeometry)) {
            m_dock->setDockBelow();
            QRect intersection = rect & windowFrameGeometry;
            pauseExecution();
            
            QPixmap intersection_pix = QPixmap::grabWindow(qt_xrootwin(), intersection.x(), intersection.y(), intersection.width(), intersection.height());    
    
            QPoint pos = m_dock->mapFromGlobal(intersection.topLeft());

            switch(m_dock->m_position) {
            case TOP:
                bitBlt(m_background.get(), pos.x(), pos.y() - 1, &intersection_pix, 0, 0, intersection.width(), intersection.height());
                break;
            case BOTTOM:
                bitBlt(m_background.get(), pos.x(), pos.y(), &intersection_pix, 0, 0, intersection.width(), intersection.height());
                break;
            case LEFT:
                bitBlt(m_background.get(), pos.x() - 1, pos.y(), &intersection_pix, 0, 0, intersection.width(), intersection.height());
                break;
            case RIGHT:
                bitBlt(m_background.get(), pos.x(), pos.y(), &intersection_pix, 0, 0, intersection.width(), intersection.height());
                break;
            default:
                break;
            }

            // fade the background
            if (m_dock->m_dockOpacity > 0)
                KPixmapEffect::fade(*m_background, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
        
            // draw borders
            QPainter p(m_background.get());
            if (m_dock->m_showBorders) {
                p.setPen(m_dock->m_borderColor);
        
                switch(m_dock->m_position) {
                case LEFT:
                    p.drawLine(0, 0, m_w - 1, 0);
                    p.drawLine(m_w - 1, 0, m_w - 1, m_h - 1);
                    p.drawLine(m_w - 1, m_h - 1, 0, m_h - 1);
                    break;
                case RIGHT:
                    p.drawLine(0, 0, m_w - 1, 0);
                    p.drawLine(0, 0, 0, m_h - 1);
                    p.drawLine(m_w - 1, m_h - 1, 0, m_h - 1);
                    break;
                case TOP:
                    p.drawLine(0, m_h - 1, m_w - 1, m_h - 1);
                    p.drawLine(0, 0, 0, m_h - 1);
                    p.drawLine(m_w - 1, m_h - 1, m_w - 1, 0);
                    break;
                case BOTTOM:
                    p.drawLine(0, 0, m_w - 1, 0);
                    p.drawLine(0, 0, 0, m_h - 1);
                    p.drawLine(m_w - 1, 0, m_w - 1, m_h - 1);
                    break;
                default:
                    break;
                }
            }
                        
            m_dock->setDockAbove();
            m_dock->repaint();
        }
    }
}


/**
 * Update autohide mode
 */

void NormalZoomState::updateAutohideMode() {
    if (m_dock->m_isAutohide && m_isHidden)
        m_dock->setDockBelow();
    updateBackgroundImage();
    updateLayout();
}

/**
 * Zoom timer event handler
 */

void NormalZoomState::updateZoom() {
    bool keep_timer = FALSE;

    for (unsigned int i = 0; i < m_dock->m_items.size(); i++) {
        if (m_itemsSizeIncrement[i] != 0) {
            m_itemsSize[i] += m_itemsSizeIncrement[i] * (m_dock->m_bigIconSize - m_dock->m_smallIconSize) / m_animationNumSteps;
    
            if (m_itemsSize[i] < m_dock->m_smallIconSize)
                m_itemsSize[i] = m_dock->m_smallIconSize;
            if (m_itemsSize[i] > m_dock->m_bigIconSize)
                m_itemsSize[i] = m_dock->m_bigIconSize;

            if (m_itemsSize[i] == m_dock->m_smallIconSize || m_itemsSize[i] == m_dock->m_bigIconSize) {
                m_itemsSizeIncrement[i] = 0;
            }
            if (m_firstIndexToUpdate > i)
                m_firstIndexToUpdate = i;
            if (m_lastIndexToUpdate < i)
                m_lastIndexToUpdate = i;
        }
    }
    
    m_dock->repaint();
    
    for (unsigned int i = 0; i < m_dock->m_items.size(); i++) {
        if (m_itemsSizeIncrement[i] != 0) {
            m_firstIndexToUpdate = i;
            keep_timer = TRUE;
            break;
        }
    }

    for (int i = (int) m_dock->m_items.size() - 1; i >= 0; i--) {
        if (m_itemsSizeIncrement[i] != 0) {
            m_lastIndexToUpdate = i;
            break;
        }
    }
    
    if (!keep_timer) {
        m_timer->stop();
        m_firstIndexToUpdate = 0;
        m_lastIndexToUpdate = m_dock->m_items.size() - 1;
    }
}

/**
 * Stop launcher acknowledgement
 */

void NormalZoomState::stopLauncherAcknowledgement() {
    m_clickedLauncherIndex = -1;
    m_dock->repaint();
}

/// PRIVATE ///

/**
 * Find the index of the item with mouse focus given mouse's x and y position
 */

int NormalZoomState::findItemIndex(int x, int y) {
    unsigned int i = 0;
    
    if (m_dock->m_orientation == Qt::Horizontal) {
        int w = 0;
        while (i < m_dock->m_items.size() && x > w) {
            w += m_dock->m_items[i]->getMaxWidth();
            i++;
        }
        if (i >= 1)
            i--;
    } else { // Vertical
        int h = 0;
        while (i < m_dock->m_items.size() && y > h) {
            h += m_dock->m_items[i]->getMaxHeight();
            i++;
        }
        if (i >= 1)
            i--;
    }

    return i;
}

/**
 * Update the background image
 */

void NormalZoomState::updateBackgroundImage() {
    int dw = QApplication::desktop()->width();
    int dh = QApplication::desktop()->height();
    int x = 0;
    int y = 0;

    switch(m_dock->m_position) {
    case LEFT:
        y = (dh - m_h) / 2;
        break;
    case RIGHT:
        x = dw - m_w;
        y = (dh - m_h) / 2;
        break;
    case TOP:
        x = (dw - m_w) / 2;
        break;
    case BOTTOM:
        x = (dw - m_w) / 2;
        y = dh - m_h;
        break;
    default:
        break;
    }

    if (m_dock->m_isAutohide) {
        if (m_isHidden || ShowDesktop::the()->desktopShowing()) {
            // copy from the wallpaper
            bitBlt(m_background.get(), 0, 0, &m_dock->m_wallpaperManager->getWallpaper(KWin::currentDesktop()), x, y, m_w, m_h);
        } else {
            m_dock->setDockBelow();
            pauseExecution();
            *m_background = QPixmap::grabWindow(qt_xrootwin(), x, y, m_w, m_h);
            m_dock->setDockAbove();
        }
    } else {
        // copy from the wallpaper
        bitBlt(m_background.get(), 0, 0, &m_dock->m_wallpaperManager->getWallpaper(KWin::currentDesktop()), x, y, m_w, m_h);
    }

    if (!m_dock->m_isAutohide || !m_isHidden) {
        // fade the background
        if (m_dock->m_dockOpacity > 0)
            KPixmapEffect::fade(*m_background, ((float)m_dock->m_dockOpacity)*0.01, m_dock->m_backgroundColor);
    
        // draw borders
        QPainter p(m_background.get());
        if (m_dock->m_showBorders) {
            p.setPen(m_dock->m_borderColor);
    
            switch(m_dock->m_position) {
            case LEFT:
                p.drawLine(0, 0, m_w - 1, 0);
                p.drawLine(m_w - 1, 0, m_w - 1, m_h - 1);
                p.drawLine(m_w - 1, m_h - 1, 0, m_h - 1);
                break;
            case RIGHT:
                p.drawLine(0, 0, m_w - 1, 0);
                p.drawLine(0, 0, 0, m_h - 1);
                p.drawLine(m_w - 1, m_h - 1, 0, m_h - 1);
                break;
            case TOP:
                p.drawLine(0, m_h - 1, m_w - 1, m_h - 1);
                p.drawLine(0, 0, 0, m_h - 1);
                p.drawLine(m_w - 1, m_h - 1, m_w - 1, 0);
                break;
            case BOTTOM:
                p.drawLine(0, 0, m_w - 1, 0);
                p.drawLine(0, 0, 0, m_h - 1);
                p.drawLine(m_w - 1, 0, m_w - 1, m_h - 1);
                break;
            default:
                break;
            }
        }
    }
}

/**
 * Update after showing/un-showing the desktop
 */

void NormalZoomState::updateAfterShowingDesktop() {
    if (m_dock->m_isAutohide) {
        bool desktopShowing = ShowDesktop::the()->desktopShowing();
        if (desktopShowing) {
            updateBackgroundImage();
        } else {
            m_dock->setDockBelow();
            
            pauseExecution();
                
            updateBackgroundImage();
    
            m_dock->setDockAbove();
        }
        m_dock->repaint();
    }
}

/**
 * Pause execution
 */

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

/**
 * Set mask on/off
 */

void NormalZoomState::setMaskOn(bool maskOn) {
    if (maskOn) {
        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 = 0;
            pm.fillRect(QRect(rx, ry, 1, m_h), Qt::color1);
            break;
        case RIGHT:
            rx = m_w - 1;
            ry = 0;
            pm.fillRect(QRect(rx, ry, 1, m_h), Qt::color1);
            break;
        case TOP:
            rx = 0;
            ry = 0;            
            pm.fillRect(QRect(rx, ry, m_w, 1), Qt::color1);
            break;
        case BOTTOM:
            rx = 0;
            ry = m_h - 1;            
            pm.fillRect(QRect(rx, ry, m_w, 1), Qt::color1);
            break;
        default:
            break;
        }

        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;
    }
}

#include "normalzoomstate.moc"