---

csgrid.h

/*
    Crystal Space Windowing System : grid class
    Copyright (C) 2000 by Norman Krämer <normank@lycosmail.com>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CSWSGRID_H__
#define __CSWSGRID_H__

#include "csws/csscrbar.h"
#include "csutil/csvector.h"
#include "csutil/csstring.h"

typedef bool (*csRegionTreeFunc) (csSome node, csSome databag);

class csRegionTree2D;
class csSparseGrid;
class csGridCell;
class csGridView;
class csGrid;
class csSplitter;

class csRegionTree2D
{
public:
  csRect region;
  csRegionTree2D *children[5]; // max. 5 children possible
  csSome data;

public:
  csRegionTree2D ();
  csRegionTree2D (csRect area, csSome data);
  ~csRegionTree2D ();

  void Insert (csRect &area, csSome data);

  void FindRegion (const csRect &area, csVector &vLeafList);

  void Traverse (csRegionTreeFunc userFunc, csSome databag = NULL);

};

class csSparseGrid
{
  friend class csGrid;
  /*
   * A single entry in the "grid row" array.
   */
  struct csGridRowEntry
  {
    int col;
    csSome data;
    // Initialize the object with given column and associated data
    csGridRowEntry (int theCol, csSome theData) : col (theCol), data (theData) {}
  };

  /*
   * A "grid row" is a horizontal stripe of cells which makes up the
   * entire grid. Every data item in this csVector is a csGridRowEntry.
   * The grid row object does not contain all the cells as separate objects;
   * this would waste too much memory. Instead, we keep only those cell
   * objects which have associated data items. The cells are kept sorted
   * by column number for faster searching.
   */
  class csGridRow : public csVector
  {
    int col;
  public:
    // Initialize the object
    csGridRow (int theCol);
    // Destroy the object
    virtual ~csGridRow ();
    // Set the data at given column
    void SetAt (int col, csSome data);
    // Get the row entry at given column
    csGridRowEntry *Get (int index);
    // Compare two row entries
    virtual int Compare (csSome Item1, csSome Item2, int Mode) const;
    // Compare a row entry with a key
    virtual int CompareKey (csSome Item1, csConstSome Key, int Mode) const;
    // Free a row entry item
    virtual bool FreeItem (csSome Item);
  };
  friend class csSparseGrid::csGridRow;

  /*
   * A "grid row set" is an array of "grid rows",
   * e.g. this is the grid itself.
   */
  class csGridRowSet : public csGridRow
  {
  public:
    // Initialize the grid row set object
    csGridRowSet (int theRow) : csGridRow (theRow) {}
    // destructor
    virtual ~csGridRowSet () {DeleteAll ();}
    // Free a particular grid row object
    virtual bool FreeItem (csSome Item)
    {
      delete (csGridRow *)((csGridRowEntry *)Item)->data;
      delete (csGridRowEntry *)Item;
      return true;
    }
  };

  // The Grid (AKA The Matrix :)
  csGridRowSet rows;

public:
  csSparseGrid () : rows (8) {}

  csSome GetAt (int row, int col)
  {
    csSome result = NULL;
    int idx1 = rows.FindSortedKey ((csConstSome)row);
    if (idx1 != -1)
    {
      int idx2 = ((csGridRow *)rows.Get (idx1)->data)->FindSortedKey ((csConstSome)col);
      if (idx2 != -1)
        result = ((csGridRow *)rows.Get (idx1)->data)->Get (idx2)->data;
    }
    return result;
  }

  // Set the data at given row/column
  void SetAt (int row, int col, csSome data)
  {
    int idx = rows.FindSortedKey ((csConstSome)row);
    if (idx == -1)
      idx = rows.InsertSorted (new csGridRowEntry (row, new csGridRow (row)));
    ((csGridRow *)rows.Get (idx)->data)->SetAt (col, data);
  }
};

enum csGridCellBorderStyle
{
  gcbsNone = 0,
  gcbsDash,
  gcbsDashPoint,
  gcbsDashPointPoint,
  gcbsDashDashPoint,
  gcbsLine
};

#define CSS_GRIDCELL_SELECTED        0x00010000

class csGridCell : public csComponent
{
  class csCellBorder
  {
  public:
    csGridCellBorderStyle style;
    int thick;
    csCellBorder () : style (gcbsLine), thick (1) {}
  };

