uboxGeom.hpp

/* ==================================================== ======== ======= *
*
*  uboxGeom.hpp: layout properties
*  Ubit Project
*  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
*  (C) 1999-2006 EricLecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
*
* ***********************************************************************
* COPYRIGHT NOTICE : 
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
* IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
* YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
* GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
* EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
* SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
* ***********************************************************************
* ==================================================== [(c)Elc] ======= *
* ==================================================== ======== ======= */

#ifndef _uboxGeom_hpp_
#define _uboxGeom_hpp_
//pragma ident  "@(#)uboxGeom.hpp       ubit:05.05.00"
#include <ubit/uprop.hpp>
namespace ubit {
  
/* ==================================================== ===== ======= */
class UScale : public UProp {
public:
  UBIT_ATTR_CLASS(UScale, UProp)

  UScale(float value = 1.);
  UScale(const UFloat&);
  
  friend UScale& uscale(float v = 1.)    {return *new UScale(v);}
  friend UScale& uscale(const UFloat& v) {return *new UScale(v);}
  
  operator float() const {return value;}
  
  UScale& operator=(float v)         {set(v); return *this;}
  UScale& operator=(const UFloat& v) {set(v); return *this;}
  UScale& operator=(const UScale& v) {set(v.value); return *this;}
  virtual void set(float);
  
  bool operator==(float v) const         {return v == value;}
  bool operator==(const UFloat& v) const {return v == value;}
  bool operator==(const UScale& v) const {return value == v.value;}
  
  virtual void mult(float);
  virtual void div(float);
  virtual void update();
  virtual void putProp(UContext*, UControl*);
  
private:
  float value;
};
  
/* ==================================================== ===== ======= */
class UPos : public UProp {
public:
  UBIT_ATTR_CLASS(UPos, UProp)

  UPos();
  UPos(float x, float y);
  UPos(const UPos&);
  UPos(const UPoint&);
  virtual ~UPos() {destructs();}
  
  friend UPos& upos() {return *new UPos;}
  friend UPos& upos(float x, float y) {return *new UPos(x, y);}
    
  bool operator==(const UPos& p) const;
  
  UPos& operator=(const UPos& p)  {set(p); return *this;}
  UPos& operator=(const UPoint& p){set(p); return *this;}
  
  void setX(float _x)             {setImpl(_x, y,true);}
  void setY(float _y)             {setImpl(x, _y,true);}
  void set(float _x, float _y)    {setImpl(_x, _y,true);}
  void set(const UPos& p)         {setImpl(p.x, p.y, true);}
  void set(const UPoint& p)       {setImpl(p.x, p.y, true);}
  
  float getX() const {return x;}
  float getY() const {return y;}
  operator UPoint() const {return UPoint(x, y);}

  void setPercentMode(bool is_percent, bool is_adjusted);
  bool isPercent() const {return modes & PERCENT_MODE;}
  bool isAdjustedPercent() const {return modes & PERCENT_ADJUSTED_MODE;}
  
  bool isPos3d() const {return modes & POS_3D_MODE;}
  
  virtual void update();
  virtual void setImpl(float x, float y, bool update);
  virtual void putProp(UContext*, UControl*);

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  virtual void addingTo(UChild*, UGroup *parent);
  virtual void removingFrom(UChild*, UGroup *parent);
protected:
  enum {PERCENT_MODE=1<<0, PERCENT_ADJUSTED_MODE=1<<1, POS_3D_MODE=1<<2};
  friend class UView;
  friend class UBox;
  friend class UWin;
  float x, y;      // NB: peuvent etre des proportions.
  unsigned short modes;
#endif
};

/* ==================================================== ===== ======= */
class UWidth : public UProp {
public:
  UBIT_ATTR_CLASS(UWidth, UProp)

  static const int UNSPECIFIED = -1;

  UWidth(float value = UNSPECIFIED);   
  UWidth(const UWidth&);

  friend UWidth& uwidth()                {return *(new UWidth());}
  friend UWidth& uwidth(float v)         {return *(new UWidth(v));}
  friend UWidth& uwidth(const UWidth& v) {return *(new UWidth(v));}

  operator float() const {return def_value;}

  UWidth& operator=(float v)             {set(v); return *this;}
  UWidth& operator=(const UFloat& v)     {set(v); return *this;}
  UWidth& operator=(const UWidth& v)     {set(v); return *this;}
  virtual void set(float);
  virtual void set(const UWidth&);

