Attachment #2115 for bug #2086

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 2086
Collapse All | Expand All




    MandrivaStyle();
    virtual ~MandrivaStyle();

    void polish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
    void unPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
    void applicationPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
    void renderMenuBlendPixmap( KPixmap& pix, const TQColorGroup &cg,
                                const TQPopupMenu* popup ) const;

    void drawTDEStylePrimitive( TDEStylePrimitive kpe,
                              TQPainter* p,
                              const TQStyleControlElementData &ceData,
                              ControlElementFlags elementFlags,
                              const TQRect &r,
                              const TQColorGroup &cg,
                              SFlags flags = Style_Default,
                              const TQStyleOption& = TQStyleOption::Default,
                              const TQWidget* widget = 0 ) const;

    void drawPrimitive( PrimitiveElement pe,
                        TQPainter* p,
                        const TQStyleControlElementData &ceData,
                        ControlElementFlags elementFlags,
                        const TQRect &r,
                        const TQColorGroup &cg,
                        SFlags flags = Style_Default,


    void drawControl( ControlElement element,
                      TQPainter *p,
                      const TQStyleControlElementData &ceData,
                      ControlElementFlags elementFlags,
                      const TQRect &r,
                      const TQColorGroup &cg,
                      SFlags flags = Style_Default,
                      const TQStyleOption& = TQStyleOption::Default,
                      const TQWidget *widget = 0 ) const;

    void drawControlMask( ControlElement element,
                          TQPainter *p,
                          const TQStyleControlElementData &ceData,
                          ControlElementFlags elementFlags,
                          const TQRect &r,
                          const TQStyleOption& = TQStyleOption::Default,
                          const TQWidget *widget = 0 ) const;

    void drawComplexControl( ComplexControl control,
                             TQPainter *p,
                             const TQStyleControlElementData &ceData,
                             ControlElementFlags elementFlags,
                             const TQRect &r,
                             const TQColorGroup &cg,
                             SFlags flags = Style_Default,
                             SCFlags controls = SC_All,
                             SCFlags active = SC_None,
                             const TQStyleOption& = TQStyleOption::Default ,
                             const TQWidget *widget = 0 ) const;

    void drawComplexControlMask( ComplexControl control,
                                 TQPainter *p,
                                 const TQStyleControlElementData &ceData,
                                 ControlElementFlags elementFlags,
                                 const TQRect &r,
                                 const TQStyleOption& = TQStyleOption::Default,
                                 const TQWidget *widget = 0 ) const;

    int pixelMetric( PixelMetric m,
                     const TQStyleControlElementData &ceData,
                     ControlElementFlags elementFlags,
                     const TQWidget *widget = 0 ) const;

    TQSize sizeFromContents( ContentsType contents,
                             const TQStyleControlElementData &ceData,
                             ControlElementFlags elementFlags,
                             const TQSize &contentSize,
                             const TQStyleOption& opt,
                             const TQWidget *widget = 0 ) const;

    TQRect subRect( SubRect r,
                    const TQStyleControlElementData &ceData,
                    const ControlElementFlags elementFlags,
                    const TQWidget *widget ) const;

    // Fix TQt3's wacky image positions
    TQPixmap stylePixmap( StylePixmap stylepixmap,
                          const TQStyleControlElementData &ceData,
                          ControlElementFlags elementFlags,
                          const TQStyleOption& = TQStyleOption::Default,
                          const TQWidget *widget = 0 ) const;

    TQRect querySubControlMetrics( ComplexControl control,
                                   const TQStyleControlElementData &ceData,
                                   ControlElementFlags elementFlags,
                                   SubControl subcontrol,
                                   const TQStyleOption& opt = TQStyleOption::Default,
                                   const TQWidget* widget = 0 ) const;

protected:
    enum Hover

    };


    virtual bool objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );

    void renderGradient(TQPainter* p,
                        const TQRect& r,

                    bool active) const;

    void drawComboboxArrow( TQPainter *p,
                            const TQStyleControlElementData &ceData,
                            ControlElementFlags elementFlags,
                            const TQRect &r,
                            const TQColorGroup &cg,
                            SFlags flags,
                            SCFlags active,
                            const TQWidget *widget)const;

    void drawMandrivaArrow( TQPointArray a, TQPainter *p,
                            const TQRect &r,

    bool isFormWidget(const TQWidget* widget) const;
    bool excludeColor(const TQColor &col, bool active) const;
    void getShade (const TQColorGroup &cg, int shadenr, TQColor &res) const;
    void updateHoverControl(const TQPoint &pos, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags);
    TQIntCache<MandrivaColorData> m_dataCache;
    static const double shading[8];
    mutable bool formMode;




    res = cdata->shades[shadenr];
}

