Changeset 8127 in ntrip for trunk/BNC/qwt/qwt_legend.cpp

Timestamp:

May 10, 2017, 3:20:54 PM (7 years ago)

Author:

stoecker

Message:

update qwt and qwtpolar, many QT5 fixes (unfinished)

File:

• trunk/BNC/qwt/qwt_legend.cpp (modified) (15 diffs)

trunk/BNC/qwt/qwt_legend.cpp

@@ -9 +9 @@
 
 #include "qwt_legend.h"
-#include "qwt_legend_itemmanager.h"
-#include "qwt_legend_item.h"
+#include "qwt_legend_label.h"
 #include "qwt_dyngrid_layout.h"
 #include "qwt_math.h"
+#include "qwt_plot_item.h"
+#include "qwt_painter.h"
 #include <qapplication.h>
-#include <qmap.h>
 #include <qscrollbar.h>
 #include <qscrollarea.h>
+#include <qpainter.h>
+#include <qstyle.h>
+#include <qstyleoption.h>
+
+class QwtLegendMap
+{
+public:
+    inline bool isEmpty() const { return d_entries.isEmpty(); }
+
+    void insert( const QVariant &, const QList<QWidget *> & );
+    void remove( const QVariant & );
+
+    void removeWidget( const QWidget * );
+
+    QList<QWidget *> legendWidgets( const QVariant & ) const;
+    QVariant itemInfo( const QWidget * ) const;
+
+private:
+    // we don't know anything about itemInfo and therefore don't have
+    // any key that can be used for a map or hashtab.
+    // But a simple linear list is o.k. here, as we will never have
+    // more than a few entries.
+
+    class Entry
+    {
+    public:
+        QVariant itemInfo;
+        QList<QWidget *> widgets;
+    };
+
+    QList< Entry > d_entries;
+};
+
+void QwtLegendMap::insert( const QVariant &itemInfo, 
+    const QList<QWidget *> &widgets )
+{
+    for ( int i = 0; i < d_entries.size(); i++ )
+    {
+        Entry &entry = d_entries[i];
+        if ( entry.itemInfo == itemInfo )
+        {
+            entry.widgets = widgets;
+            return;
+        }
+    }
+
+    Entry newEntry;
+    newEntry.itemInfo = itemInfo;
+    newEntry.widgets = widgets;
+
+    d_entries += newEntry;
+}
+
+void QwtLegendMap::remove( const QVariant &itemInfo )
+{
+    for ( int i = 0; i < d_entries.size(); i++ )
+    {
+        Entry &entry = d_entries[i];
+        if ( entry.itemInfo == itemInfo )
+        {
+            d_entries.removeAt( i );
+            return;
+        }
+    }
+}
+
+void QwtLegendMap::removeWidget( const QWidget *widget )
+{
+    QWidget *w = const_cast<QWidget *>( widget );
+
+    for ( int i = 0; i < d_entries.size(); i++ )
+        d_entries[ i ].widgets.removeAll( w );
+}
+
+QVariant QwtLegendMap::itemInfo( const QWidget *widget ) const
+{
+    if ( widget != NULL )
+    {
+        QWidget *w = const_cast<QWidget *>( widget );
+
+        for ( int i = 0; i < d_entries.size(); i++ )
+        {
+            const Entry &entry = d_entries[i];
+            if ( entry.widgets.indexOf( w ) >= 0 )
+                return entry.itemInfo;
+        }
+    }
+
+    return QVariant();
+}
+
+QList<QWidget *> QwtLegendMap::legendWidgets( const QVariant &itemInfo ) const
+{
+    if ( itemInfo.isValid() )
+    {
+        for ( int i = 0; i < d_entries.size(); i++ )
+        {
+            const Entry &entry = d_entries[i];
+            if ( entry.itemInfo == itemInfo )
+                return entry.widgets;
+        }
+    }
+
+    return QList<QWidget *>();
+}
 
 class QwtLegend::PrivateData
 {
 public:
-    class LegendMap
-    {
-    public:
-        void insert( const QwtLegendItemManager *, QWidget * );
-
-        void remove( const QwtLegendItemManager * );
-        void remove( QWidget * );
-
-        void clear();
-
-        uint count() const;
-
-        inline const QWidget *find( const QwtLegendItemManager * ) const;
-        inline QWidget *find( const QwtLegendItemManager * );
-
-        inline const QwtLegendItemManager *find( const QWidget * ) const;
-        inline QwtLegendItemManager *find( const QWidget * );
-
-        const QMap<QWidget *, const QwtLegendItemManager *> &widgetMap() const;
-        QMap<QWidget *, const QwtLegendItemManager *> &widgetMap();
-
-    private:
-        QMap<QWidget *, const QwtLegendItemManager *> d_widgetMap;
-        QMap<const QwtLegendItemManager *, QWidget *> d_itemMap;
-    };
-
-    QwtLegend::LegendItemMode itemMode;
-
-    LegendMap map;
+    PrivateData():
+        itemMode( QwtLegendData::ReadOnly ),
+        view( NULL )
+    {
+    }
+
+    QwtLegendData::Mode itemMode;
+    QwtLegendMap itemMap;
 
     class LegendView;
@@ -61 +145 @@
         QScrollArea( parent )
     {
-        setFocusPolicy( Qt::NoFocus );
-
         contentsWidget = new QWidget( this );
         contentsWidget->setObjectName( "QwtLegendViewContents" );
@@ -77 +159 @@
     }
 
-    virtual bool viewportEvent( QEvent *e )
-    {
-        bool ok = QScrollArea::viewportEvent( e );
-
-        if ( e->type() == QEvent::Resize )
-        {
-            QEvent event( QEvent::LayoutRequest );
-            QApplication::sendEvent( contentsWidget, &event );
+    virtual bool event( QEvent *event )
+    {
+        if ( event->type() == QEvent::PolishRequest )
+        {
+            setFocusPolicy( Qt::NoFocus );
+        }
+
+        if ( event->type() == QEvent::Resize )
+        {
+            // adjust the size to en/disable the scrollbars
+            // before QScrollArea adjusts the viewport size
+
+            const QRect cr = contentsRect();
+
+            int w = cr.width();
+            int h = contentsWidget->heightForWidth( cr.width() );
+            if ( h > w )
+            {
+                w -= verticalScrollBar()->sizeHint().width();
+                h = contentsWidget->heightForWidth( w );
+            }
+
+            contentsWidget->resize( w, h );
+        }
+
+        return QScrollArea::event( event );
+    }
+
+    virtual bool viewportEvent( QEvent *event )
+    {
+        bool ok = QScrollArea::viewportEvent( event );
+
+        if ( event->type() == QEvent::Resize )
+        {
+            layoutContents();
         }
         return ok;
@@ -112 +221 @@
     }
 
+    void layoutContents()
+    {
+        const QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+            contentsWidget->layout() );
+        if ( tl == NULL )
+            return;
+
+        const QSize visibleSize = viewport()->contentsRect().size();
+
+        const int minW = int( tl->maxItemWidth() ) + 2 * tl->margin();
+
+        int w = qMax( visibleSize.width(), minW );
+        int h = qMax( tl->heightForWidth( w ), visibleSize.height() );
+
+        const int vpWidth = viewportSize( w, h ).width();
+        if ( w > vpWidth )
+        {
+            w = qMax( vpWidth, minW );
+            h = qMax( tl->heightForWidth( w ), visibleSize.height() );
+        }
+
+        contentsWidget->resize( w, h );
+    }
+
     QWidget *contentsWidget;
 };
 
-void QwtLegend::PrivateData::LegendMap::insert(
-    const QwtLegendItemManager *item, QWidget *widget )
-{
-    d_itemMap.insert( item, widget );
-    d_widgetMap.insert( widget, item );
-}
-
-void QwtLegend::PrivateData::LegendMap::remove( const QwtLegendItemManager *item )
-{
-    QWidget *widget = d_itemMap[item];
-    d_itemMap.remove( item );
-    d_widgetMap.remove( widget );
-}
-
-void QwtLegend::PrivateData::LegendMap::remove( QWidget *widget )
-{
-    const QwtLegendItemManager *item = d_widgetMap[widget];
-    d_itemMap.remove( item );
-    d_widgetMap.remove( widget );
-}
-
-void QwtLegend::PrivateData::LegendMap::clear()
-{
-
-    /*
-       We can't delete the widgets in the following loop, because
-       we would get ChildRemoved events, changing d_itemMap, while
-       we are iterating.
-     */
-
-    QList<const QWidget *> widgets;
-
-    QMap<const QwtLegendItemManager *, QWidget *>::const_iterator it;
-    for ( it = d_itemMap.begin(); it != d_itemMap.end(); ++it )
-        widgets.append( it.value() );
-
-    d_itemMap.clear();
-    d_widgetMap.clear();
-
-    for ( int i = 0; i < widgets.size(); i++ )
-        delete widgets[i];
-}
-
-uint QwtLegend::PrivateData::LegendMap::count() const
-{
-    return d_itemMap.count();
-}
-
-inline const QWidget *QwtLegend::PrivateData::LegendMap::find( 
-    const QwtLegendItemManager *item ) const
-{
-    if ( !d_itemMap.contains( item ) )
-        return NULL;
-
-    return d_itemMap[item];
-}
-
-inline QWidget *QwtLegend::PrivateData::LegendMap::find( 
-    const QwtLegendItemManager *item )
-{
-    if ( !d_itemMap.contains( item ) )
-        return NULL;
-
-    return d_itemMap[item];
-}
-
-inline const QwtLegendItemManager *QwtLegend::PrivateData::LegendMap::find(
-    const QWidget *widget ) const
-{
-    QWidget *w = const_cast<QWidget *>( widget );
-    if ( !d_widgetMap.contains( w ) )
-        return NULL;
-
-    return d_widgetMap[w];
-}
-
-inline QwtLegendItemManager *QwtLegend::PrivateData::LegendMap::find(
-    const QWidget *widget )
-{
-    QWidget *w = const_cast<QWidget *>( widget );
-    if ( !d_widgetMap.contains( w ) )
-        return NULL;
-
-    return const_cast<QwtLegendItemManager *>( d_widgetMap[w] );
-}
-
-inline const QMap<QWidget *, const QwtLegendItemManager *> &
-QwtLegend::PrivateData::LegendMap::widgetMap() const
-{
-    return d_widgetMap;
-}
-
-inline QMap<QWidget *, const QwtLegendItemManager *> &
-QwtLegend::PrivateData::LegendMap::widgetMap()
-{
-    return d_widgetMap;
-}
-
 /*!
   Constructor
-
   \param parent Parent widget
 */
 QwtLegend::QwtLegend( QWidget *parent ):
-    QFrame( parent )
+    QwtAbstractLegend( parent )
 {
     setFrameStyle( NoFrame );
 
     d_data = new QwtLegend::PrivateData;
-    d_data->itemMode = QwtLegend::ReadOnlyItem;
 
     d_data->view = new QwtLegend::PrivateData::LegendView( this );
@@ -247 +280 @@
 }
 
-//! \sa LegendItemMode
-void QwtLegend::setItemMode( LegendItemMode mode )
+/*!
+  \brief Set the maximum number of entries in a row
+
+  F.e when the maximum is set to 1 all items are aligned
+  vertically. 0 means unlimited
+
+  \param numColums Maximum number of entries in a row
+
+  \sa maxColumns(), QwtDynGridLayout::setMaxColumns()
+ */
+void QwtLegend::setMaxColumns( uint numColums )
+{
+    QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
+        d_data->view->contentsWidget->layout() );
+    if ( tl )
+        tl->setMaxColumns( numColums );
+}
+
+/*!
+  \return Maximum number of entries in a row
+  \sa setMaxColumns(), QwtDynGridLayout::maxColumns()
+ */
+uint QwtLegend::maxColumns() const
+{
+    uint maxCols = 0;
+
+    const QwtDynGridLayout *tl = qobject_cast<const QwtDynGridLayout *>(
+        d_data->view->contentsWidget->layout() );
+    if ( tl )
+        maxCols = tl->maxColumns();
+
+    return maxCols;
+}
+
+/*!
+  \brief Set the default mode for legend labels
+
+  Legend labels will be constructed according to the
+  attributes in a QwtLegendData object. When it doesn't
+  contain a value for the QwtLegendData::ModeRole the
+  label will be initialized with the default mode of the legend.
+
+  \param mode Default item mode
+
+  \sa itemMode(), QwtLegendData::value(), QwtPlotItem::legendData()
+  \note Changing the mode doesn't have any effect on existing labels.
+ */
+void QwtLegend::setDefaultItemMode( QwtLegendData::Mode mode )
 {
     d_data->itemMode = mode;
 }
 
