ZPixelCoord.H

// ZPixelCoord.H        $Revision: 1.11 $   $Date: 2003/12/28 14:38:34 $ 

#if !defined __ZPixelCoord_H

#define __ZPixelCoord_H


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


/*************************************************************
 * Pixel hint of group
 *************************************************************/

enum ZSizeLimit
{
  NoLimits, /* object may have any size */
  MinSize,  /* object must have minimum size or greater */
  FixedSize /* object must have fixed size */
};

struct ZPOwnHint
{
  ZGroupId  id; /* group id */

  ZSizeLimit    kind;   /* type of size limit */
  int       size;   /* value of limit */
};

struct ZPGroupHint : public ZPOwnHint
{
  int       c[2];   /* coords: c[0] <= c[1] */

  Logic     linked; /* TRUE if group has linked */
  ZGroupId  linked_id;  /* id of linked group */
  int       delta[2];   /* delta for computing this coords from
                   coords of linked group by addition */

  /* 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 ZPHintAr : public SortedAr
{
private:

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

public:

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

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

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

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

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

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

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

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

};


/* Forward definition */
class ZPCoordMaster;


/*************************************************************
 * Slave object with pixel coord grid
 *************************************************************/
class ZPCoordSlave
{
private:

  ZPOwnHint hint;       /* own hints */

  ZPCoordMaster *master;    /* pointer at own master */

public:

  ZPCoordSlave (ZPCoordMaster *pMaster, ZGroupId gid);

  virtual~ZPCoordSlave ();

  /* 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 pixel coords of group */
  void  get_pc (int pc[2]) const;
  int   get_pc1 () const;
  int   get_pc2 () const;
  int   get_psize () const;

  /* Set natural coords of group */
  void  set_pc (int pc[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;

  /* Size limitation */
  ZSizeLimit    get_limit (int* pValue = NULL) const;
  void      set_limit (ZSizeLimit limit_type, int limit_value);

  /* Link and unlink operations */
  void      link (ZGroupId id);
  void      unlink ();

  /* Get information about link */
  Logic     is_linked () const;
  ZGroupId  linked_group () const;

  /* Get delta of pointed group if it's linked */
  void      get_delta (int d[2]) const;

  /* Set delta for pointed group and negative delta for linked one */
  void      set_delta (int d[2]);

};


#define PtrType     ZPCoordSlave*
#define PtrAr       ZPCSAr
#include <mix/PtrAr.H>  /* ==> class ZPCSAr */

/* Reserved id for unexist group */
#define BAD_GROUP_ID    (-1)


class ZPCoordMaster
{
public:

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

  /* Get pixel coords of group */
  void  get_pc (ZGroupId gid, int pc[2]) const;
  int   get_pc1 (ZGroupId gid) const;
  int   get_pc2 (ZGroupId gid) const;
  int   get_psize (ZGroupId gid) const;

  /* Set pixel coords of group */
  void  set_pc (ZGroupId gid, int pc[2]);

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

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

  /* Check for existent group id.  Quicker than 0==slaves_count(). */
  Logic is_group (ZGroupId gid) const;

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

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

  /* 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;

  /* Get size limitation */
  ZSizeLimit    get_limit (ZGroupId gid, int* pValue = NULL) const;

  /* Two linked groups (group' and group'') have associated
     coords by rule:
       c' = c'' + delta';
       c'' = c' + delta'',
     where
       c': c'[0], c'[1],
       c'': c''[0], c''[1],
     so delta' = - delta'' */
  Logic     is_linked (ZGroupId gid) const;
  ZGroupId  linked_group (ZGroupId gid) const;
  void      link (ZGroupId gid1, ZGroupId gid2);

  /* Get delta of pointed group if it's linked */
  void      get_delta (ZGroupId gid, int d[2]) const;

  /* Set delta for pointed group and negative delta for linked one */
  void      set_delta (ZGroupId gid, int d[2]);

  /*
   * Refresh operations: makes group array up-to-date.
   */

  /* Recomputes group size limitations */
  void  relimit ();

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

private:

  char      *name;      
  char      *spy_env;   
  Logic     spy;        
  ZPHintAr  *group;     
  ZPCSAr    *slave;     
  /* Add slave's limitation for pointed group */
  void      add_limit (ZPGroupHint* pGroup,
               ZPCoordSlave* pSlave);

};


#endif  // ZPixelCoord.H