void MandrivaStyle::updateHoverControl(const TQPoint &pos, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags)
{
    TQRegion repaint;
    enum Hover oldControl = hoverControl;


    if (hoverWidget->inherits("TQScrollBar"))
    {
        TQRect subline(querySubControlMetrics(CC_ScrollBar, ceData, elementFlags,
                                             SC_ScrollBarSubLine, hoverWidget)),
              addline(querySubControlMetrics(CC_ScrollBar, ceData, elementFlags,
                                             SC_ScrollBarAddLine, hoverWidget)),
              slider(querySubControlMetrics(CC_ScrollBar, ceData, elementFlags,
                                            SC_ScrollBarSlider, hoverWidget));
        if (subline.contains(pos))
            hoverControl = HoverScrollBarSubLine;
        else if (addline.contains(pos))

        if (!cb->editable())
            return;

        TQRect comboArrow(querySubControlMetrics(CC_ComboBox, ceData, elementFlags,
                                                SC_ComboBoxArrow, hoverWidget)),
              comboEditField(querySubControlMetrics(CC_ComboBox, ceData, elementFlags,
                                                SC_ComboBoxEditField, hoverWidget));

        if (comboArrow.contains(pos))
            hoverControl = HoverComboBoxArrow;

        hoverWidget->repaint(repaint, false);
}

void MandrivaStyle::applicationPolish(const TQStyleControlElementData &ceData, ControlElementFlags, void *ptr)
{
    if (ceData.widgetObjectTypes.contains(TQAPPLICATION_OBJECT_NAME_STRING)) {
        TQApplication *app = reinterpret_cast<TQApplication*>(ptr);
        if (!qstrcmp(app->argv()[0], "kicker")) {
            kickerMode = true;
        }
    }
}

void MandrivaStyle::polish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr)
{
	if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
		TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);

		// Put in order of highest occurance to maximize hit rate
		if (   widget->inherits( "TQComboBox" )
			|| widget->inherits( "TQScrollBar" )
			|| widget->inherits( "TQHeader" )
			|| widget->inherits( "TQSlider" )
			|| widget->inherits( "TQCheckBox" )
			|| widget->inherits("TQSplitterHandle") ) 
		{
			widget->installEventFilter(this);
			if (widget->inherits( "TQScrollBar" ) || widget->inherits( "TQComboBox" ))
			   widget->setMouseTracking( true );
		} 
		else if (widget->inherits("TQMenuBar")
				 || widget->inherits("TQPopupMenu") ) 
		{
			widget->setBackgroundMode(TQWidget::NoBackground);
		}
		else if (widget->inherits("TQPushButton") )
		{
			widget->installEventFilter(this);
			widget->setBackgroundMode( TQWidget::PaletteBackground );
		}
		else if ( widget->inherits( "TDEToolBarSeparator" ) || widget->inherits( "TQToolBarSeparator" ) )
		{
			widget->setBackgroundMode( TQWidget::PaletteBackground );
		}
		else if (widget->inherits("TQToolBarExtensionWidget")) 
		{
			widget->installEventFilter(this);
		}
		else if ( widget->parentWidget() &&
				( ( widget->inherits( "TQListBox" ) && widget->parentWidget()->inherits( "TQComboBox" ) ) 
					|| widget->inherits( "TDECompletionBox" ) ) ) 
		{
			TQListBox* listbox = (TQListBox*) widget;
			listbox->setLineWidth( 1 );
			listbox->setBackgroundMode( NoBackground );
			widget->installEventFilter( this );
		}
		else if ( !qstrcmp( widget->name(), kdeToolbarWidget) ) 
		{
			widget->setBackgroundMode( NoBackground ); // We paint the whole background.
			widget->installEventFilter(this);
		}
	}
	
    TDEStyle::polish( ceData, elementFlags, ptr );
}


void MandrivaStyle::unPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *ptr)
{
	if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
		TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);

		TQFont f = TQApplication::font();
		TQApplication::setFont( f, TRUE ); // get rid of the special fonts for special widget classes

		if (   widget->inherits( "TQComboBox"  )
			|| widget->inherits("TQScrollBar")
			|| widget->inherits("TQHeader")
			|| widget->inherits( "TQSlider" )
			|| widget->inherits( "TQCheckBox" )
			|| widget->inherits("TQSplitterHandle")) 
		{
			widget->removeEventFilter(this);
		}
		else if (   widget->inherits("TQMenuBar")
				 || widget->inherits("TQPopupMenu")) 
		{
			widget->setBackgroundMode(TQWidget::PaletteBackground);
		}
		else if ( widget->inherits("TQPushButton") ) 
		{
			widget->removeEventFilter(this);
		}
		else if (widget->inherits("TQToolBarExtensionWidget")) 
		{
			widget->removeEventFilter(this);
		}
		else if ( widget->parentWidget() &&
				  ( ( widget->inherits( "TQListBox" ) && widget->parentWidget()->inherits( "TQComboBox" ) ) 
					  || widget->inherits( "TDECompletionBox" ) ) ) 
		{
			TQListBox* listbox = (TQListBox*) widget;
			listbox->setLineWidth( 1 );
			listbox->setBackgroundMode( PaletteBackground );
			widget->removeEventFilter( this );
			widget->clearMask();
		}
		//For toolbar internal separators, return to button, too (can't use tqt_cast here since don't have access to the class)
		else if ( widget->inherits( "TDEToolBarSeparator" ) || widget->inherits( "TQToolBarSeparator" ) )
		{
			widget->setBackgroundMode( TQWidget::PaletteBackground );
		}
		else if ( !qstrcmp( widget->name(), kdeToolbarWidget) ) 
		{
			widget->setBackgroundMode( PaletteBackground );
			widget->removeEventFilter(this);
		}
	}

    TDEStyle::unPolish( ceData, elementFlags, ptr );
}

/* reimp. */

// This function draws primitive elements as well as their masks.
void MandrivaStyle::drawPrimitive( PrimitiveElement pe,
                                   TQPainter *p,
                                   const TQStyleControlElementData &ceData,
                                   ControlElementFlags elementFlags,
                                   const TQRect &r,
                                   const TQColorGroup &cg,
                                   SFlags flags,
                                   const TQStyleOption& opt ) const
{
    int x, y, xw;
    x= r.x();
    y= r.y();
    xw = r.x()+r.width()-1;
    yh = r.y()+r.height()-1;
    bool down = flags & Style_Down;
    bool on   = flags & Style_On;
    const MandrivaColorData *cdata = lookupData(cg);

        int y  = r.y();
        int x2 = r.x() + r.width()  - 1;
        int y2 = r.y() + r.height() - 1;
        int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags)
                                 : opt.lineWidth();

        //FIXME

    case PE_PanelPopup:
    case PE_WindowFrame:
    {
        int lw = /*opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags)
                   : opt.lineWidth()*/1;
        if (lw == 1 || lw == 2)
        {

            p->setPen(oldPen);
        }
        else
            TDEStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
        break;
    }
    case  PE_GroupBoxFrame:

    }
