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 <sh@suse.de>

/-*/


#ifndef YQPkgObjList_h
#define YQPkgObjList_h

#include <QPixmap>
#include <QRegExp>
#include <QMenu>
#include <QEvent>
#include <map>
#include <list>
#include <QY2ListView.h>
#include "YQZypp.h"
#include <zypp/Edition.h>
#include <FSize.h>

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


/**
 * @short Abstract base class to display a list of zypp::ResObjects.
 * Handles most generic stuff like setting status etc.
 **/
class YQPkgObjList : public QY2ListView
{
    Q_OBJECT

protected:
    /**
     * Constructor. Does not add any QListView columns!
     **/
    YQPkgObjList( QWidget * parent );

    /**
     * Destructor
     **/
    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;     }

    /**
     * Return whether or not items in this list are generally editable,
     * i.e. the user can change their status. Note that individual items can be
     * set to non-editable even if the list is generally editable.
     * Lists are editable by default.
     **/
    bool editable() const { return _editable; }

    /**
     * Set the list's editable status.
     **/
    void setEditable( bool editable = true ) { _editable = editable; }

    /**
     * Sets the currently selected item's status.
     * Automatically selects the next item if 'selectNextItem' is 'true'.
     **/
    void setCurrentStatus( ZyppStatus   newStatus,
                           bool         selectNextItem = false, 
                           bool         ifNewerOnly = false );


    /**
     * Sets the status of all (toplevel) list items to 'newStatus', if possible.
     * Only one single statusChanged() signal is emitted.
     *
     * 'force' overrides sensible defaults like setting only zypp::ResObjects to
     * 'update' that really come with a newer version.
     **/
    void setAllItemStatus( ZyppStatus newStatus, bool force = false );

    /**
     * Add a submenu "All in this list..." to 'menu'.
     * Returns the newly created submenu.
     **/
    virtual QMenu * addAllInListSubMenu( QMenu * menu );

    /**
     * Returns the suitable icon for a zypp::ResObject status - the regular
     * icon if 'enabled' is 'true' or the insensitive icon if 'enabled' is
     * 'false.  'bySelection' is relevant only for auto-states: This uses the
     * icon for 'auto-by-selection" rather than the default auto-icon.
     **/
    virtual QPixmap statusIcon( ZyppStatus status,
                                bool            enabled     = true,
                                bool            bySelection = false );

    /**
     * Returns a short (one line) descriptive text for a zypp::ResObject status.
     **/
    virtual QString statusText( ZyppStatus status ) const;


    class ExcludeRule;

    /**
     * Add an exclude rule to this list.
     **/
    void addExcludeRule( YQPkgObjList::ExcludeRule * rule );

    /**
     * Apply all exclude rules of this list to all items,
     * including those that are currently excluded.
     **/
    void applyExcludeRules();

    /**
     * Apply all exclude rules of this list to one item.
     **/
    void applyExcludeRules( QTreeWidgetItem * );

    /**
     * Exclude or include an item, i.e. remove it from the visible items
     * and add it to the internal exclude list or vice versa.
     **/
    void exclude( YQPkgObjListItem * item, bool exclude );


