uchild.hpp

/* ***********************************************************************
 *
 *  uchild.hpp [internal implementation]
 *  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 _uchild_hpp_
#define _uchild_hpp_ 1
namespace ubit {

class UChild {
public:
  UChild(UNode& o) : obj(&o), parent(0), cond(0) {}
  UChild(UNode* o) : obj(o),  parent(0), cond(0) {}
  UChild(UNode* o, const UCond& c) : obj(o), parent(0), cond(&c) {}
  UChild(const char* s);

  UNode* operator*() {return obj;}  
  const UNode* operator*() const {return obj;}  
  
  UElem* getParent() {return parent;}

  const UCond* getCond() const {return cond;}
  void setCond(const UCond& c)  {cond = &c;}
  void setCond(const UChild& c) {cond = c.cond;}
  
 private:
  friend class UParent;
  friend class UNode;
  friend class UElem;
  UNode* obj;
  UElem* parent;
  const UCond* cond;
};

/* ==================================================== ===== ======= */

template <class _Iter>
class _UChildIter : public _Iter {
public:
  //_UChildIter() : _Iter(null) {}       // !ATT: peut poser probleme si pas g++ !
  _UChildIter() : _Iter() {}
  _UChildIter(const _Iter& i) : _Iter(i) {}
  _UChildIter(const _UChildIter& i) : _Iter(i) {}
  
  UNode*  operator*()    {return static_cast<UNode*>(*_Iter::operator*());}
  UChild& child()        {return _Iter::operator*();}
  const UCond* getCond() {return _Iter::operator*().getCond();}
};

// ==================================================== [(c)Elc] ======= 

typedef _UChildIter<std::list<UChild>::iterator> UChildIter;

typedef _UChildIter<std::list<UChild>::reverse_iterator> UChildReverseIter;

/* ==================================================== ===== ======= */
class UChildren : public std::list<UChild> {
public:
  UChildIter at(int pos);

  UChildIter find(const UNode& child);
  
  UChildIter findStr(const UStr& value, bool ignore_case = true);
  UChildIter findBox(const UStr& value, bool ignore_case = true);
  template <class CC>
    UChildIter findClass(CC*& c) {
      c = null;
      for (UChildIter i = begin(); i != end(); ++i) {
        if (dynamic_cast<CC*>(*i)) {c = (CC*)*i; return i;}
      }
      return end();
    }
};

}
#endif