#if 0
    case PE_PanelGroupBox:
        drawPrimitive( PE_GroupBoxFrame, p, ceData, elementFlags, r, cg, flags, opt );
        break;
#endif
    case PE_Separator:

    case PE_HeaderArrow:
    {
        if ( flags & Style_Up )
            drawPrimitive( PE_ArrowUp, p, ceData, elementFlags, r, cg, Style_Enabled );
        else
            drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, r, cg, Style_Enabled );
        break;
    }
    case PE_HeaderSection:

        if(!item)
                return;
        int x = r.x(), y = r.y(), w = r.width(), h = r.width();
        drawPrimitive(PE_Indicator, p, ceData, elementFlags, TQRect(x-2, y-2 , w+3, h+3 ) , cg, flags );
        break;
    }
    //case PE_IndicatorMask:

        }

        // draw the arrow
        drawPrimitive( arrow, p, ceData, elementFlags, r, cg, flags );
        break;
    }


            drawMandrivaArrow( a, p, r, cg, flags, opt );
        }
        else
            TDEStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
    }
    } //switch
}

    p->setPen( oldPen ); // restore pen
}

void MandrivaStyle::drawTDEStylePrimitive( TDEStylePrimitive pe,
                                         TQPainter* p,
                                         const TQStyleControlElementData &ceData,
                                         ControlElementFlags elementFlags,
                                         const TQRect &r,
                                         const TQColorGroup &cg,
                                         SFlags flags,
                                         const TQStyleOption &opt,
                                         const TQWidget* widget) const
{
    const MandrivaColorData *cdata = lookupData(cg);
    switch(pe)

        break;
    }
    default:
        TDEStyle::drawTDEStylePrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt, widget);
    }
}

void MandrivaStyle::drawControl( ControlElement element,
                                 TQPainter *p,
                                 const TQStyleControlElementData &ceData,
                                 ControlElementFlags elementFlags,
                                 const TQRect &r,
                                 const TQColorGroup &cg,
                                 SFlags flags,
                                 const TQStyleOption& opt,
                                 const TQWidget *widget ) const
{
    const MandrivaColorData *cdata = lookupData(cg);
    switch (element)
    {
    case CE_CheckBox: 
    {
        drawPrimitive (PE_Indicator, p, ceData, elementFlags, r, cg, flags);
        break;
    }
    //progressbar
    case CE_ProgressBarContents: 
    {
        const TQProgressBar* pb = (const TQProgressBar*)widget;
        TQRect backend = subRect(SR_ProgressBarContents, ceData, elementFlags, widget);
        double progress = pb->progress();
        bool reverse = TQApplication::reverseLayout();
        int steps = pb->totalSteps();

        p->fillRect(backend , cg.background() );

        //draw border
        drawPrimitive( PE_PanelLineEdit, p, ceData, elementFlags, r, cg );

        TQRect cr(backend);
        cr.addCoords( 1, 1, -2, -2 );

    case CE_ProgressBarLabel:
    {
        const TQProgressBar * pb = (const TQProgressBar *) widget;
        const int unit_width = pixelMetric( PM_ProgressBarChunkWidth, ceData, elementFlags, pb );
        int u = r.width() / unit_width;
        int p_v = pb->progress();
        int t_s = pb->totalSteps();

    }
    case CE_ToolButtonLabel:
    {
        TDEStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
        break;
    }


    //CHECK
    case CE_MenuBarItem:
    {
        TQMenuBar  *mb = (TQMenuBar*)widget;
        TQMenuItem *mi = opt.menuItem();
        TQRect      pr = mb->rect();

        bool active  = flags & Style_Active;
        bool focused = flags & Style_HasFocus;

        bool enabled    = mi->isEnabled();
        bool checkable  = popupmenu->isCheckable();
        bool active     = flags & Style_Active;
        bool etchtext   = styleHint( SH_EtchDisabledText, ceData, elementFlags );
        bool reverse    = TQApplication::reverseLayout();
        int x, y, w, h;
        r.rect( &x, &y, &w, &h );

                     // Draw the checkmark
                     SFlags cflags = Style_Default;
                     cflags |= active ? Style_Enabled : Style_On;
                     drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect( cx + itemFrame, y + itemFrame,
                                                            checkcol - itemFrame*2, h - itemFrame*2), cg, cflags );
                 }
                 else

                 // Draw the checkmark
                 SFlags cflags = Style_Default;
                 cflags |= active ? Style_Enabled : Style_On;
                 drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect( cx + itemFrame, y + itemFrame,
                                                        checkcol - itemFrame*2, h - itemFrame*2), cg, cflags );
             }


             if ( mi->popup() )
             {
                 PrimitiveElement arrow = reverse ? PE_ArrowLeft : PE_ArrowRight;
                 int dim = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags)- itemFrame;
                 TQRect vr = visualRect( TQRect( x + w - arrowHMargin - itemFrame - dim,
                                               y + h / 2 - dim / 2, dim, dim), r );


                     TQColorGroup g2( cg.highlightedText ()/*white*/, cg.highlight(), /*white*/cg.highlightedText (), /*white*/cg.highlightedText (),
                                     enabled ? cg.highlightedText () : discol, /*discol*/cg.highlightedText (), cg.highlightedText () );

                     drawPrimitive( arrow, p, ceData, elementFlags, vr, g2, Style_Enabled );
                 }
                 else
                     drawPrimitive( arrow, p, ceData, elementFlags, vr, cg,
                                    enabled ? Style_Enabled : Style_Default );
             }
             break;

        // Shift button contents if pushed.
        if ( active )
        {
            x += pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget);
            y += pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget);
            flags |= Style_Sunken;
        }

        // Does the button have a popup menu?
        if ( button->isMenuButton() )
        {
            int dx = pixelMetric( PM_MenuButtonIndicator, ceData, elementFlags, widget );
            drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, TQRect(x + w - dx - 2, y + 2, dx, h - 4),
                           cg, flags, opt );
            w -= dx;
        }

        }
        // Draw a focus rect if the button has focus
        if ( flags & Style_HasFocus )
            drawPrimitive( PE_FocusRect, p, ceData, elementFlags,
                           TQStyle::visualRect(subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget), widget),
                           cg, flags );
        break;
    }

        if (isFormWidget(btn))
            formMode = true;

        drawPrimitive(  btn->isDefault( ) ? PE_ButtonDefault : PE_ButtonCommand, p, ceData, elementFlags, r, cg, flags );
    }
    break;
    default:
        TDEStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
    }
}

