开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
table_panel.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：49k
源码类别：

生物技术

开发平台：

C/C++

table_panel.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: table_panel.hpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:52:33  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef GUI_WIDGETS_TABLE___TABLE_PANEL__HPP
  11. #define GUI_WIDGETS_TABLE___TABLE_PANEL__HPP
  13. /*  $Id: table_panel.hpp,v 1000.4 2004/06/01 19:52:33 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software/database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software/database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Authors:  Mike DiCuccio
  39.  *
  40.  * File Description:
  41.  *    CTablePanel -- Extends Flv_Table to provide notions of hidden and visible
  42.  *                   columns
  43.  *    CListPanel  -- Extends CTablePanel to provide a row-selectable
  44.  *                   multicolumn list widget that stores arbitrary data with
  45.  *                   each row.
  46.  */
  48. #include <corelib/ncbiobj.hpp>
  49. #include <gui/gui.hpp>
  51. #include <FL/Enumerations.H>
  52. #include <FL/Fl.H>
  53. #include <FL/fl_draw.H>
  54. #include <gui/widgets/Fl_Table/Fl_Table_Row.H>
  55. #include <gui/utils/fltk_utils.hpp>
  57. #include <algorithm>
  58. #include <memory>
  59. #include <string>
  60. #include <vector>
  62. /** @addtogroup GUI_FltkWidgets
  63.  *
  64.  * @{
  65.  */
  67. BEGIN_NCBI_SCOPE
  70. class NCBI_GUIWIDGETS_TABLE_EXPORT CTablePanelBase : public Fl_Table_Row
  71. {
  72. public:
  73.     CTablePanelBase(int x, int y, int w, int h, const char* label = NULL);
  75.     // safe (virtual) accessors
  76.     virtual size_t GetRows() const;
  77.     virtual void   SetRows(size_t r);
  78.     virtual size_t GetCols() const;
  79.     virtual void   SetCols(size_t c);
  81.     // overrides from Fl_Table_Row (these may be dangerous - they're not
  82.     // virtual)
  83.     void rows(int r);
  84.     int  rows() const;
  85.     void cols(int c);
  86.     int  cols() const;
  88.     // draw() - enforces clipping
  89.     void draw();
  91.     // handle() - traps double-clicks on headers
  92.     int handle(int event);
  94.     // check if a given row is selected.  The base class row_selected() is
  95.     // non-const, for reasons that baffle me.
  96.     bool IsRowSelected(size_t row) const;
  98.     // access the FLTK box type used for drawing a cell
  99.     Fl_Boxtype  GetCellBox(void) const;
  100.     void        SetCellBox(CFltkUtils::EBoxType);
  101.     void        SetCellBox(Fl_Boxtype);
  103.     // access the FLTK box type used for drawing row header cells
  104.     Fl_Boxtype  GetRowHeaderBox(void) const;
  105.     void        SetRowHeaderBox(CFltkUtils::EBoxType);
  106.     void        SetRowHeaderBox(Fl_Boxtype);
  108.     Fl_Boxtype  GetColHeaderBox(void) const;
  109.     void        SetColHeaderBox(CFltkUtils::EBoxType);
  110.     void        SetColHeaderBox(Fl_Boxtype);
  112.     // set the box type for both rows and cols simultaneously
  113.     void        SetHeaderBox(Fl_Boxtype);
  114.     void        SetHeaderBox(CFltkUtils::EBoxType);
  116. protected:
  118.     // GUI event processor
  119.     CGUIEvent m_Handler;
  121.     // box styles for cells and headers
  122.     Fl_Boxtype  m_CellBox;
  123.     Fl_Boxtype  m_RowHeaderBox;
  124.     Fl_Boxtype  m_ColHeaderBox;
  126.     // internal handlers for cut/copy/paste operations
  127.     virtual int x_OnCut();
  128.     virtual int x_OnCopy();
  129.     virtual int x_OnPaste();
  131.     // internal handlers for header cell clicks
  132.     virtual int x_HandleRowHeaderClick(size_t row);
  133.     virtual int x_HandleColHeaderClick(size_t col);
  134.     virtual int x_HandleCellClick(size_t row, size_t col);
  135. };
  139. class CColumnSelectDlg;
  142. //
  143. // clas ITableData defines the data interface used by all table classes
  144. //
  145. template <class RowData>
  146. class ITableData : public CObject
  147. {
  148. public:
  149.     virtual ~ITableData() {}
  151.     virtual void   Reserve  (size_t rows, size_t cols) = 0;
  152.     virtual void   SetSize  (size_t rows, size_t cols) = 0;
  153.     virtual void   SetRows  (size_t rows) = 0;
  154.     virtual void   SetCols  (size_t cols) = 0;
  155.     virtual void   AddRow   (void) = 0;
  156.     virtual void   RemoveRow(size_t row) = 0;
  157.     virtual size_t GetRows  (void) const = 0;
  158.     virtual size_t GetCols  (void) const = 0;
  160.     virtual const vector<string>& GetRow(size_t row) const = 0;
  161.     virtual vector<string>&       SetRow(size_t row) = 0;
  163.     virtual const string& GetCell(size_t row, size_t col) const = 0;
  164.     virtual string&       SetCell(size_t row, size_t col) = 0;
  166.     virtual const string& GetRowHeader(size_t row) const = 0;
  167.     virtual string&       SetRowHeader(size_t row) = 0;
  169.     // access a given row's data
  170.     virtual const RowData& GetData(size_t row) const = 0;
  171.     virtual RowData&       SetData(size_t row) = 0;
  173.     // sort the data
  174.     virtual void SortByCol(size_t col, bool ascending, bool numeric) = 0;
  175. };
  178. //
  179. // class CTableData defines a specialization of the table data
  180. // structure with a concrete type stored in each row
  181. //
  182. template <class RowData>
  183. class CTableData : public ITableData<RowData>
  184. {
  185. public:
  187.     CTableData();
  189.     // interface requirements
  190.     virtual void   Reserve  (size_t rows, size_t cols);
  191.     virtual void   SetSize  (size_t rows, size_t cols);
  192.     virtual void   SetRows  (size_t rows);
  193.     virtual void   SetCols  (size_t cols);
  194.     virtual void   AddRow   (void);
  195.     virtual void   RemoveRow(size_t row);
  196.     virtual size_t GetRows  (void) const;
  197.     virtual size_t GetCols  (void) const;
  199.     virtual const vector<string>& GetRow(size_t row) const;
  200.     virtual vector<string>&       SetRow(size_t row);
  202.     virtual const string& GetCell(size_t row, size_t col) const;
  203.     virtual string&       SetCell(size_t row, size_t col);
  205.     virtual const string& GetRowHeader(size_t row) const;
  206.     virtual string&       SetRowHeader(size_t row);
  208.     // access a given row's data
  209.     const RowData& GetData(size_t row) const;
  210.     RowData&       SetData(size_t row);
  212.     // sort the data
  213.     void SortByCol(size_t col, bool ascending, bool numeric);
  215. private:
  217.     // typedefs and nested classes for our columns and data
  218.     // NB: these are public to avoid compiler errors regarding use of a
  219.     // protected typedef in a protected nested class
  220.     class CRow
  221.     {
  222.     public:
  223.         RowData         m_Data;
  224.         string          m_RowHeader;
  225.         vector<string>  m_Columns;
  226.     };
  227.     typedef CRow TRow;
  228.     typedef vector<TRow>    TTable;
  230.     size_t m_Cols;
  231.     TTable m_Data;
  233.     //
  234.     // internal functors for sorting columns
  235.     //
  236.     struct SColSorter {
  237.         size_t col_idx;
  238.         bool   sort_ascending;
  239.         bool   sort_numeric;
  240.         SColSorter(size_t col, bool asc, bool numeric)
  241.             : col_idx(col),
  242.               sort_ascending(asc),
  243.               sort_numeric(numeric) { }
  245.         bool operator() (const TRow& row0, const TRow& row1) const
  246.         {
  247.             _ASSERT(col_idx < row0.m_Columns.size());
  248.             _ASSERT(col_idx < row1.m_Columns.size());
  249.             _ASSERT(row0.m_Columns.size() == row1.m_Columns.size());
  251.             if (sort_ascending) {
  252.                 if (sort_numeric) {
  253.                     return (NStr::StringToDouble(row0.m_Columns[col_idx]) <
  254.                             NStr::StringToDouble(row1.m_Columns[col_idx]));
  255.                 } else {
  256.                     return (row0.m_Columns[col_idx] < row1.m_Columns[col_idx]);
  257.                 }
  258.             } else {
  259.                 if (sort_numeric) {
  260.                     return (NStr::StringToDouble(row0.m_Columns[col_idx]) >
  261.                             NStr::StringToDouble(row1.m_Columns[col_idx]));
  262.                 } else {
  263.                     return (row0.m_Columns[col_idx] > row1.m_Columns[col_idx]);
  264.                 }
  265.             }
  266.         }
  267.     };
  269.     struct SColSorter_Asc_Numeric {
  270.         size_t col_idx;
  271.         SColSorter_Asc_Numeric(size_t col)
  272.             : col_idx(col) { }
  274.         bool operator() (const TRow& row0, const TRow& row1) const
  275.         {
  276.             _ASSERT(col_idx < row0.m_Columns.size());
  277.             _ASSERT(col_idx < row1.m_Columns.size());
  278.             _ASSERT(row0.m_Columns.size() == row1.m_Columns.size());
  280.             return (NStr::StringToDouble(row0.m_Columns[col_idx]) <
  281.                     NStr::StringToDouble(row1.m_Columns[col_idx]));
  282.         }
  283.     };
  285.     struct SColSorter_Desc_Numeric {
  286.         size_t col_idx;
  287.         SColSorter_Desc_Numeric(size_t col)
  288.             : col_idx(col) { }
  290.         bool operator() (const TRow& row0, const TRow& row1) const
  291.         {
  292.             _ASSERT(col_idx < row0.m_Columns.size());
  293.             _ASSERT(col_idx < row1.m_Columns.size());
  294.             _ASSERT(row0.m_Columns.size() == row1.m_Columns.size());
  296.             return (NStr::StringToDouble(row0.m_Columns[col_idx]) >
  297.                     NStr::StringToDouble(row1.m_Columns[col_idx]));
  298.         }
  299.     };
  301.     struct SColSorter_Asc_Text {
  302.         size_t col_idx;
  303.         SColSorter_Asc_Text(size_t col)
  304.             : col_idx(col) { }
  306.         bool operator() (const TRow& row0, const TRow& row1) const
  307.         {
  308.             _ASSERT(col_idx < row0.m_Columns.size());
  309.             _ASSERT(col_idx < row1.m_Columns.size());
  310.             _ASSERT(row0.m_Columns.size() == row1.m_Columns.size());
  312.             return (row0.m_Columns[col_idx] < row1.m_Columns[col_idx]);
  313.         }
  314.     };
  316.     struct SColSorter_Desc_Text {
  317.         size_t col_idx;
  318.         SColSorter_Desc_Text(size_t col)
  319.             : col_idx(col) { }
  321.         bool operator() (const TRow& row0, const TRow& row1) const
  322.         {
  323.             _ASSERT(col_idx < row0.m_Columns.size());
  324.             _ASSERT(col_idx < row1.m_Columns.size());
  325.             _ASSERT(row0.m_Columns.size() == row1.m_Columns.size());
  327.             return (row0.m_Columns[col_idx] > row1.m_Columns[col_idx]);
  328.         }
  329.     };
  331. };
  335. //
  336. // class CTablePanel extends Fl_Table with a few convenience functions.
  337. //
  338. // The main provision is for things such as uniform handling of column headers,
  339. // widths, alignments, and visibility.
  340. //
  341. template <class RowData>
  342. class CTablePanel : public CTablePanelBase
  343. {
  344. public:
  346.     typedef ITableData<RowData> TTableData;
  348.     // enumerated list of sort states for our columns
  349.     enum ESortState {
  350.         eNotSorted,
  351.         eAscending,
  352.         eDescending
  353.     };
  355.     // enumerated list of column representations
  356.     enum EColumnType {
  357.         eString,
  358.         eNumeric
  359.     };
  361.     CTablePanel(int x, int y, int w, int h, const char* label = NULL);
  362.     virtual ~CTablePanel() { }
  364.     // clear the contents of the table
  365.     virtual void Clear();
  367.     // reserve space in the table for a certain number of rows
  368.     void   Reserve(size_t rows, size_t cols);
  369.     void   Reserve(size_t rows);
  371.     // set the size of the table in rows and cols
  372.     void   SetSize(size_t rows, size_t cols);
  374.     // set the number of rows in the table
  375.     void   SetRows(size_t rows);
  377.     // set the number of columns in the table
  378.     void   SetCols(size_t cols);
  380.     // get the number of rows in the table
  381.     size_t GetRows(void) const;
  383.     // get the number of columns in the table
  384.     size_t GetCols(void) const;
  386.     // add a row to the table, returning its index
  387.     size_t AddRow (void);
  389.     // remove a row to the table, returning its index
  390.     void RemoveRow(size_t row);
  392.     // return a single row from the table
  393.     const vector<string>& GetRow(size_t row) const;
  394.     vector<string>& SetRow(size_t row);
  396.     // access a single cell in the table
  397.     const string& GetCell(size_t row, size_t col) const;
  398.     string&       SetCell(size_t row, size_t col);
  399.     void          SetCell(size_t row, size_t col, const string& val);
  401.     // access the row headers
  402.     const string& GetRowHeader(size_t row) const;
  403.     string&       SetRowHeader(size_t row);
  404.     void          SetRowHeader(size_t row, const string& val);
  406.     // access the col headers
  407.     const string& GetColHeader(size_t col) const;
  408.     string&       SetColHeader(size_t col);
  409.     void          SetColHeader(size_t col, const string& val);
  411.     // access a given row's data
  412.     const RowData& GetData(size_t row) const;
  413.     RowData&       SetData(size_t row);
  414.     void           SetData(size_t row, const RowData& data);
  416.     // FLTK overload: resize the widget
  417.     virtual void resize(int x, int y, int w, int h);
  419.     // get/set the column data type.  This determines behavior on sorting.
  420.     void            SetColType(size_t col, EColumnType type);
  421.     EColumnType     GetColType(size_t col) const;
  423.     // get/set the column relative widths
  424.     // These are a vector of floats that will be normalized ( = sum to 1.0) to
  425.     // compute actual widths
  426.     void        SetRelWidth(size_t col, float width_frac);
  427.     float       GetRelWidth(size_t col) const;
  429.     // get/set the absolute column widths, in pixels
  430.     void        SetWidth(size_t col, float width);
  431.     float       GetWidth(size_t col) const;
  433.     // set the default alignment for a given column
  434.     void        SetColAlign(size_t col, Fl_Align align);
  435.     Fl_Align    GetColAlign(size_t col) const;
  437.     // set all column parameters at once
  438.     void        SetColumn(size_t col, const string& header, EColumnType type,
  439.                           Fl_Align align, float rel_width);
  441.     // function to set up the width and alignments for the current
  442.     // visible columns.
  443.     void SetupColumns();
  445.     // sort by an indicated column in a given sort order
  446.     void SortByCol(size_t col_idx, ESortState sort_order = eAscending);
  448.     // set the virtual column for a given index
  449.     void        SetVirtualCol(int visible_col, int actual_col);
  451.     // clear all virtual columns.  NOTE: this will leave the table with no
  452.     // columns!
  453.     void        ClearVirtualCols();
  455.     // show the column selector dialog and process its results.  This allows
  456.     // users to select from the list of virtual columns.
  457.     //void        ShowColSelectDlg();
  459. protected:
  461.     CRef<TTableData> m_Data;
  463.     // safe accessors for m_Data
  464.     TTableData&       x_SetData(void);
  465.     const TTableData& x_GetData(void) const;
  467.     // general information we store concerning columns
  468.     // this allows us to be smart about such things as sorting, visibility,
  469.     // etc.
  470.     struct SColInfo {
  471.         SColInfo()
  472.             : align(FL_ALIGN_LEFT),
  473.               width_frac(1.0f),
  474.               width(100.0f),
  475.               sort_state(eNotSorted) {}
  477.         string      header;
  478.         Fl_Align    align;
  479.         float       width_frac;
  480.         float       width;
  481.         ESortState  sort_state;
  482.         EColumnType type;
  483.     };
  484.     typedef vector<SColInfo>    TColInfo;
  485.     TColInfo m_ColInfo;
  487.     // FLTK overloads
  488.     virtual void draw_cell(TableContext ctx, int row, int col,
  489.                            int x, int y, int w, int h);
  491.     // get the foreground color associated with a given row.  This is virtual
  492.     // to permit derived classes to easily change what the color will be, based
  493.     // on criteria not known to this class
  494.     virtual Fl_Color x_GetRowForegroundColor(size_t row);
  495.     virtual Fl_Color x_GetRowBackgroundColor(size_t row);
  497.     // handle column header clicks for sorting
  498.     int x_HandleColHeaderClick(size_t col);
  500.     // our virtual columns.
  501.     // We store or represent internally a number of columns potentially larger
  502.     // than that whic we display.  This allows for a high degree of
  503.     // customization - the user could theoretically select which columns to
  504.     // display and the order of display as well.
  505.     vector<size_t> m_VirtCols;
  507.     // a dialog that allows us to select columns for viewing
  508.     //auto_ptr<CColumnSelectDlg>  m_SelectDlg;
  510.     // virtual function to adjust internal structures to fit a certain number
  511.     // of columns.  These are real, not virtual, columns!
  512.     //virtual void x_SetNumColumns(int cols);
  513. };
  517. //////////////////////////////////////////////////////////////
  518. //
  519. // CTableData implementation
  520. //
  523. template <class RowData>
  524. inline CTableData<RowData>::CTableData()
  525.     : m_Cols(0)
  526. {
  527. }
  530. template <class RowData>
  531. inline void CTableData<RowData>::Reserve(size_t rows, size_t cols)
  532. {
  533.     if (cols > GetCols()) {
  534.         SetCols(cols);
  535.     }
  536.     m_Data.reserve(rows);
  537. }
  540. template <class RowData>
  541. inline void CTableData<RowData>::SetSize(size_t rows, size_t cols)
  542. {
  543.     SetCols(cols);
  544.     SetRows(rows);
  545. }
  548. template <class RowData>
  549. inline void CTableData<RowData>::SetCols(size_t cols)
  550. {
  551.     NON_CONST_ITERATE (typename TTable, iter, m_Data) {
  552.         iter->m_Columns.resize(cols);
  553.     }
  554.     m_Cols = cols;
  555. }
  558. template <class RowData>
  559. inline void CTableData<RowData>::SetRows(size_t rows)
  560. {
  561.     m_Data.resize(rows);
  562.     NON_CONST_ITERATE (typename TTable, iter, m_Data) {
  563.         iter->m_Columns.resize(m_Cols);
  564.     }
  565. }
  568. template <class RowData>
  569. inline void CTableData<RowData>::AddRow(void)
  570. {
  571.     TRow row;
  572.     row.m_Columns.resize(GetCols());
  573.     m_Data.push_back(row);
  574. }
  577. template <class RowData>
  578. inline void CTableData<RowData>::RemoveRow(size_t idx)
  579. {
  580.     _ASSERT(idx < GetRows());
  581.     m_Data.erase(m_Data.begin() + idx);
  582. }
  585. template <class RowData>
  586. inline size_t CTableData<RowData>::GetRows(void) const
  587. {
  588.     return m_Data.size();
  589. }
  592. template <class RowData>
  593. inline size_t CTableData<RowData>::GetCols(void) const
  594. {
  595.     return m_Cols;
  596. }
  599. template <class RowData>
  600. inline const RowData&
  601. CTableData<RowData>::GetData(size_t row) const
  602. {
  603.     _ASSERT(row < GetRows());
  604.     return m_Data[row].m_Data;
  605. }
  608. template <class RowData>
  609. inline RowData&
  610. CTableData<RowData>::SetData(size_t row)
  611. {
  612.     if (row >= GetRows()) {
  613.         SetRows(row + 1);
  614.     }
  615.     return m_Data[row].m_Data;
  616. }
  619. template <class RowData>
  620. inline const vector<string>&
  621. CTableData<RowData>::GetRow(size_t row) const
  622. {
  623.     _ASSERT(row < GetRows());
  624.     return m_Data[row].m_Columns;
  625. }
  628. template <class RowData>
  629. inline vector<string>&
  630. CTableData<RowData>::SetRow(size_t row)
  631. {
  632.     if (row >= GetRows()) {
  633.         SetRows(row + 1);
  634.     }
  635.     return m_Data[row].m_Columns;
  636. }
  639. template <class RowData>
  640. inline const string&
  641. CTableData<RowData>::GetCell(size_t row, size_t col) const
  642. {
  643.     _ASSERT(row < GetRows());
  644.     _ASSERT(col < GetCols());
  646.     return m_Data[row].m_Columns[col];
  647. }
  650. template <class RowData>
  651. inline string&
  652. CTableData<RowData>::SetCell(size_t row, size_t col)
  653. {
  654.     if (row >= GetRows()) {
  655.         SetRows(row + 1);
  656.     }
  658.     _ASSERT(row < GetRows());
  659.     _ASSERT(col < GetCols());
  660.     return m_Data[row].m_Columns[col];
  661. }
  664. template <class RowData>
  665. inline const string&
  666. CTableData<RowData>::GetRowHeader(size_t row) const
  667. {
  668.     _ASSERT(row < GetRows());
  669.     return m_Data[row].m_RowHeader;
  670. }
  673. template <class RowData>
  674. inline string&
  675. CTableData<RowData>::SetRowHeader(size_t row)
  676. {
  677.     if (row >= GetRows()) {
  678.         SetRows(row + 1);
  679.     }
  680.     return m_Data[row].m_RowHeader;
  681. }
  684. template <class RowData>
  685. inline void
  686. CTableData<RowData>::SortByCol(size_t col_idx, bool ascending, bool numeric)
  687. {
  688.     _ASSERT(col_idx < GetCols());
  690.     if (ascending) {
  691.         if (numeric) {
  692.             SColSorter_Asc_Numeric sorter(col_idx);
  693.             std::stable_sort(m_Data.begin(), m_Data.end(), sorter);
  694.         } else {
  695.             SColSorter_Asc_Text sorter(col_idx);
  696.             std::stable_sort(m_Data.begin(), m_Data.end(), sorter);
  697.         }
  698.     } else {
  699.         if (numeric) {
  700.             SColSorter_Desc_Numeric sorter(col_idx);
  701.             std::stable_sort(m_Data.begin(), m_Data.end(), sorter);
  702.         } else {
  703.             SColSorter_Desc_Text sorter(col_idx);
  704.             std::stable_sort(m_Data.begin(), m_Data.end(), sorter);
  705.         }
  706.     }
  707. }
  711. //////////////////////////////////////////////////////////////
  712. //
  713. // CTablePanel implementation
  714. //
  717. template <class RowData>
  718. inline
  719. CTablePanel<RowData>::CTablePanel(int x, int y, int w, int h,
  720.                                   const char* label)
  721.     : CTablePanelBase(x, y, w, h, label)
  722. {
  723.     // this creates a dummy data class for us
  724.     x_SetData();
  726.     row_header(false);
  727.     col_header(true);
  728.     col_resize(RESIZE_ROW_BELOW);
  729. }
  732. //
  733. // get the data object associated with a single row
  734. //
  735. template <class RowData>
  736. inline
  737. const RowData& CTablePanel<RowData>::GetData(size_t row) const
  738. {
  739.     _ASSERT(row < GetRows());
  740.     return x_GetData().GetData(row);
  741. }
  744. template <class RowData>
  745. inline
  746. RowData& CTablePanel<RowData>::SetData(size_t row)
  747. {
  748.     return x_SetData().SetData(row);
  749. }
  752. template <class RowData>
  753. inline
  754. void CTablePanel<RowData>::SetData(size_t row, const RowData& data)
  755. {
  756.     x_SetData().SetData(row) = data;
  757. }
  760. //
  761. // get the data class associated with the table
  762. // this makes no assumptions about whether the data class is valid
  763. //
  764. template <class RowData>
  765. inline
  766. const typename CTablePanel<RowData>::TTableData&
  767. CTablePanel<RowData>::x_GetData(void) const
  768. {
  769.     _ASSERT(m_Data);
  770.     return *m_Data;
  771. }
  774. //
  775. // get the data class in non-const form.  If the data class isn't present,
  776. // a default one is created.
  777. //
  778. template <class RowData>
  779. inline
  780. typename CTablePanel<RowData>::TTableData&
  781. CTablePanel<RowData>::x_SetData(void)
  782. {
  783.     if ( !m_Data ) {
  784.         m_Data.Reset(new CTableData<RowData>());
  785.         m_Data->SetCols(GetCols());
  786.         m_Data->SetRows(GetRows());
  787.     }
  788.     _ASSERT(m_Data);
  789.     return *m_Data;
  790. }
  793. // reserve space in the table for a certain number of rows
  794. template <class RowData>
  795. inline
  796. void CTablePanel<RowData>::Reserve(size_t rows, size_t cols)
  797. {
  798.     if (cols >= GetCols()) {
  799.         SetCols(cols + 1);
  800.     }
  801.     x_SetData().Reserve(rows, cols);
  802. }
  805. template <class RowData>
  806. inline
  807. void CTablePanel<RowData>::Reserve(size_t rows)
  808. {
  809.     x_SetData().Reserve(rows, GetCols());
  810. }
  813. // set the size of the table in rows and cols
  814. template <class RowData>
  815. inline
  816. void CTablePanel<RowData>::SetSize(size_t rows, size_t cols)
  817. {
  818.     SetCols(cols);
  819.     SetRows(rows);
  820. }
  823. // set the number of rows in the table
  824. template <class RowData>
  825. inline
  826. void CTablePanel<RowData>::SetRows(size_t rows)
  827. {
  828.     x_SetData().SetRows(rows);
  829.     CTablePanelBase::SetRows(rows);
  830. }
  833. // set the number of columns in the table
  834. template <class RowData>
  835. inline
  836. void CTablePanel<RowData>::SetCols(size_t cols)
  837. {
  838.     x_SetData().SetCols(cols);
  839.     m_ColInfo.resize(cols);
  841.     // adjust for our virtual columns
  842.     vector<size_t>::iterator iter = m_VirtCols.begin();
  843.     for ( ;  iter != m_VirtCols.end();  ) {
  844.         if (*iter >= cols) {
  845.             iter = m_VirtCols.erase(iter);
  846.         } else {
  847.             ++iter;
  848.         }
  849.     }
  851.     // pass the virtual columns to the base class
  852.     CTablePanelBase::SetCols(m_VirtCols.size());
  853. }
  858. // clear the table
  859. template <class RowData>
  860. inline
  861. void CTablePanel<RowData>::Clear()
  862. {
  863.     SetRows(0);
  864.     select_all_rows(0);
  865. }
  868. // add a row to the table, returning its index
  869. template <class RowData>
  870. inline
  871. size_t CTablePanel<RowData>::AddRow(void)
  872. {
  873.     x_SetData().AddRow();
  874.     SetRows(x_GetData().GetRows());
  875.     return x_GetData().GetRows() - 1;
  876. }
  879. template <class RowData>
  880. inline
  881. void CTablePanel<RowData>::RemoveRow(size_t idx)
  882. {
  883.     x_SetData().RemoveRow(idx);
  884.     SetRows(x_GetData().GetRows());
  885. }
  888. // get the number of rows in the table
  889. template <class RowData>
  890. inline
  891. size_t CTablePanel<RowData>::GetRows(void) const
  892. {
  893.     return x_GetData().GetRows();
  894. }
  896. // get the number of columns in the table
  897. template <class RowData>
  898. inline
  899. size_t CTablePanel<RowData>::GetCols(void) const
  900. {
  901.     return x_GetData().GetCols();
  902. }
  905. // retrieve a single row from the table
  906. template <class RowData>
  907. inline
  908. const vector<string>& CTablePanel<RowData>::GetRow(size_t row) const
  909. {
  910.     return x_GetData().GetRow(row);
  911. }
  914. template <class RowData>
  915. inline
  916. vector<string>& CTablePanel<RowData>::SetRow(size_t row)
  917. {
  918.     if (row >= GetRows()) {
  919.         SetRows(row + 1);
  920.     }
  921.     return x_SetData().SetRow(row);
  922. }
  925. template <class RowData>
  926. inline
  927. void CTablePanel<RowData>::SetCell(size_t row, size_t col, const string& val)
  928. {
  929.     if (row >= GetRows()) {
  930.         SetRows(row + 1);
  931.     }
  932.     x_SetData().SetCell(row, col) = val;
  933. }
  936. template <class RowData>
  937. inline
  938. string& CTablePanel<RowData>::SetCell(size_t row, size_t col)
  939. {
  940.     if (row >= GetRows()) {
  941.         SetRows(row + 1);
  942.     }
  943.     return x_SetData().SetCell(row, col);
  944. }
  947. template <class RowData>
  948. inline
  949. const string& CTablePanel<RowData>::GetCell(size_t row, size_t col) const
  950. {
  951.     return x_GetData().GetCell(row, col);
  952. }
  955. template <class RowData>
  956. inline
  957. string& CTablePanel<RowData>::SetRowHeader(size_t row)
  958. {
  959.     return x_SetData().SetRowHeader(row);
  960. }
  963. template <class RowData>
  964. inline
  965. void CTablePanel<RowData>::SetRowHeader(size_t row, const string& str)
  966. {
  967.     x_SetData().SetRowHeader(row) = str;
  968. }
  971. template <class RowData>
  972. inline
  973. const string& CTablePanel<RowData>::GetRowHeader(size_t row) const
  974. {
  975.     return x_GetData().GetRowHeader(row);
  976. }
  979. //
  980. // overloaded resize().  Here, we force the columns to size correctly.
  981. //
  982. template <class RowData>
  983. inline
  984. void CTablePanel<RowData>::resize(int x, int y, int w, int h)
  985. {
  986.     float total_width = 0;
  987.     ITERATE (vector<size_t>, iter, m_VirtCols) {
  988.         const SColInfo& info = m_ColInfo[*iter];
  989.         total_width += info.width;
  990.     }
  992.     Fl_Table_Row::resize(x, y, w, h);
  994.     if (w > total_width) {
  995.         int idx = 0;
  996.         NON_CONST_ITERATE (vector<size_t>, iter, m_VirtCols) {
  997.             SColInfo& info = m_ColInfo[*iter];
  999.             info.width *= w / total_width;
  1000.             col_width(idx++, (int)info.width);
  1001.         }
  1002.     }
  1003. }
  1006. template <class RowData>
  1007. inline
  1008. int CTablePanel<RowData>::x_HandleColHeaderClick(size_t col)
  1009. {
  1010.     if (Fl::event_clicks() != 0) {
  1011.         NON_CONST_ITERATE (typename TColInfo, iter, m_ColInfo) {
  1012.             string::size_type pos = iter->header.find_last_of("@");
  1013.             if (pos != string::npos  &&  pos > 0) {
  1014.                 iter->header.erase(pos - 1);
  1015.             }
  1016.         }
  1017.         SColInfo& col_info = m_ColInfo[col];
  1019.         // double click - sort by column
  1020.         switch (col_info.sort_state) {
  1021.         case eNotSorted:
  1022.         case eDescending:
  1023.             {{
  1024.                  col_info.sort_state = eAscending;
  1025.                  col_info.header += " @-28UpArrow";
  1026.              }}
  1027.             break;
  1029.         case eAscending:
  1030.             {{
  1031.                  col_info.sort_state = eDescending;
  1032.                  col_info.header += " @-22UpArrow";
  1033.              }}
  1034.             break;
  1035.         }
  1036.         SortByCol(col, col_info.sort_state);
  1037.         redraw();
  1038.         return 1;
  1039.     }
  1041.     return CTablePanelBase::x_HandleColHeaderClick(col);
  1042. }
  1045. template <class RowData>
  1046. inline Fl_Color
  1047. CTablePanel<RowData>::x_GetRowForegroundColor(size_t row)
  1048. {
  1049.     return labelcolor();
  1050. }
  1053. template <class RowData>
  1054. inline Fl_Color
  1055. CTablePanel<RowData>::x_GetRowBackgroundColor(size_t row)
  1056. {
  1057.     return FL_BACKGROUND2_COLOR;
  1058. }
  1061. //
  1062. // sort by a given column
  1063. //
  1064. template <class RowData>
  1065. inline
  1066. void CTablePanel<RowData>::SortByCol(size_t col, ESortState sort_order)
  1067. {
  1068.     _ASSERT(col < GetCols());
  1069.     x_SetData().SortByCol(col,
  1070.                           (sort_order == eAscending),
  1071.                           (m_ColInfo[col].type == eNumeric));
  1072. }
  1075. //
  1076. // SetColType()
  1077. // set the type of data represented in the column.  This determines how the
  1078. // column is sorted.
  1079. //
  1080. template <class RowData>
  1081. inline
  1082. void CTablePanel<RowData>::SetColType(size_t col, EColumnType type)
  1083. {
  1084.     if (col >= GetCols()) {
  1085.         SetCols(col + 1);
  1086.     }
  1087.     m_ColInfo[col].type = type;
  1088. }
  1091. //
  1092. // GetColType()
  1093. // Return the type of data used in a given column
  1094. // 
  1095. template <class RowData>
  1096. inline typename CTablePanel<RowData>::EColumnType
  1097. CTablePanel<RowData>::GetColType(size_t col) const
  1098. {
  1099.     _ASSERT(col < GetCols());
  1100.     return m_ColInfo[col].type;
  1101. }
  1104. //
  1105. // SetRelWidth()
  1106. // Set the relative width of a given column.  The relative width only
  1107. // makes sense in the context of the sum of the relative widths of all the
  1108. // other visible columns.
  1109. //
  1110. template <class RowData>
  1111. inline
  1112. void CTablePanel<RowData>::SetRelWidth(size_t col, float width_frac)
  1113. {
  1114.     if (col >= GetCols()) {
  1115.         SetCols(col + 1);
  1116.     }
  1117.     m_ColInfo[col].width_frac = width_frac;
  1118. }
  1121. //
  1122. // GetRelWidth()
  1123. // Returns the relative width of a given column.  The number returned only
  1124. // makes sense in the context of the sum of the relative widths of all the
  1125. // other visible columns.
  1126. //
  1127. template <class RowData>
  1128. inline
  1129. float CTablePanel<RowData>::GetRelWidth(size_t col) const
  1130. {
  1131.     _ASSERT(col < GetCols());
  1132.     return m_ColInfo[col].width_frac;
  1133. }
  1136. //
  1137. // SetWidth()
  1138. // Set the actual width in pixels for a given column
  1139. template <class RowData>
  1140. inline
  1141. void CTablePanel<RowData>::SetWidth(size_t col, float width)
  1142. {
  1143.     if (col >= GetCols()) {
  1144.         SetCols(col + 1);
  1145.     }
  1146.     m_ColInfo[col].width = width;
  1148.     ITERATE (vector<size_t>, iter, m_VirtCols) {
  1149.         if (*iter == col) {
  1150.             col_width(iter - m_VirtCols.begin(), (int)width);
  1151.         }
  1152.     }
  1153. }
  1156. //
  1157. // GetWidth()
  1158. // Returns the relative width of a given column.  The number returned only
  1159. // makes sense in the context of the sum of the relative widths of all the
  1160. // other visible columns.
  1161. //
  1162. template <class RowData>
  1163. inline
  1164. float CTablePanel<RowData>::GetWidth(size_t col) const
  1165. {
  1166.     _ASSERT(col < GetCols());
  1167.     return m_ColInfo[col].width;
  1168. }
  1171. //
  1172. // SetColAlign()
  1173. // set the default alignment for a given column
  1174. //
  1175. template <class RowData>
  1176. inline
  1177. void CTablePanel<RowData>::SetColAlign(size_t col, Fl_Align align)
  1178. {
  1179.     if (col >= GetCols()) {
  1180.         SetCols(col + 1);
  1181.     }
  1182.     m_ColInfo[col].align = align;
  1183. }
  1186. //
  1187. // GetColAlign()
  1188. // Return the current slignment setting for a given column
  1189. //
  1190. template <class RowData>
  1191. inline
  1192. Fl_Align CTablePanel<RowData>::GetColAlign(size_t col) const
  1193. {
  1194.     _ASSERT(col < GetCols());
  1195.     return m_ColInfo[col].align;
  1196. }
  1199. //
  1200. // SetColumn()
  1201. // This function sets all column properties; internally, it just calls other
  1202. // functions to set individual properties on the selected column.
  1203. //
  1204. template <class RowData>
  1205. inline
  1206. void CTablePanel<RowData>::SetColumn(size_t col, const string& header,
  1207.                                      EColumnType type,
  1208.                                      Fl_Align align,
  1209.                                      float rel_width)
  1210. {
  1211.     SetColHeader(col, header);
  1212.     SetColType  (col, type);
  1213.     SetColAlign (col, align);
  1214.     SetRelWidth (col, rel_width);
  1216.     // always add a new column
  1217.     SetVirtualCol(m_VirtCols.size(), col);
  1219.     SetupColumns();
  1220. }
  1223. //
  1224. // SetVirtualCol()
  1225. //
  1226. template <class RowData>
  1227. inline void
  1228. CTablePanel<RowData>::ClearVirtualCols()
  1229. {
  1230.     m_VirtCols.clear();
  1231.     CTablePanelBase::SetCols(0);
  1232. }
  1234. //
  1235. // SetVirtualCol()
  1236. //
  1237. template <class RowData>
  1238. inline void
  1239. CTablePanel<RowData>::SetVirtualCol(int virt_col, int actual_col)
  1240. {
  1241.     m_VirtCols.push_back(actual_col);
  1243.     // call our base class's resize
  1244.     CTablePanelBase::SetCols(m_VirtCols.size());
  1245. }
  1248. //
  1249. // SetupColumns()
  1250. // Internal function to correctly set column widths and alignments.  This is
  1251. // intended to be called any time the column setup changes - i.e., any time the
  1252. // user selects a different set of visible columns.
  1253. //
  1254. template <class RowData>
  1255. inline
  1256. void CTablePanel<RowData>::SetupColumns()
  1257. {
  1258.     float sum = 0;
  1260.     ITERATE (vector<size_t>, iter, m_VirtCols) {
  1261.         const SColInfo& info = m_ColInfo[ *iter];
  1262.         sum += info.width_frac;
  1263.     }
  1265.     float widget_width = (float)(w() - 1);
  1266.     int idx = 0;
  1267.     float total_rel_width = 0.0f;
  1268.     NON_CONST_ITERATE (vector<size_t>, iter, m_VirtCols) {
  1269.         SColInfo& info = m_ColInfo[ *iter];
  1271.         float prev_rel_width = total_rel_width;
  1272.         total_rel_width += info.width_frac;
  1274.         float prev_width  = (widget_width * prev_rel_width / sum);
  1275.         float total_width = (widget_width * total_rel_width / sum);
  1276.         info.width = total_width - prev_width;
  1278.         // actually set our width
  1279.         // we take this opportunity to set the column style as well
  1280.         col_width(idx++, (int)info.width);
  1281.     }
  1282. }
  1285. //
  1286. // access a column header
  1287. //
  1288. template <class RowData>
  1289. inline
  1290. void CTablePanel<RowData>::SetColHeader(size_t col, const string& str)
  1291. {
  1292.     if (col >= GetCols()) {
  1293.         SetCols(col + 1);
  1294.     }
  1295.     m_ColInfo[col].header = str;
  1296. }
  1299. template <class RowData>
  1300. inline
  1301. const string& CTablePanel<RowData>::GetColHeader(size_t col) const
  1302. {
  1303.     _ASSERT(col < GetCols());
  1304.     return m_ColInfo[col].header;
  1305. }
  1308. //
  1309. // Fl_Table_Row overload: draw_cell()
  1310. // This actually does the work of drawing our data
  1311. //
  1312. template <class Data>
  1313. inline
  1314. void CTablePanel<Data>::draw_cell(TableContext ctx,
  1315.                                   int row, int col,
  1316.                                   int x, int y, int w, int h)
  1317. {
  1318.     // flip for our virtual columns
  1319.     if (m_VirtCols.size()) {
  1320.         col = m_VirtCols[col];
  1321.     }
  1323.     switch (ctx) {
  1324.     case CONTEXT_STARTPAGE:
  1325. fl_font(labelfont(), labelsize());
  1326.         break;
  1328.     case CONTEXT_ROW_HEADER:
  1329.         fl_push_clip(x, y, w, h);
  1330.         {{
  1331.             fl_draw_box(m_RowHeaderBox, x, y, w, h, row_header_color());
  1332.             if ((size_t)row < GetRows()) {
  1333.                 fl_color(labelcolor());
  1334.                 fl_draw(GetRowHeader(row).c_str(),
  1335.                         x, y, w, h, FL_ALIGN_CENTER);
  1336.             }
  1337.          }}
  1338.         fl_pop_clip();
  1339.         break;
  1341.     case CONTEXT_COL_HEADER:
  1342.         fl_push_clip(x, y, w, h);
  1343.         {{
  1344.             fl_draw_box(m_ColHeaderBox, x, y, w, h, col_header_color());
  1345.             if ((size_t)col < GetCols()) {
  1346.                 fl_color(labelcolor());
  1347.                 fl_draw(GetColHeader(col).c_str(),
  1348.                         x, y, w, h, FL_ALIGN_CENTER);
  1349.             }
  1350.          }}
  1351.         fl_pop_clip();
  1352.         break;
  1354.     case CONTEXT_CELL:
  1355.         fl_push_clip(x, y, w, h);
  1356.         {{
  1357.     // BG COLOR
  1358.             if (row_selected(row)) {
  1359.         fl_color(selection_color());
  1360.             } else {
  1361.                 fl_color(x_GetRowBackgroundColor(row));
  1362.             }
  1363.     fl_rectf(x, y, w, h);
  1365.     // TEXT
  1366.             if ((size_t)row < GetRows()  && (size_t)col < GetCols()) {
  1367.                 if (row_selected(row)) {
  1368.                     fl_color(FL_YELLOW);
  1369.                 } else {
  1370.                     fl_color(x_GetRowForegroundColor(row));
  1371.                 }
  1372.                 const char *p = GetCell(row, col).c_str();
  1373.                 fl_draw(p,
  1374.                         x + Fl::box_dx(m_CellBox),
  1375.                         y + Fl::box_dy(m_CellBox),
  1376.                         w - Fl::box_dw(m_CellBox),
  1377.                         h - Fl::box_dh(m_CellBox),
  1378.                         GetColAlign(col));
  1379.             }
  1381.             // BORDER
  1382.             fl_draw_box(m_CellBox, x, y, w, h, FL_LIGHT2);
  1383.         }}
  1384.         fl_pop_clip();
  1385.         break;
  1387.     case CONTEXT_ENDPAGE:
  1388.         fl_push_clip(this->x(), this->y(), this->w(), this->h());
  1389.         {{
  1390.             fl_draw_box(box(),
  1391.                         this->x(), this->y(), this->w(), this->h(),
  1392.                         color());
  1393.         }}
  1394.         fl_pop_clip();
  1395.         break;
  1397.     default:
  1398.         break;
  1399.     }
  1400. }
  1403. #if 0
  1405. //
  1406. // stock data comparators - one to dereference, and one to compare by value
  1407. //
  1409. template <class Data>
  1410. struct SCompareByPtr {
  1411.     bool operator() (const Data& d0, const Data& d1) const {
  1412.         return (*d0 < *d1);
  1413.     }
  1414. };
  1417. template <class Data>
  1418. struct SCompareByValue {
  1419.     bool operator() (const Data& d0, const Data& d1) const {
  1420.         return (d0 < d1);
  1421.     }
  1422. };
  1425. //
  1426. // class CListPanel extends CTablePanel by creating a multi-column list panel.
  1427. //
  1428. // This panel has a few features not found in CTablePanel:
  1429. //  - It stores all data in the widget itself, rather than relying on a virtual
  1430. //    accessor mechanism.
  1431. //  - It provides a means of sorting by columns.  -1 = sort by original data.
  1432. //
  1433. template <class Data, class Comparator = SCompareByPtr<Data> >
  1434. class CListPanel : public CTablePanel
  1435. {
  1436. public:
  1437.     // typedefs and nested classes for our columns and data
  1438.     // NB: these are public to avoid compiler errors regarding use of a
  1439.     // protected typedef in a protected nested class
  1440.     typedef vector<string>  TColumns;
  1441.     class CRow
  1442.     {
  1443.     public:
  1444.         Data        m_Data;
  1445.         string      m_RowHeader;
  1446.         TColumns    m_Columns;
  1447.     };
  1448.     typedef CRow TRow;
  1449.     typedef vector<TRow>    TTable;
  1452.     CListPanel(int x, int y, int w, int h, const char* label = NULL);
  1453.     virtual ~CListPanel() {}
  1455.     // sort by a given column
  1456.     void        SortByCol(int col);
  1458.     // get/set the row headers
  1459.     void            SetRowHeader(int row, const string& header);
  1460.     const string&   GetRowHeader(int row) const;
  1462.     // access the data for a given row
  1463.     Data        GetData(int row)    { return m_Data[row].m_Data; }
  1465. protected:
  1467.     // our data
  1468.     TTable                  m_Data;
  1470.     // predicate for sorting our table data by a given column
  1471.     struct SColSorter
  1472.     {
  1473.         int m_Col;
  1474.         bool m_Ascending;
  1475.         EColumnType type;
  1476.         Comparator m_Comparator;
  1477.         SColSorter(int col, bool ascending, EColumnType type)
  1478.             : m_Col(col)
  1479.             , m_Ascending(ascending)
  1480.             , type(type) {}
  1482.         bool operator() (const TRow& row0, const TRow& row1) const
  1483.         {
  1484.             bool comp = false;
  1486.             switch (type) {
  1487.             case eString:
  1488.                 if (row0.m_Columns[m_Col] != row1.m_Columns[m_Col]) {
  1489.                     comp = (row0.m_Columns[m_Col] < row1.m_Columns[m_Col]);
  1490.                 } else {
  1491.                     comp = m_Comparator(row0.m_Data, row1.m_Data);
  1492.                 }
  1493.                 break;
  1495.             case eNumeric:
  1496.                 {
  1497.                     int r0 = 0;
  1498.                     int r1 = 0;
  1499.                     if ( !row0.m_Columns[m_Col].empty() ) {
  1500.                         r0 = NStr::StringToInt(row0.m_Columns[m_Col],
  1501.                                                10, NStr::eCheck_Skip);
  1502.                     }
  1503.                     if ( !row1.m_Columns[m_Col].empty() ) {
  1504.                         r1 = NStr::StringToInt(row1.m_Columns[m_Col],
  1505.                                                10, NStr::eCheck_Skip);
  1506.                     }
  1507.                     if (r0 != r1) {
  1508.                         comp = (r0 < r1);
  1509.                     } else {
  1510.                         comp = m_Comparator(row0.m_Data, row1.m_Data);
  1511.                     }
  1512.                 }
  1513.                 break;
  1514.             }
  1516.             return (m_Ascending ? comp : !comp);
  1517.         }
  1518.     };
  1520.     // predicate for sorting our table data by the underlying data object
  1521.     struct SDataSorter
  1522.     {
  1523.         bool m_Ascending;
  1524.         Comparator m_Comp;
  1525.         SDataSorter(bool ascending)
  1526.             : m_Ascending(ascending) {}
  1527.         bool operator() (const TRow& row0, const TRow& row1) const
  1528.         {
  1529.             return (m_Ascending ?
  1530.                     ( m_Comp(row0.m_Data, row1.m_Data) ):
  1531.                     ( m_Comp(row1.m_Data, row0.m_Data) ) );
  1532.         }
  1533.     };
  1535.     // FLTK overloads
  1536.     virtual int handle(int event);
  1537.     virtual void draw_cell(TableContext ctx, int row, int col,
  1538.                            int x, int y, int w, int h);
  1539. };
  1542. //
  1543. // default ctor
  1544. //
  1545. template <class Data, class Comparator>
  1546. inline CListPanel<Data, Comparator>::CListPanel(int x, int y, int w, int h,
  1547.                                     const char* label)
  1548.     : CTablePanel(x, y, w, h, label)
  1549. {
  1550. }
  1553. //
  1554. // Utility function: sort by a given column
  1555. // NOTE: the 'column' here is the *actual* column.  The one exception is the
  1556. // special column '-1', which indicates 'sort by underlying data'
  1557. //
  1558. template <class Data, class Comparator>
  1559. inline void CListPanel<Data, Comparator>::SortByCol(int col)
  1560. {
  1561.     if (col >= 0) {
  1562.         if (col >= int (m_ColInfo.size())) {
  1563.             return;
  1564.         }
  1566.         bool ascending = false;
  1567.         if (m_ColInfo[col].sort_state != eAscending) {
  1568.             ascending = true;
  1569.         }
  1571.         NON_CONST_ITERATE (TColInfo, iter, m_ColInfo) {
  1572.             iter->sort_state = eNotSorted;
  1573.         }
  1574.         m_ColInfo[col].sort_state = (ascending ? eAscending : eDescending);
  1576.         // string sort by column
  1577.         // we need to map our visible column to our underlying data column
  1578.         std::sort(m_Data.begin(), m_Data.end(),
  1579.                   SColSorter(col, ascending, m_ColInfo[col].type));
  1580.     } else {
  1581.         // sort by data
  1582.         std::sort(m_Data.begin(), m_Data.end(), SDataSorter(true));
  1583.     }
  1584. }
  1587. //
  1588. // SetRowHeader()
  1589. // Set the header for a given row
  1590. //
  1591. template <class Data, class Comparator>
  1592. inline void
  1593. CListPanel<Data, Comparator>::SetRowHeader(int row, const string& header)
  1594. {
  1595.     if (int (m_Data.size()) <= row) {
  1596.         m_Data.resize(row + 1);
  1597.     }
  1598.     m_Data[row].m_RowHeader = header;
  1599. }
  1602. //
  1603. // GetRowHeader()
  1604. // Return the header for a given row
  1605. //
  1606. template <class Data, class Comparator>
  1607. inline const string&
  1608. CListPanel<Data, Comparator>::GetRowHeader(int row) const
  1609. {
  1610.     return m_Data[row].m_RowHeader;
  1611. }
  1614. //
  1615. // Flek overload: draw_cell()
  1616. // This actually does the work of drawing our data
  1617. //
  1618. template <class Data, class Comparator>
  1619. inline void CListPanel<Data, Comparator>::draw_cell(TableContext ctx,
  1620.                                                     int row, int col,
  1621.                                                     int x, int y,
  1622.                                                     int w, int h)
  1623. {
  1624.     // transform col (virtual col) to actual table column
  1625.     int actual_col = 0;
  1626.     if (col < m_VirtCols.size() ) {
  1627.         actual_col = m_VirtCols[col];
  1628.     }
  1630.     switch (ctx) {
  1631.     case CONTEXT_STARTPAGE:
  1632. fl_font(labelfont(), labelsize());
  1633.         break;
  1635.     case CONTEXT_ROW_HEADER:
  1636.         fl_push_clip(x, y, w, h);
  1637.         {{
  1638.             fl_draw_box(m_HeaderBox, x, y, w, h, row_header_color());
  1639.             fl_color(labelcolor());
  1640.             if (row < m_Data.size()) {
  1641.                 fl_draw(m_Data[row].m_RowHeader.c_str(),
  1642.                         x, y, w, h, FL_ALIGN_CENTER);
  1643.             }
  1644.          }}
  1645.         fl_pop_clip();
  1646.         break;
  1648.     case CONTEXT_COL_HEADER:
  1649.         fl_push_clip(x, y, w, h);
  1650.         {{
  1651.             fl_draw_box(m_HeaderBox, x, y, w, h, col_header_color());
  1652.             if (actual_col < m_ColInfo.size()) {
  1653.                 fl_color(labelcolor());
  1654.                 fl_draw(m_ColInfo[actual_col].header.c_str(),
  1655.                         x, y, w, h, FL_ALIGN_CENTER);
  1656.             }
  1657.          }}
  1658.         fl_pop_clip();
  1659.         break;
  1661.     case CONTEXT_CELL:
  1662.         fl_push_clip(x, y, w, h);
  1663.         {{
  1664.     // BG COLOR
  1665.     fl_color(row_selected(row) ?
  1666.                      selection_color() : FL_BACKGROUND2_COLOR);
  1667.     fl_rectf(x, y, w, h);
  1669.     // TEXT
  1670.             if (row < m_Data.size()  &&
  1671.                 actual_col < m_Data[row].m_Columns.size()) {
  1672.         fl_color(labelcolor());
  1673.                 const char *p = m_Data[row].m_Columns[actual_col].c_str();
  1674.                 fl_draw(p,
  1675.                         x + Fl::box_dx(m_CellBox),
  1676.                         y + Fl::box_dy(m_CellBox),
  1677.                         w - Fl::box_dw(m_CellBox),
  1678.                         h - Fl::box_dh(m_CellBox),
  1679.                         GetColAlign(actual_col));
  1680.             }
  1682.     // BORDER
  1683.     fl_draw_box(m_CellBox, x, y, w, h, FL_LIGHT2);
  1684.          }}
  1685.         fl_pop_clip();
  1686.         break;
  1688.     default:
  1689.         break;
  1690.     }
  1692. }
  1695. //
  1696. // overloaded event handler
  1697. // here we trigger column sorting
  1698. //
  1699. template <class Data, class Comparator>
  1700. inline int CListPanel<Data, Comparator>::handle(int event)
  1701. {
  1702.     int row = -1;
  1703.     int col = -1;
  1705.     switch (event)
  1706.     {
  1707.     case FL_PUSH:
  1708.         /** FIXME
  1709.         row = get_row(Fl::event_x(), Fl::event_y());
  1710.         if (row != -1  ||  Fl::event_clicks() != 1) {
  1711.             break;
  1712.         }
  1713.         col = get_col(Fl::event_x(), Fl::event_y());
  1714.         SortByCol(m_VirtCols[col]);
  1715.         redraw();
  1716.         **/
  1717.         break;
  1719.     default:
  1720.         break;
  1721.     };
  1723.     return Fl_Table_Row::handle(event);
  1724. }
  1726. #endif
  1728. END_NCBI_SCOPE
  1730. /* @} */
  1733. /*
  1734.  * ===========================================================================
  1735.  * $Log: table_panel.hpp,v $
  1736.  * Revision 1000.4  2004/06/01 19:52:33  gouriano
  1737.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.15
  1738.  *
  1739.  * Revision 1.15  2004/05/28 14:54:54  dicuccio
  1740.  * Added functions to take CFltkUtils::EBoxType directly
  1741.  *
  1742.  * Revision 1.14  2004/05/25 17:06:39  dicuccio
  1743.  * MOved border drawing code outside of row check.  Changed ascending/descending
  1744.  * sort arrows to meet user expectations
  1745.  *
  1746.  * Revision 1.13  2004/05/11 18:55:14  dicuccio
  1747.  * Added doxygen modules info
  1748.  *
  1749.  * Revision 1.12  2004/05/07 15:44:47  dicuccio
  1750.  * Fixed compiler warning about type conversion
  1751.  *
  1752.  * Revision 1.11  2004/05/03 12:47:08  dicuccio
  1753.  * Added #include for gui/gui.hpp.  gui/utils ->gui/objutils where needed.
  1754.  *
  1755.  * Revision 1.10  2004/04/22 15:08:08  gorelenk
  1756.  * Fixed compilation error in implementation of 'CTablePanel<RowData>::SetRow'
  1757.  *
  1758.  * Revision 1.9  2004/04/22 14:21:41  gorelenk
  1759.  * Fixed compilation errors on MSVC7.
  1760.  *
  1761.  * Revision 1.8  2004/04/16 14:32:54  dicuccio
  1762.  * Added IsRowSelected() - const wrapper around non-const function
  1763.  *
  1764.  * Revision 1.7  2004/04/07 12:42:08  dicuccio
  1765.  * Call SetRows() in RemoveRow().  Make sure that draw_cell() will be entered even
  1766.  * if no items are present (insures that column headers will be drawn)
  1767.  *
  1768.  * Revision 1.6  2004/03/19 18:02:17  dicuccio
  1769.  * Added SetWidth()/GetWidth() - width of a column in pixels.  Added better
  1770.  * (smooth) handling of resize() - resize columns to fit only if they are less
  1771.  * than the current width.
  1772.  *
  1773.  * Revision 1.5  2004/03/19 17:00:12  dicuccio
  1774.  * Fix for resize() - preserve virtual width of the table
  1775.  *
  1776.  * Revision 1.4  2004/03/11 17:22:41  dicuccio
  1777.  * Reinstaed virtual columns
  1778.  *
  1779.  * Revision 1.3  2004/03/05 17:28:26  dicuccio
  1780.  * Added standard handlers for cut/copy/paste events.  Added abiluty to remove
  1781.  * rows
  1782.  *
  1783.  * Revision 1.2  2004/01/20 18:11:11  dicuccio
  1784.  * Changed SetColumns() to SetCols().  Introduced GetRows()/SetRows()/SetCols()
  1785.  * as virtual replacements for rows()/cols().  Added sorting of columns on
  1786.  * double-click of header.  Added standard virtual hooks for trapping click
  1787.  * events inside of cells / headers.  Added more natural API to SetCells().
  1788.  *
  1789.  * Revision 1.1  2003/12/09 15:54:10  dicuccio
  1790.  * Deprecated Fl_Tree_Browser - use Flu_Tree_Browser instead
  1791.  *
  1792.  * Revision 1.22  2003/12/05 02:03:14  ucko
  1793.  * Add missing definitions of CTablePanel::{Get,Set}RowHeader(size_t),
  1794.  * and fix the other definition of GetRowHeader to avoid looping forever.
  1795.  *
  1796.  * Revision 1.21  2003/12/04 18:07:48  dicuccio
  1797.  * Removed direct access to underlying data component in CTablePanel<> - makes
  1798.  * the class more tightly encapsulated
  1799.  *
  1800.  * Revision 1.20  2003/09/29 15:16:02  dicuccio
  1801.  * Added typename where required
  1802.  *
  1803.  * Revision 1.19  2003/09/24 18:21:56  dicuccio
  1804.  * Introduce new base class interposed between CTablePanel<> and Fl_Table_Row;
  1805.  * this class incorporates most of the generic features of CTablePanel<> and
  1806.  * allows for easier extension of list views
  1807.  *
  1808.  * Revision 1.18  2003/09/17 16:19:58  dicuccio
  1809.  * Make sure to set the row height appropriately for the font when setting rows
  1810.  *
  1811.  * Revision 1.17  2003/08/18 14:53:04  dicuccio
  1812.  * Code clean-up.  Made interface class for table data cleaner, more
  1813.  * comprehensive
  1814.  *
  1815.  * Revision 1.16  2003/07/28 11:53:29  dicuccio
  1816.  * Rewrote CTablePanel<> to be more flexible and better contained
  1817.  *
  1818.  * Revision 1.15  2003/07/25 13:40:46  dicuccio
  1819.  * Replaced Flv_Table with Fl_Table
  1820.  *
  1821.  * Revision 1.14  2003/06/25 16:59:42  dicuccio
  1822.  * Changed CPluginHandle into a pointer-to-implementation (the previous
  1823.  * implementation is now the pointer held).  Lots of #include file clean-ups.
  1824.  *
  1825.  * Revision 1.13  2003/03/17 14:58:33  dicuccio
  1826.  * Eliminated annoying compiler warning about unsigned-signed compare
  1827.  *
  1828.  * Revision 1.12  2003/03/10 17:49:04  kuznets
  1829.  * iterate->ITERATE
  1830.  *
  1831.  * Revision 1.11  2003/02/25 14:43:20  dicuccio
  1832.  * Added smart resizing of multicolumn list widget
  1833.  *
  1834.  * Revision 1.10  2003/02/20 19:43:13  dicuccio
  1835.  * Changed column sort to be triggered on double-click, not single-click
  1836.  *
  1837.  * Revision 1.9  2003/01/17 21:09:49  dicuccio
  1838.  * Altered sorting - fall back to feature sort order if sort returns
  1839.  * equivalence
  1840.  *
  1841.  * Revision 1.8  2003/01/15 17:48:32  dicuccio
  1842.  * Fixed thinko: don't try to numerically convert an empty column string
  1843.  *
  1844.  * Revision 1.7  2003/01/13 13:11:44  dicuccio
  1845.  * Namespace clean-up.  Retired namespace gui -> converted to namespace ncbi.
  1846.  * Moved all FLUID-generated code into namespace ncbi.
  1847.  *
  1848.  * Revision 1.6  2003/01/08 20:19:19  dicuccio
  1849.  * Fix for solaris builds: cannot use protected typedefs in protected nested
  1850.  * classes.
  1851.  *
  1852.  * Revision 1.5  2003/01/08 14:47:45  dicuccio
  1853.  * Moved column selection dialog into internal directory.  Made column
  1854.  * selection dialog part of the base class; it is expressible via
  1855.  * CTablePanel::ShowColSelectDlg().  Added ability to specify type of data
  1856.  * stored in column (currently string or numeric); added ability to sort based
  1857.  * on underlying type.
  1858.  *
  1859.  * Revision 1.4  2003/01/03 18:38:08  dicuccio
  1860.  * Fixed compilation error in WIndows - can't reference protected enum from
  1861.  * nested protected class.
  1862.  *
  1863.  * Revision 1.3  2003/01/03 13:28:14  dicuccio
  1864.  * Lots of clean-up.  Added stored sort state.  Added new class to hold all
  1865.  * info for one virtual column.  Added dialog box for selecting visible
  1866.  * columns.
  1867.  *
  1868.  * Revision 1.2  2002/12/30 20:18:14  dicuccio
  1869.  * Added Win32 export specifier.  Rearranged #include directives
  1870.  *
  1871.  * Revision 1.1  2002/12/30 18:42:39  dicuccio
  1872.  * Initial revision
  1873.  *
  1874.  * ===========================================================================
  1875.  */
  1877. #endif  // GUI_WIDGETS_TABLE___TABLE_PANEL__HPP