YQPkgPatternList.cc

/**************************************************************************
Copyright (C) 2000 - 2010 Novell, Inc.
All Rights Reserved.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
**************************************************************************/
 
 
/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/
 
  File:       YQPkgPatternList.cc
 
  Author:     Stefan Hundhammer <sh@suse.de>
 
  Textdomain "qt-pkg"
 
/-*/
 
#define YUILogComponent "qt-pkg"
#include "YUILog.h"
#include <QRegExp>
#include <zypp/ZYppFactory.h>
#include <zypp/Resolver.h>
#include <QPainter>
#include <QHeaderView>
#include <QLabel>
#include <QLayout>
#include <QItemDelegate>
 
#include "YQi18n.h"
#include "utf8.h"
#include "YQPackageSelector.h"
#include "YQPkgPatternList.h"
#include "YQIconPool.h"
#include "YQApplication.h"
#include "YQUI.h"
 
using std::string;
using std::set;
 
 
class YQPkgPatternItemDelegate : public QItemDelegate
{
    YQPkgPatternList *_view;
 
public:
 
    YQPkgPatternItemDelegate( YQPkgPatternList *parent ) : QItemDelegate( parent ), _view( parent )
    {
    }
 
 
    virtual void paint ( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
    {
        painter->save();
 
        YQPkgPatternCategoryItem *citem = dynamic_cast<YQPkgPatternCategoryItem *>(_view->itemFromIndex(index));
 
        // special painting for category items
        if ( citem )
        {
            QFont f = painter->font();
            f.setWeight( QFont::Bold );
            QFontMetrics fm(f);
            f.setPixelSize( (int) ( fm.height() * 1.1 ) );
            citem->setFont( _view->summaryCol(), f );
 
            QItemDelegate::paint( painter, option, index );
            painter->restore();
            return;
        }
 
        YQPkgPatternListItem *item = dynamic_cast<YQPkgPatternListItem *>( _view->itemFromIndex( index ) );
 
        if ( item )
        {
            //if ( index.column() == _view->howmanyCol() )
            if ( false )
            {
                QColor background = option.palette.color(QPalette::Window);
                painter->setBackground( background );
 
                float percent = (item->totalPackages() > 0)
                    ? (((float)item->installedPackages()*100) / (float)item->totalPackages())
                    : 0;
 
                QColor fillColor = option.palette.color(QPalette::Mid);
 
                if ( percent > 100.0 )  percent = 100.0;
                if ( percent < 0.0       )      percent = 0.0;
                int x = option.rect.left() + 1;
                int y = option.rect.top() + 1;
                int w = option.rect.width() - 2;
                int h = (int) ( ( (float) option.rect.height() )/2 );
                int fillWidth = 0;
                if ( w > 0 )
                {
                    fillWidth = (int) ( w * percent / 100.0 );
 
                    // Fill the desired percentage.
 
                    painter->fillRect( x, y,  fillWidth, h, fillColor );
 
                    QString percentageText = QString( "%1/%2" )
                        .arg( item->installedPackages() )
                        .arg( item->totalPackages() );
 
                    painter->setPen( _view->palette().color( QPalette::Base ) );
                    painter->drawText( QRect( x, y,
                                              w, h ),
                                       Qt::AlignHCenter, percentageText );
                    painter->restore();
                }
                painter->restore();
                return;
 
            }
            else
            {
                painter->restore();
                QItemDelegate::paint( painter, option, index );
            }
        }
    }
};
 
 
YQPkgPatternList::YQPkgPatternList( QWidget * parent, bool autoFill, bool autoFilter )
    : YQPkgObjList( parent )
    , _howmanyCol(0)
{
    yuiDebug() << "Creating pattern list" << std::endl;
 
    int numCol = 0;
    QStringList headers;
    //headers << "";
    headers << "";      _statusCol      = numCol++;
 
    // Translators: "Pattern" refers to so-called "installation patterns",
    // i.e., specific task-oriented groups of packages, like "everything that
    // is needed to run a web server". The idea of patterns is that they also
    // include the configuration workflow needed for that task, such of
    // configuring the web server. For the scope of the package selector, this
    // is only of little relevance, though.
 
    headers << "";              _iconCol        = numCol++;
    headers << _( "Pattern" );  _summaryCol     = numCol++;
 
    //headers << "";    _howmanyCol     = numCol++;
 
    setColumnCount( numCol );
    setHeaderLabels(headers);
 
    setIndentation(0);
 
    setItemDelegateForColumn( _iconCol,    new YQPkgPatternItemDelegate( this ) );
    setItemDelegateForColumn( _statusCol,  new YQPkgPatternItemDelegate( this ) );
    setItemDelegateForColumn( _summaryCol, new YQPkgPatternItemDelegate( this ) );
    //setItemDelegateForColumn( _howmanyCol, new YQPkgPatternItemDelegate(this) );
 
    // Can use the same colum for "broken" and "satisfied":
    // Both states are mutually exclusive
 
    _satisfiedIconCol   = -42;
    _brokenIconCol      = -42;
 
//     header()->setStretchEnabled( _statusCol , false );
//     header()->setStretchEnabled( _summaryCol, true  );
 
    setSortingEnabled( true );
    sortByColumn( summaryCol(), Qt::AscendingOrder );
 
    setAllColumnsShowFocus( true );
 
    header()->setSectionResizeMode( statusCol(),  QHeaderView::Fixed   );
    header()->setSectionResizeMode( summaryCol(), QHeaderView::Stretch );
    header()->setSectionResizeMode( howmanyCol(), QHeaderView::Fixed   );
 
    header()->resizeSection( statusCol(), 25 );
    setColumnWidth( statusCol(), 25 );
    setColumnWidth( summaryCol(), 100 );
    setColumnWidth( howmanyCol(), 15 );
 
    //header()->resizeSection( 0, 0 );
 
    //header()->setMinimumSectionSize( 25 );
 
    if ( autoFilter )
    {
        connect( this, SIGNAL( currentItemChanged( QTreeWidgetItem *,
                                                   QTreeWidgetItem * ) ),
                 this, SLOT  ( filter()                                ) );
    }
 
    setIconSize(QSize(32,32));
    header()->resizeSection( iconCol(), 34 );
    //header()->resizeSection( howmanyCol(), 15 );
 
    if ( autoFill )
    {
        fillList();
        selectSomething();
    }
 
    yuiDebug() << "Creating pattern list done" << std::endl;
}
 
 
YQPkgPatternList::~YQPkgPatternList()
{
    // NOP
}
 
 
void
YQPkgPatternList::fillList()
{
    _categories.clear();
 
    clear();
    yuiDebug() << "Filling pattern list" << std::endl;
 
    for ( ZyppPoolIterator it = zyppPatternsBegin();
          it != zyppPatternsEnd();
          ++it )
    {
        ZyppPattern zyppPattern = tryCastToZyppPattern( (*it)->theObj() );
 
        if ( zyppPattern )
        {
            if ( zyppPattern->userVisible() )
            {
                addPatternItem( *it, zyppPattern );
            }
            else
                yuiDebug() << "Pattern " << zyppPattern->name()
                           << " is not user-visible" << std::endl;
        }
        else
        {
            yuiError() << "Found non-Pattern selectable" << std::endl;
        }
    }
 
    yuiDebug() << "Pattern list filled" << std::endl;
    resizeColumnToContents(_iconCol);
    resizeColumnToContents(_statusCol);
    resizeColumnToContents(_howmanyCol);
}
 
 
YQPkgPatternCategoryItem *
YQPkgPatternList::category( const QString & categoryName )
{
    if ( categoryName.isEmpty() )
        return 0;
 
    YQPkgPatternCategoryItem * cat = _categories[ categoryName ];
 
    if ( ! cat )
    {
        yuiDebug() << "New pattern category \""<< categoryName << "\"" << std::endl;
 
        cat = new YQPkgPatternCategoryItem( this, categoryName );
        Q_CHECK_PTR( cat );
        _categories.insert( categoryName, cat );
    }
 
    return cat;
}
 
 
 
void
YQPkgPatternList::filterIfVisible()
{
    if ( isVisible() )
        filter();
}
 
 
void
YQPkgPatternList::filter()
{
    emit filterStart();
 
    if ( selection() )  // The seleted QListViewItem
    {
        ZyppPattern zyppPattern = selection()->zyppPattern();
 
        if ( zyppPattern )
        {
            int total = 0;
            int installed = 0;
 
            zypp::Pattern::Contents  c(zyppPattern->contents());
            for ( zypp::Pattern::Contents::Selectable_iterator it = c.selectableBegin();
                  it != c.selectableEnd();
                  ++it )
            {
                ZyppPkg zyppPkg = tryCastToZyppPkg( (*it)->theObj() );
                if ( zyppPkg )
                {
                    if ( (*it)->installedSize() > 0 )
                        ++installed;
                    ++total;
 
                    emit filterMatch( *it, zyppPkg );
                }
            }
            selection()->setInstalledPackages(installed);
            selection()->setTotalPackages(total);
            selection()->resetToolTip();
        }
    }
 
    emit filterFinished();
    resizeColumnToContents(_howmanyCol);
}
 
 
void
YQPkgPatternList::addPatternItem( ZyppSel       selectable,
                                  ZyppPattern   zyppPattern )
{
    if ( ! selectable )
    {
        yuiError() << "NULL ZyppSelectable!" << std::endl;
        return;
    }
 
    YQPkgPatternCategoryItem * cat = category( fromUTF8( zyppPattern->category() ) );
    YQPkgPatternListItem * item = 0;
 
    if ( cat )
    {
        item = new YQPkgPatternListItem( this, cat, selectable, zyppPattern );
    }
    else
    {
        item = new YQPkgPatternListItem( this, selectable, zyppPattern );
    }
 
    resizeColumnToContents(_howmanyCol);
    resizeColumnToContents(_summaryCol);
 
    addTopLevelItem(item);
    applyExcludeRules( item );
}
 
 
YQPkgPatternListItem *
YQPkgPatternList::selection() const
{
    QTreeWidgetItem * item = currentItem();
 
    if ( ! item )
        return 0;
 
    return dynamic_cast<YQPkgPatternListItem *> (item);
}
 
 
void
YQPkgPatternList::pkgObjClicked( int                    button,
                                 QTreeWidgetItem *      listViewItem,
                                 int                    col,
                                 const QPoint &         pos )
{
    YQPkgPatternCategoryItem * categoryItem
        = dynamic_cast<YQPkgPatternCategoryItem *> (listViewItem);
 
    if ( categoryItem )
    {
        if ( button == Qt::LeftButton )
        {
            if ( col == 0 )
            {
                categoryItem->setExpanded( ! categoryItem->isExpanded() );
            }
        }
    }
    else
    {
 
        YQPkgObjList::pkgObjClicked( button, listViewItem, col, pos );
    }
}
 
 
void
YQPkgPatternList::selectSomething()
{
#if FIXME
    QTreeWidgetItemIterator it( this );
 
    while ( *it )
    {
        QY2ListViewItem * item = dynamic_cast<QY2ListViewItem *> (*it);
        YQPkgPatternCategoryItem * categoryItem =
            dynamic_cast<YQPkgPatternCategoryItem *> (*it);
 
        if ( item && item->isSelectable() && ! categoryItem )
        {
            setSelected( item, true ); // emits signal, too
            return;
        }
 
        ++it;
    }
#endif
}
 
 
YQPkgPatternListItem::YQPkgPatternListItem( YQPkgPatternList *  patternList,
                                            ZyppSel             selectable,
                                            ZyppPattern         zyppPattern )
    : YQPkgObjListItem( patternList, selectable, zyppPattern )
    , _patternList( patternList )
    , _zyppPattern( zyppPattern )
    , _total(0), _installed(0)
{
    init();
}
 
 
YQPkgPatternListItem::YQPkgPatternListItem( YQPkgPatternList *          patternList,
                                            YQPkgPatternCategoryItem *  parentCategory,
                                            ZyppSel                     selectable,
                                            ZyppPattern                 zyppPattern )
    : YQPkgObjListItem( patternList, parentCategory, selectable, zyppPattern )
    , _patternList( patternList )
    , _zyppPattern( zyppPattern )
    , _total(0), _installed(0)
{
    init();
    parentCategory->addPattern( _zyppPattern );
}
 
 
void
YQPkgPatternListItem::init()
{
    if ( ! _zyppPattern )
        _zyppPattern = tryCastToZyppPattern( selectable()->theObj() );
 
    if (_zyppPattern)
    {
        string iconName = _zyppPattern->icon().basename();
        if ( iconName.empty() )
            iconName = "pattern-generic";
 
        setIcon( _patternList->iconCol(), YQUI::ui()->loadIcon( iconName ) );
 
    }
 
    setStatusIcon();
    resetToolTip();
    setFirstColumnSpanned ( false );
}
 
 
 
YQPkgPatternListItem::~YQPkgPatternListItem()
{
    // NOP
}
 
 
void
YQPkgPatternListItem::cycleStatus()
{
    if ( ! _editable || ! _pkgObjList->editable() )
        return;
 
    ZyppStatus oldStatus = status();
    ZyppStatus newStatus = oldStatus;
 
    switch ( oldStatus )
    {
        case S_Install:
            newStatus = S_NoInst;
            break;
 
// see: bnc 476965
//      case S_KeepInstalled:
//          newStatus = S_Install;
//          break;
 
        case S_NoInst:
            newStatus = S_Install;
            break;
 
        case S_AutoInstall:
            newStatus =  S_NoInst;
            break;
 
        default:
            break;
    }
 
    if ( oldStatus != newStatus )
    {
        setStatus( newStatus );
 
        if ( showLicenseAgreement() )
        {
            showNotifyTexts( newStatus );
        }
        else // License not confirmed?
        {
            // Status is now S_Taboo or S_Del - update status icon
            setStatusIcon();
        }
 
        _patternList->sendStatusChanged();
    }
}
 
 
void
YQPkgPatternListItem::resetToolTip()
{
    std::string infoToolTip;
    infoToolTip +=  ("<p>" + zyppPattern()->description() + "</p>");
 
    if ( totalPackages() > 0 )
    {
        infoToolTip += ("<p>" + zypp::str::form("%d / %d", installedPackages(), totalPackages() ) + "</p>");
    }
 
    setToolTip(_patternList->summaryCol(), fromUTF8(infoToolTip));
}
 
 
void
YQPkgPatternListItem::applyChanges()
{
    solveResolvableCollections();
}
 
 
bool YQPkgPatternListItem::operator< ( const QTreeWidgetItem & otherListViewItem ) const
{
    const YQPkgPatternListItem * otherPatternListitem    = dynamic_cast<const YQPkgPatternListItem     *>(&otherListViewItem);
 
    if ( _zyppPattern && otherPatternListitem && otherPatternListitem->zyppPattern() )
    {
        if ( _zyppPattern->order() != otherPatternListitem->zyppPattern()->order() )
            return _zyppPattern->order() < otherPatternListitem->zyppPattern()->order();
        else
            return _zyppPattern->name() < otherPatternListitem->zyppPattern()->name();
    }
 
    const YQPkgPatternCategoryItem * otherCategoryItem = dynamic_cast<const YQPkgPatternCategoryItem *>(&otherListViewItem);
 
    if ( otherCategoryItem )    // Patterns without category should always be sorted
        return true;            // before any category
 
    return QTreeWidgetItem::operator<( otherListViewItem );
}
 
 
YQPkgPatternCategoryItem::YQPkgPatternCategoryItem( YQPkgPatternList *  patternList,
                                                    const QString &     category        )
    : QY2ListViewItem( patternList )
    , _patternList( patternList )
{
    setText( _patternList->summaryCol(), category );
 
    setExpanded( true );
    setTreeIcon();
}
 
 
YQPkgPatternCategoryItem::~YQPkgPatternCategoryItem()
{
    // NOP
}
 
 
void
YQPkgPatternCategoryItem::addPattern( ZyppPattern pattern )
{
    if ( ! _firstPattern )
    {
        _firstPattern = pattern;
    }
    else
    {
        if ( _firstPattern->order().compare( pattern->order() ) < 0 )
            _firstPattern = pattern;
    }
}
 
 
void
YQPkgPatternCategoryItem::setExpanded( bool open )
{
    QTreeWidgetItem::setExpanded( open );
    setTreeIcon();
}
 
 
void
YQPkgPatternCategoryItem::setTreeIcon()
{
    setIcon( 0,
             isExpanded() ?
             YQIconPool::arrowDown() :
             YQIconPool::arrowRight()   );
 
}
 
 
bool YQPkgPatternCategoryItem::operator< ( const QTreeWidgetItem & otherListViewItem ) const
{
    const YQPkgPatternCategoryItem * otherCategoryItem = dynamic_cast<const YQPkgPatternCategoryItem *>(&otherListViewItem);
 
    if ( _firstPattern && otherCategoryItem && otherCategoryItem->firstPattern() )
        return _firstPattern->order() < otherCategoryItem->firstPattern()->order();
 
 
    const YQPkgPatternListItem * otherPatternListitem    = dynamic_cast<const YQPkgPatternListItem *>(&otherListViewItem);
 
    if ( otherPatternListitem ) // Patterns without category should always be sorted
        return false;           // before any category
 
    return QTreeWidgetItem::operator<( otherListViewItem );
}