MonitorTable.h

#ifndef CARMA_UI_RTD_MONITORTABLE_H
#define CARMA_UI_RTD_MONITORTABLE_H


/*
 * @file
 *
 * Create a table to include in a MonitorDisplay.
 *
 * @author Steve Scott 
 * $id: $
 *
 * $CarmaCopyright$
 *
 */


#include <vector>
#include <boost/shared_ptr.hpp>

#include <carma/ui/rtd/common/RtDisplay.h>


namespace carma {


namespace monitor {

class MonitorContainer;
class MonitorPoint;

}  // namespace carma::monitor


namespace ui {
namespace rtd { 


const int AUTO_SIZE = 0;

const int AUTO_SIZE_EACH_COLUMN = -1;

class MonitorTableVisitor;
typedef boost::shared_ptr<MonitorTableVisitor> MonitorTableVisitorPtr;

struct MonitorColumnInfo {
    ::std::string                     heading;
    const monitor::MonitorContainer * container;

    MonitorColumnInfo( const ::std::string &             inHeading,
                       const monitor::MonitorContainer & inContainer );
};

class MonitorTable;
typedef boost::shared_ptr<MonitorTable> MonitorTablePtr;

class MonitorTable : public RtTable {
    public:
        static MonitorTablePtr makeTable(
            const ::std::vector<MonitorColumnInfo>& columns, 
            int                                       columnWidth= AUTO_SIZE,
            int                                       hierarchyDepth=1,
            int                                       sampleNo=0,
            bool                                      unitsInRowLabels=true,
            bool                                      switchRowsAndColumns=false,
            const MonitorTableVisitorPtr              visitor=MonitorTableVisitorPtr(),
            bool                                      displayRowLabels=true);

        static MonitorTablePtr makeTable(
            const MonitorColumnInfo&    column, 
            int                         columnWidth= AUTO_SIZE,
            int                         hierarchyDepth=1,
            int                         sampleNo=0,
            bool                        unitsInRowLabels=true,
            bool                        switchRowsAndColumns=false,
            const MonitorTableVisitorPtr visitor=MonitorTableVisitorPtr(),
            const bool                  displayRowLabels=true);
        
        static MonitorTablePtr makeTable(
            const ::std::string&              heading, 
            const monitor::MonitorContainer&  container,
            int                               columnWidth = AUTO_SIZE,
            int                               hierarchyDepth=1,
            int                               sampleNo=0,
            bool                              unitsInRowLabels=true,
            bool                              switchRowsAndColumns=false,
            const MonitorTableVisitorPtr      visitor=MonitorTableVisitorPtr(),
            const bool                        displayRowLabels=true);
        
        static MonitorTablePtr makeTable(
            const std::vector<std::string>&              headings, 
            const std::vector<const monitor::MonitorContainer*>& containers,
            int                                          columnWidth = AUTO_SIZE,
            int                                          hierarchyDepth =1,
            int                                          sampleNo = 0,
            bool                                         unitsInRowLabels=true,
            bool                                         switchRowsAndColumns=false,
            const MonitorTableVisitorPtr                 visitor=MonitorTableVisitorPtr(),
            bool                                         displayRowLabels=true);
        
        static MonitorTablePtr makeTable(
            const std::vector< std::string >&        headings, 
            const std::vector<monitor::MonitorContainer*>& containers,
            int                                      columnWidth=AUTO_SIZE,
            int                                      hierarchyDepth=1,
            int                                      sampleNo=0,
            bool                                     unitsInRowLabels=true,
            bool                                     switchRowsAndColumns=false,
            const MonitorTableVisitorPtr             visitor=MonitorTableVisitorPtr(),
            bool                                     displayRowLabels=true);
        
        virtual ~MonitorTable();
        
        static int autoFitColumnWidth(
            const ::std::vector< const monitor::MonitorContainer * > & containers,
            int                                                        levels,
            int                                                        minWidth,
            const MonitorTableVisitorPtr                               visitor ); 
         
        static int autoFitColumnWidth(
            const monitor::MonitorContainer & container,
            int                               levels,
            int                               minWidth,
            const MonitorTableVisitorPtr      visitor );
        
        static int autoFitColumnWidth(
            const ::std::vector< monitor::MonitorContainer * > & containers,
            int                                                  levels,
            int                                                  minWidth,
            const MonitorTableVisitorPtr                         visitor );
         
        static int autoFitColumnWidth(
            const ::std::vector< MonitorColumnInfo > & columns,
            int                                        levels,
            int                                        minWidth,
            const MonitorTableVisitorPtr               visitor );

        static int autoFitColumnWidth(
            const MonitorColumnInfo &   column,
            int                         levels,
            int                         minWidth,
            const MonitorTableVisitorPtr visitor );

        static ::std::string
        generateRowLabel( const monitor::MonitorPoint & mp,
                          bool                          showUnits );

    protected:
        MonitorTable(
            const std::vector<MonitorColumnInfo>& columns, 
            int                                   columnWidth,
            int                                   hierarchyDepth,
            int                                   sampleNo,
            bool                                  unitsInRowLabels,
            bool                                  switchRowsAndColumns,
            const MonitorTableVisitorPtr          visitor,
            bool                                  displayRowLabels);

    private:
        static ::std::vector< int > getWidths(
            const monitor::MonitorContainer & container,
            int                               levels,
            int                               minWidth,
            const MonitorTableVisitorPtr      visitor );

        void addRowLabels(const monitor::MonitorContainer& container,
                          bool                             unitsInRowLabels,
                          bool                             switchRowsAndColumns,
                          const MonitorTableVisitorPtr     visitor,
                          const bool                       displayRowLabels);
        
        void addContainerMonitorPoints(
            const monitor::MonitorContainer & container,
            const MonitorTableVisitorPtr      visitor,
            const int                         defaultWidth,
            const ::std::vector< int > &      individualWidths );

        const int hierarchyDepth_;
        const int sampleNo_;
};


}  // namespace carma::ui::rtd
}  // namespace carma::ui


}  // namespace carma


#endif