public slots:

    /**
     * Add a zypp::ResObject to the list. Connect a filter's filterMatch()
     * signal to this slot. Remember to connect filterStart() to clear()
     * (inherited from QListView).
     *
     * 'zyppObj' has to be one of the objects of 'selectable'. If it is 0,
     * selectable->theObject() will be used.
     *
     * Intentionally NOT named addItem() so the calling class cannot confuse
     * this method with overlaid methods of the same name that were simply
     * forgotten to implement!
     **/
    void addPkgObjItem( ZyppSel selectable,
                        ZyppObj zyppObj = 0 );

    /**
     * Add a purely passive list item that has a name and optional summary and
     * size.
     **/
    void addPassiveItem( const QString & name,
                         const QString & summary = QString::null,
                         FSize           size    = -1 );

    /**
     * Dispatcher slot for mouse click: cycle status depending on column.
     **/
    virtual void pkgObjClicked( int             button,
                                QTreeWidgetItem * item,
                                int             col,
                                const QPoint &  pos );

    /**
     * Reimplemented from QY2ListView:
     * Emit currentItemChanged() signal after clearing the list.
     **/
    virtual void clear();

    /**
     * Update the internal actions for the currently selected item ( if any ).
     * This only calls updateActions( YQPkgObjListItem * ) with the currently
     * selected item as argument, so there is normally no need to reimplement
     * this method, too, if the other one is reimplemented.
     **/
    virtual void updateActions( YQPkgObjListItem * item = 0);

    /**
     * Emit an updatePackages() signal.
     **/
    void sendUpdatePackages() { emit updatePackages(); }

    /**
     * Select the next item, i.e. move the selection one item further down the
     * list.
     **/
    void selectNextItem();

    /**
     * Emit a statusChanged() signal for the specified zypp::ResObject.
     **/
    void sendStatusChanged() { emit statusChanged(); }

    /**
     * Display a one-line message in the list.
     **/
    virtual void message( const QString & text );

    /**
     * Write statistics about excluded items to the log, if there are any.
     **/
    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:

    /**
     * Dispatcher slot for selection change - internal only.
     **/
    virtual void currentItemChangedInternal( QTreeWidgetItem * item );

    /**
     * slot that shows context menu when requested
     **/
    void slotCustomContextMenu(const QPoint& pos);


signals:


    /**
     * Emitted when a zypp::ui::Selectable is selected.
     * May be called with a null poiner if no zypp::ResObject is selected.
     **/
    void currentItemChanged( ZyppSel selectable );

    /**
     * Emitted when the status of a zypp::ResObject is changed.
     **/
    void statusChanged();

    /**
     * Emitted when it's time to update displayed package information,
     * e.g., package states.
     **/
    void updatePackages();


protected:

    /**
     * Event handler for keyboard input.
     * Only very special keys are processed here.
     *
     * Reimplemented from QListView / QWidget.
     **/
    virtual void keyPressEvent( QKeyEvent * ev );

    /**
     * Returns the context menu for items that are not installed.
     * Creates the menu upon the first call.
     **/
    virtual QMenu * installedContextMenu();

    /**
     * Returns the context menu for items that are installed.
     * Creates the menu upon the first call.
     **/
    virtual QMenu * notInstalledContextMenu();

    /**
     * Create the context menu for items that are not installed.
     **/
    virtual void createNotInstalledContextMenu();

    /**
     * Create the context menu for installed items.
     **/
    virtual void createInstalledContextMenu();

    /**
     * Create the actions for the context menus.
     * Note: This is intentionally not virtual!
     **/
    void createActions();

    /**
     * Create an action based on a zypp::ResObject status - automatically
     * retrieve the corresponding status icons (both sensitive and insensitive)
     * and text.  'key' is only a descriptive text, no true accelerator.
     **/
    QAction * createAction( ZyppStatus  status,
                            const QString &     key     = QString::null,
                            bool                enabled = false );

    /**
     * Low-level: Create an action.
     * 'key' is only a descriptive text, no true accelerator.
     **/
    QAction * createAction( const QString &     text,
                            const QPixmap &     icon            = QPixmap(),
                            const QPixmap &     insensitiveIcon = QPixmap(),
                            const QString &     key             = QString::null,
                            bool                enabled         = false );

    class ExcludedItems;

    // Data members

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

    typedef list<ExcludeRule *> ExcludeRuleList;

    ExcludeRuleList     _excludeRules;
    ExcludedItems *     _excludedItems;

    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:

    /**
     * Constructor for root items: Creates a YQPkgObjList item that corresponds
     * to the ZYPP selectable that 'selectable' refers to. 'zyppObj' has to be
     * one object of 'selectable'.  If it is 0, selectable->theObject() will be
     * used.
     **/
    YQPkgObjListItem( YQPkgObjList *    pkgObjList,
                      ZyppSel           selectable,
                      ZyppObj           zyppObj = 0 );

    /**
     * Constructor for root items: Creates a YQPkgObjList item that does not
     * correspond to a ZYPP selectable. You need to overload _AND RUN_ init
     * yourself then.
     **/
    YQPkgObjListItem( YQPkgObjList *    pkgObjList );

protected:
    /**
     * Constructor for non-root items.
     **/
    YQPkgObjListItem( YQPkgObjList *    pkgObjList,
                      QY2ListViewItem * parent,
                      ZyppSel           selectable,
                      ZyppObj           zyppObj = 0 );

