ZtObject.H

// ZtObject.H       $Revision: 1.15 $   $Date: 2004/10/07 14:01:36 $ 

#if !defined __ZtObject_H

#define __ZtObject_H

#include <stdio.h>
#include <stdarg.h>
#include <zm/InfoLine.H>

#include <zm/ZBase.H>
#include <zm/ZPixelCoord.H>
#include <zm/ZNaturalCoord.H>


class ZtMain;

class ZtObject : public ZDrawable, public ZRect
{
public:

  ZtObject (ZtMain* pManager, ZGroupId pxid, ZGroupId pyid);

  ZtObject (ZtMain* pManager, ZGroupId pxid, ZGroupId pyid,
        ZDimension dim, ZGroupId nid);

  ZtObject (ZtMain* pManager, ZGroupId pxid, ZGroupId pyid,
        ZGroupId nxid, ZGroupId nyid);

  ZtObject (const ZtObject& zobj);

  virtual ~ZtObject ();

  ZtMain*   get_manager () const;

  virtual void  prepare_xywh ();

  ZNCoordSlave& nx () const;
  ZNCoordSlave& ny () const;

  Logic     is_vertical () const;
  Logic     is_horizontal () const;

  /* Proportionality tools */
  float     x_p2n (int pcoord) const;
  float     y_p2n (int pcoord) const;
  int       x_n2p (float ncoord) const;
  int       y_n2p (float ncoord) const;

  Logic     clip_line_by_rect (float sx[2], float sy[2]) const;
  Logic     clip_line_by_rect (int sx[2], int sy[2]) const;
  Logic     clip_line_by_rect (float sx[2], float sy[2],
                   float nx[2], float ny[2]) const;
  Logic     clip_line_by_rect (float sx[2], float sy[2],
                   int px[2], int py[2]) const;

  Logic     clip_rect_by_rect (float rcx[2], float rcy[2]) const;
  Logic     clip_rect_by_rect (float rx[2], float ry[2],
                   float cx[2], float cy[2]) const;

  void      seldom_redraw (Logic flag);

  Logic     is_seldom_redraw () const;

  void      changes ();

  void      done ();

  Logic     is_changed () const;

  virtual void  extent_rect (ZRect& res);

  virtual void  expose ();

  virtual void  redraw ();

  virtual void  can_hear_events (Logic flag);

  Logic     is_deaf () const;

  virtual ZInputStatus  input (const XEvent* xev);

  virtual void  show ();

  virtual void  hide ();

  Logic     is_hidden () const;

  virtual Logic belong (int px, int py) const;

  void      raise_exch ();

  void      raise_shift ();

  virtual const char*   class_id () const;

  /***********************************************************************
   * Special facility for window-local user messages
   ***********************************************************************/

  void      wePutMsg (int elevel, const char* s);

  void      weFormatMsg (int elevel, const char* format, ...);

  void      put_msg (int elevel, const char* format, va_list val);

  void      format_msg (int elevel, const char* format, ...);

  void      set_info_lines (InfoLine* il);

  InfoLine* get_info_lines () const;

protected:/* data */

  InfoLine  *pInfoLine;

public:/* data */

  /* Always have pixel place */
  ZPCoordSlave  px; 
  ZPCoordSlave  py; 
  float     belong_eps;

private:

  Logic     deaf_flag;  
  Logic     changes_flag;   
  Logic     seldom_flag;    
  Logic     hidden_flag;    
  /* For redraw optimization */
  Drawable  pix_image;  
  ZRect     pix_rect;   
  void      construct (ZtMain* pManager);

protected:

  ZNCoordSlave  *pnx;       
  ZNCoordSlave  *pny;       
  ZtMain    *manager;   
};

/*
 * General proportionality tools.
 */

float   p2n (const ZPCoordSlave& ps, const ZNCoordSlave& ns, int pcoord);


int n2p (const ZNCoordSlave& ns, const ZPCoordSlave& ps, float ncoord);



/*************************************************************
 * INLINES
 *************************************************************/

/*************************************************************
 * Get mode of expose: with buffered pixmap (TRUE) or without
 * (FALSE)
 */
inline Logic
ZtObject::is_seldom_redraw () const
{
  return !!seldom_flag;
}


/*************************************************************
 * Returns TRUE if some perameters of object has been changed.
 */
inline Logic
ZtObject::is_changed () const
{
  return !!changes_flag;
}


/*************************************************************
 * Get mode of event control: TRUE(can't process), FALSE(hears
 * events).
 */
inline Logic
ZtObject::is_deaf () const
{
  return !!deaf_flag;
}


/*************************************************************
 * Returns TRUE if object will expose itself or FALSE
 * otherwise.
 */
inline Logic
ZtObject::is_hidden () const
{
  return !!hidden_flag;
}


#endif  // ZtObject.H