YQPkgObjList.h

/**************************************************************************
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:       YQPkgObjList.h

  Author:     Stefan Hundhammer <shundhammer.de>

/-*/


#ifndef YQPkgObjList_h
#define YQPkgObjList_h

#include <QPixmap>
#include <QRegExp>
#include <QMenu>
#include <QEvent>

#include <map>
#include <list>

#include <yui/FSize.h>
#include <yui/qt/QY2ListView.h>
#include <zypp/Edition.h>
#include "YQZypp.h"

class YQPkgObjListItem;
class QAction;
class QMenu;
using std::string;
using std::list;


class YQPkgObjList : public QY2ListView
{
    Q_OBJECT

protected:
    YQPkgObjList( QWidget * parent );

    virtual ~YQPkgObjList();

    // avoiding warning about virtuals
    using QTreeWidget::currentItemChanged;

public:

    // make it public
    QTreeWidgetItem * itemFromIndex ( const QModelIndex & index ) const
    { return QY2ListView::itemFromIndex(index); }

    // Column numbers

    int iconCol()     const { return _iconCol; }
    int statusCol()     const   { return _statusCol;        }
    int nameCol()       const   { return _nameCol;      }
    int summaryCol()        const   { return _summaryCol;       }
    int sizeCol()       const   { return _sizeCol;      }
    int versionCol()        const   { return _versionCol;       }
    int instVersionCol()    const   { return _instVersionCol;   }
    int brokenIconCol()     const   { return _brokenIconCol;    }
    int satisfiedIconCol()  const   { return _satisfiedIconCol; }

    bool editable() const { return _editable; }

    void setEditable( bool editable = true ) { _editable = editable; }

    void setCurrentStatus( ZyppStatus   newStatus,
               bool     selectNextItem = false,
               bool     ifNewerOnly = false );


    void setAllItemStatus( ZyppStatus newStatus, bool force = false );

    virtual QMenu * addAllInListSubMenu( QMenu * menu );

    virtual QPixmap statusIcon( ZyppStatus status,
                bool        enabled     = true,
                bool        bySelection = false );

    virtual QString statusText( ZyppStatus status ) const;


    class ExcludeRule;

    void addExcludeRule( YQPkgObjList::ExcludeRule * rule );

    void applyExcludeRules();

    void applyExcludeRules( QTreeWidgetItem * );

    void exclude( YQPkgObjListItem * item, bool exclude );


public slots:

    void addPkgObjItem( ZyppSel selectable,
            ZyppObj zyppObj = 0 );

    void addPassiveItem( const QString & name,
             const QString & summary = QString(),
             FSize       size    = -1 );

    virtual void pkgObjClicked( int     button,
                QTreeWidgetItem * item,
                int     col,
                const QPoint &  pos );

    virtual void clear();

    virtual void updateActions( YQPkgObjListItem * item = 0);

    void sendUpdatePackages() { emit updatePackages(); }

    void selectNextItem();

    void sendStatusChanged() { emit statusChanged(); }

    virtual void message( const QString & text );

    void logExcludeStatistics();


    // Direct access to some states for menu actions

    void setCurrentInstall()       { setCurrentStatus( S_Install    ); }
    void setCurrentDontInstall()   { setCurrentStatus( S_NoInst     ); }
    void setCurrentKeepInstalled() { setCurrentStatus( S_KeepInstalled  ); }
    void setCurrentDelete()    { setCurrentStatus( S_Del        ); }
    void setCurrentUpdate()    { setCurrentStatus( S_Update, false, true ); }
    void setCurrentUpdateForce()   { setCurrentStatus( S_Update     ); }
    void setCurrentTaboo()     { setCurrentStatus( S_Taboo      ); }
    void setCurrentProtected()     { setCurrentStatus( S_Protected  ); }

    void setListInstall()      { setAllItemStatus( S_Install    ); }
    void setListDontInstall()      { setAllItemStatus( S_NoInst     ); }
    void setListKeepInstalled()    { setAllItemStatus( S_KeepInstalled  ); }
    void setListDelete()       { setAllItemStatus( S_Del        ); }
    void setListUpdate()       { setAllItemStatus( S_Update     ); }
    void setListUpdateForce()      { setAllItemStatus( S_Update, true   ); }
    void setListTaboo()        { setAllItemStatus( S_Taboo      ); }
    void setListProtected()    { setAllItemStatus( S_Protected  ); }


protected slots:

    virtual void currentItemChangedInternal( QTreeWidgetItem * item );

    void slotCustomContextMenu(const QPoint& pos);


signals:


    void currentItemChanged( ZyppSel selectable );

    void statusChanged();

    void updatePackages();


protected:

    virtual void keyPressEvent( QKeyEvent * ev );

    virtual QMenu * installedContextMenu();

    virtual QMenu * notInstalledContextMenu();

    virtual void createNotInstalledContextMenu();

    virtual void createInstalledContextMenu();

    void createActions();

    QAction * createAction( ZyppStatus  status,
                const QString & key = QString(),
                bool        enabled = false );

    QAction * createAction( const QString & text,
                const QPixmap & icon        = QPixmap(),
                const QPixmap & insensitiveIcon = QPixmap(),
                const QString & key     = QString(),
                bool        enabled     = false );

    // Data members

    int     _iconCol;
    int     _statusCol;
    int     _nameCol;
    int     _summaryCol;
    int     _sizeCol;
    int     _versionCol;
    int     _instVersionCol;
    int     _brokenIconCol;
    int     _satisfiedIconCol;
    bool    _editable;
    bool        _debug;
    int     _excludedItemsCount;

