object.h

Go to the documentation of this file.

// -*- C++ -*-

/*
 * Gnome Chemistry Utils
 * object.h
 *
 * Copyright (C) 2002-2011 Jean Bréfort <jean.brefort@normalesup.org>
 *
 * 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 3 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#ifndef GCU_OBJECT_H
#define GCU_OBJECT_H

#include "macros.h"
#include "matrix2d.h"
#include <libxml/parser.h>
#include <map>
#include <set>
#include <list>
#include <string>
#include <stdexcept>

#define square(x) ((x)*(x))

namespace gcu
{

class Dialog;
class Application;
class UIManager;

enum GcuTypeId
{
        NoType,
        AtomType,
        FragmentType,
        BondType,
        MoleculeType,
        ChainType,
        CycleType,
        ReactantType,
        ReactionArrowType,
        ReactionOperatorType,
        ReactionType,
        MesomeryType,
        MesomeryArrowType,
        DocumentType,
        TextType,
        OtherType
};

typedef unsigned TypeId;

class Object;

// FIXME: create a class for UIManager
typedef bool (*BuildMenuCb) (Object *target, UIManager *uim, Object *object, double x, double y);

class TypeDesc
{
public:
        TypeDesc ();

        TypeId Id;
        Object* (*Create) ();
        std::set <TypeId> PossibleChildren;
        std::set <TypeId> PossibleParents;
        std::set <TypeId> RequiredChildren;
        std::set <TypeId> RequiredParents;
        std::string CreationLabel;
        std::list <BuildMenuCb> MenuCbs;
};

class Object;

enum RuleId
{
        RuleMayContain,
        RuleMustContain,
        RuleMayBeIn,
        RuleMustBeIn
};

typedef unsigned SignalId;

class Document;

class Object
{
friend class Application;
public:
        Object (TypeId Id = OtherType);
        virtual ~Object ();

        TypeId GetType () const {return m_Type;}
        void SetId (gchar const *Id);
        char const *GetId () const {return m_Id;}
        virtual void AddChild (Object* object);
        Object* GetMolecule () const;
        Object* GetReaction () const;
        Object* GetGroup () const;
        Document* GetDocument () const;
        Application* GetApplication () const;
        Object* GetParentOfType (TypeId Id) const;
        Object* GetChild (const gchar* Id) const;
        Object *GetFirstChild (std::map<std::string, Object*>::iterator& i);
        Object const *GetFirstChild (std::map<std::string, Object*>::const_iterator& i) const;
        Object *GetNextChild (std::map<std::string, Object*>::iterator& i);
        Object const *GetNextChild (std::map<std::string, Object*>::const_iterator& i) const;
        Object* GetDescendant (const char* Id) const;
        Object* GetParent () const {return m_Parent;};
        void SetParent (Object* Parent);
        virtual xmlNodePtr Save (xmlDocPtr xml) const;
        virtual bool Load (xmlNodePtr node);
        virtual bool GetCoords (double *x, double *y, double *z = NULL) const;
        virtual void Move (double x, double y, double z = 0.);
        virtual void Transform2D (Matrix2D& m, double x, double y);
        bool SaveChildren (xmlDocPtr xml, xmlNodePtr node) const;
        void SaveId (xmlNodePtr node) const;
        xmlNodePtr GetNodeByProp (xmlNodePtr node, char const *Property, char const *Id);
        xmlNodePtr GetNextNodeByProp (xmlNodePtr node, char const *Property, char const *Id);
        xmlNodePtr GetNodeByName (xmlNodePtr node, char const *Name);
        xmlNodePtr GetNextNodeByName (xmlNodePtr node, char const *Name);
        bool HasChildren () const {return m_Children.size () != 0;}

        unsigned GetChildrenNumber () const {return m_Children.size ();}

        virtual Object* GetAtomAt (double x, double y, double z = 0.);

        virtual bool Build (std::set < Object * > const &Children) throw (std::invalid_argument);

        virtual double GetYAlign ();

        virtual bool BuildContextualMenu (UIManager *uim, Object *object, double x, double y);

        void EmitSignal (SignalId Signal);

        virtual bool OnSignal (SignalId Signal, Object *Child);

        void Lock (bool state = true);

        bool IsLocked () {return m_Locked > 0;}

        Object* GetFirstLink (std::set<Object*>::iterator& i);

        Object* GetNextLink (std::set<Object*>::iterator& i);

        void Link (Object *object);

        void Unlink (Object *object);

        virtual void OnUnlink (Object *object);

        void GetPossibleAncestorTypes (std::set<TypeId>& types) const;

        virtual bool SetProperty (unsigned property, char const *value);

        virtual std::string GetProperty (unsigned property) const;

        virtual void OnLoaded ();

        void SetDirty (bool dirty = true);

        virtual void Clear ();

        virtual std::string Name ();

        std::string Identity ();

        virtual char const *HasPropertiesDialog () const;

        virtual bool CanSelect () const {return true;}

        virtual void NotifyEmpty () {;}

        void ShowPropertiesDialog ();

        static TypeId AddType (std::string TypeName, Object* (*CreateFunc) (), TypeId id = OtherType);

        static void AddAlias (TypeId id, std::string TypeName);

        static Object* CreateObject (const std::string& TypeName, Object* parent = NULL);

        static TypeId GetTypeId (const std::string& Name);

        static std::string GetTypeName (TypeId Id);

        static void AddMenuCallback (TypeId Id, BuildMenuCb cb);

        static void AddRule (TypeId type1, RuleId rule, TypeId type2);

        static void AddRule (const std::string& type1, RuleId rule, const std::string& type2);

        static  const std::set<TypeId>& GetRules (TypeId type, RuleId rule);

        static const std::set<TypeId>& GetRules (const std::string& type, RuleId rule);

        static void SetCreationLabel (TypeId Id, std::string Label);

        static const std::string& GetCreationLabel (TypeId Id);

        static const std::string& GetCreationLabel (const std::string& TypeName);

        static SignalId CreateNewSignalId ();

protected:
        virtual Dialog *BuildPropertiesDialog ();

private:
        Object* RealGetDescendant (const gchar* Id) const;

private:
        char* m_Id;
        TypeId m_Type;
        Object *m_Parent;
        std::map<std::string, Object*> m_Children; //string is Id of object, so each object must have an Id
        std::set<Object*> m_Links; //objects linked to this but outside of the hierarchy
        TypeDesc const *m_TypeDesc;

private:
        int m_Locked;

GCU_RO_PROP (bool, Dirty);
};

}
#endif //GCU_OBJECT_H