public:

    /**
     * Destructor
     **/
    virtual ~YQPkgObjListItem();

    /**
     * Returns the original selectable within the package manager backend.
     **/
    ZyppSel selectable() const { return _selectable; }

    /**
     * Returns the original object within the package manager backend.
     **/
    ZyppObj zyppObj() const { return _zyppObj; }

    /**
     * Return whether or not this items is editable, i.e. the user can change
     * its status. This requires the corresponding list to be editable, too.
     * Items are editable by default.
     **/
    bool editable() const { return _editable; }

    /**
     * Set this item's editable status.
     **/
    void setEditable( bool editable = true ) { _editable = editable; }

    /**
     * Returns the (binary RPM) package status
     **/
    virtual ZyppStatus status() const;

    /**
     * Returns 'true' if this selectable's status is set by a selection
     * (rather than by the user or by the dependency solver).
     **/
    virtual bool bySelection() const;

    /**
     * Set the (binary RPM) package status.
     *
     * If 'sendSignals' is 'true' (default), the parent list will be requested
     * to send update signals. List operations might want to use this for
     * optimizations to send the signals only once after all changes are done.
     **/
    virtual void setStatus( ZyppStatus newStatus, bool sendSignals = true );


    /**
     * Set a status icon according to the package's status.
     **/
    virtual void setStatusIcon();

    /**
     * Update this item's status.
     * Triggered by QY2ListView::updateAllItemStates().
     * Overwritten from QY2ListViewItem.
     **/
    virtual void updateStatus();

    /**
     * Cycle the package status to the next valid value.
     **/
    virtual void cycleStatus();

    /**
     * Check if the candidate is newer than the installed version.
     **/
    bool candidateIsNewer() const { return _candidateIsNewer; }

    /**
     * Check if the installed version is newer than the candidate.
     **/
    bool installedIsNewer() const { return _installedIsNewer; }

    /**
     * Check if this item is satisfied, even though it is not installed.
     * This is useful for package collections, e.g., patterns and patches:
     * 'true' is returned if all requirements are fulfilled, but the object
     * itself is not installed.
     **/
    bool isSatisfied() const;

    /**
     * Check if this item is "broken": If it is installed, but any of its
     * dependencies are no longer satisfied.
     * This is useful for package collections, e.g., patterns and patches.
     **/
    bool isBroken() const;

    /**
     * Display this item's notify text (if there is any) that corresponds to
     * the specified status (S_Install, S_Del) in a pop-up window.
     **/
    void showNotifyTexts( ZyppStatus status );

    /**
     * Display a selectable's license agreement (if there is any) that
     * corresponds to its current status (S_Install, S_Update) in a pop-up
     * window.
     *
     * Returns 'true' if the user agreed to that license , 'false' otherwise.
     * The item's status may have changed to S_Taboo, S_Proteced or S_Del if
     * the user disagreed with the license.
     **/
    static bool showLicenseAgreement( ZyppSel sel );

    /**
     * Display this item's license agreement (if there is any) that corresponds
     * to its current status (S_Install, S_Update) in a pop-up window.
     **/
    bool showLicenseAgreement();

    /**
     * sorting function
     */
    virtual bool operator< ( const QTreeWidgetItem & other ) const;

    /**
     * Calculate a numerical value to compare versions, based on version
     * relations:
     *
     * - Installed newer than candidate (red)
     * - Candidate newer than installed (blue) - worthwhile updating
     * - Installed
     * - Not installed, but candidate available
     **/
    int versionPoints() const;

    /**
     * Update this item's data completely.
     * Triggered by QY2ListView::updateAllItemData().
     *
     * Reimplemented from QY2ListViewItem.
     **/
    virtual void updateData();

    /**
     * Returns a tool tip text for a specific column of this item.
     * 'column' is -1 if the mouse pointer is in the tree indentation area.
     *
     * Reimplemented from QY2ListViewItem.
     **/
    virtual QString toolTip( int column );

    /**
     * Returns 'true' if this item is excluded.
     **/
    bool isExcluded() const { return _excluded; }

    /**
     * Set this item's exclude flag.
     * Note that this is just a marker. It is the caller's responsibility
     * to add or remove it from exclude lists etc.
     **/
    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:

    /**
     * Initialize internal data and set fields accordingly. Only works for items
     * presenting selectables - see YQPkgObjListItem
     **/
    void init();

    /**
     * Apply changes hook. This is called each time the user changes the status
     * of a list item manually (if the old status is different from the new
     * one). Insert code to propagate changes to other objects here, for
     * example to trigger a "small" solver run (Resolver::transactObjKind()
     * etc.).
     *
     * This default implementation does nothing.
     **/
    virtual void applyChanges() {}

    /**
     * Do a "small" solver run for all "resolvable collections", i.e., for
     * selections, patterns, languages, patches.
     **/
    void solveResolvableCollections();

    /**
     * Set a column text via STL string.
     * ( QListViewItem::setText() expects a QString! )
     **/
    void setText( int column, const string text );

 public:
    /**
     * Re-declare ordinary setText() method so the compiler doesn't get
     * confused which one to use.
     **/
    void setText( int column, const QString & text )
          { QTreeWidgetItem::setText( column, text ); }
 protected:
    /**
     * Set a column text via Edition.
     **/
    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:

    /**
     * Constructor: Creates a new exclude rule with a regular expression
     * to check against the text of the specified column of each list
     * entry.
     *
     * The parent YQPkgObjList will assume ownership of this exclude rule
     * and destroy it when the parent is destroyed.
     **/
    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();

    /**
     * Enable or disable this exclude rule.
     * New exclude rules are enabled by default.
     **/
    void enable( bool enable = true );

    /**
     * Returns 'true' if this exclude rule is enabled,
     * 'false' otherwise.
     **/
    bool isEnabled() const { return _enabled; }

    /**
     * Change the regular expression after creation.
     **/
    void setRegexp( const QRegExp & regexp );

    /**
     * Returns the regexp.
     **/
    QRegExp regexp() const { return _regexp; };

    /**
     * Change the column number to check against after creation.
     **/
    void setColumn( int column = 0 );

    /**
     * Returns the column number.
     **/
    int column() const { return _column; }

    /**
     * Returns this exclude rule's parent YQPkgObjList.
     **/
    YQPkgObjList * parent() const { return _parent; }

    /**
     * Check a list item against this exclude rule.
     * Returns 'true' if the item matches this exclude rule,
     * i.e. if it should be excluded.
     **/
    bool match( QTreeWidgetItem * item );

