ZNaturalCoord.H

// ZNaturalCoord.H  $Revision: 1.13 $   $Date: 2003/12/28 12:53:17 $ 

#if !defined __ZNaturalCoord_H

#define __ZNaturalCoord_H


#include <mix/SortedAr.H>
#include <zm/ZTypes.h>


/*************************************************************
 * Natural hint of group
 *************************************************************/
struct ZNOwnHint
{
  ZGroupId  id; /* group id */
  float     b[2];   /* bounds: b[0] <= b[1] */
  Logic     known;  /* TRUE - known bounds, FALSE - unknown */
};

struct ZNGroupHint : public ZNOwnHint
{
  float     c[2];   /* coords: c[0], c[1] any order */

  /* TRUE if group has been resized since last expose; FALSE --
     coords may be changed without touching size */
  Logic     resized;

  /* TRUE if group has been moved since last expose; FALSE --
     coords have the same value that have had after last expose */
  Logic     moved;
};


/*************************************************************
 * Array of group hints
 *************************************************************/
class ZNHintAr : public SortedAr
{
private:

  /* Returns index of group or -1 if is not found */
  int   group_index (ZGroupId gid) const;

public:

  ZNHintAr (const ZNHintAr& hintar)
    : SortedAr(hintar) {};
  ZNHintAr (unsigned quant = DEFAULT_QUANT,
        unsigned volume = START_VOLUME)
    : SortedAr(sizeof(ZNGroupHint), quant, volume) {};

  /* Usual compare between two elements */
  virtual Compar    compare (const char* item1, const char* item2) const;

  /* Add one more group */
  void  add (const ZNGroupHint& item);

  /* Remove the group from hint array */
  void  remove_group (ZGroupId gid);

  /* Get reference at needed group */
  ZNGroupHint&  operator[] (ZGroupId gid) const
    {return fetch(gid);}
  ZNGroupHint&  fetch (ZGroupId gid) const;

  /* Returns TRUE if group with gid is already exist */
  Logic check (ZGroupId gid) const;

  /* Returns contents of group with index */
  ZNGroupHint&  group_body (unsigned index) const
    {return *(ZNGroupHint*)item_ptr(index);}

  /* Print item for debug purpose */
  virtual void  print_item (unsigned i) const;

};


/* Forward definition */
class ZNCoordMaster;


/*************************************************************
 * Slave object with natural coord grid
 *************************************************************/
class ZNCoordSlave
{
private:

  ZNOwnHint bounds;     /* own bounds of object and group id */

  ZNCoordMaster *master;    /* pointer at own master */

public:

  ZNCoordSlave (ZNCoordMaster *pMaster, ZGroupId gid);

  virtual~ZNCoordSlave ();

  /* Get group id */
  ZGroupId  group () const;

  /* Change group at new one */
  void      group (ZGroupId new_gid);

  /* Erase from group list -- before destructor */
  void      erase ();

  /* Get natural coords of group */
  void  get_nc (float nc[2]) const;
  float get_nc1 () const;
  float get_nc2 () const;
  float get_nc_min () const;
  float get_nc_max () const;
  float get_nsize () const;

  /* Set natural coords of group */
  void  set_nc (float nc[2]);

  /* Set or clear knowledge of own bounds */
  void  set_bounds (float b[2]);
  void  clear_bounds ();

  /* Get own bounds or FALSE if they are unknown */
  Logic own_bounds (float b[2]);

  /* Get group bounds or FALSE if they are unknown */
  Logic group_bounds (float b[2]);

  /* Get group bounds or natural coords of group if bounds are unknown.
     It's guaranteed that b[0]<b[1] if nc[0]<nc[1] and vise versa. */
  void  applied_bounds (float b[2]);

  /* Answers TRUE if group of object has been resized */
  Logic is_resized () const;

  /* Answers TRUE if group of object has been moved */
  Logic is_moved () const;

};


#define PtrType     ZNCoordSlave*
#define PtrAr       ZNCSAr
#include <mix/PtrAr.H>  /* ==> class ZNCSAr */


/*************************************************************
 * Kinds of group bounds computation from many different own
 * bounds:
 * -- UnifyBounds -- OR-like operation;
 * -- IntersectBounds -- AND-like operation;
 *************************************************************/
enum ZBoundMode {UnifyBounds, IntersectBounds};


class ZNCoordMaster
{
public:

  ZNCoordMaster (const char* szName = NULL);
  virtual ~ZNCoordMaster ();

  /* Get natural coords of group */
  void  get_nc (ZGroupId gid, float nc[2]) const;
  float get_nc1 (ZGroupId gid) const;
  float get_nc2 (ZGroupId gid) const;
  float get_nc_min (ZGroupId gid) const;
  float get_nc_max (ZGroupId gid) const;
  float get_nsize (ZGroupId gid) const;

  /* Set natural coords of group */
  void  set_nc (ZGroupId gid, float nc[2]);

  /* Add new slave into gid group */
  void  add_slave (ZNCoordSlave* pSlave);

  /* Add group if no such and do nothing if group exists */
  void  add_group (ZGroupId gid);

  /* Get count of slaves in group */
  unsigned  slaves_count (ZGroupId gid);

  /* Erase some slave from groups list */
  void  erase_slave (ZNCoordSlave* pSlave);

  /* Get group bounds or FALSE if they are unknown */
  Logic group_bounds (ZGroupId gid, float b[2]);

  /* Get group bounds or natural coords of group if bounds are unknown.
     It's guaranteed that b[0]<b[1] if nc[0]<nc[1] and vise versa. */
  void  applied_bounds (ZGroupId gid, float b[2]);

  /* Answers TRUE if group of object has been resized */
  Logic is_resized (ZGroupId gid) const;

  /* Answers TRUE if group of object has been moved */
  Logic is_moved (ZGroupId gid) const;

  /* Recompute all group bounds */
  void  rebounds (ZBoundMode mode);

  /* As if expose has been done */
  void  redrawn ();

private:

  char      *name;      
  char      *spy_env;   
  Logic     spy;        
  ZNHintAr  *group;     
  ZNCSAr    *slave;     
};


#endif  // ZNaturalCoord.H