uview.hpp

/* ==================================================== ======== ======= *
 *
 *  uview.hpp
 *  Ubit Project
 *  Author: Eric Lecolinet
 *  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
 *  (C) 1999-2005 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 _uview_hpp_
#define _uview_hpp_
//pragma ident  "@(#)uview.hpp  ubit:05.05.00"
#include <list>
#include <ubit/ucontrol.hpp>
#include <ubit/uevent.hpp>
#include <ubit/ugeom.hpp>
namespace ubit {

  class UFlowView;
  class UTableView;
  class UPaneView;
  class UViewExt;
  class UViewLayout;
  class UViewUpdate;
  class UViewLayoutImpl;
  class UViewUpdateImpl;
  class UFlowLayoutImpl;
  class UFlowUpdateImpl;
  class UMultiList;

/* ==================================================== ===== ======= */
class UViewStyle : public UMode {
public:
  UViewStyle(UView* (*)(UChild*, UView*, UHardWinImpl*), UMask = 0);
  virtual ~UViewStyle() {destructs();}

  UView* (*createView)(UChild*, UView* parview, UHardWinImpl*);

  virtual void addingTo(UChild* self, UGroup *parent);
  virtual void removingFrom(UChild* self, UGroup *parent);
};

/* ==================================================== [Elc] ======= */
/* ==================================================== ===== ======= */
class UView : public URegion {
public:
  UView(UChild*, UView* parview, UHardWinImpl*);
  virtual ~UView();

  static UViewStyle style;
  
  virtual UViewStyle* getViewStyle() {return &style;}
  
  static UView* createView(UChild*, UView* parview, UHardWinImpl*);

  virtual UFlowView*  flowCast()  {return null;}
  virtual UTableView* tableCast() {return null;}
  virtual UPaneView*  paneCast()  {return null;}

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  bool isShown() const;

  bool isRealized() const;
  UBox* getBox() const;
  
  UBox* getBoxParent() const;
  /*< returns the direct or *indirect* box parent of getBox().
    * 'boxes' are UBox objects or objects that derive from UBox.
    */
    
  UView* getParentView() const {return parview;}

  UDisp* getDisp() const;
  
  UWin*  getWin() const;
  UView* getWinView() const;

  UHardWinImpl* getHardWinImpl() {return win;}
  UNatWin*  getNatWin() const;
  UNatDisp* getNatDisp() const;
  //< [impl] return native counterparts.
  
  UView* getNext() {return nextview;}
  
  UChild* getChildNode() {return childnode;}
  
