table.hh

Go to the documentation of this file.

#ifndef __DW_TABLE_HH__
#define __DW_TABLE_HH__
 
#include "oofawarewidget.hh"
#include "alignedtablecell.hh"
#include "../lout/misc.hh"
 
namespace dw {
 
class Table: public oof::OOFAwareWidget
{
private:
   struct Cell {
      core::Widget *widget;
      int colspanOrig, colspanEff, rowspan;
   };
   struct SpanSpace {
      int startCol, startRow;  // where the cell starts
   };
 
   struct Child
   {
      enum {
         CELL,       // cell starts here
         SPAN_SPACE  // part of a spanning cell
      } type;
      union {
         struct Cell cell;
         struct SpanSpace spanSpace;
      };
   };
 
   class TableIterator: public OOFAwareWidgetIterator
   {
   protected:
      int numContentsInFlow ();
      void getContentInFlow (int index, core::Content *content);
 
   public:
      TableIterator (Table *table, core::Content::Type mask, bool atEnd);
 
      lout::object::Object *clone();
 
      void highlight (int start, int end, core::HighlightLayer layer);
      void unhighlight (int direction, core::HighlightLayer layer);
      void getAllocation (int start, int end, core::Allocation *allocation);
   };
 
   friend class TableIterator;
 
   static bool adjustTableMinWidth;
 
   bool limitTextWidth, rowClosed;
 
   int numRows, numCols, curRow, curCol;
   lout::misc::SimpleVector<Child*> *children;
 
   int redrawX, redrawY;
 
   lout::misc::SimpleVector<core::Extremes> *colExtremes;
 
   lout::misc::SimpleVector<bool> *colWidthSpecified;
   int numColWidthSpecified;
 
   lout::misc::SimpleVector<bool> *colWidthPercentage;
   int numColWidthPercentage;
 
   lout::misc::SimpleVector<int> *colWidths;
 
   lout::misc::SimpleVector<int> *cumHeight;
   lout::misc::SimpleVector<int> *rowSpanCells;
   lout::misc::SimpleVector<int> *baseline;
 
   lout::misc::SimpleVector<core::style::Style*> *rowStyle;
 
   bool colWidthsUpToDateWidthColExtremes;
 
   enum ExtrMod { MIN, MIN_INTR, MIN_MIN, MAX_MIN, MAX, MAX_INTR, DATA };
 
   const char *getExtrModName (ExtrMod mod);
   int getExtreme (core::Extremes *extremes, ExtrMod mod);
   void setExtreme (core::Extremes *extremes, ExtrMod mod, int value);
   int getColExtreme (int col, ExtrMod mod, void *data);
   inline void setColExtreme (int col, ExtrMod mod, void *data, int value);
 
   inline bool childDefined(int n)
   {
      return n < children->size() && children->get(n) != NULL &&
         children->get(n)->type != Child::SPAN_SPACE;
   }
 
   int calcAvailWidthForDescendant (Widget *child);
 
   void reallocChildren (int newNumCols, int newNumRows);
 
   void calcCellSizes (bool calcHeights);
   void forceCalcCellSizes (bool calcHeights);
   void actuallyCalcCellSizes (bool calcHeights);
   void apportionRowSpan ();
 
   void forceCalcColumnExtremes ();
   void calcExtremesSpanMultiCols (int col, int cs,
                                   core::Extremes *cellExtremes,
                                   ExtrMod minExtrMod, ExtrMod maxExtrMod,
                                   void *extrData);
   void calcAdjustmentWidthSpanMultiCols (int col, int cs,
                                          core::Extremes *cellExtremes);
 
   void apportion2 (int totalWidth, int firstCol, int lastCol,
                    ExtrMod minExtrMod, ExtrMod maxExtrMod, void *extrData,
                    lout::misc::SimpleVector<int> *dest, int destOffset);
 
   void setCumHeight (int row, int value)
   {
      if (value != cumHeight->get (row)) {
         redrawY = lout::misc::min ( redrawY, value );
         cumHeight->set (row, value);
      }
   }
 
protected:
   void sizeRequestSimpl (core::Requisition *requisition);
   void getExtremesSimpl (core::Extremes *extremes);
   void sizeAllocateImpl (core::Allocation *allocation);
   void resizeDrawImpl ();
 
   bool getAdjustMinWidth () { return Table::adjustTableMinWidth; }
 
   int getAvailWidthOfChild (Widget *child, bool forceValue);
 
   void containerSizeChangedForChildren ();
   bool affectsSizeChangeContainerChild (Widget *child);
   bool usesAvailWidth ();
 
   bool isBlockLevel ();
 
   void drawLevel (core::View *view, core::Rectangle *area, int level,
                   core::DrawingContext *context);
 
   Widget *getWidgetAtPointLevel (int x, int y, int level,
                                  core::GettingWidgetAtPointContext *context);
 
   //bool buttonPressImpl (core::EventButton *event);
   //bool buttonReleaseImpl (core::EventButton *event);
   //bool motionNotifyImpl (core::EventMotion *event);
 
   void removeChild (Widget *child);
 
public:
   static int CLASS_ID;
 
   inline static void setAdjustTableMinWidth (bool adjustTableMinWidth)
   { Table::adjustTableMinWidth = adjustTableMinWidth; }
 
   inline static bool getAdjustTableMinWidth ()
   { return Table::adjustTableMinWidth; }
 
   Table(bool limitTextWidth);
   ~Table();
 
   int applyPerWidth (int containerWidth, core::style::Length perWidth);
   int applyPerHeight (int containerHeight, core::style::Length perHeight);
 
   core::Iterator *iterator (core::Content::Type mask, bool atEnd);
 
   void addCell (Widget *widget, int colspan, int rowspan);
   void addRow (core::style::Style *style);
   AlignedTableCell *getCellRef ();
};
 
} // namespace dw
 
#endif // __DW_TABLE_HH__