/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   copyright (C) 2002-2007                                               *
 *   Umbrello UML Modeller Authors <uml-devel@uml.sf.net>                  *
 ***************************************************************************/

#ifndef UMLOBJECT_H
#define UMLOBJECT_H

//qt includes
#include <tqobject.h>
#include <tqstring.h>
#include <tqdom.h>

#include "umlnamespace.h"
#include "umlpackagelist.h"

class kdbgstream;
class UMLStereotype;
class UMLObject;

/**
 * This class is the non-graphical version of @ref UMLWidget.  These are
 * created and maintained in the class @ref UMLDoc.  This class holds all
 * the generic information needed for all UML objects.
 *
 * @short The base class for UML objects.
 * @author Paul Hensgen <phensgen@techie.com>
 * Bugs and comments to uml-devel@lists.sf.net or http://bugs.trinitydesktop.org
 */
class UMLObject : public TQObject {
    TQ_OBJECT
  
public:

    /**
     * Creates a UMLObject.
     *
     * @param parent    The parent of the object.
     * @param name              The name of the object.
     * @param id                The ID of the object (optional.) If omitted
     *                  then a new ID will be assigned internally.
     */
    UMLObject(const UMLObject * parent, const TQString &name, Uml::IDType id = Uml::id_None);

    /**
     * Creates a UMLObject.
     *
     * @param   parent          The parent of the object.
     */
    UMLObject(const UMLObject * parent);

    /**
     * Creates a UMLObject with a given name and unique ID.
     *
     * @param   name            The name of the object.
     * @param   id              The unique ID of the object.
     */
    explicit UMLObject(const TQString &name = "" , Uml::IDType id = Uml::id_None);

    /**
     * Overloaded '==' operator
     */
    virtual bool operator==(UMLObject & rhs );

    /**
     * Standard deconstructor.
     */
    virtual ~UMLObject();

    /**
     * Copy the internal presentation of this object into the new
     * object.
     */
    virtual void copyInto(UMLObject *rhs) const;

    /**
     * Make a clone of this object.
     * To be implemented by inheriting classes.
     */
    virtual UMLObject* clone() const = 0;

    /**
     * Returns the type of the object.
     *
     * @return  Returns the type of the object.
     */
    Uml::Object_Type getBaseType() const;

    /**
     * Set the type of the object.
     *
     * @param ot The Uml::Object_Type to set.
     */
    virtual void setBaseType(Uml::Object_Type ot);

    /**
     * Returns the ID of the object.
     *
     * @return  Returns the ID of the object.
     */
    virtual Uml::IDType getID() const;

    /**
     * Sets the documentation for the object.
     *
     * @param d The documentation for the object.
     */
    void setDoc(const TQString &d);

    /**
     * Returns the documentation for the object.
     *
     * @return  Returns the documentation for the object.
     */
    TQString getDoc() const;

    /**
     * Returns the visibility of the object.
     *
     * @return  Returns the visibility of the object.
     */
    Uml::Visibility getVisibility() const;

    /**
     * Sets the visibility of the object.
     *
     * @param s The visibility of the object.
     */
    virtual void setVisibility(Uml::Visibility s);

    /**
     * Sets the classes stereotype name.
     * Internally uses setUMLStereotype().
     *
     * @param _name     Sets the classes stereotype name.
     */
    void setStereotype(const TQString &_name);

    /**
     * Sets the class' UMLStereotype. Adjusts the reference counts
     * at the previously set stereotype and at the new stereotype.
     * If the previously set UMLStereotype's reference count drops
     * to zero then the UMLStereotype is removed at the UMLDoc and
     * it is then physically deleted.
     *
     * @param s Sets the classes UMLStereotype.
     */
    void setUMLStereotype(UMLStereotype *s);

    /**
     * Sets the classes Package.
     * DEPRECATED - use SetUMLPackage instead.
     *
     * @param _name     The classes Package name.
     */
    void setPackage(const TQString &_name);

    /**
     * Sets the UMLPackage in which this class is located.
     *
     * @param pPkg              Pointer to the class' UMLPackage.
     */
    void setUMLPackage(UMLPackage* pPkg);

    /**
     * Returns the classes UMLStereotype object.
     *
     * @return  Returns the classes UMLStereotype object.
     */
    const UMLStereotype * getUMLStereotype();