void MandrivaStyle::drawControlMask( ControlElement element,
                                     TQPainter *p,
                                     const TQStyleControlElementData &ceData,
                                     ControlElementFlags elementFlags,
                                     const TQRect &r,
                                     const TQStyleOption& opt,
                                     const TQWidget *widget ) const
{
    switch (element) 
    {

       break;
    }
    default:
        TDEStyle::drawControlMask(element, p, ceData, elementFlags, r, opt, widget);
    }
}

void MandrivaStyle::drawComboboxArrow( TQPainter *p,
                                       const TQStyleControlElementData &ceData,
                                       ControlElementFlags elementFlags,
                                       const TQRect &ar,
                                       const TQColorGroup &cg,
                                       SFlags flags,
                                       SCFlags active,
                                       const TQWidget *widget)const
{
    const TQComboBox * cb = (const TQComboBox *) widget;
    bool editableCombo = cb->editable();

        a.setPoints(TQCOORDARRLEN(c_arrow), c_arrow);

    if ( flags & Style_Down )
        p->translate( pixelMetric( PM_ButtonShiftHorizontal, ceData, elementFlags ),
                      pixelMetric( PM_ButtonShiftVertical, ceData, elementFlags ) );

    if ( flags & Style_Enabled ) 
    {


void MandrivaStyle::drawComplexControl( ComplexControl control,
                                        TQPainter *p,
                                        const TQStyleControlElementData &ceData,
                                        ControlElementFlags elementFlags,
                                        const TQRect &r,
                                        const TQColorGroup &cg,
                                        SFlags flags,
                                        SCFlags controls,
                                        SCFlags active,
                                        const TQStyleOption& opt,
                                        const TQWidget *widget ) const
{
    const MandrivaColorData *cdata = lookupData(cg);
    switch(control)

    case CC_SpinWidget:
    {
        const TQSpinWidget* sw = static_cast< const TQSpinWidget* >( widget );
        TQRect br = visualRect( querySubControlMetrics( CC_SpinWidget, ceData, elementFlags, SC_SpinWidgetButtonField, opt, widget ), widget );
        //FIXME
        p->fillRect( r, widget->isEnabled() ? cg.base() : cg.background() );


            if ( controls  & SC_SpinWidgetUp)
            {
                TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->palette().disabled();
                drawPrimitive( PE_SpinWidgetUp,p, ceData, elementFlags, TQRect(br.x()+1, br.y()+1 , br.width()-2 , br.height() / 2 ), ucg, flags, opt);
            }
            if ( controls & SC_SpinWidgetDown)
            {
                TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->palette().disabled();

                drawPrimitive( PE_SpinWidgetDown,p, ceData, elementFlags, TQRect( br.x()+1 , br.y() + br.height() / 2 , br.width()-2, br.height()/ 2 -1 ), dcg, flags, opt);
            }
        }
        if ( controls & SC_SpinWidgetFrame )
            drawPrimitive( PE_PanelLineEdit, p, ceData, elementFlags, r, cg );

        break;
    }

        const TQToolButton *tb = (const TQToolButton *) widget;

        TQRect button, menuarea;
        button   = querySubControlMetrics(control, ceData, elementFlags, SC_ToolButton, opt, widget);
        menuarea = querySubControlMetrics(control, ceData, elementFlags, SC_ToolButtonMenu, opt, widget);

        SFlags bflags = flags,
            mflags = flags;

            // If we're pressed, on, or raised...
            if (bflags & (Style_Down | Style_On | Style_Raised) || widget==hoverWidget ) 
            {
                drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, button, cg, bflags, opt);
            } 
            else if (tb->parentWidget() &&
                     tb->parentWidget()->backgroundPixmap() &&

        if (controls & SC_ToolButtonMenu) 
        {
            if (mflags & (Style_Down | Style_On | Style_Raised)) 
                drawPrimitive(PE_ButtonDropDown, p, ceData, elementFlags, menuarea, cg, mflags, opt);

            drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, menuarea, cg, mflags, opt);
        }

        if (tb->hasFocus() && !tb->focusProxy()) 
        {
            TQRect fr = tb->rect();
            fr.addCoords(2, 2, -2, -2);
            drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg);
        }

        // Set the color for the ToolButton menu indicator

        bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
        scrollmin = ( scrollbar->minValue() == scrollbar->value() );
        scrollmax = (( scrollbar->maxValue() == scrollbar->value() )|| maxedOut);
        subline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubLine, opt, widget);
        addline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, opt, widget);
        subpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubPage, opt, widget);
        addpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddPage, opt, widget);
        slider  = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSlider,  opt, widget);

        first   = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarFirst,   opt, widget);
        last    = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarLast,    opt, widget);

        if ((controls & SC_ScrollBarSubLine) && subline.isValid()) 
        {

                flags |= Style_Horizontal;
            if (hoverWidget == widget && hoverControl == HoverScrollBarSubLine)
                flags |= Style_MouseOver;
            drawPrimitive(PE_ScrollBarSubLine, p, ceData, elementFlags, subline, cg, flags);
        }
        if ((controls & SC_ScrollBarAddLine) && addline.isValid())
        {

                flags |= Style_Horizontal;
            if (hoverWidget == widget && hoverControl == HoverScrollBarAddLine)
                flags |= Style_MouseOver;
            drawPrimitive(PE_ScrollBarAddLine, p, ceData, elementFlags, addline, cg, flags);
        }
        if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
            drawPrimitive(PE_ScrollBarSubPage, p, ceData, elementFlags, subpage, cg,
                          Style_Enabled | ((active == SC_ScrollBarSubPage) ?
                                           Style_Down : Style_Default) |
                          ((scrollbar->orientation() == TQt::Horizontal) ?
                           Style_Horizontal : 0));
        if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
            drawPrimitive(PE_ScrollBarAddPage, p, ceData, elementFlags, addpage, cg,
                          ((maxedOut) ? Style_Default : Style_Enabled) |
                          ((active == SC_ScrollBarAddPage) ?
                           Style_Down : Style_Default) |
                          ((scrollbar->orientation() == TQt::Horizontal) ?
                           Style_Horizontal : 0));
        if ((controls & SC_ScrollBarFirst) && first.isValid())
            drawPrimitive(PE_ScrollBarFirst, p, ceData, elementFlags, first, cg,
                          Style_Enabled | ((active == SC_ScrollBarFirst) ?
                                           Style_Down : Style_Default) |
                          ((scrollbar->orientation() == TQt::Horizontal) ?
                           Style_Horizontal : 0));
        if ((controls & SC_ScrollBarLast) && last.isValid())
            drawPrimitive(PE_ScrollBarLast, p, ceData, elementFlags, last, cg,
                          Style_Enabled | ((active == SC_ScrollBarLast) ?
                                           Style_Down : Style_Default) |
                          ((scrollbar->orientation() == TQt::Horizontal) ?

                flags |= Style_Horizontal;
            if (hoverWidget == widget && hoverControl == HoverScrollBarSlider)
                flags |= Style_MouseOver;
            drawPrimitive(PE_ScrollBarSlider, p, ceData, elementFlags, slider, cg, flags);

            // ### perhaps this should not be able to accept focus if maxedOut?
            if (scrollbar->hasFocus()) 
            {
                TQRect fr(slider.x() + 2, slider.y() + 2,
                         slider.width() - 5, slider.height() - 5);
                drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, Style_Default);
            }
        }
        break;


            if( (controls & SC_ComboBoxEditField ))
            {
                TQRect ar = TQStyle::visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxEditField, opt, widget), widget );

                drawPrimitive( PE_PanelLineEdit, p, ceData, elementFlags, ar, cg );
            }
            //if ( controls & SC_ComboBoxListBoxPopup )
            //{

            //}
            if( (controls & SC_ComboBoxArrow ))
            {
                TQRect ar = TQStyle::visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow, opt, widget), widget );
                bool mouseOver = (flags & Style_MouseOver) && (hoverControl == HoverComboBoxArrow);
                if ( sunken )
                    renderGradient(p, TQRect(ar.x()+1, ar.y()+1, ar.width()-1, ar.height()-2), cdata->shades[2], cdata->shades[0], false);

                else
                    p->drawLine( ar.x(), ar.y()+1, ar.x(), ar.height()-2 );

                drawComboboxArrow( p,ceData,elementFlags,ar,cg,flags,active,widget);
            }
        }
        else

            TQPen oldPen = p->pen();

            // Get the button bounding box
            TQRect ar = TQStyle::visualRect(querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow, opt, widget), widget );
            drawButton(  cdata,r,p,cg,flags | (sunken ? Style_Down : Style_Default));

            //test reverse !

                p->drawLine( ar.x()-2,ar.y()+5,ar.x()-2,ar.height()-6);
            }

            drawComboboxArrow( p,ceData,elementFlags,ar,cg,flags,active,widget);
            p->setPen( oldPen );// restore pen

        }
        break;
    }
    default:
        TDEStyle::drawComplexControl(control, p, ceData, elementFlags,
                                   r, cg, flags, controls, active, opt, widget);
    }
}

