uobject.hpp

/************************************************************************
 *
 *  uobject.hpp: Base Class for all Ubit Objects
 *  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 _uobject_hpp_
#define _uobject_hpp_ 1
#include <stdlib.h>    // for size_t, new(), delete()
#include <exception>
#include <ubit/udefs.hpp>
#include <ubit/uclass.hpp>
namespace ubit {
  
  class UError : public std::exception {
  public:
    enum {
      FATAL_ERROR = -1, WARNING, ERROR, INTERNAL_ERROR, STYLE_ERROR, CSS_ERROR, XML_ERROR
    };
    
    UError(int errnum, const UObject*, const char* funcname);
    virtual ~UError() throw ();
    
    virtual const char* what() const throw();

    static const int message_capacity = 2000;
    int errnum;
    const UObject* object;
    const char* function_name;
    char message[message_capacity];
  };
  
  void uerror(const char* function_name, const char* format, ...);
  void uwarning(const char* function_name, const char* format, ...);
  

  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  class UObject {
  public:
    struct MetaClass : public UClass {
      MetaClass() : UClass("UObject") {}
      //virtual bool isInstance(UObject& obj) const {return dynamic_cast<UObject&>(obj);}
      virtual bool isInstance(UObject* obj) const {return dynamic_cast<UObject*>(obj);}
      virtual UObject* newInstance() const {return null;} 
      virtual UStyle* newStyle() const {return null;}
    };
    
    UObject();
    UObject(const UObject&);
    virtual ~UObject();
    UObject& operator=(const UObject&);
    
    static const char* getVersion();

    static const UClass& Class() {static MetaClass& c = *new MetaClass; return c;}

    virtual const UClass& getClass() const {return Class();}
    const UStr& getClassName() const;
         
    static UStyle* createStyle() {return null;}

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

    virtual void error(const char* function_name, const char* format, ...) const;
    virtual void warning(const char* function_name, const char* format, ...) const;
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

    bool isDeletable() const {return omodes.IS_DYNAMIC;}
    bool isConst() const {return omodes.IS_CONST;}
    
    UObject& setConst();
    bool isAutoUpdate() const {return !omodes.DONT_AUTO_UPDATE;}

    UObject& setAutoUpdate(bool state = true);
    bool isIgnoringChangeCallbacks() const {return omodes.IGNORE_CHANGE_CALLBACKS;}
    
    UObject& ignoreChangeCallbacks(bool state);
    
    // - - - dynamic cast - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    virtual UNode* toNode() {return null;}
    
    virtual const UNode* toNode() const {return null;}
    
    virtual UAttr* toAttr() {return null;}
    
    virtual const UAttr* toAttr() const {return null;}
    
    virtual UElem* toElem() {return null;}
    
    virtual const UElem* toElem() const {return null;}
        
    virtual UData* toData() {return null;}
    
    virtual const UData* toData() const {return null;}
    
    virtual UStr* toStr() {return null;}
    
    virtual const UStr* toStr() const {return null;}
    
    virtual UCall* toCall() {return null;}
    
    virtual const UCall* toCall() const {return null;}
        
    virtual UBox* toBox() {return null;}
    
    virtual const UBox* toBox() const {return null;}
    
    virtual UWin* toWin() {return null;}
    
    virtual const UWin* toWin() const {return null;}
    
    virtual UMenu* toMenu() {return null;}
    
    virtual const UMenu* toMenu() const {return null;}
      
    // - - - Impl - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    
    typedef unsigned char State;
    typedef short PtrCount;
    
    State getState() const {return ostate;}
    
    void setState(State s) {ostate = s;}
    
    PtrCount getPtrCount() const {return ptr_count;}  
    
    struct Modes {
      unsigned IS_DYNAMIC:1;         // this obj was allocated in dynamic memory
      unsigned IS_CONST:1;           // this obj is const, its value can't be changed
      unsigned IS_DESTRUCTED:1;      // this obj has been destructed
      unsigned IS_DESTRUCTING:1;     // this obj is being destructed
      unsigned DONT_AUTO_UPDATE:1;   // set(), add() and remove() do NOT call update().
      unsigned IS_UPDATING:1;        // is being updated (repainted or re-layed out).
      unsigned IS_IN_SELECTION:1;    // is part of a text selection
      unsigned IGNORE_CHANGE_CALLBACKS:1;
    };
    
    struct UConst {};
    
    static UConst UCONST;
    bool checkConst() const;
    
    bool isDestructed()  const {return omodes.IS_DESTRUCTED;}
    
    bool isDestructing() const {return omodes.IS_DESTRUCTING;}
    
    virtual bool hasSceneGraphParent() const {return false;};    // !MUST be virtual!
    
    void* operator new(size_t);
    
    void operator delete(void*);
    
    void addPtr() const;       
    void removePtr() const;    

  protected:
    friend class UNode;
    friend class UUpdateContext;
    friend class UAppliImpl;
    friend class USelection;
    friend class UPtr;
    
    mutable PtrCount ptr_count;  // uptr<> reference count
    Modes omodes;
    State ostate;
  };
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  class UPtr {
  protected:
    //void addPtr(const UObject* o) {if (o) o->addPtr();}  
    //void removePtr(const UObject* o) {if (o) o->removePtr();}
    void deferenceError() const;
  };
  
  
  template <class CC> class uptr : public UPtr {
  public:
    void addPtr(const CC* o) {if (o) o->addPtr();}  
    void removePtr(const CC* o) {if (o) o->removePtr();}
    
    uptr()         {obj = null;}
    uptr(CC& _obj) {obj = &_obj; addPtr(obj);}
    uptr(CC* _obj) {obj = _obj; addPtr(obj);}
    
    uptr(const uptr<CC>& p2) {obj = p2.obj; addPtr(obj);}
    
    ~uptr() {removePtr(obj);}
    
    uptr<CC>& operator=(CC& _obj) {
      removePtr(obj); obj = &_obj; addPtr(obj); return *this;
    }
    uptr<CC>& operator=(CC* _obj) {
      removePtr(obj); obj = _obj; addPtr(obj); return *this;
    }
    
    uptr<CC>& operator=(const uptr<CC>& p2) {
      removePtr(obj); obj = p2.obj; addPtr(obj); return *this;
    }
    
    operator CC*() const {return obj;}
    
    CC* operator&() const {return obj;}

    CC* operator()() const {return obj;}
    
    CC& operator*() const {
      if (!obj) deferenceError();
      return *obj;
    }
    
    CC* operator->() const {
      if (!obj) deferenceError();
      return obj;
    }
    
  private:
    CC* obj;
    CC& operator[](int);  // [] meaningless and forbidden.
  };
  
}
#endif