NCPkgTable.h

/****************************************************************************
|
| Copyright (c) [2002-2011] Novell, Inc.
| Copyright (C) 2020 SUSE LLC
| All Rights Reserved.
|
| This program is free software; you can redistribute it and/or
| modify it under the terms of version 2 of the GNU General Public License as
| published by the Free Software Foundation.
|
| 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, contact Novell, Inc.
|
| To contact Novell about this file by physical or electronic mail,
| you may find current contact information at www.novell.com
|
|***************************************************************************/


/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       NCPkgTable.h

   Author:     Gabriele Strattner <gs@suse.de>

/-*/
#ifndef NCPkgTable_h
#define NCPkgTable_h

#include <iosfwd>
#include <string>
#include <map>
#include <utility>      // for STL std::pair

#include <zypp/ui/Selectable.h>

#include <yui/ncurses/NCPadWidget.h>
#include <yui/ncurses/NCTablePad.h>
#include <yui/ncurses/NCTable.h>
#include <yui/ncurses/NCTableItem.h>

#include "NCPkgStrings.h"
#include "NCPkgStatusStrategy.h"


class NCPackageSelector;

class NCPkgTableTag : public YTableCell
{
private:

    ZyppStatus status;
    ZyppObj dataPointer;
    // cannot get at it from dataPointer
    ZyppSel selPointer;

public:

    NCPkgTableTag( ZyppObj pkgPtr,
           ZyppSel selPtr,
           ZyppStatus stat = S_NoInst );

    ~NCPkgTableTag() {}

    void setStatus( ZyppStatus  stat ) { status = stat; }
    ZyppStatus getStatus() const { return status; }
    // returns the corresponding std::string value to given package status
    std::string statusToString( ZyppStatus stat ) const;

    ZyppObj getDataPointer() const { return dataPointer; }
    ZyppSel getSelPointer() const  { return selPointer; }
};


class NCPkgTableSort : public NCTableSortStrategyBase
{
public:

    NCPkgTableSort( const std::vector<std::string> & head )
    : _header( head )
    {}

    virtual void sort( YItemIterator itemsBegin,
                       YItemIterator itemsEnd ) override
    {
        if ( _header[ sortCol() ] == NCPkgStrings::PkgSize() )
        {
            std::sort( itemsBegin, itemsEnd, CompareSize() );
        }
        else if ( _header[ sortCol() ] == NCPkgStrings::PkgName() )
        {
            std::sort( itemsBegin, itemsEnd, CompareName( sortCol() ) );
        }
        else
        {
            std::sort( itemsBegin, itemsEnd, Compare( sortCol() ) );
        }

        if ( reverse() )
            std::reverse( itemsBegin, itemsEnd );
    }

private:

    std::vector<std::string> _header;


    static std::wstring cellContent( YItem * item, int col )
    {
        std::wstring empty;

        if ( ! item )
            return empty;

        YTableItem * tableItem = dynamic_cast<YTableItem *>( item );

        if ( ! tableItem )
            return empty;

        YTableCell * tableCell = tableItem->cell( col );

        if ( ! tableCell )
            return empty;

        return NCstring( tableCell->label() ).str();
    }


    class CompareSize
    {
    public:
    CompareSize()
        {}

    bool operator() ( YItem * item1, YItem * item2 ) const
    {
            YTableItem * tableItem1 = dynamic_cast<YTableItem *>( item1 );
            YTableItem * tableItem2 = dynamic_cast<YTableItem *>( item2 );

            if ( ! tableItem1 ) return true;
            if ( ! tableItem2 ) return true;

            const NCPkgTableTag * tag1 = static_cast<const NCPkgTableTag *>( tableItem1->cell(0) );
            const NCPkgTableTag * tag2 = static_cast<const NCPkgTableTag *>( tableItem2->cell(0) );

            return tag1->getDataPointer()->installSize() <
                tag2->getDataPointer()->installSize();
        }
    };


    class CompareName
    {
    public:
    CompareName( int uiCol )
        : _uiCol( uiCol )
        {}

    bool operator() ( YItem * item1, YItem * item2 ) const
    {
            std::wstring w1 = cellContent( item1, _uiCol );
            std::wstring w2 = cellContent( item2, _uiCol );

            // It is safe to use collate unaware wscasecmp() here because package names
            // are 7 bit ASCII only. Better yet, we don't even want this to be sorted
            // by locale specific rules: "ch" for example would be sorted after "h" in
            // Czech which in the context of package names (which are English) would be
            // plain wrong.
            int result = wcscasecmp( w1.data(), w2.data() );

            return result < 0;
        }