TQRect MandrivaStyle::querySubControlMetrics( ComplexControl control,
                                             const TQStyleControlElementData &ceData,
                                             ControlElementFlags elementFlags,
                                             SubControl subcontrol,
                                             const TQStyleOption& opt,
                                             const TQWidget* widget ) const
{
    switch (control)
    {

        case SC_SpinWidgetButtonField:
            return TQRect( widget->width() -14 , 0, 14, widget->height() );
        default:
            return TDEStyle::querySubControlMetrics( control, ceData, elementFlags, subcontrol, opt, widget );
        }
    }
    //TODO verify it.

                return TQRect( 5, 1, widget->width() - arrow-12, widget->height() - 2);
        }
        default:
            return TDEStyle::querySubControlMetrics( control, ceData, elementFlags, subcontrol, opt, widget );
        }
        break;
    }

        bool horizontal = sl->orientation() == Horizontal;
        TQSlider::TickSetting ticks = sl->tickmarks();
        int pos = sl->sliderStart();
        int handleSize = pixelMetric( PM_SliderThickness, ceData, elementFlags, widget );
        int len = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
        switch ( subcontrol )
        {
        case SC_SliderHandle:

    default:
        break;
    }
    return TDEStyle::querySubControlMetrics( control, ceData, elementFlags, subcontrol, opt, widget );
}

