klearlook.cpp

LINUX下的混音软件

                    return ;
            }

    if ( a.isNull() )
        return ;

    p->save();
    a.translate( ( r.x() + ( r.width() >> 1 ) ), ( r.y() + ( r.height() >> 1 ) ) );
    p->setBrush( col );
    p->setPen( col );
    p->drawPolygon( a );
    p->restore();
}

void KlearlookStyle::drawPrimitiveMenu( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg,
                                        SFlags flags, const QStyleOption &data ) const {
    switch ( pe ) {
        case PE_CheckMark:
            if ( flags & Style_On || !( flags & Style_Off ) )      // !(flags&Style_Off) is for tri-state
            {
                QPointArray check;
                int x = r.center().x() - 3,
                        y = r.center().y() - 3;

                check.setPoints( 6,
                                 x, y + 2,
                                 x + 2, y + 4,
                                 x + 6, y,
                                 x + 6, y + 2,
                                 x + 2, y + 6,
                                 x, y + 4 );

                if ( flags & Style_On ) {
                    if ( flags & Style_Active ) {
                        p->setBrush( cg.highlightedText() );
                        p->setPen( cg.highlightedText() );
                    } else {
                        p->setBrush( cg.text() );
                        p->setPen( cg.text() );
                    }
                } else {
                    p->setBrush( cg.text() );
                    p->setPen( cg.text() );
                }
                p->drawPolygon( check );
            }
            break;

        default:
            KStyle::drawPrimitive( pe, p, r, cg, flags, data );
    }
}