  bool operator==(float) const;
  bool operator==(const UWidth&) const;

  bool isResizable() const {return is_resizable;}
  UWidth& resizable(bool state = true);
  bool isAdjustable() const {return is_adjustable;}
  UWidth& adjustable(bool = true);
  virtual void update();
  virtual void putProp(UContext*, UControl*);  

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
protected:
  friend class UViewLayoutImpl;
  float def_value, actual_value;
  bool is_resizable, is_adjustable;
};

/* ==================================================== ===== ======= */
class UHeight : public UProp {
public:
  UBIT_ATTR_CLASS(UHeight, UProp)

  static const int UNSPECIFIED = -1;

  UHeight(float = UNSPECIFIED);
  UHeight(const UHeight&);
  
  friend UHeight& uheight()                 {return *(new UHeight());}
  friend UHeight& uheight(float v)          {return *(new UHeight(v));}
  friend UHeight& uheight(const UHeight& v) {return *(new UHeight(v));}

  UHeight& operator=(float v)             {set(v); return *this;}
  UHeight& operator=(const UFloat& v)     {set(v); return *this;}
  UHeight& operator=(const UHeight& v)    {set(v); return *this;}
  virtual void set(float);
  virtual void set(const UHeight&);
  
  operator float() const {return def_value;}
  
  bool operator==(float) const;
  bool operator==(const UHeight&) const;
  
  bool isResizable() const {return is_resizable;}
  UHeight& resizable(bool = true);

  bool isAdjustable() const {return is_adjustable;}
  UHeight& adjustable(bool = true);

  virtual void update();
  virtual void putProp(UContext*, UControl*);

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
protected:
  friend class UViewLayoutImpl;
  float def_value, actual_value;
  bool is_resizable, is_adjustable;
};

/* ==================================================== [Elc] ======= */
/* ==================================================== ===== ======= */
struct UPosChooser : public UProp {
  UPosChooser(UPos& pos);
  
  virtual ~UPosChooser();
  
  void freezeX(bool b) {freeze_x = b;}
  void freezeY(bool b) {freeze_y = b;}
  
  // - - - impl - - - - -- - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  virtual void putProp(UContext*, UControl*) {}
  virtual void addingTo(UChild*, UGroup* parent);
  virtual void removingFrom(UChild*, UGroup* parent);
  // NOTE that removingFrom() requires a destructor to be defined.
protected:
  UView* moving_area;
  uptr<UPos> pos;
  uptr<UCall> drag_call, press_call, release_call;
  int x_in_movable, y_in_movable;
  bool freeze_x, freeze_y;
  virtual void drag(UMouseEvent&);
  virtual void press(UMouseEvent&);
  virtual void release(UMouseEvent&);
#endif
};

/* ==================================================== ======== ======= */
struct UMagicLensPosChooser : public UPosChooser {
  UMagicLensPosChooser(UPos&, UScrollpane& clip);
  
  // - - - impl - - - - -- - - - - - - - - - - - - - - - - - - - - - - -
private:
  uptr<UScrollpane> clip;
  virtual void drag(UMouseEvent&);
};

/* ==================================================== ===== ======= */
class UWidthChooser: public UWidth {
public:
  UWidthChooser();
  UWidthChooser(float value);
  UWidthChooser(const UWidth&);
  virtual ~UWidthChooser();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  void addingTo(UChild*, UGroup *parent);
  void removingFrom(UChild*, UGroup *parent);
protected:
  virtual void constructs();
  virtual void press(UMouseEvent&);
  virtual void drag(UMouseEvent&);
private:
  uptr<UBox> phandle;
  int curpos;
#endif
};

/* ==================================================== ===== ======= */
class UHeightChooser: public UHeight {
public:
  UHeightChooser();
  UHeightChooser(float value);
  UHeightChooser(const UHeight&);
  virtual ~UHeightChooser();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  void addingTo(UChild*, UGroup *parent);
  void removingFrom(UChild*, UGroup *parent);
protected:
  virtual void constructs();
  virtual void press(UMouseEvent&);
  virtual void drag(UMouseEvent&);
private:
  uptr<UBox> phandle;
  int curpos;
#endif
};

}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---