classmodelnode.h

Go to the documentation of this file.

/*
 * KDevelop Class Browser
 *
 * Copyright 2007-2009 Hamish Rodda <[email protected]>
 * Copyright 2009 Lior Mualem <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
#ifndef KDEVPLATFORM_CLASSMODELNODE_H
#define KDEVPLATFORM_CLASSMODELNODE_H
 
#include "classmodel.h"
 
#include "../duchain/identifier.h"
#include "../duchain/duchainpointer.h"
#include "classmodelnodescontroller.h"
 
#include <QIcon>
 
class NodesModelInterface;
 
namespace KDevelop {
class ClassDeclaration;
class ClassFunctionDeclaration;
class ClassMemberDeclaration;
class Declaration;
}
 
namespace ClassModelNodes {
class Node
{
public:
    Node(const QString& a_displayName, NodesModelInterface* a_model);
    virtual ~Node();
 
public: // Operations
    void clear();
 
    virtual void collapse() {};
 
    virtual void expand() {};
 
    void addNode(Node* a_child);
 
    void removeNode(Node* a_child);
 
    void removeSelf() { m_parentNode->removeNode(this); }
 
    void recursiveSort();
 
public: // Info retrieval
    Node* parent() const { return m_parentNode; }
 
    int row();
 
    QString displayName() const { return m_displayName; }
 
    const QList<Node*>& children() const { return m_children; }
 
    QIcon cachedIcon();
 
public: // overridables
    virtual int score() const = 0;
 
    virtual bool hasChildren() const { return !m_children.empty(); }
 
    virtual QString sortableString() const { return m_displayName; }
 
protected:
    virtual bool getIcon(QIcon& a_resultIcon) = 0;
 
private:
    Node* m_parentNode;
 
    void recursiveSortInternal();
 
protected:
    using NodesList = QList<Node*>;
    NodesList m_children;
    QString m_displayName;
    QIcon m_cachedIcon;
    NodesModelInterface* m_model;
};
 
 
class DynamicNode
    : public Node
{
public:
    DynamicNode(const QString& a_displayName, NodesModelInterface* a_model);
 
    bool isPopulated() const { return m_populated; }
 
    void performPopulateNode(bool a_forceRepopulate = false);
 
public: // Node overrides.
    void collapse() override;
    void expand() override;
    bool hasChildren() const override;
 
protected: // overridables
    virtual void populateNode() {}
 
    virtual void nodeCleared() {}
 
private:
    bool m_populated;
 
    void performNodeCleanup();
};
 
 
class IdentifierNode
    : public DynamicNode
{
public:
    IdentifierNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model,
                   const QString& a_displayName = QString());
 
public:
    const KDevelop::IndexedQualifiedIdentifier& identifier() const { return m_identifier; }
 
public: // Node overrides
    bool getIcon(QIcon& a_resultIcon) override;
 
public: // Overridables
    virtual KDevelop::Declaration* declaration();
 
private:
    KDevelop::IndexedQualifiedIdentifier m_identifier;
    KDevelop::IndexedDeclaration m_indexedDeclaration;
    KDevelop::DeclarationPointer m_cachedDeclaration;
};
 
 
class EnumNode
    : public IdentifierNode
{
public:
    EnumNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
public: // Node overrides
    int score() const override { return 102; }
    bool getIcon(QIcon& a_resultIcon) override;
    void populateNode() override;
};
 
 
class ClassNode
    : public IdentifierNode
    , public ClassModelNodeDocumentChangedInterface
{
public:
    ClassNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
    ~ClassNode() override;
 
    ClassNode* findSubClass(const KDevelop::IndexedQualifiedIdentifier& a_id);
 
public: // Node overrides
    int score() const override { return 300; }
    void populateNode() override;
    void nodeCleared() override;
    bool hasChildren() const override { return true; }
 
protected: // ClassModelNodeDocumentChangedInterface overrides
    void documentChanged(const KDevelop::IndexedString& a_file) override;
 
private:
    using SubIdentifiersMap = QMap<uint, Node*>;
    SubIdentifiersMap m_subIdentifiers;
 
    KDevelop::IndexedString m_cachedUrl;
 
    bool updateClassDeclarations();
 
    bool addBaseAndDerived();
};
 
 
class FunctionNode
    : public IdentifierNode
{
public:
    FunctionNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
public: // Node overrides
    int score() const override { return 400; }
    QString sortableString() const override { return m_sortableString; }
 
private:
    QString m_sortableString;
};
 
 
class ClassMemberNode
    : public IdentifierNode
{
public:
    ClassMemberNode(KDevelop::ClassMemberDeclaration* a_decl, NodesModelInterface* a_model);
 
public: // Node overrides
    int score() const override { return 500; }
    bool getIcon(QIcon& a_resultIcon) override;
};
 
 
class FolderNode
    : public Node
{
public:
    FolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
public: // Node overrides
    bool getIcon(QIcon& a_resultIcon) override;
    int score() const override { return 100; }
};
 
 
class DynamicFolderNode
    : public DynamicNode
{
public:
    DynamicFolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
public: // Node overrides
    bool getIcon(QIcon& a_resultIcon) override;
    int score() const override { return 100; }
};
 
 
class BaseClassesFolderNode
    : public DynamicFolderNode
{
public:
    explicit BaseClassesFolderNode(NodesModelInterface* a_model);
 
public: // Node overrides
    void populateNode() override;
};
 
 
class DerivedClassesFolderNode
    : public DynamicFolderNode
{
public:
    explicit DerivedClassesFolderNode(NodesModelInterface* a_model);
 
public: // Node overrides
    void populateNode() override;
};
} // namespace classModelNodes
 
#endif