void MandrivaStyle::drawComplexControlMask( ComplexControl control,
                                            TQPainter *p,
                                            const TQStyleControlElementData &ceData,
                                            ControlElementFlags elementFlags,
                                            const TQRect &r,
                                            const TQStyleOption& opt,
                                            const TQWidget *widget ) const
{
//TODO verify
//#if 0

    }

    default:
        TDEStyle::drawComplexControlMask(control, p, ceData, elementFlags, r, opt, widget);
    }
//#endif
        //TDEStyle::drawComplexControlMask(control, p, ceData, elementFlags, r, opt, widget);
}


int MandrivaStyle::pixelMetric(PixelMetric m, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
{
    switch(m)
    {

    case PM_TabBarTabShiftVertical:
        return 0;
    default:
        return TDEStyle::pixelMetric(m, ceData, elementFlags, widget);
    }
}


TQSize MandrivaStyle::sizeFromContents( ContentsType contents,
                                       const TQStyleControlElementData &ceData,
                                       ControlElementFlags elementFlags,
                                       const TQSize &contentSize,
                                       const TQStyleOption& opt,
                                       const TQWidget* widget ) const
{
    switch (contents)
    {

        }
        else
        {
            return TDEStyle::sizeFromContents( contents, ceData, elementFlags, contentSize, opt, widget );
        }
    }
    case CT_ComboBox:

        const TQPushButton* button = (const TQPushButton*) widget;
        int w  = contentSize.width();
        int h  = contentSize.height();
        int bm = pixelMetric( PM_ButtonMargin, ceData, elementFlags, widget );
        int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget ) * 2;

        w += bm + fw + 6;	// ### Add 6 to make way for bold font.
        h += bm + fw;

    }

    default:
        return TDEStyle::sizeFromContents( contents, ceData, elementFlags, contentSize, opt, widget );
    }
}

//Why ? why create virtual function ?
// Fix TQt's wacky image alignment
TQPixmap MandrivaStyle::stylePixmap(StylePixmap stylepixmap,
                                   const TQStyleControlElementData &ceData,
                                   ControlElementFlags elementFlags,
                                   const TQStyleOption& opt,
                                   const TQWidget* widget) const
{
    return TDEStyle::stylePixmap(stylepixmap, ceData, elementFlags, opt, widget);
}

bool MandrivaStyle::objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *ev )
{
	if (TDEStyle::objectEventHandler(ceData, elementFlags, source, ev)) {
		return true;
	}

	if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) {
		TQObject* obj = reinterpret_cast<TQObject*>(source);

		TQToolBar* toolbar;
		//Hover highlight on buttons and combos
		if ( obj->inherits("TQPushButton")
			 || obj->inherits("TQComboBox")
			 || obj->inherits("TQScrollBar")
			 || obj->inherits("TQHeader")
			 || obj->inherits("TQSlider")
			 || obj->inherits("TQCheckBox")
			 || obj->inherits("TQSplitterHandle"))
		{
			if ( (ev->type() == TQEvent::Enter) && static_cast<TQWidget*>(obj)->isEnabled())
			{
				TQWidget* button = static_cast<TQWidget*>(obj);
				hoverWidget = button;
				button->repaint( false );
			}
			else if ( (ev->type() == TQEvent::Leave) && (obj == hoverWidget) )
			{
				TQWidget* button = static_cast<TQWidget*>(obj);
				hoverWidget = 0;
				hoverControl = HoverNone;
				button->repaint( false );
			}
			if ((obj->inherits("TQScrollBar") || obj->inherits("TQComboBox"))
				&& ev->type() == TQEvent::MouseMove)
			{
				TQMouseEvent *e = static_cast<TQMouseEvent*>(ev);
				// updateHoverControl will trigger a repainting if necessary
				updateHoverControl(e->pos(), ceData, elementFlags);
			}

		}
		else if (obj->inherits("TQListBox"))
		{
			if ( ev->type() == TQEvent::Show || ev->type() == TQEvent::Hide)
			{
				TQWidget *w = static_cast<TQWidget*>(obj);
				if (w->parentWidget() && w->parentWidget()->inherits("TQComboBox"))
					w->parentWidget()->repaint(false);
			}
		}
		else if ( obj->parent() && !qstrcmp( obj->name(), kdeToolbarWidget ) )
		{
			// Draw a gradient background for custom widgets in the toolbar
			// that have specified a "tde toolbar widget" name.

			if (ev->type() == TQEvent::Paint ) 
			{
				// Find the top-level toolbar of this widget, since it may be nested in other
				// widgets that are on the toolbar.
				TQWidget *widget = static_cast<TQWidget*>(obj);
				TQWidget *parent = static_cast<TQWidget*>(obj->parent());
				int x_offset = widget->x(), y_offset = widget->y();
				while (parent && parent->parent() && !qstrcmp( parent->name(), kdeToolbarWidget ) )
				{
					x_offset += parent->x();
					y_offset += parent->y();
					parent = static_cast<TQWidget*>(parent->parent());
				}

				TQRect r  = widget->rect();
				TQRect pr = parent->rect();
				bool horiz_grad = pr.width() < pr.height();

				// Check if the parent is a TQToolbar, and use its orientation, else guess.
				TQToolBar* tb = dynamic_cast<TQToolBar*>(parent);
				if (tb) horiz_grad = tb->orientation() == TQt::Vertical;

				TQPainter p( widget );
				renderGradient(&p, r, parent->colorGroup().background(),parent->colorGroup().background(), horiz_grad);/*,
							   x_offset, y_offset, pr.width(), pr.height());*/
				//FIXME: check this code later
				return false;	// Now draw the contents
			}
		} 
		else if ( obj->parent() &&
					(toolbar = dynamic_cast<TQToolBar*>(obj->parent())) )
		{

			// We need to override the paint event to draw a
			// gradient on a TQToolBarExtensionWidget.
			if ( ev->type() == TQEvent::Paint ) 
			{
				TQWidget *widget = static_cast<TQWidget*>(obj);
				TQRect wr = widget->rect();
				TQPainter p( widget );
				renderGradient(&p, wr, toolbar->colorGroup().background(),toolbar->colorGroup().background(),
							   toolbar->orientation() == TQt::Vertical);/*,
							   wr.x(), wr.y(), tr.width() - 2, tr.height() - 2);*/
				//FIXME: check this code later
				p.setPen( toolbar->colorGroup().dark() );
				if ( toolbar->orientation() == TQt::Horizontal )
					p.drawLine( wr.width()-1, 0, wr.width()-1, wr.height()-1 );
				else
					p.drawLine( 0, wr.height()-1, wr.width()-1, wr.height()-1 );
				return true;
			}
		}
	}
    return false;
}



}

