NCTableItem.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  Copyright (C) 2020 SUSE LLC
  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) version 3.0 of the License. This library
  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 Lesser General Public
  License for more details. You should have received a copy of the GNU
  Lesser General Public License along with this library; if not, write
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/


/*-/

   File:       NCTableItem.h

   Authors:    Michael Andres <ma@suse.de>
               Stefan Hundhammer <shundhammer@suse.de>

/-*/

#ifndef NCTableItem_h
#define NCTableItem_h

#include <iosfwd>
#include <vector>

#include "position.h"
#include "NCWidget.h"
#include <yui/YTableItem.h>

class NCTableCol;
class NCTableStyle;
class NCTableTag;


class NCTableLine
{
public:

    enum STATE
    {
    S_NORMAL    = 0x00,
    S_ACTIVE    = 0x01,
    S_DISABLED  = 0x10,
    S_HIDDEN    = 0x20,
    S_HEADLINE  = 0x40
    };


    NCTableLine( std::vector<NCTableCol*> & cells,
                 int                        index  = -1,
                 bool                       nested = false,
                 unsigned                   state  = S_NORMAL );

    NCTableLine( NCTableLine *              parentLine,
                 YItem *                    yitem,
                 std::vector<NCTableCol*> & cells,
                 int                        index  = -1,
                 bool                       nested = false,
                 unsigned                   state  = S_NORMAL );

    NCTableLine( unsigned      colCount,
                 int           index     = -1,
                 bool          nested    = false,
                 unsigned      state     = S_NORMAL );

    NCTableLine( NCTableLine * parentLine,
                 YItem *       yitem,
                 unsigned      colCount,
                 int           index     = -1,
                 bool          nested    = false,
                 unsigned      state     = S_NORMAL );

    virtual ~NCTableLine();

    YTableItem * origItem() const { return dynamic_cast<YTableItem *>( _yitem ); }

    void setOrigItem( YTableItem *yitem );

    int index() const { return _index; }

    unsigned Cols() const { return _cells.size(); }

    void SetCols( unsigned idx );

    void SetCols( std::vector<NCTableCol*> & newCells );

    void ClearLine()  { SetCols( 0 ); }

    std::vector<NCTableCol*> GetItems() const { return _cells; }

    void Append( NCTableCol * cell ) { AddCol( Cols(), cell ); }

    void AddCol( unsigned idx, NCTableCol * item );
    void DelCol( unsigned idx );

    NCTableCol * GetCol( unsigned idx );

    const NCTableCol * GetCol( unsigned idx ) const
    {
    return const_cast<NCTableLine*>( this )->GetCol( idx );
    }

    void  SetState  ( const STATE s ) { _state |= s; }
    void  ClearState( const STATE s ) { _state &= ~s; }

    bool  isHidden() const    { return ( _state & S_HIDDEN ); }
    bool  isDisabled() const  { return ( _state & S_DISABLED ); }
    bool  isSpecial() const   { return ( _state & ( S_HIDDEN | S_DISABLED ) ); }
    bool  isActive() const    { return ( _state & S_ACTIVE ); }

    virtual bool isVisible() const;

    virtual bool isEnabled() const { return isVisible() && !isDisabled(); }

    virtual bool isNested() const { return _nested; }

    virtual void setNested( bool val ) { _nested = val; }

    void openBranch();

    void closeBranch();

    void toggleOpenClosedState();

    virtual bool handleInput( wint_t key );

    virtual bool ChangeToVisible() { return false; }

    virtual unsigned Hotspot( unsigned & at ) const { at = 0; return 0; }

    virtual void UpdateFormat( NCTableStyle & tableStyle );

    virtual void updatePrefix();


    virtual void DrawAt( NCursesWindow & w,
                         const wrect     at,
             NCTableStyle &  tableStyle,
             bool            active ) const;

    void stripHotkeys();

    //
    // Tree operations
    //

    virtual NCTableLine * parent()      const { return _parent;      }
    virtual NCTableLine * firstChild()  const { return _firstChild;  }
    virtual NCTableLine * nextSibling() const { return _nextSibling; }

    void setParent     ( NCTableLine * newVal ) { _parent      = newVal; }
    void setFirstChild ( NCTableLine * newVal ) { _firstChild  = newVal; }
    void setNextSibling( NCTableLine * newVal ) { _nextSibling = newVal; }

    int treeLevel() const { return _treeLevel; }

