uboxLayout.hpp

/* ==================================================== ======== ======= *
*
*  uboxLayout.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 _uboxlayout_hpp_
#define _uboxlayout_hpp_
//pragma ident  "@(#)uboxLayout.hpp     ubit:05.05.00"
#include <ubit/uprop.hpp>
namespace ubit {
  
/* ==================================================== ===== ======= */
class UOrient : public UProp {
public:
  UBIT_ATTR_CLASS(UOrient,UProp)

  static UOrient horizontal, vertical;

  UOrient();
  UOrient(const UOrient&);
  friend UOrient& uorient(const UOrient&);

  UOrient& operator=(const UOrient& v);
  bool operator==(const UOrient& v) const {return value == v.value;}

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

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  enum {HORIZONTAL=0, VERTICAL=1, INHERIT=2}; //dont change values
  void addingTo(UChild* self, UGroup *parent);
  void removingFrom(UChild* self, UGroup *parent);
private:
  char value;
  UOrient(char value, UMask = 0);
#endif
};

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

  static UHalign left, right, flex, center;

  UHalign();
  UHalign(const UHalign&);
  friend UHalign& uhalign(const UHalign&);

  UHalign& operator=(const UHalign&);
  bool operator==(const UHalign& v) const {return value == v.value;}

  friend UHalign& uleft() {return UHalign::left;}
  friend UHalign& uright() {return UHalign::right;}
  friend UHalign& uhcenter() {return UHalign::center;}
  friend UHalign& uhflex() {return UHalign::flex;}
  virtual void update();
  virtual void putProp(UContext*, UControl*);

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  enum {INHERIT, LEFT, RIGHT, FLEX, CENTER};
private:
  char value;
  UHalign(char value, UMask = 0);
};

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

  static UValign top, bottom, flex, center;

  UValign();
  UValign(const UValign&);
  friend UValign& uvalign(const UValign&);

  UValign& operator=(const UValign& v);
  bool operator==(const UValign& v) const {return value == v.value;}

  friend UValign& utop()     {return UValign::top;}
  friend UValign& ubottom()  {return UValign::bottom;}
  friend UValign& uvcenter() {return UValign::center;}
  friend UValign& uvflex()   {return UValign::flex;}

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

  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  enum {INHERIT, TOP, BOTTOM, FLEX, CENTER};
private:
  char value;
  UValign(char value, UMask = 0);
};

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

  static UVspacing none;
  
  UVspacing(int = 0);
  friend UVspacing& uvspacing(int = 0);
  
  operator int() const {return value;}
  
  UVspacing& operator=(int);
  UVspacing& operator=(const UVspacing&);
  
  bool operator==(int v) const {return value == v;}  
  bool operator==(const UVspacing& v) const {return value == v.value;}
  
  virtual void update();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  enum {INHERIT = -1};
  virtual void putProp(UContext*, UControl*);
private:
    int value;
};

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

  static UHspacing none;
  
  UHspacing(int = 0);
  friend UHspacing& uhspacing(int = 0);
  
  operator int() const {return value;}
  
  UHspacing& operator=(int);
  UHspacing& operator=(const UHspacing&);
  
  bool operator==(int v) const {return value == v;}  
  bool operator==(const UHspacing& v) const {return value == v.value;}
  
  virtual void update();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  enum {INHERIT = -1};
  virtual void putProp(UContext*, UControl*);
private:
  int value;
};

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

  static UVmargin none;
  
  UVmargin(int margins = 0);
  UVmargin(int top_margin, int bottom_margin);
  
  friend UVmargin& uvmargin(int margins = 0);
  friend UVmargin& uvmargin(int top_margin, int bottom_margin);
  
  UVmargin& operator=(int margins) {set(margins); return *this;} 
  virtual void set(int margins);
  virtual void set(int top_margin, int bottom_margin);
  
  int getTopMargin()    const {return top_value;}
  int getBottomMargin() const {return bottom_value;}
  
  virtual void update();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  virtual void putProp(UContext*, UControl*);
private:
  int top_value, bottom_value;
};

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

  static UHmargin none;
  
  UHmargin(int margins = 0);
  UHmargin(int left_margin, int right_margin);
  
  friend UHmargin& uhmargin(int margins = 0);
  friend UHmargin& uhmargin(int left_margin, int right_margin);
  
  UHmargin& operator=(int margins) {set(margins); return *this;} 
  virtual void set(int margins);
  virtual void set(int left_margin, int right_margin);
  
  int getLeftMargin()  const {return left_value;}
  int getRightMargin() const {return right_value;}
  
  virtual void update();
  
  // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  virtual void putProp(UContext*, UControl*);
private:
  int left_value, right_value;
};

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

---