TQRect MandrivaStyle::subRect(SubRect r, const TQStyleControlElementData &ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const
{
    switch ( r )
    {

    }
    case SR_ComboBoxFocusRect:
    {
        return querySubControlMetrics( CC_ComboBox, ceData, elementFlags , SC_ComboBoxEditField, TQStyleOption::Default, widget );
    }
    default:
        return TDEStyle::subRect( r, ceData, elementFlags, widget );
    }
}


Return to bug 2086

Lines 51-72 Link Here

(-)./src/widget/ia_ora.h.ORI (-27 / +51 lines)
51	MandrivaStyle();	51	MandrivaStyle();
52	virtual ~MandrivaStyle();	52	virtual ~MandrivaStyle();
53		53
54	void polish( TQWidget* widget );	54	void polish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
55	void unPolish( TQWidget* widget );	55	void unPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
56	void polish( TQApplication *app );	56	void applicationPolish(const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void *);
57	void renderMenuBlendPixmap( KPixmap& pix, const TQColorGroup &cg,	57	void renderMenuBlendPixmap( KPixmap& pix, const TQColorGroup &cg,
58	const TQPopupMenu* popup ) const;	58	const TQPopupMenu* popup ) const;
59		59
60	void drawKStylePrimitive( TDEStylePrimitive kpe,	60	void drawTDEStylePrimitive( TDEStylePrimitive kpe,
61	TQPainter* p,	61	TQPainter* p,
62	const TQWidget* widget,	62	const TQStyleControlElementData &ceData,
		63	ControlElementFlags elementFlags,
63	const TQRect &r,	64	const TQRect &r,
64	const TQColorGroup &cg,	65	const TQColorGroup &cg,
65	SFlags flags = Style_Default,	66	SFlags flags = Style_Default,
66	const TQStyleOption& = TQStyleOption::Default ) const;	67	const TQStyleOption& = TQStyleOption::Default,
		68	const TQWidget* widget = 0 ) const;