  template <typename T> T* getProp(T*& p) { 
    p = null; 
    for (UViewProps::iterator i = props.begin(); i != props.end(); ++i)
    { if (dynamic_cast<T*>(*i)) {p = (T*)*i; return p;} }
    return null;
  }
  template <typename T> T& obtainProp(T*& p) {
    getProp(p); if (!p) {p = new T(); props.push_back(p);} return *p;
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // size 
  
  int getWidth()  const {return width;}

  int getHeight() const {return height;}

  void getSize(int& w, int& h) const {w = width; h = height;}

  UDimension getSize() const;

  void setSize(int width, int height);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // position

  int getX() const;
  
  int getY() const;

  void getPos(int& x, int& y) const;

  UPoint getPos() const;

  void getPosInWin(int& x, int& y) const;

  UPoint getPosInWin() const;

  void getPosOnScreen(int& x, int& y) const;

  UPoint getPosOnScreen() const;
  
  void setPos(int x, int y);
  void setAutoPositioning(bool);
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // conversions

  static bool convertPos(const UView* to_view, int& to_x, int& to_y,
                         const UView* from_view, int from_x, int from_y);
  int XToXwin(int x_in_view) const {return x_in_view + x;}
  int YToYwin(int y_in_view) const {return y_in_view + y;}

  int XwinToX(int x_in_win) const {return x_in_win - x;}
  int YwinToY(int y_in_win) const {return y_in_win - y;}

  int eventToX(const UMouseEvent& e) const {return e.getXwin() - x;}
  int eventToY(const UMouseEvent& e) const {return e.getYwin() - y;}
  virtual bool caretPosToXY(long caret_pos, int& line, int& col) const;
  virtual bool xyToCaretPos(int line, int col, long& caret_pos) const;
  // - - - - - - - - - - - - - -- - -- - - -- - - -- - -- - -- - - -- - - - - - -

  enum VMODES {
    INITIALIZING = 1<<0,
    INITIALIZED = 1<<1,

    DAMAGED = 1<<2,

    DESTRUCTED = 1<<3,

    FIXED_WIDTH = 1<<4,
    FIXED_HEIGHT = 1<<5,

    REALIZED_CHILDREN = 1<<6,

    FORCE_POS = 1<<7,

    POS_HAS_CHANGED = 1<<9,
    SIZE_HAS_CHANGED = 1<<10,

    NO_DOUBLE_BUFFER = 1<< 11 // !BEWARE: no comma after last item!
 };

  int  getVModes() const {return vmodes;}

  bool hasVMode(int modes) const {return (vmodes & modes) != 0;}

  void addVModes(UMask modes) {vmodes |= modes;}
  
  void removeVModes(UMask modes) {vmodes &= ~modes;}

  // - - - - - - - - - - - - - - - - - -

  void updatePaint(URegion* view_region = null, int dbf_mode = 0);
  void updateWinPaint(const URegion& window_region, int dbf_mode,
                      bool all_layers, UView* first_layer);
  int updateWinData(const URegion& window_region);
  virtual bool doLayout(UContext&, UViewLayout&);

  virtual void doUpdate(UContext&, URegion r, URegion clip, UViewUpdate&);

  void operator delete(void*);
  // [impl] requests view deletion.
  
#ifndef NO_DOC
  void setParentView(UView* parent_view);
  void setNext(UView* v) {nextview = v;}

  virtual bool updatePos(UViewUpdateImpl&, UGroup*, UContext& curctx,
                         URegion& r, URegion& clip, UViewUpdate&);
  virtual void beginUpdate3d(UViewUpdateImpl&, UGroup*, UContext& curctx);
  virtual void endUpdate3d(UViewUpdateImpl&, UGroup*, UContext& curctx);

  virtual bool retrieveProps(UEventProps& /*inout*/);

  virtual UView* findInBox(UBox*, UEvent&, const UContext& parent_ctx, 
                           URegion clip, UEventProps);
  virtual UView* findInGroup(UGroup*, UEvent&, const UContext& parent_ctx,
                             URegion clip,  UEventProps&);
  virtual UView* findInChildren(UGroup*, UEvent&, const UContext& current_ctx, 
                                const URegion& clip, UEventProps&);

protected:                               
  virtual void doLayout2(UViewLayoutImpl&, UGroup*, UContext&, UViewLayout&);
  virtual void doUpdate2(UViewUpdateImpl&, UGroup*, UContext&,
                         URegion& r, URegion& clip, UViewUpdate&);
                         
  virtual bool findDataV(UContext&, UChildIter data_it, UChildIter end_it, 
                         const URegion&, UViewUpdate&);
  virtual bool findDataH(UContext&, UChildIter data_it, UChildIter end_it, 
                         const URegion&, UViewUpdate&);
  virtual bool findDataPtr(UContext&, UChildIter data_it, UChildIter end_it, 
                           const URegion&, UViewUpdate&);
private:
  friend class UViewLayoutImpl;
  friend class UViewUpdateImpl;
  friend class UBox;
  friend class UWin;
  friend class UChild;
  friend class UPlugpane;
  
  UView(const UView&);
  UView& operator=(const UView&);  // assigment is forbidden
  
protected:
  UView *parview;      // parent view
  UChild *childnode;   // childnode that points to the corresponding UBox
  UHardWinImpl *win;   // hard window 
  UView *nextview;         // next view
  int vmodes;          // modes of this view

public:
  int chwidth, chheight;   // size occupied by children
  int edit_shift;          // for UEdit
  unsigned short hflex_count, vflex_count; // number of horiz and vert flexible children
  typedef std::list<struct UViewProp*> UViewProps;
  UViewProps props;
#endif
};

// ==================================================== ===== ======= //
struct UViewProp {
  virtual ~UViewProp() {}
};

// used by resize callbacks to check if size has changed.
struct UViewPrevSizeProp : public UViewProp {
  UViewPrevSizeProp() : width(0), height(0) {}
  int width, height;
};

// used by the keep size mode of UWidth/UHeight.
struct UViewKeepSizeProp : public UViewProp {
  UViewKeepSizeProp() : width(-1), height(-1) {}
  int width, height;
};

// used by to force position.
struct UViewForcePosProp : public UViewProp {
  UViewForcePosProp() : x(0), y(0) {}
  int x, y;
};

// border margins of this view.
struct UViewBorderProp : public UViewProp, public UMargins {
  UViewBorderProp() : UMargins(0,0) {}
};

// ==================================================== ===== ======= //

class UFlowView: public UView {
public:
  static UViewStyle style;  // renderer
  virtual UViewStyle* getViewStyle() {return &style;}
  
  UFlowView(UChild*, UView* parview, UHardWinImpl*);
  virtual ~UFlowView();

  static UView* createView(UChild*, UView* parview, UHardWinImpl*);

  virtual UFlowView* flowCast() {return this;}
  
  virtual bool caretPosToXY(long caret_pos, int& x, int& y) const;
  virtual bool xyToCaretPos(int x, int y, long& caret_pos) const;
  
  // - - - Impl. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifndef NO_DOC
  virtual bool doLayout(UContext& parent_context, UViewLayout&);
  virtual void doUpdate(UContext& parent_context, URegion r, URegion clip, UViewUpdate&);
  int getMaxWidth() const;

private:
  friend class UFlowLayoutImpl;
  friend class UFlowUpdateImpl;
  class UFlowLine* lines;
  class UFlowCell* cells;
  int line_count, cell_count, lastline_strcell;
  int alloc_line_count, alloc_cell_count;

  //NB: flowview utilise des fonctions differentes de sa superclasse UView

  /*static*/ void flowDoLayout(UFlowLayoutImpl&, UGroup*, UContext&, UMultiList&);
  /*static*/ void flowDoUpdate(UFlowUpdateImpl&, UContext&, UGroup*, UMultiList&,
                               const URegion& r, URegion& clip, UViewUpdate&);

  //NB: NOT virtual: these functions are used instead of findDataV, findDataH, findDataPtr
  bool flowFindDataPos(UContext&, UChildIter data_it, UChildIter end_it, 
                       UFlowCell*, const URegion&, UViewUpdate&);
                     
  bool flowFindDataPtr(UContext&, UChildIter data_it, UChildIter end_it,
                       UFlowCell*, const URegion&, UViewUpdate&);

#endif
};
}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== ======= ======= */

---