    private:
    const int _uiCol;
    };


    class Compare
    {
    public:
    Compare( int uiCol )
        : _uiCol( uiCol )
        {}

    bool operator() ( YItem * item1, YItem * item2 ) const
    {
            std::wstring w1 = cellContent( item1, _uiCol );
            std::wstring w2 = cellContent( item2, _uiCol );

            int result = wcscoll ( w1.data(), w2.data() );

            return result < 0;
        }

    private:
    const int _uiCol;
    };
};


class NCPkgTable : public NCTable
{
public:

    enum NCPkgTableType
    {
    T_Packages,
    T_Availables,
    T_Patches,
    T_Update,
    T_PatchPkgs,
    T_Selections,
    T_Languages,
        T_MultiVersion,
    T_Unknown
    };

    enum NCPkgTableListAction
    {
    A_Install,
    A_Delete,
    A_Keep,
    A_UpdateNewer,
    A_Update,
    A_Unknown
    };

    enum NCPkgTableListType
    {
    L_Changes,
    L_Installed,
    L_Unknown
    };

    enum NCPkgTableInfoType
    {
    I_Descr,
    I_Technical,
    I_Versions,
    I_Files,
    I_Deps,
    I_PatchDescr,
    I_PatchPkgs
    };

private:

    NCPkgTable & operator=( const NCPkgTable & );
    NCPkgTable            ( const NCPkgTable & );

    NCPackageSelector * packager;       // connection to the PackageSelector,

    NCPkgStatusStrategy * statusStrategy;   // particular methods to get the status

    NCPkgTableType tableType;   // the type (e.g. table of packages, patches)
    bool haveInstalledVersion;  // for T_Packages and T_Update

    // returns the first column of line with 'index' (the tag)
    NCPkgTableTag * getTag ( const int & index );

    NCPkgTableInfoType visibleInfo;

    std::vector<std::string> header;        // the table header


public:

    NCPkgTable( YWidget * parent, YTableHeader * tableHeader );

    virtual ~NCPkgTable();


    virtual void addLine( ZyppStatus status,
              const std::vector<std::string> & elements,
              ZyppObj objPtr,
              ZyppSel slbPtr );

    void drawList() { sortItems( 1 ); return DrawPad(); }

    virtual void itemsCleared();

    NClabel getCellContents( int index, int colnum );

    virtual NCursesEvent wHandleInput( wint_t key );

    void setPackager( NCPackageSelector * pkg ) { packager = pkg; }

    bool changeStatus( ZyppStatus newstat,
               const ZyppSel & slbPtr,
               ZyppObj objPtr,
               bool singleChange );

    bool changeObjStatus( int key );

    bool changeListObjStatus( NCPkgTableListAction key );

    bool cycleObjStatus();

    bool updateTable();

    ZyppStatus getStatus( int index );

#ifdef FIXME

    bool SourceInstall( bool install );
#endif

    bool setTableType( NCPkgTableType type, NCPkgStatusStrategy * strategy )
    {
    if ( !strategy )
        return false;

    delete statusStrategy;
    statusStrategy = strategy;
    tableType = type;

    return true;
    }

    NCPkgTableType getTableType() { return tableType; }

    ZyppObj getDataPointer( int index );

    ZyppSel getSelPointer( int index );

    unsigned int getNumLines() { return myPad()->Lines(); }

    void fillHeader();

    bool createListEntry ( ZyppPkg pkgPtr, ZyppSel slbPtr );

    bool createPatchEntry ( ZyppPatch pkgPtr,  ZyppSel slbPtr );

    bool createInfoEntry ( std::string text );

    bool showInformation();

    bool confirmRetracted( ZyppObj pkg, ZyppSel sel );

    void setVisibleInfo( NCPkgTableInfoType info) { visibleInfo = info;  }

    NCPkgTableInfoType VisibleInfo() { return visibleInfo; }

    bool fillAvailableList ( ZyppSel slb );
    bool fillSummaryList ( NCPkgTableListType type );

    void updateInfo( ZyppObj pkgPtr, ZyppSel slbPtr, NCPkgTableInfoType mode );

};


#endif // NCPkgTable_h