    /**
     * Returns the classes stereotype name.
     * Returns an empty string if no stereotype object is set.
     *
     * @param includeAdornments Include surrounding angled brackets
     *                          "«" and "»".
     * @return  Returns the classes stereotype name.
     */
    TQString getStereotype(bool includeAdornments = false) const;

    /**
     * Return the package(s) in which this UMLObject is contained
     * as a text.
     *
     * @param separator Separator string for joining together the
     *                  individual package prefixes (optional.)
     *                  If no separator is given then the separator
     *                  of the currently selected language is used.
     * @param includeRoot  Whether to prefix the root folder name.
     *                     Default: false.
     * @return  The UMLObject's enclosing package(s) as a text.
     */
    TQString getPackage(const TQString& separator = TQString(),
                       bool includeRoot = false);

    /**
     * Return a list of the packages in which this class is embedded.
     * The outermost package is first in the list.
     *
     * @param includeRoot  Whether to prefix the root folder name.
     *                     Default: false.
     * @return  UMLPackageList of the containing packages.
     */
    UMLPackageList getPackages(bool includeRoot = false) const;

    /**
     * Returns the UMLPackage that this class is located in.
     *
     * @return  Pointer to the UMLPackage of this class.
     */
    UMLPackage* getUMLPackage();

    /**
     * Assigns a new Id to the object
     */
    virtual void setID(Uml::IDType NewID);

    /**
     * Returns a copy of m_Name
     */
    TQString getName() const;

    /**
     * Set the UMLObject's name
     */
    virtual void setName(const TQString &strName);

    /**
     * Returns the fully qualified name, i.e. all package prefixes and then m_Name.
     *
     * @param separator  The separator string to use (optional.)
     *                   If not given then the separator is chosen according
     *                   to the currently selected active programming language
     *                   of import and code generation.
     * @param includeRoot  Whether to prefix the root folder name to the FQN.
     *                     See UMLDoc::getRootFolder(). Default: false.
     * @return  The fully qualified name of this UMLObject.
     */
    virtual TQString getFullyQualifiedName(const TQString& separator = TQString(),
                                          bool includeRoot = false) const;

    /**
     * Returns the abstract state of the object.
     */
    bool getAbstract() const;

    /**
     * Sets the abstract state of the object.
     */
    void setAbstract(bool bAbstract);

    /**
     * Sets the abstract state of the object.
     */
    void setInPaste(bool bInPaste = true);

    /**
     * This method is called if you wish to see the properties of a
     * UMLObject.  A dialog box will be displayed from which you
     * can change the object's properties.
     *
     * @param page              The page to show.
     * @param assoc             Whether to show association page.
     * @return          True if we modified the object.
     */
    bool showProperties(int page = 0, bool assoc = false);

    /**
     * Resolve referenced objects (if any.)
     * Needs to be called after all UML objects are loaded from file.
     * This needs to be done after all model objects are loaded because
     * some of the xmi.id's might be forward references, i.e. they may
     * identify model objects which were not yet loaded at the point of
     * reference.
     * The default implementation attempts resolution of the m_SecondaryId.
     *
     * @return  True for success.
     */
    virtual bool resolveRef();

    /**
     * This method saves the XMI attributes of each specific model class.
     * It needs to be implemented by each child class.
     * For creating the TQDomElement and saving the common XMI parts,
     * it can use the save() method.
     */
    virtual void saveToXMI( TQDomDocument & qDoc, TQDomElement & qElement ) = 0;

    /**
     * This method loads the generic parts of the XMI common to most model
     * classes.  It is not usually reimplemented by child classes.
     * Instead, it invokes the load() method which implements the loading
     * of the specifics of each child class.
     *
     * @param element   The TQDomElement from which to load.
     */
    virtual bool loadFromXMI( TQDomElement & element );

    /**
     * Analyzes the given TQDomElement for a reference to a stereotype.
     *
     * @param element    TQDomElement to analyze.
     * @return        True if a stereotype reference was found, else false.
     */
    bool loadStereotype(TQDomElement & element);

    /**
     * Returns true if this UMLObject has classifier scope,
     * otherwise false (the default).
     */
    bool getStatic() const;


    /**
     * Sets the value for m_bStatic.
     */
    void setStatic(bool bStatic);