    void setTreeLevel( int newVal ) { _treeLevel = newVal; }

    int prefixLen() const { return _nested ? treeLevel() + 3 : 0; }

    NCTableTag * tagCell() const;

    std::string indentationStr() const;

protected:

    void treeInit( NCTableLine * parentLine, YItem * yitem );

    void initPrefixPlaceholder();

    void addToTree( NCTableLine * parent );

    bool isOpen( YItem * yitem ) const;

    YItem * yitem() const { return _yitem; }

    void setYItem( YItem * yitem );

    virtual void DrawItems( NCursesWindow & w,
                            const wrect     at,
                NCTableStyle &  tableStyle,
                bool            active ) const;

    void assertCol( unsigned idx );

    const std::string & prefixPlaceholder() const { return _prefixPlaceholder; }

    void drawPrefix( NCursesWindow & w,
                     const wrect     at,
                     NCTableStyle  & tableStyle ) const;

private:

    friend std::ostream & operator<<( std::ostream & str, const NCTableLine & obj );

    // Disable unwanted assignment operator and copy constructor

    NCTableLine & operator=( const NCTableLine & );
    NCTableLine( const NCTableLine & );


    //
    // Data members
    //

protected:

    std::vector<NCTableCol*> _cells; 

    unsigned      _state;        
    int           _index;        
    YItem *       _yitem;        
    bool          _nested;       

    // Tree-related

    int           _treeLevel;
    NCTableLine * _parent;
    NCTableLine * _nextSibling;
    NCTableLine * _firstChild;

    // This should have been an argument for DrawItems.
    //
    // It needs to be mutable because some methods that change it promise to be
    // const, but they break that promise with this variable.
    mutable STATE _vstate;

    // Tree hierarchy line graphics for this line.
    //
    // chtype is a very basic NCurses type to store one character with its
    // attributes (bg/fg color).
    chtype *         _prefix;
    std::string      _prefixPlaceholder;
};


class NCTableCol
{

    friend std::ostream & operator<<( std::ostream & str, const NCTableCol & obj );

public:

    enum STYLE
    {
    NONE = 0,    // use current bg
    PLAIN,       // plain text
    DATA,        // data style
    ACTIVEDATA,  // data style if line active, else plain
    HINT,        // hint
    SEPARATOR    // separator
    };


    NCTableCol( const NCstring & label = "", STYLE st = ACTIVEDATA );

    virtual ~NCTableCol();

    const NClabel & Label() const { return _label; }
    virtual void SetLabel( const NClabel & newVal ) { _label = newVal; }
    virtual void SetLabel( const std::string & newVal ) { _label = NCstring( newVal ); }

    const NClabel & prefix() const { return _prefix; }

    virtual void setPrefix( const NClabel & newVal ) { _prefix = newVal; }
    virtual void setPrefix( const std::string & newVal ) { _prefix = NCstring( newVal); }
    int prefixWidth() const { return _prefix.width(); }

    wrect prefixAdjusted( const wrect origRect ) const;

    virtual wsze Size() const { return wsze( 1, _prefix.width() + _label.width() ); }

    virtual void DrawAt( NCursesWindow &    w,
                         const wrect        at,
             NCTableStyle &     tableStyle,
             NCTableLine::STATE linestate,
             unsigned           colidx ) const;

    void stripHotkey() { _label.stripHotkey(); }

    bool      hasHotkey() const { return _label.hasHotkey(); }
    unsigned char hotkey()    const { return _label.hotkey(); }

protected:

    chtype setBkgd( NCursesWindow &    w,
            NCTableStyle &     tableStyle,
            NCTableLine::STATE linestate,
            STYLE              colstyle ) const ;

private:

    NClabel _prefix;
    NClabel _label;
    STYLE   _style;
};


class NCTableHead : public NCTableLine
{

public:

    NCTableHead( unsigned cols )
        : NCTableLine( cols )
        {}

    NCTableHead( std::vector<NCTableCol*> & headCells )
        : NCTableLine( headCells )
        {}

    virtual ~NCTableHead()
        {}

    virtual void DrawAt( NCursesWindow & w,
                         const wrect     at,
             NCTableStyle &  tableStyle,
             bool            active ) const;
};


class NCTableStyle
{

    friend std::ostream & operator<<( std::ostream & str, const NCTableStyle & obj );

public:

    static const chtype currentBG = (chtype) - 1;