    typedef list<ExcludeRule *> ExcludeRuleList;

    ExcludeRuleList _excludeRules;

    QMenu * _installedContextMenu;
    QMenu * _notInstalledContextMenu;


public:

    QAction *       actionSetCurrentInstall;
    QAction *       actionSetCurrentDontInstall;
    QAction *       actionSetCurrentKeepInstalled;
    QAction *       actionSetCurrentDelete;
    QAction *       actionSetCurrentUpdate;
    QAction *       actionSetCurrentUpdateForce;
    QAction *       actionSetCurrentTaboo;
    QAction *       actionSetCurrentProtected;

    QAction *       actionSetListInstall;
    QAction *       actionSetListDontInstall;
    QAction *       actionSetListKeepInstalled;
    QAction *       actionSetListDelete;
    QAction *       actionSetListUpdate;
    QAction *       actionSetListUpdateForce;
    QAction *       actionSetListTaboo;
    QAction *       actionSetListProtected;
};



class YQPkgObjListItem: public QY2ListViewItem
{
public:

    YQPkgObjListItem( YQPkgObjList *    pkgObjList,
              ZyppSel       selectable,
              ZyppObj       zyppObj = 0 );

    YQPkgObjListItem( YQPkgObjList *    pkgObjList );

protected:
    YQPkgObjListItem( YQPkgObjList *    pkgObjList,
              QY2ListViewItem * parent,
              ZyppSel       selectable,
              ZyppObj       zyppObj = 0 );

public:

    virtual ~YQPkgObjListItem();

    ZyppSel selectable() const { return _selectable; }

    ZyppObj zyppObj() const { return _zyppObj; }

    bool editable() const { return _editable; }

    void setEditable( bool editable = true ) { _editable = editable; }

    virtual ZyppStatus status() const;

    virtual bool bySelection() const;

    virtual void setStatus( ZyppStatus newStatus, bool sendSignals = true );


    virtual void setStatusIcon();

    virtual void updateStatus();

    virtual void cycleStatus();

    bool candidateIsNewer() const { return _candidateIsNewer; }

    bool installedIsNewer() const { return _installedIsNewer; }

    bool isSatisfied() const;

    bool isBroken() const;

    void showNotifyTexts( ZyppStatus status );

    static bool showLicenseAgreement( ZyppSel sel );

    bool showLicenseAgreement();

    virtual bool operator< ( const QTreeWidgetItem & other ) const;

    int versionPoints() const;

    virtual void updateData();

    virtual QString toolTip( int column );

    bool isExcluded() const { return _excluded; }

    void setExcluded( bool exclude = true );


    // Handle Debug isBroken and isSatisfied flags

    bool debugIsBroken()    const       { return _debugIsBroken;        }
    bool debugIsSatisfied() const       { return _debugIsSatisfied;     }
    void setDebugIsBroken   ( bool val = true ) { _debugIsBroken = val;         }
    void setDebugIsSatisfied( bool val = true ) { _debugIsSatisfied = val;      }
    void toggleDebugIsBroken()          { _debugIsBroken = ! _debugIsBroken;    }
    void toggleDebugIsSatisfied()       { _debugIsSatisfied = ! _debugIsSatisfied; }


    // Columns

    int statusCol()     const   { return _pkgObjList->statusCol();  }
    int nameCol()       const   { return _pkgObjList->nameCol();    }
    int summaryCol()        const   { return _pkgObjList->summaryCol(); }
    int sizeCol()       const   { return _pkgObjList->sizeCol();    }
    int versionCol()        const   { return _pkgObjList->versionCol(); }
    int instVersionCol()    const   { return _pkgObjList->instVersionCol(); }
    int brokenIconCol()     const   { return _pkgObjList->brokenIconCol();  }
    int satisfiedIconCol()  const   { return _pkgObjList->satisfiedIconCol(); }


protected:

    void init();

    virtual void applyChanges() {}

    void solveResolvableCollections();

    void setText( int column, const string text );

 public:
    void setText( int column, const QString & text )
      { QTreeWidgetItem::setText( column, text ); }
 protected:
    void setText( int column, const zypp::Edition & edition );


    //
    // Data members
    //

    YQPkgObjList *  _pkgObjList;
    ZyppSel     _selectable;
    ZyppObj     _zyppObj;
    bool        _editable:1;
    bool        _candidateIsNewer:1;
    bool        _installedIsNewer:1;

    bool        _debugIsBroken:1;
    bool        _debugIsSatisfied:1;
    bool        _excluded:1;
};



class YQPkgObjList::ExcludeRule
{
public:

    ExcludeRule( YQPkgObjList *     parent,
         const QRegExp &    regexp,
         int            column = 0 );


    // Intentionally omitting virtual destructor:
    // No allocated objects, no other virtual methods,
    // no need to have a vtable for each instance of this class.
    //
    // virtual ~ExcludeRule();

    void enable( bool enable = true );

    bool isEnabled() const { return _enabled; }

    void setRegexp( const QRegExp & regexp );

    QRegExp regexp() const { return _regexp; };

    void setColumn( int column = 0 );

    int column() const { return _column; }

    YQPkgObjList * parent() const { return _parent; }

    bool match( QTreeWidgetItem * item );

private:

    YQPkgObjList *  _parent;
    QRegExp     _regexp;
    int         _column;
    bool        _enabled;
};


#endif // ifndef YQPkgObjList_h