Project stdui: "Simple Type Dialog User-Interface"

|

Home The design of the project The Roadmap Screenshots Examples Api Documentations Downloads

Home / Api Documentation /

stdobject.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Serge Lussier,,,   *
 *   serge.lussier@videotron.ca   *
 *                                                                         *
 *   This program is free software; 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.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <stdui.h>
#ifndef STDUISTDOBJECT_H
#define STDUISTDOBJECT_H

#include <stdui.h>

#include <list>
#include <stack>
#include <stdmessage.h>
#include <cevent.h>

namespace stdui {

class stdobject : public sigc::trackable
{
public:
   typedef std::list<stdobject*> list;
   typedef stdobject::list::iterator iterator;
   typedef stdobject::list::const_iterator const_iterator;

    stdobject();
    stdobject(stdobject* __parentobj, const std::string& nameid="undef", stdflags __flags=0);

   template <class T>   int  parent_chain(std::list<T*>& l);
   template <class T>   T*   parentof();
   template <class T>  int  childrenof(std::list<T>& l);
   template <class T>  T*   firstchildof();
   template <class T>  T*   nextchildof();
   template <class T>  T*   lastchildof();

   virtual ~stdobject();
   int addchild(stdobject* _obj);

   stdobject* parent() { return _parent; }
   int destroy_children();
   int setparent(stdobject* _obj);

    sigc::signal<bool, stdobject*>& destroy_signal() { return destroy_; }

    const std::string& classname() const { return _clsname; }

    const std::string& name() const { return _name; }

    sigc::signal<bool, stdobject*>::iterator destroy_delegate(const sigc::slot<bool, stdobject*>& _slot){
      return destroy_.connect(_slot);
    }

    pthread_t threadid() { return _thid; }
    int postevent( stdmessage msg );
private:
   stdflag _flags;
   list::iterator _tpl_it;
    pthread_t _thid;
    std::stack<stdmessage> _holdmsgqueu;
   bool _destroy(stdobject* o);
protected:
   stdobject* _parent;
   sigc::signal<bool, stdobject*> destroy_;
   stdobject::list _children;
   list _parents;
    std::string _clsname;
    std::string _name;
protected:
    void purgemessages();
    virtual evt::result messageevent( cmessageevent* mes );


    virtual evt::result keyevent(ckeypressevent* kev) { return evt::reject; }

    virtual evt::result mouseevent( cmouseevent* mev ) { return evt::reject; }
}; // end of stdobject


template<class T> int stdobject::parent_chain(std::list<T*>& l)
{
    T* pr = parentof<T>();
    while(pr){
        l.push_back(pr);
        pr = pr->parentof<T>();
    }
    return l.size();
}


template<class T> T* stdobject::parentof()
{
    T* P=0l;
    stdobject* o = this;
    while(P == 0l){
        o = o->parent();
        if(!o) return 0l;
        if( ( P = dynamic_cast<T*>(o) ) != 0l) return P;
    }
    return (T*)0l;
}


template <class T> int stdobject::childrenof(std::list<T>& l)
{
   T* obj=0l;
   iterator temp_it = _tpl_it;
   if( !l.empty() ) l.clear();
   if( ! ( obj = firstchildof<T>() ) ){
      _tpl_it = temp_it;
      return 0;
   }
   do l.push_back(obj); while( ( obj = nextchildof<T>() ) != 0l);
   _tpl_it = temp_it;
    return l.size();
}


template <class T> T* stdobject::firstchildof()
{
   T* pobj;
   if( _children.empty() ) return (T*)0l;
   _tpl_it = _children.begin();
   do{
      if( (pobj = dynamic_cast<T*>(_tpl_it)) != 0l ) return pobj;
      _tpl_it++;
   } while(_tpl_it != _children.end());
   return (T*)0l;
}


template <class T> T* stdobject::nextchildof()
{
   T* pobj;
   if(_tpl_it == _children.end() ) if( !(pobj = firstchildof<T>())) return (T*)0l;
   _tpl_it++;
   do{
      if( (pobj = dynamic_cast<T*>(_tpl_it)) != 0l ) return pobj;
      _tpl_it++;
   } while(_tpl_it != _children.end());
   return (T*)0l;
}


template <class T> T* stdobject::lastchildof()
{
   T* pobj;
   iterator it = _children.end();
   it--;
   if(it == _children.end()) return (T*)0l;
   do{
      if( (pobj = dynamic_cast<T*>(*it)) ) return pobj;
      it--;
   }while(_tpl_it != _children.end());
   return it == _children.end() ? (T*)0l : *it;
}



}

#endif

---

About the author | Site started with trial version of DreamWeaver MX 2004 | Finalizing with  | Contact | ©2005, Serge Lussier ( Bretzel )