    NCTableStyle( const NCWidget & parentWidget );
    ~NCTableStyle() {}

    bool SetStyleFrom( const std::vector<NCstring> & head );

    void SetSepChar( const chtype sepChar ) { _colSepChar = sepChar; }

    void SetSepWidth( const unsigned sepWidth ) { _colSepWidth = sepWidth; }

    void SetHotCol( int hcol )
    {
    _hotCol = ( hcol < 0 || Cols() <= (unsigned) hcol ) ? -1 : hcol;
    }

    void ResetToMinCols()
    {
    _colWidth.clear();
    AssertMinCols( _headline.Cols() );
    _headline.UpdateFormat( *this );
    }

    void AssertMinCols( unsigned num )
    {
    if ( _colWidth.size() < num )
    {
        _colWidth.resize( num, 0 );
        _colAdjust.resize( _colWidth.size(), NC::LEFT );
    }
    }

    void MinColWidth( unsigned num, unsigned val )
    {
    AssertMinCols( num );

    if ( val > _colWidth[num] )
        _colWidth[ num ] = val;
    }

    NC::ADJUST ColAdjust( unsigned num ) const { return _colAdjust[num]; }

    unsigned Cols()              const { return _colWidth.size(); }

    unsigned ColWidth( unsigned num )    const { return _colWidth[num]; }

    unsigned ColSepWidth()           const { return _colSepWidth; }

    chtype   ColSepChar()            const { return _colSepChar; }

    unsigned HotCol()                const { return _hotCol; }

    const NCstyle::StList & listStyle()  const { return _parentWidget.listStyle(); }

    chtype getBG() const { return listStyle().item.plain; }

    chtype getBG( const NCTableLine::STATE lstate,
          const NCTableCol::STYLE  cstyle = NCTableCol::PLAIN ) const;

    chtype highlightBG( const NCTableLine::STATE lstate,
            const NCTableCol::STYLE  cstyle,
            const NCTableCol::STYLE  dstyle = NCTableCol::PLAIN ) const ;

    chtype hotBG( const NCTableLine::STATE lstate, unsigned colidx ) const
    {
    return ( colidx == _hotCol ) ?
            getBG( lstate, NCTableCol::HINT ) : currentBG;
    }

    const NCTableLine & Headline() const { return _headline; }

    unsigned TableWidth() const
    {
    unsigned twidth = 0;

    for ( unsigned i = 0; i < Cols(); ++i )
        twidth += _colWidth[i];

    if ( Cols() > 1 )
        twidth += _colSepWidth * ( Cols() - 1 );

    return twidth;
    }


private:

    const NCWidget &            _parentWidget;
    NCTableHead                 _headline;
    std::vector<unsigned>   _colWidth;  
    std::vector<NC::ADJUST> _colAdjust; 


    unsigned _colSepWidth;

    chtype   _colSepChar;   
    unsigned _hotCol;       
};


class NCTableTag : public NCTableCol
{
public:

    NCTableTag( YItem *item, bool sel = false, bool singleSel = false )
        : NCTableCol( NCstring( singleSel ? "( )" : "[ ]" ), SEPARATOR )
        , _yitem( item )
        , _selected( sel )
        , _singleSelection( singleSel )
    {
    // store pointer to this tag in Yitem data
    _yitem->setData( this );
    }

    virtual ~NCTableTag() {}

    virtual void SetLabel( const NClabel & ) { /*NOOP*/; }

    virtual void DrawAt( NCursesWindow &    w,
                         const wrect        at,
             NCTableStyle &     tableStyle,
             NCTableLine::STATE linestate,
             unsigned           colidx ) const
    {
        // Use parent DrawAt to draw the static part: "[ ]"
    NCTableCol::DrawAt( w, at, tableStyle, linestate, colidx );

    if ( _selected )
    {
            // Draw the "x" inside the "[ ]" with different attributes

        setBkgd( w, tableStyle, linestate, DATA );
            wrect drawRect = prefixAdjusted( at );
        w.addch( drawRect.Pos.L, drawRect.Pos.C + 1, 'x' );
    }
    }

    virtual bool Selected() const        { return _selected; }

    virtual void SetSelected( bool sel ) { _selected = sel; }

    virtual bool SingleSelection() const { return _singleSelection; }

    YItem *origItem() const              { return _yitem; }

private:

    YItem * _yitem; 
    bool    _selected;
    bool    _singleSelection;
};


#endif // NCTableItem_h