private:

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


class YQPkgObjList::ExcludedItems
{
public:

    typedef std::map <QTreeWidgetItem *, QTreeWidgetItem *> ItemMap;
    typedef std::pair<QTreeWidgetItem *, QTreeWidgetItem *> ItemPair;
    typedef ItemMap::iterator                           iterator;

    /**
     * Constructor
     **/
    ExcludedItems( YQPkgObjList * parent );

    /**
     * Destructor
     **/
    virtual ~ExcludedItems();

    /**
     * Add a list item to the excluded items and transfer ownership to this
     * class.
     *
     * oldParent is the previous parent item of this item
     * or 0 if it was a root item.
     **/
    void add( QTreeWidgetItem * item, QTreeWidgetItem * oldParent );

    /**
     * Remove a list item from the excluded items and transfer ownership back
     * to the caller.
     **/
    void remove( QTreeWidgetItem * item );

    /**
     * Clear the excluded items. Delete all items still excluded.
     **/
    void clear();

    /**
     * Returns 'true' if the specified item is in the excluded items.
     **/
    bool contains( QTreeWidgetItem * item );

    /**
     * Returns the old parent of this item so it can be reparented
     * or 0 if it was a root item.
     **/
    QTreeWidgetItem * oldParentItem( QTreeWidgetItem * item );

    /**
     * Returns the number of items
     **/
    int size() const { return (int) _excludeMap.size(); }

    /**
     * Returns an iterator that points to the first excluded item.
     **/
    iterator begin() { return _excludeMap.begin(); }

    /**
     * Returns an iterator that points after the last excluded item.
     **/
    iterator end()   { return _excludeMap.end(); }

private:
    void updateActions();

    ItemMap             _excludeMap;
    YQPkgObjList *      _pkgObjList;
};


#endif // ifndef YQPkgObjList_h