-//! \sa LegendItemMode
-QwtLegend::LegendItemMode QwtLegend::itemMode() const
+/*!
+  \return Default item mode
+  \sa setDefaultItemMode()
+*/
+QwtLegendData::Mode QwtLegend::defaultItemMode() const
 {
     return d_data->itemMode;
@@ -261 +343 @@
 /*!
   The contents widget is the only child of the viewport of 
-  the internal QScrollArea  and the parent widget of all legend items.
+  the internal QScrollArea and the parent widget of all legend items.
 
   \return Container widget of the legend items
@@ -290 +372 @@
 /*!
   The contents widget is the only child of the viewport of 
-  the internal QScrollArea  and the parent widget of all legend items.
+  the internal QScrollArea and the parent widget of all legend items.
 
   \return Container widget of the legend items
@@ -301 +383 @@
 
 /*!
-  Insert a new item for a plot item
-  \param plotItem Plot item
-  \param legendItem New legend item
-  \note The parent of item will be changed to contentsWidget()
-*/
-void QwtLegend::insert( const QwtLegendItemManager *plotItem, QWidget *legendItem )
-{
-    if ( legendItem == NULL || plotItem == NULL )
-        return;
-
-    QWidget *contentsWidget = d_data->view->contentsWidget;
-
-    if ( legendItem->parent() != contentsWidget )
-        legendItem->setParent( contentsWidget );
-
-    legendItem->show();
-
-    d_data->map.insert( plotItem, legendItem );
-
-    layoutContents();
-
-    if ( contentsWidget->layout() )
-    {
-        contentsWidget->layout()->addWidget( legendItem );
-
+  \brief Update the entries for an item
+
+  \param itemInfo Info for an item
+  \param data List of legend entry attributes for the item
+ */
+void QwtLegend::updateLegend( const QVariant &itemInfo, 
+    const QList<QwtLegendData> &data )
+{
+    QList<QWidget *> widgetList = legendWidgets( itemInfo );
+
+    if ( widgetList.size() != data.size() )
+    {
+        QLayout *contentsLayout = d_data->view->contentsWidget->layout();
+
+        while ( widgetList.size() > data.size() )
+        {
+            QWidget *w = widgetList.takeLast();
+
+            contentsLayout->removeWidget( w );
+
+            // updates might be triggered by signals from the legend widget
+            // itself. So we better don't delete it here.
+
+            w->hide();
+            w->deleteLater();
+        }
+
+        for ( int i = widgetList.size(); i < data.size(); i++ )
+        {
+            QWidget *widget = createWidget( data[i] );
+
+            if ( contentsLayout )
+                contentsLayout->addWidget( widget );
+
+            if ( isVisible() )
+            {
+                // QLayout does a delayed show, with the effect, that
+                // the size hint will be wrong, when applications
+                // call replot() right after changing the list
+                // of plot items. So we better do the show now.
+
+                widget->setVisible( true );
+            }
+
+            widgetList += widget;
+        }
+
+        if ( widgetList.isEmpty() )
+        {
+            d_data->itemMap.remove( itemInfo );
+        }
+        else
+        {
+            d_data->itemMap.insert( itemInfo, widgetList );
+        }
+
+        updateTabOrder();
+    }
+    
+    for ( int i = 0; i < data.size(); i++ )
+        updateWidget( widgetList[i], data[i] );
+}
+
+/*!
+  \brief Create a widget to be inserted into the legend
+
+  The default implementation returns a QwtLegendLabel.
+
+  \param data Attributes of the legend entry
+  \return Widget representing data on the legend
+  
+  \note updateWidget() will called soon after createWidget()
+        with the same attributes.
+ */
+QWidget *QwtLegend::createWidget( const QwtLegendData &data ) const
+{
+    Q_UNUSED( data );
+
+    QwtLegendLabel *label = new QwtLegendLabel();
+    label->setItemMode( defaultItemMode() );
+
+    connect( label, SIGNAL( clicked() ), SLOT( itemClicked() ) );
+    connect( label, SIGNAL( checked( bool ) ), SLOT( itemChecked( bool ) ) );
+
+    return label;
+}
+
+/*!
+  \brief Update the widget 
+
+  \param widget Usually a QwtLegendLabel
+  \param data Attributes to be displayed
+
+  \sa createWidget()
+  \note When widget is no QwtLegendLabel updateWidget() does nothing.
+ */
+void QwtLegend::updateWidget( QWidget *widget, const QwtLegendData &data )
+{
+    QwtLegendLabel *label = qobject_cast<QwtLegendLabel *>( widget );
+    if ( label )
+    {
+        label->setData( data );
+        if ( !data.value( QwtLegendData::ModeRole ).isValid() )
+        {
+            // use the default mode, when there is no specific
+            // hint from the legend data
+
+            label->setItemMode( defaultItemMode() );
+        }
+    }
+}
+
+void QwtLegend::updateTabOrder()
+{
+    QLayout *contentsLayout = d_data->view->contentsWidget->layout();
+    if ( contentsLayout )
+    {
         // set tab focus chain
 
         QWidget *w = NULL;
 
-        for ( int i = 0; i < contentsWidget->layout()->count(); i++ )
-        {
-            QLayoutItem *item = contentsWidget->layout()->itemAt( i );
+        for ( int i = 0; i < contentsLayout->count(); i++ )
+        {
+            QLayoutItem *item = contentsLayout->itemAt( i );
             if ( w && item->widget() )
                 QWidget::setTabOrder( w, item->widget() );
@@ -339 +513 @@
         }
     }
-    if ( parentWidget() && parentWidget()->layout() == NULL )
-    {
-        /*
-           updateGeometry() doesn't post LayoutRequest in certain
-           situations, like when we are hidden. But we want the
-           parent widget notified, so it can show/hide the legend
-           depending on its items.
-         */
-        QApplication::postEvent( parentWidget(),
-            new QEvent( QEvent::LayoutRequest ) );
-    }
-}
-
-/*!
-  Find the widget that represents a plot item
-
-  \param plotItem Plot item
-  \return Widget on the legend, or NULL
-*/
-QWidget *QwtLegend::find( const QwtLegendItemManager *plotItem ) const
-{
-    return d_data->map.find( plotItem );
-}
-
-/*!
-  Find the widget that represents a plot item
-
-  \param legendItem Legend item
-  \return Widget on the legend, or NULL
-*/
-QwtLegendItemManager *QwtLegend::find( const QWidget *legendItem ) const
-{
-    return d_data->map.find( legendItem );
-}
-
-/*!
-   Find the corresponding item for a plotItem and remove it
-   from the item list.
-
-   \param plotItem Plot item
-*/
-void QwtLegend::remove( const QwtLegendItemManager *plotItem )
-{
-    QWidget *legendItem = d_data->map.find( plotItem );
-    d_data->map.remove( legendItem );
-    delete legendItem;
-}
-
-//! Remove all items.
-void QwtLegend::clear()
-{
-    bool doUpdate = updatesEnabled();
-    if ( doUpdate )
-        setUpdatesEnabled( false );
-
-    d_data->map.clear();
-
-    if ( doUpdate )
-        setUpdatesEnabled( true );
-
-    update();
 }
 
@@ -412 +525 @@
 
 /*!
-  \return The preferred height, for the width w.
+  \return The preferred height, for a width.
   \param width Width
 */
@@ -426 +539 @@
 }
 
-/*!
-  Adjust contents widget and item layout to the size of the viewport().
-*/
-void QwtLegend::layoutContents()
-{
-    const QSize visibleSize = 
-        d_data->view->viewport()->contentsRect().size();
-
-    const QwtDynGridLayout *tl = qobject_cast<QwtDynGridLayout *>(
-        d_data->view->contentsWidget->layout() );
-    if ( tl )
-    {
-        const int minW = int( tl->maxItemWidth() ) + 2 * tl->margin();
-
-        int w = qMax( visibleSize.width(), minW );
-        int h = qMax( tl->heightForWidth( w ), visibleSize.height() );
-
-        const int vpWidth = d_data->view->viewportSize( w, h ).width();
-        if ( w > vpWidth )
-        {
-            w = qMax( vpWidth, minW );
-            h = qMax( tl->heightForWidth( w ), visibleSize.height() );
-        }
-
-        d_data->view->contentsWidget->resize( w, h );
-    }
-}
 
 /*!
@@ -460 +546 @@
   \param object Object to be filtered
   \param event Event
+
+  \return Forwarded to QwtAbstractLegend::eventFilter()
 */
 bool QwtLegend::eventFilter( QObject *object, QEvent *event )
@@ -474 +562 @@
                 {
                     QWidget *w = static_cast< QWidget * >( ce->child() );
-                    d_data->map.remove( w );
+                    d_data->itemMap.removeWidget( w );
                 }
                 break;
@@ -480 +568 @@
             case QEvent::LayoutRequest:
             {
-                layoutContents();
+                d_data->view->layoutContents();
+
+                if ( parentWidget() && parentWidget()->layout() == NULL )
+                {
+                    /*
+                       We want the parent widget ( usually QwtPlot ) to recalculate
+                       its layout, when the contentsWidget has changed. But
+                       because of the scroll view we have to forward the LayoutRequest
+                       event manually.
+
+                       We don't use updateGeometry() because it doesn't post LayoutRequest
+                       events when the legend is hidden. But we want the
+                       parent widget notified, so it can show/hide the legend
+                       depending on its items.
+                     */
+                    QApplication::postEvent( parentWidget(),
+                        new QEvent( QEvent::LayoutRequest ) );
+                }                
                 break;
             }
@@ -488 +593 @@
     }
 
-    return QFrame::eventFilter( object, event );
-}
-
-
-//! Return true, if there are no legend items.
+    return QwtAbstractLegend::eventFilter( object, event );
+}
+
+/*!
+  Called internally when the legend has been clicked on.
+  Emits a clicked() signal.
+*/
+void QwtLegend::itemClicked()
+{
+    QWidget *w = qobject_cast<QWidget *>( sender() );
+    if ( w )
+    {
+        const QVariant itemInfo = d_data->itemMap.itemInfo( w );
+        if ( itemInfo.isValid() )
+        {
+            const QList<QWidget *> widgetList =
+                d_data->itemMap.legendWidgets( itemInfo );
+
+            const int index = widgetList.indexOf( w );
+            if ( index >= 0 )
+                Q_EMIT clicked( itemInfo, index );
+        }
+    }
+}
+
+/*!
+  Called internally when the legend has been checked
+  Emits a checked() signal.
+*/
+void QwtLegend::itemChecked( bool on )
+{
+    QWidget *w = qobject_cast<QWidget *>( sender() );
+    if ( w )
+    {
+        const QVariant itemInfo = d_data->itemMap.itemInfo( w );
+        if ( itemInfo.isValid() )
+        {
+            const QList<QWidget *> widgetList =
+                d_data->itemMap.legendWidgets( itemInfo );
+
+            const int index = widgetList.indexOf( w );
+            if ( index >= 0 )
+                Q_EMIT checked( itemInfo, on, index );
+        }
+    }
+}
+
+/*!
+  Render the legend into a given rectangle.
+
+  \param painter Painter
+  \param rect Bounding rectangle
+  \param fillBackground When true, fill rect with the widget background 
+
+  \sa renderLegend() is used by QwtPlotRenderer - not by QwtLegend itself
+*/
+void QwtLegend::renderLegend( QPainter *painter, 
+    const QRectF &rect, bool fillBackground ) const
+{
+    if ( d_data->itemMap.isEmpty() )
+        return;
+
+    if ( fillBackground )
+    {
+        if ( autoFillBackground() ||
+            testAttribute( Qt::WA_StyledBackground ) )
+        {
+            QwtPainter::drawBackgound( painter, rect, this );
+        }
+    }
+
+    const QwtDynGridLayout *legendLayout = 
+        qobject_cast<QwtDynGridLayout *>( contentsWidget()->layout() );
+    if ( legendLayout == NULL )
+        return;
+
+    int left, right, top, bottom;
+    getContentsMargins( &left, &top, &right, &bottom );
+
+    QRect layoutRect; 
+    layoutRect.setLeft( qCeil( rect.left() ) + left );
+    layoutRect.setTop( qCeil( rect.top() ) + top );
+    layoutRect.setRight( qFloor( rect.right() ) - right );
+    layoutRect.setBottom( qFloor( rect.bottom() ) - bottom );
+
+    uint numCols = legendLayout->columnsForWidth( layoutRect.width() );
+    QList<QRect> itemRects =
+        legendLayout->layoutItems( layoutRect, numCols );
+
+    int index = 0;
+
+    for ( int i = 0; i < legendLayout->count(); i++ )
+    {
+        QLayoutItem *item = legendLayout->itemAt( i );
+        QWidget *w = item->widget();
+        if ( w )
+        {
+            painter->save();
+
+            painter->setClipRect( itemRects[index], Qt::IntersectClip );
+            renderItem( painter, w, itemRects[index], fillBackground );
+
+            index++;
+            painter->restore();
+        }
+    }
+}
+
+/*!
+  Render a legend entry into a given rectangle.
+
+  \param painter Painter
+  \param widget Widget representing a legend entry
+  \param rect Bounding rectangle
+  \param fillBackground When true, fill rect with the widget background 
+
+  \note When widget is not derived from QwtLegendLabel renderItem
+        does nothing beside the background
+*/
+void QwtLegend::renderItem( QPainter *painter, 
+    const QWidget *widget, const QRectF &rect, bool fillBackground ) const
+{
+    if ( fillBackground )
+    {
+        if ( widget->autoFillBackground() ||
+            widget->testAttribute( Qt::WA_StyledBackground ) )
+        {
+            QwtPainter::drawBackgound( painter, rect, widget );
+        }
+    }
+
+    const QwtLegendLabel *label = qobject_cast<const QwtLegendLabel *>( widget );
+    if ( label )
+    {
+        // icon
+
+        const QwtGraphic &icon = label->data().icon();
+        const QSizeF sz = icon.defaultSize();
+
+        const QRectF iconRect( rect.x() + label->margin(),
+            rect.center().y() - 0.5 * sz.height(), 
+            sz.width(), sz.height() );
+
+        icon.render( painter, iconRect, Qt::KeepAspectRatio );
+
+        // title
+
+        QRectF titleRect = rect;
+        titleRect.setX( iconRect.right() + 2 * label->spacing() );
+
+        painter->setFont( label->font() );
+        painter->setPen( label->palette().color( QPalette::Text ) );
+        const_cast< QwtLegendLabel *>( label )->drawText( painter, titleRect );
+    }
+}
+
+/*!
+  \return List of widgets associated to a item
+  \param itemInfo Info about an item
+  \sa legendWidget(), itemInfo(), QwtPlot::itemToInfo()
+ */
+QList<QWidget *> QwtLegend::legendWidgets( const QVariant &itemInfo ) const
+{
+    return d_data->itemMap.legendWidgets( itemInfo );
+}
+
+/*!
+  \return First widget in the list of widgets associated to an item
+  \param itemInfo Info about an item
+  \sa itemInfo(), QwtPlot::itemToInfo()
+  \note Almost all types of items have only one widget
+*/
+QWidget *QwtLegend::legendWidget( const QVariant &itemInfo ) const
+{
+    const QList<QWidget *> list = d_data->itemMap.legendWidgets( itemInfo );
+    if ( list.isEmpty() )
+        return NULL;
+
+    return list[0];
+}
+
+/*!
+  Find the item that is associated to a widget
+
+  \param widget Widget on the legend
+  \return Associated item info
+  \sa legendWidget()
+ */
+QVariant QwtLegend::itemInfo( const QWidget *widget ) const
+{
+    return d_data->itemMap.itemInfo( widget );
+}
+
+//! \return True, when no item is inserted
 bool QwtLegend::isEmpty() const
 {
-    return d_data->map.count() == 0;
-}
-
-//! Return the number of legend items.
-uint QwtLegend::itemCount() const
-{
-    return d_data->map.count();
-}
-
-//! Return a list of all legend items
-QList<QWidget *> QwtLegend::legendItems() const
-{
-    const QMap<QWidget *, const QwtLegendItemManager *> &map =
-        d_data->map.widgetMap();
-
-    QList<QWidget *> list;
-
-    QMap<QWidget *, const QwtLegendItemManager *>::const_iterator it;
-    for ( it = map.begin(); it != map.end(); ++it )
-        list += it.key();
-
-    return list;
-}
+    return d_data->itemMap.isEmpty();
+}
+
+/*!
+    Return the extent, that is needed for the scrollbars
+
+    \param orientation Orientation ( 
+    \return The width of the vertical scrollbar for Qt::Horizontal and v.v.
+ */
+int QwtLegend::scrollExtent( Qt::Orientation orientation ) const
+{
+    int extent = 0;
+
+    if ( orientation == Qt::Horizontal )
+        extent = verticalScrollBar()->sizeHint().width();
+    else
+        extent = horizontalScrollBar()->sizeHint().height();
+
+    return extent;
+}
+