  bool inUse;

public:
  csCellBorder upper, lower, left, right;
  int row, col;
  csSome data;
  csString valuePattern;

  csGridCell ();
  virtual void Draw ();
  bool IsUsed () { return inUse; }
  void SetUsed (bool iState = true) { inUse = iState; }

protected:
  void DrawLine (int x1, int y1, int x2, int y2, csCellBorder &border);
};



#define CSGVS_HSCROLL  0x00000001

#define CSGVS_VSCROLL  0x00000002

#define CSGVS_DEFAULTVALUE (CSGVS_HSCROLL | CSGVS_VSCROLL)

class csGridView : public csComponent
{
protected:
  csRect area;
  csGrid *pGrid;
  int row, col;
  bool fPlaceItems;
  int Style;
  csScrollBar *hscroll, *vscroll;

  void CooAt (int theX, int theY, int &theRow, int &theCol);

public:
  float areafactor;

  csGridView (csGrid *pParent, const csRect &region,
    int iStyle = CSGVS_DEFAULTVALUE);
  csGridView (const csGridView &view, int iStyle = -1);

  virtual void Draw ();
  virtual bool HandleEvent (iEvent& Event);
  virtual bool SetRect (int xmin, int ymin, int xmax, int ymax);
  const csRect& GetArea (){return area;}
  virtual void FixSize (int &newW, int &newH);
  virtual void SuggestSize (int &w, int &h);

  csGridView *SplitX (int x, int iStyle = -1);
  csGridView *SplitY (int y, int iStyle = -1);

  void SetViewArea (const csRect& rc)
  {
    area.Set (rc.xmin, rc.ymin, rc.xmax, rc.ymax);
    col = area.xmin; row = area.ymin;
  }

protected:
  virtual csGridView *CreateCopy (int iStyle);
  void PlaceItems ();
};


#define CSGS_HSPLIT             0x00000004

#define CSGS_VSPLIT             0x00000008

#define CSGS_DEFAULTVALUE       (CSGS_HSPLIT | CSGS_VSPLIT)

#define CSGCS_NONE   1
#define CSGCS_CELL   2
#define CSGCS_ROW    3
#define CSGCS_COLUMN 4

enum
{
  cscmdGridCursorChanged = 0x00000F00
};

class csGrid : public csComponent
{
protected:
  friend class csGridView;
  csRegionTree2D *regions, *viewlayout;
  csSparseGrid *grid;
  csVector vViews;
  csGridView *activeView;
  csVector vRegionStyles;
  csSplitter *splitterX, *splitterY;
  int cursorStyle;
  int xcur, ycur;

  void CalcMinimalSize (csRegionTree2D *node, int &w, int &h);
  void PlaceGadgets ();

private:
  // Common method for constructors
  void init (csComponent *pParent, csRect &rc, int iStyle, csGridCell *gc);

public:
  csGrid (csComponent *pParent, int nRows, int nCols,
    int iStyle = CSGS_DEFAULTVALUE | CSGVS_DEFAULTVALUE);
  csGrid (csComponent *pParent, int nRows, int nCols, csGridCell *gridpattern,
   int iStyle = CSGS_DEFAULTVALUE | CSGVS_DEFAULTVALUE);
  virtual ~csGrid ();

  virtual void SetCursorStyle (int iCursorStyle = CSGCS_NONE);
  virtual int GetCursorStyle ();
  virtual void GetCursorPos (int &row, int &col);
  virtual void SetCursorPos (int row, int col);

  virtual void Draw ();
  virtual bool SetRect (int xmin, int ymin, int xmax, int ymax);
  virtual void FixSize (int &newW, int &newH);
  virtual void SuggestSize (int &w, int &h);
  virtual bool HandleEvent (iEvent &Event);

  void CreateRegion (csRect& rc, csGridCell *cell);
  csGridView* GetRootView ()
  { return (csGridView*)vViews.Get (0); }
  csGridView *GetActiveView () {return activeView;}
  void SetActiveView (csGridView *view);

  virtual void SetStringAt (int row, int col, const char *data);
  csString *GetStringAt (int row, int col);
};

#endif

---

Generated for Crystal Space by doxygen 1.2.5 written by Dimitri van Heesch, ©1997-2000