uboxgeom.hpp

/************************************************************************
 *
 *  uboxgeom.hpp: attributes for controlling UBox geometry
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | 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.
 * ***********************************************************************/

#ifndef uboxgeom_hpp
#define uboxgeom_hpp 1
#include <ubit/uattr.hpp>
#include <ubit/ulength.hpp>
#include <ubit/ugeom.hpp>
namespace ubit {
  
  class UScale : public UAttr {
  public:
    UCLASS(UScale)
    
    UScale(float value = 1.);
    
    UScale(const UFloat&);
    
    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;}
    
    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 set(float);
    virtual void mult(float);
    virtual void div(float);
    virtual void update();
    
  private:
    float value;
    virtual void putProp(UUpdateContext*, UElem&);
  };
  
  inline UScale& uscale(float v = 1.)    {return *new UScale(v);}
  
  inline UScale& uscale(const UFloat& v) {return *new UScale(v);}
  
  
  // ==================================================== Ubit Toolkit =========  
  class UPos : public UAttr, public UPosSpec {
  public:
    UCLASS(UPos)

    static const ULength::Modes TOP, LEFT, RIGHT, BOTTOM;
      
    UPos() : UPosSpec(0,0) {}
      
    UPos(ULength x, ULength y) : UPosSpec(x, y) {}
           
    UPos(const UPoint& p) : UPosSpec(p.x, p.y) {}
    
    UPos(const UPos& p) : UPosSpec(p.x, p.y) {}
    
    //UPos(const UStr& xSpec, const UStr& ySpec);
    //creates a new position attribute.

    virtual ~UPos() {destructs();}
      
    const ULength& getX() const {return x;}
    const ULength& getY() const {return y;}

    UPos& setX(const ULength& _x) {return set(_x, y);}
    UPos& setY(const ULength& _y) {return set(x, _y);}
    
    virtual UPos& set(const ULength& x, const ULength& y);
    UPos& operator=(const UPos& p)   {return set(p.x, p.y);}
    UPos& operator=(const UPoint& p) {return set(p.x, p.y);}

    virtual bool equals(const ULength& x, const ULength& y) const;
    bool operator==(const UPos& p) const {return equals(p.x, p.y);}
    bool operator==(const UPoint& p) const {return equals(p.x, p.y);}

    bool isFloating() const;
    virtual bool is3Dpos() const {return false;}

    virtual void update();

   private:
    friend class UView;
    friend class UBox;
    friend class UWin;
    virtual void putProp(UUpdateContext*, UElem&);
    virtual void addingTo(UChild&, UElem& parent);
    virtual void removingFrom(UChild&, UElem& parent);
    //NB: removingFrom() requires UPos to have a destructor.    
  };
    
  inline UPos& upos(const ULength& x, const ULength& y) {return *new UPos(x, y);}
  
  inline UPos& upos(const UPoint& p) {return *new UPos(p);}

  
  // ==================================================== Ubit Toolkit =========
  class UPosControl : public UAttr {
  public:
    UCLASS(UPosControl)
    
    UPosControl(UPos* = null);
    ~UPosControl();
    
    UPosControl& setModel(UPos*);
    UPosControl& changeCursor(bool state);
    UPosControl& freezeX(bool state);
    UPosControl& freezeY(bool state);
    
    // - - - impl - - - - -- - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  protected:
    static const int MARGIN = 5;
    UPoint box_pos0, pt_in_pane0;
    bool change_cursor, freeze_x, freeze_y;
    UView* moved_view;
    uptr<UCall> callbacks;
    uptr<UPos> posAttr;
    
    virtual void putProp(UUpdateContext*, UElem&) {}
    virtual void addingTo(UChild&, UElem& parent);
    virtual void removingFrom(UChild&, UElem& parent);
    // NOTE that removingFrom() requires a destructor to be defined.
    
    virtual void mouseCB(UMouseEvent&);
    virtual void pressCB(UMouseEvent&);
    virtual void releaseCB(UMouseEvent&);
    virtual void dragCB(UMouseEvent&);
#endif
  };
  
  class UMagicLensControl : public UPosControl {
  public:
    UCLASS(UMagicLensControl)
    UMagicLensControl(UPos* = null, UScrollpane* = null);
    UMagicLensControl& setModel(UPos*, UScrollpane*);
  private:
    uptr<UScrollpane> pane;
    virtual void dragCB(UMouseEvent&);
  };
  
  
  // ==================================================== Ubit Toolkit =========
  class USize : public UAttr, public USizeSpec {
  public:
    UCLASS(USize)
    
    static const ULength INITIAL;
    static const ULength::Modes UNRESIZABLE;
    
    USize() : USizeSpec(UIGNORE,UIGNORE) {}
    
    USize(ULength width, ULength height = UIGNORE) : USizeSpec(width, height) {}
    
    USize(const UDimension& d) : USizeSpec(d.width, d.height) {}

    USize(const USize& s) : USizeSpec(s) {}
    
    //UPos(const UStr& widthSpec, const UStr& heightSpec);
    //creates a new position attribute.

    const ULength& getWidth()  const {return width;}
    const ULength& getHeight() const {return height;}
    
    USize& setWidth(const ULength& _w)  {return set(_w, height);}
    USize& setHeight(const ULength& _h) {return set(width, _h);}
    
    virtual USize& set(const ULength& width, const ULength& height);
    USize& operator=(const USize& s) {return set(s.width, s.height);}
    USize& operator=(const UDimension& d) {return set(d.width, d.height);}
    
    virtual bool equals(const ULength& w, const ULength& h) const;
    bool operator==(const USize& s) const {return equals(s.width, s.height);}
    bool operator==(const UDimension& d) const {return equals(d.width, d.height);}

    virtual void update();
    
  private:
    virtual void putProp(UUpdateContext*, UElem&);  
    friend class UViewLayoutImpl;
  };
  
  inline USize& usize() {return *new USize();}

  inline USize& usize(const ULength& w, const ULength& h =UIGNORE) {return *new USize(w,h);}
  
  inline USize& usize(const UDimension& d) {return *new USize(d);}
  
  
  // ==================================================== Ubit Toolkit =========
  class USizeControl : public UAttr {
  public:
    UCLASS(USizeControl)
    
    USizeControl(USize* = null);    
    ~USizeControl();
    
    USizeControl& setModel(USize*);
    USizeControl& freezeWidth(bool state);
    USizeControl& freezeHeight(bool state);
    
    // - - - impl - - - - -- - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
    virtual void putProp(UUpdateContext*, UElem&) {}
    virtual void addingTo(UChild&, UElem& parent);
    virtual void removingFrom(UChild&, UElem& parent);
    // NOTE that removingFrom() requires a destructor to be defined.
  protected:
    float w0, h0;
    float xev0, yev0;
    bool freeze_w, freeze_h;
    uptr<UCall> callbacks;
    uptr<USize> psize;
    virtual void mouseCB(UMouseEvent&);
    virtual void pressCB(UMouseEvent&);
    virtual void releaseCB(UMouseEvent&);
    virtual void dragCB(UMouseEvent&);
#endif
  };
  
  
  // ==================================================== Ubit Toolkit =========
  class UPadding : public UAttr {
  public:
    UCLASS(UPadding)
    
    UPadding() : val(UIGNORE,UIGNORE) {}
    UPadding(ULength width, ULength height) : val(width, height) {}
        
    UPadding& operator=(const UPadding&);
    
    UPadding& setWidth(ULength);
    
    UPadding& setHeight(ULength);

    UPadding& setTop(ULength);
    UPadding& setRight(ULength);
    UPadding& setBottom(ULength);
    UPadding& setLeft(ULength);
    
    ULength getTop()   const {return val.top;}
    ULength getRight() const {return val.right;}
    ULength getBottom()const {return val.bottom;}
    ULength getLeft()  const {return val.left;}
    
    virtual void update();
  private:
    UPaddingSpec val;
    virtual void putProp(UUpdateContext*, UElem&);
  };
  
  
  inline UPadding& upadding() {return *new UPadding();}
  
  inline UPadding& upadding(ULength horiz, ULength vert) {return *new UPadding(horiz,vert);}

  
  // ==================================================== Ubit Toolkit =========
  class UOrient : public UAttr {
  public:
    UCLASS(UOrient)
    
    static UOrient horizontal, vertical;
    
    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(UUpdateContext*, UElem&);
    
    // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
    enum {HORIZONTAL=0, VERTICAL=1, INHERIT=2}; //dont change values
    void addingTo(UChild&, UElem& parent);
    void removingFrom(UChild&, UElem& parent);
  private:
    char value;
    UOrient(char value, UConst);
#endif
  };
  
  inline UOrient& uorient(const UOrient& val) {return *new UOrient(val);}
  
  
  // ==================================================== Ubit Toolkit =========
  class UHalign : public UAttr {
  public:
    UCLASS(UHalign)

    static UHalign left, right, flex, center;
    
    UHalign();
    
    UHalign(const UHalign&);
    
    UHalign& operator=(const UHalign&);
    bool operator==(const UHalign& v) const {return value == v.value;}
    
    virtual void update();
    virtual void putProp(UUpdateContext*, UElem&);
    
    // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    enum {INHERIT, LEFT, RIGHT, FLEX, CENTER};
  private:
    char value;
    UHalign(char value, UConst);
  };
  
  
  inline UHalign& uhalign(const UHalign& val) {return *new UHalign(val);}
  
  inline UHalign& uleft() {return UHalign::left;}
  inline UHalign& uright() {return UHalign::right;}
  inline UHalign& uhcenter() {return UHalign::center;}
  inline UHalign& uhflex() {return UHalign::flex;}
  // ==================================================== Ubit Toolkit =========
  class UValign : public UAttr {
  public:
    UCLASS(UValign)

    static UValign top, bottom, flex, center;
    
    UValign();
    
    UValign(const UValign&);
    
    UValign& operator=(const UValign& v);
    bool operator==(const UValign& v) const {return value == v.value;}
    
    virtual void update();
    virtual void putProp(UUpdateContext*, UElem&);
    
    // - impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    enum {INHERIT, TOP, BOTTOM, FLEX, CENTER};
  private:
    char value;
    UValign(char value, UConst);
  };
  
  inline UValign& uvalign(const UValign& val) {return *new UValign(val);}
  
  inline UValign& utop() {return UValign::top;}
  inline UValign& ubottom() {return UValign::bottom;}
  inline UValign& uvcenter() {return UValign::center;}
  inline UValign& uvflex() {return UValign::flex;}
  // ==================================================== Ubit Toolkit =========
  class UVspacing : public UAttr {
  public:
    UCLASS(UVspacing)

    static UVspacing none;
    
    UVspacing(float = 0);
    
    operator float() const {return value;}
    
    UVspacing& operator=(float);
    UVspacing& operator=(const UVspacing&);
    
    bool operator==(float 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(UUpdateContext*, UElem&);
  private:
    float value;
  };
  
  inline UVspacing& uvspacing(float val = 0) {return *new UVspacing(val);}
  
  // ==================================================== Ubit Toolkit =========
  class UHspacing : public UAttr {
  public:
    UCLASS(UHspacing)
    
    static UHspacing none;
    
    UHspacing(float = 0);
    
    operator float() const {return value;}
    
    UHspacing& operator=(float);
    UHspacing& operator=(const UHspacing&);
    
    bool operator==(float 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(UUpdateContext*, UElem&);
  private:
    float value;
  };
  
  inline UHspacing& uhspacing(float val) {return *new UHspacing(val);}
  
}  
#endif