void KlearlookStyle::drawPrimitive( PrimitiveElement pe, QPainter *p, const QRect &r, const QColorGroup &cg,
                                    SFlags flags, const QStyleOption &data ) const {
    int x, y, w, h;

    r.rect(&x, &y, &w, &h);
                                    
    switch ( pe ) {
        case PE_HeaderSection: {
                const QColor * use = buttonColors( cg );


                if ( APP_KICKER == themedApp ) {
                    if ( flags & Style_Down )
                        flags = ( ( flags | Style_Down ) ^ Style_Down ) | Style_Sunken;
                    flags |= Style_Enabled;
#if KDE_VERSION >= 0x30200
#if KDE_VERSION >= 0x30400

                    if ( HOVER_KICKER == hover && hoverWidget )   //  && hoverWidget==p->device())
                        flags |= Style_MouseOver;
#endif

                    formMode = isTransKicker;
#endif

                    drawLightBevelButton( p, r, cg, flags | Style_Horizontal,
                        true, ROUNDED_ALL, getFill( flags, use ), use );
#if KDE_VERSION >= 0x30200

                    formMode = false;
#endif

                } else {
                    flags = ( ( flags | Style_Sunken ) ^ Style_Sunken ) | Style_Raised;

                    if ( QTC_NO_SECT != hoverSect && HOVER_HEADER == hover && hoverWidget ) {
                        QHeader * hd = dynamic_cast<QHeader *>( hoverWidget );

                        if ( hd && hd->isClickEnabled( hoverSect ) && r == hd->sectionRect( hoverSect ) )
                            flags |= Style_MouseOver;
                    }
                    drawLightBevelButton( p, r, cg, flags | Style_Horizontal,
                        true, ROUNDED_NONE, getFill( flags, use ), use );
                }
                break;
            }
        case PE_HeaderArrow:
            drawArrow( p, r, cg, flags, flags & Style_Up ? PE_ArrowUp : PE_ArrowDown );
            break;
        case PE_ButtonCommand:
        case PE_ButtonBevel:
        case PE_ButtonTool:
        case PE_ButtonDropDown: {
                const QColor *use = buttonColors( cg );

                if ( !( flags & QStyle::Style_Sunken ) )   // If its not sunken, its raised-don't want flat buttons.
                    flags |= QStyle::Style_Raised;

                drawLightBevelButton( p, r, cg, flags | Style_Horizontal, true,
                                      r.width() < 16 || r.height() < 16
#if KDE_VERSION >= 0x30200
                                      || ( APP_KORN == themedApp && isTransKicker && PE_ButtonTool == pe )
#endif
                                      ? ROUNDED_NONE : ROUNDED_ALL,
                                      getFill( flags, use ), use );
                break;
            }
        case PE_ButtonDefault:
            switch ( defBtnIndicator ) {
                case IND_BORDER:
                    p->setBrush( NoBrush );
                    if ( rounded )   // borderButton)      CPD Only use color[4] for rounded def buttons!
                    {
                        const QColor * use = buttonColors( cg );

                        p->setPen( use[ 4 ] );
                        int offset = r.width() >= QTC_MIN_BTN_SIZE && r.height() >= QTC_MIN_BTN_SIZE ? 4 : 3;

                        p->drawLine( r.x() + offset, r.y(), r.x() + r.width() - ( 1 + offset ), r.y() );
                        p->drawLine( r.x() + offset, r.y() + r.height() - 1,
                            r.x() + r.width() - ( 1 + offset ), r.y() + r.height() - 1 );
                        p->drawLine( r.x(), r.y() + offset, r.x(), r.y() + r.height() - ( 1 + offset ) );
                        p->drawLine( r.x() + r.width() - 1, r.y() + offset,
                            r.x() + r.width() - 1, r.y() + r.height() - ( 1 + offset ) );
                    } else {
                        p->setPen( cg.text() );
                        p->drawRect( r );
                    }
                    break;
                case IND_CORNER: {
                        const QColor *use = buttonColors( cg );
                        QPointArray points;
                        bool sunken = flags & Style_Down || flags & QStyle::Style_Sunken;
                        int offset = sunken ? 4 : 3;

                        points.setPoints( 3, r.x() + offset, r.y() + offset, r.x() + offset + 6, r.y() + offset,
                                          r.x() + offset, r.y() + offset + 6 );

                        p->setBrush( use[ sunken ? 0 : borderButton ? 4 : 5 ] );
                        p->setPen( use[ sunken ? 0 : borderButton ? 4 : 5 ] );
                        p->drawPolygon( points );
                        break;
                    }
                default:
                    break;
            }
            break;
        case PE_IndicatorMask:
            if ( rounded ) {
                p->fillRect( r, color0 );
                p->fillRect( r.x() + 1, r.y() + 1, r.width() - 2, r.height() - 2, color1 );
                p->setPen( color1 );
                p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
                p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 );
                p->drawLine( r.x(), r.y() + 1, r.x(), r.y() + r.height() - 2 );
                p->drawLine( r.x() + r.width() - 1, r.y() + 1, r.x() + r.width() - 1, r.y() + r.height() - 2 );
            } else
                p->fillRect( r, color1 );
            break;
        case PE_CheckMark:
            if ( flags & Style_On || !( flags & Style_Off ) )      // !(flags&Style_Off) is for tri-state
            {
                QPointArray check;
                int x = r.center().x() - 3,
                        y = r.center().y() - 3;

                check.setPoints( 6,
                                 x, y + 2,
                                 x + 2, y + 4,
                                 x + 6, y,
                                 x + 6, y + 2,
                                 x + 2, y + 6,
                                 x, y + 4 );
                p->setBrush( flags & Style_On
                             ? flags & Style_Enabled
                             ? flags & Style_Selected
                             ? cg.highlightedText()
                             : cg.text()
                                     : cg.mid()
                                     : cg.light() );
                p->setPen( flags & Style_Enabled
                           ? flags & Style_Selected
                           ? cg.highlightedText()
                           : cg.text()
                                   : cg.mid() );
                p->drawPolygon( check );
            }
            break;
        case PE_CheckListController: {
                QCheckListItem *item = data.checkListItem();

                if ( item ) {
                    QListView * lv = item->listView();
                    int x = r.x(), y = r.y(), w = r.width(), h = r.height(), marg = lv->itemMargin();

                    p->setPen( QPen( flags & Style_Enabled ? cg.text()
                                     : lv->palette().color( QPalette::Disabled, QColorGroup::Text ) ) );

                    if ( flags & Style_Selected && !lv->rootIsDecorated() &&
                         !( ( item->parent() && 1 == item->parent() ->rtti() &&
                         QCheckListItem::Controller == ( ( QCheckListItem* ) item->parent() ) ->type() ) )) {
                            p->fillRect( 0, 0, x + marg + w + 4, item->height(),
                                cg.brush( QColorGroup::Highlight ) );
                            if ( item->isEnabled() )
                                p->setPen( QPen( cg.highlightedText() ) );
                    }

                    if ( flags & Style_NoChange )
                        p->setBrush( cg.brush( QColorGroup::Button ) );
                    p->drawRect( x + marg + 2, y + 4 + 2, w - 7, h - 8 );
                    p->drawRect( x + marg, y + 4, w - 7, h - 8 );
                }
                break;
            }
        case PE_CheckListIndicator: {
                QCheckListItem *item = data.checkListItem();

                if ( item ) {
                    QListView * lv = item->listView();

                    p->setPen( QPen( flags & Style_Enabled ? cg.text()
                                     : lv->palette().color( QPalette::Disabled, QColorGroup::Text ), 2 ) );
                    if ( flags & Style_Selected ) {
                        flags -= Style_Selected;
                        if ( !lv->rootIsDecorated() &&
                             !( ( item->parent() && 1 == item->parent() ->rtti() &&
                             QCheckListItem::Controller ==
                             ( ( QCheckListItem* ) item->parent() ) ->type() ) ) ) {
                            p->fillRect( 0, 0, r.x() + lv->itemMargin() + r.width() + 4, item->height(),
                                         cg.brush( QColorGroup::Highlight ) );
                            if ( item->isEnabled() ) {
                                p->setPen( QPen( cg.highlightedText(), 2 ) );
                                flags += Style_Selected;
                            }
                        }
                    }

                    if ( flags & Style_NoChange )
                        p->setBrush( cg.brush( QColorGroup::Button ) );
                    p->drawRect( r.x() + lv->itemMargin(), r.y() + 2, r.width() - 4, r.width() - 4 );
                    if ( flags & QStyle::Style_On || !( flags & Style_Off ) )
                        drawPrimitive( PE_CheckMark, p, QRect( r.x() + lv->itemMargin(),
                            r.y() + 2, r.width() - 4, r.width() - 4 ), cg, flags );
                }
                break;
            }
        case PE_Indicator: {
                const QColor *use = buttonColors( cg );
                bool on = flags & QStyle::Style_On || !( flags & Style_Off );

                if ( APPEARANCE_FLAT != appearance )
                    drawPrimitive( PE_ButtonTool, p, r, cg, flags );
                else {
                    p->fillRect( r.x() + 1, r.y() + 2, QTC_CHECK_SIZE - 2, QTC_CHECK_SIZE - 2,
                                 flags & Style_Enabled ? cg.base() : cg.background() );
                    p->setPen( use[ 4 ] );
                    p->drawLine( r.x() + 1, r.y() + QTC_CHECK_SIZE - 1, r.x() + 1, r.y() + 1 );
                    p->drawLine( r.x() + 1, r.y() + 1, r.x() + QTC_CHECK_SIZE - 2, r.y() + 1 );
                }
                p->setPen( use[ 5 ] );
                p->setBrush( NoBrush );
                if ( rounded ) {
                    p->drawLine( r.x() + 1, r.y(), r.x() + r.width() - 2, r.y() );
                    p->drawLine( r.x() + 1, r.y() + r.height() - 1, r.x() + r.width() - 2, r.y() + r.height() - 1 );
                    p->drawLine( r.x(), r.y() + 1, r.x(), r.y() + r.height() - 2 );
                    p->drawLine( r.x() + r.width() - 1, r.y() + 1, r.x() + r.width() - 1, r.y() + r.height() - 2 );

                    p->setPen( midColor( use[ 3 ], cg.background() ) );
                    p->drawPoint( r.x(), r.y() );
                    p->drawPoint( r.x(), r.y() + r.width() - 1 );
                    p->drawPoint( r.x() + r.height() - 1, r.y() );
                    p->drawPoint( r.x() + r.height() - 1, r.y() + r.width() - 1 );
                } else if ( APPEARANCE_FLAT == appearance || borderButton )
                    p->drawRect( r.x(), r.y(), QTC_CHECK_SIZE, QTC_CHECK_SIZE );

                if ( on )
                    drawPrimitive( PE_CheckMark, p, r, cg, flags );
                break;
            }
        case PE_CheckListExclusiveIndicator: {
                QCheckListItem *item = data.checkListItem();

                if ( item ) {
                    const QColor & bgnd = cg.background(),
                                          &on = flags & Style_Enabled
                                                ? cg.text()
                                                : cg.mid();
                    bool set
                        = flags & QStyle::Style_On;
                    QPointArray outer,
                    inner,
                    aa;
                    int x = r.x(), y = r.y() + 2;

                    outer.setPoints( 24, x, y + 8, x, y + 4, x + 1, y + 3, x + 1, y + 2,
                                     x + 2, y + 1, x + 3, y + 1, x + 4, y, x + 8, y,
                                     x + 9, y + 1, x + 10, y + 1, x + 11, y + 2, x + 11, y + 3,
                                     x + 12, y + 4, x + 12, y + 8, x + 11, y + 9, x + 11, y + 10,
                                     x + 10, y + 11, x + 9, y + 11, x + 8, y + 12, x + 4, y + 12,
                                     x + 3, y + 11, x + 2, y + 11, x + 1, y + 10, x + 1, y + 9 );
                    inner.setPoints( 20, x + 1, y + 8, x + 1, y + 4, x + 2, y + 3, x + 2, y + 2,
                                     x + 3, y + 2, x + 4, y + 1, x + 8, y + 1, x + 9, y + 2,
                                     x + 10, y + 2, x + 10,