67		69
68	void drawPrimitive( PrimitiveElement pe,	70	void drawPrimitive( PrimitiveElement pe,
69	TQPainter* p,	71	TQPainter* p,
		72	const TQStyleControlElementData &ceData,
		73	ControlElementFlags elementFlags,
70	const TQRect &r,	74	const TQRect &r,
71	const TQColorGroup &cg,	75	const TQColorGroup &cg,
72	SFlags flags = Style_Default,	76	SFlags flags = Style_Default,
Lines 74-127 Link Here
74		78
75	void drawControl( ControlElement element,	79	void drawControl( ControlElement element,
76	TQPainter *p,	80	TQPainter *p,
77	const TQWidget *widget,	81	const TQStyleControlElementData &ceData,
		82	ControlElementFlags elementFlags,
78	const TQRect &r,	83	const TQRect &r,
79	const TQColorGroup &cg,	84	const TQColorGroup &cg,
80	SFlags flags = Style_Default,	85	SFlags flags = Style_Default,
81	const TQStyleOption& = TQStyleOption::Default ) const;	86	const TQStyleOption& = TQStyleOption::Default,
		87	const TQWidget *widget = 0 ) const;
82		88
83	void drawControlMask( ControlElement element,	89	void drawControlMask( ControlElement element,
84	TQPainter *p,	90	TQPainter *p,
85	const TQWidget *widget,	91	const TQStyleControlElementData &ceData,
		92	ControlElementFlags elementFlags,
86	const TQRect &r,	93	const TQRect &r,
87	const TQStyleOption& = TQStyleOption::Default ) const;	94	const TQStyleOption& = TQStyleOption::Default,
		95	const TQWidget *widget = 0 ) const;
88		96
89	void drawComplexControl( ComplexControl control,	97	void drawComplexControl( ComplexControl control,
90	TQPainter *p,	98	TQPainter *p,
91	const TQWidget *widget,	99	const TQStyleControlElementData &ceData,
		100	ControlElementFlags elementFlags,
92	const TQRect &r,	101	const TQRect &r,
93	const TQColorGroup &cg,	102	const TQColorGroup &cg,
94	SFlags flags = Style_Default,	103	SFlags flags = Style_Default,
95	SCFlags controls = SC_All,	104	SCFlags controls = SC_All,
96	SCFlags active = SC_None,	105	SCFlags active = SC_None,
97	const TQStyleOption& = TQStyleOption::Default ) const;	106	const TQStyleOption& = TQStyleOption::Default ,
		107	const TQWidget *widget = 0 ) const;
98		108
99	void drawComplexControlMask( ComplexControl control,	109	void drawComplexControlMask( ComplexControl control,
100	TQPainter *p,	110	TQPainter *p,
101	const TQWidget *widget,	111	const TQStyleControlElementData &ceData,
		112	ControlElementFlags elementFlags,
102	const TQRect &r,	113	const TQRect &r,
103	const TQStyleOption& = TQStyleOption::Default ) const;	114	const TQStyleOption& = TQStyleOption::Default,
		115	const TQWidget *widget = 0 ) const;
104		116
105	int pixelMetric( PixelMetric m,	117	int pixelMetric( PixelMetric m,
		118	const TQStyleControlElementData &ceData,
		119	ControlElementFlags elementFlags,
106	const TQWidget *widget = 0 ) const;	120	const TQWidget *widget = 0 ) const;
107		121
108	TQSize sizeFromContents( ContentsType contents,	122	TQSize sizeFromContents( ContentsType contents,
109	const TQWidget *widget,	123	const TQStyleControlElementData &ceData,
110	const TQSize &contentSize,	124	ControlElementFlags elementFlags,
111	const TQStyleOption& opt ) const;	125	const TQSize &contentSize,
		126	const TQStyleOption& opt,
		127	const TQWidget *widget = 0 ) const;
112		128
113	TQRect subRect( SubRect r,	129	TQRect subRect( SubRect r,
114	const TQWidget *widget ) const;	130	const TQStyleControlElementData &ceData,
		131	const ControlElementFlags elementFlags,
		132	const TQWidget *widget ) const;
115		133
116	// Fix TQt3's wacky image positions	134	// Fix TQt3's wacky image positions
117	TQPixmap stylePixmap( StylePixmap stylepixmap,	135	TQPixmap stylePixmap( StylePixmap stylepixmap,
118	const TQWidget *widget = 0,	136	const TQStyleControlElementData &ceData,
119	const TQStyleOption& = TQStyleOption::Default ) const;	137	ControlElementFlags elementFlags,
		138	const TQStyleOption& = TQStyleOption::Default,
		139	const TQWidget *widget = 0 ) const;
120		140
121	TQRect querySubControlMetrics( ComplexControl control,	141	TQRect querySubControlMetrics( ComplexControl control,
122	const TQWidget* widget,	142	const TQStyleControlElementData &ceData,
123	SubControl subcontrol,	143	ControlElementFlags elementFlags,
124	const TQStyleOption& opt = TQStyleOption::Default ) const;	144	SubControl subcontrol,
		145	const TQStyleOption& opt = TQStyleOption::Default,
		146	const TQWidget* widget = 0 ) const;
125		147
126	protected:	148	protected:
127	enum Hover	149	enum Hover
Lines 141-147 Link Here
141	};	163	};
142		164
143		165
144	bool eventFilter( TQObject object, TQEvent event );	166	virtual bool objectEventHandler( const TQStyleControlElementData &ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
145		167
146	void renderGradient(TQPainter* p,	168	void renderGradient(TQPainter* p,
147	const TQRect& r,	169	const TQRect& r,
Lines 225-235 Link Here
225	bool active) const;	247	bool active) const;
226		248
227	void drawComboboxArrow( TQPainter *p,	249	void drawComboboxArrow( TQPainter *p,
228	const TQWidget *widget,	250	const TQStyleControlElementData &ceData,
		251	ControlElementFlags elementFlags,
229	const TQRect &r,	252	const TQRect &r,
230	const TQColorGroup &cg,	253	const TQColorGroup &cg,
231	SFlags flags,	254	SFlags flags,
232	SCFlags active)const;	255	SCFlags active,
		256	const TQWidget *widget)const;
233		257
234	void drawMandrivaArrow( TQPointArray a, TQPainter *p,	258	void drawMandrivaArrow( TQPointArray a, TQPainter *p,
235	const TQRect &r,	259	const TQRect &r,
Lines 243-249 Link Here
243	bool isFormWidget(const TQWidget* widget) const;	267	bool isFormWidget(const TQWidget* widget) const;
244	bool excludeColor(const TQColor &col, bool active) const;	268	bool excludeColor(const TQColor &col, bool active) const;
245	void getShade (const TQColorGroup &cg, int shadenr, TQColor &res) const;	269	void getShade (const TQColorGroup &cg, int shadenr, TQColor &res) const;
246	void updateHoverControl(const TQPoint &pos);	270	void updateHoverControl(const TQPoint &pos, const TQStyleControlElementData &ceData, ControlElementFlags elementFlags);
247	TQIntCache<MandrivaColorData> m_dataCache;	271	TQIntCache<MandrivaColorData> m_dataCache;
248	static const double shading[8];	272	static const double shading[8];
249	mutable bool formMode;	273	mutable bool formMode;