    /**
     * This should be reimplemented by subclasses if they wish to
     * accept certain types of associations. Note that this only
     * tells if this UMLObject can accept the association
     * type. When creating an association another check is made to
     * see if the association is valid. For example a UMLClass
     * (UMLClassifier) can accept generalizations and should
     * return true. If while creating a generalization the
     * superclass is already subclassed from this, the association
     * is not valid and will not be created.  The default accepts
     * nothing (returns false)
     */
    virtual bool acceptAssociationType(Uml::Association_Type);

    /**
     * Return secondary ID. Required by resolveRef().
     */
    TQString getSecondaryId() const;

    /**
     * Set the secondary ID.
     * Currently only required by petalTree2Uml(); all other setting of the
     * m_SecondaryID is internal to the UMLObject class hierarchy.
     */
    void setSecondaryId(const TQString& id);

    /**
     * Return secondary ID fallback.
     * Required by resolveRef() for imported model files.
     */
    TQString getSecondaryFallback() const;

    /**
     * Set the secondary ID fallback.
     * Currently only used by petalTree2Uml().
     */
    void setSecondaryFallback(const TQString& id);

    /**
     * Auxiliary to saveToXMI.
     * Create a TQDomElement with the given tag, and save the XMI attributes
     * that are common to all child classes to the newly created element.
     * This method does not need to be overridden by child classes.
     */
    TQDomElement save( const TQString &tag, TQDomDocument & qDoc );

public slots:
    /**
     * Forces the emission of the modified signal.  Useful when
     * updating several attributes at a time: you can block the
     * signals, update all atts, and then force the signal.
     */
    void emitModified();

signals:
    /** Emitted when the UMLObject has changed. Note that some objects emit
      * this signal when one of its children changes, for example, a UMLClass
      * emits a modified() signal when one of its operation changes while the Operation
      * itself emits the corresponding signal as well.
      */
    void modified();

protected:
    /**
     * Initializes key variables of the class.
     */
    virtual void init();

    /**
     * Calls UMLDoc::signalUMLObjectCreated() if m_BaseType affords
     * doing so.
     */
    void maybeSignalObjectCreated();

    /**
     * Auxiliary to loadFromXMI.
     * This method is usually overridden by child classes.
     * It is responsible for loading the specific XMI structure
     * of the child class.
     */
    virtual bool load( TQDomElement& element );

    /**
     * The object's id.
     */
    Uml::IDType m_nId;

    /**
     * The object's documentation.
     */
    TQString m_Doc;

    /**
     * The package the object belongs to if applicable.
     */
    UMLPackage* m_pUMLPackage;

    /**
     * The stereotype of the object if applicable.
     */
    UMLStereotype* m_pStereotype;

    /**
     * The objects name.
     */
    TQString m_Name;

    /**
     * The objects type.
     */
    Uml::Object_Type m_BaseType;

    /**
     * The objects visibility.
     */
    Uml::Visibility m_Vis;

    /**
     * The state of whether the object is abstract or not.
     */
    bool m_bAbstract;

    /**
     * This attribute holds whether the UMLObject has instance scope
     * (false - the default) or classifier scope (true).
     */
    bool m_bStatic;

    /**
     * Caller sets this true when in paste operation.
     */
    bool m_bInPaste;

    /**
     * Auxiliary to maybeSignalObjectCreated().
     */
    bool m_bCreationWasSignalled;

    /**
     * Pointer to an associated object.
     * Only a few of the classes inheriting from UMLObject use this.
     * However, it needs to be here because of inheritance graph
     * disjunctness.
     */
    UMLObject* m_pSecondary;

    /**
     * xmi.id of the secondary object for intermediate use during
     * loading.  The secondary ID is resolved to the m_pSecondary
     * in the course of resolveRef() at the end of loading.
     */
    TQString m_SecondaryId;

    /**
     * Last-chance backup for when m_SecondaryId is not found.
     * Used by Rose import: MDL files specify both a "quidu"
     * (which corresponds to m_SecondaryId) and the human readable
     * fully qualified target name of a reference.
     * In case the quidu is not found, the human readable name is
     * used which we store in m_SecondaryFallback.
     */
    TQString m_SecondaryFallback;
};

/**
 * Print UML Object to kdgstream, so it can be used like
 *   kdWarn() << "This object shouldn't be here:" << illegalObject << endl;
 */
kdbgstream& operator<< (kdbgstream& s, const UMLObject& a);

#endif
