uitreeitem.h

Go to the documentation of this file.

#pragma once

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        Kristofer Tingdahl
 Date:          4-11-2002
________________________________________________________________________


-*/

#include "uitoolsmod.h"
#include "sets.h"
#include "iopar.h"
#include "notify.h"
#include "bufstring.h"
#include "task.h"
#include "thread.h"

class uiTreeViewItem;
class uiTreeView;
class uiParent;
namespace ColTab { class Sequence; }


mExpClass(uiTools) uiTreeItem : public CallBacker
{ mODTextTranslationClass(uiTreeItem)
public:
                                uiTreeItem(const uiString& nm=
                                           uiString::emptyString() );
    virtual                     ~uiTreeItem();
    virtual void                prepareForShutdown();
    virtual bool                askContinueAndSaveIfNeeded(bool withcancel);
    void                        setName( const uiString& nm )   { name_ = nm; }
    uiString                    name() const;

    bool                        areAllParentsChecked();

    void                        entryInEditMode(int col);

    virtual int                 selectionKey() const { return -1; }
    virtual bool                select();
    virtual bool                isSelected() const;
    void                        setChecked(bool yn,bool trigger=false);
    virtual bool                isChecked() const;
    NotifierAccess*             checkStatusChange();
    NotifierAccess*             keyPressed();
    void                        expand();
    bool                        isExpanded() const;
    void                        collapse();
    bool                        isCollapsed() const;

    bool                        allChildrenExpanded() const;
    bool                        allChildrenCollapsed() const;
    bool                        allChildrenChecked() const;
    bool                        allChildrenUnchecked() const;

    virtual int                 siblingIndex() const;
                                /*\returns the index of this item among
                                   its siblings.
                                  \note this index is not neseccarely the same
                                        as the item's index in the parent's
                                        child-list. */

    virtual uiTreeItem*         siblingAbove();
    virtual uiTreeItem*         siblingBelow();
    virtual void                moveItem(uiTreeItem* after);
    virtual void                moveItemToTop();
    uiTreeItem*                 lastChild();

    int                         nrChildren() const { return children_.size(); }
    const uiTreeItem*           getChild(int) const;
    uiTreeItem*                 getChild(int);
    ObjectSet<uiTreeItem>&      getChildren()   { return children_; }
    const ObjectSet<uiTreeItem>& getChildren() const { return children_; }

    virtual bool                addChild(uiTreeItem* child,bool below);
    virtual void                removeChild(uiTreeItem*);
    virtual void                removeAllChildren();

    virtual const uiTreeItem*   findChild(const char* name) const;
    virtual const uiTreeItem*   findChild(int selkey) const;
    virtual uiTreeItem*         findChild(const char* name);
    virtual uiTreeItem*         findChild(int selkey);
    virtual void                findChildren(const char*,
                                             ObjectSet<uiTreeItem>&);
    template<class T> inline void setProperty(const char* key,const T&);
    inline void                 setPropertyPtr(const char* key,void*);
    template<class T> inline bool getProperty(const char* key, T& res) const;
    inline bool                 getPropertyPtr(const char* key,void*&) const;
    void                        updateSelTreeColumnText(int col);
    virtual void                updateColumnText(int col);
    virtual void                updateCheckStatus();

    virtual void                translateText() { updateColumnText( 0 ); }
    uiTreeViewItem*             getItem()       { return uitreeviewitem_; }
    const uiTreeViewItem*       getItem() const { return uitreeviewitem_; }

    void                        setPixmap(int col,const ColTab::Sequence*);

protected:

    virtual int                 uiTreeViewItemType() const;
    virtual uiParent*           getUiParent() const;

    virtual bool                addChld(uiTreeItem*,bool below,bool downwards);
    virtual const char*         parentType() const = 0;
    virtual bool                useParentType() const       { return true; }
    virtual bool                init() { return true; }

    virtual bool                rightClick(uiTreeViewItem*);
    virtual bool                anyButtonClick(uiTreeViewItem*);
    virtual bool                doubleClick(uiTreeViewItem*);
    virtual void                setTreeViewItem(uiTreeViewItem*);
    virtual void                removeItem(uiTreeViewItem*);
    virtual void                renameItem(uiTreeViewItem*);

    virtual bool                showSubMenu() { return true; }
    virtual bool                selectWithKey(int selkey);

    virtual bool                isSelectable() const { return false; }
    virtual bool                isExpandable() const { return true; }

    virtual void                updateSelection(int selectionKey,
                                                bool dw=false );
    virtual bool                shouldSelect(int selectionkey) const;
    IOPar                       properties_;

    uiTreeItem*                 parent_;
    uiString                    name_;

    uiTreeViewItem*             uitreeviewitem_;
    ObjectSet<uiTreeItem>       children_;
    friend                      class uiTreeTopItem;
    friend                      class uiODTreeTop;

private:

    bool                        addChildImpl(CallBacker*,uiTreeItem*,bool,bool);

};

mExpClass(uiTools) uiTreeItemRemover : public SequentialTask
{
public:
    uiTreeItemRemover(uiTreeItem* parent,uiTreeItem* child);
    int nextStep();

protected:
    uiTreeItem* parent_;
    uiTreeItem* child_;
};



mExpClass(uiTools) uiTreeTopItem : public uiTreeItem
{ mODTextTranslationClass(uiTreeTopItem)
public:
                        uiTreeTopItem(uiTreeView*, bool=false );
                        ~uiTreeTopItem();

    virtual bool        addChild(uiTreeItem*,bool below);
    virtual void        updateSelection(int selectionkey, bool=false );
    virtual void        updateColumnText(int col);
    bool                isChecked() const               { return true; }

    void                disabRightClick(bool yn)        { disabrightclick_=yn; }
    void                disabAnyClick(bool yn)          { disabanyclick_=yn; }
    uiTreeView*         getTreeView() const             { return listview_; }

protected:

    virtual bool        addChld(uiTreeItem*,bool below,bool downwards);
    virtual void        removeItem(uiTreeViewItem*);

    void                selectionChanged(CallBacker*);
    void                rightClickCB(CallBacker*);
    void                anyButtonClickCB(CallBacker*);
    void                doubleClickCB(CallBacker*);
    void                itemRenamed(CallBacker*);
    void                handleSelectionChanged(bool frmbtclk);

    virtual const char* parentType() const { return 0; }
    virtual uiParent*   getUiParent() const;

    uiTreeView*         listview_;
    bool                disabrightclick_;
    bool                disabanyclick_;
    bool                disabselcngresp_;

};


mExpClass(uiTools) uiTreeItemFactory
{
public:
    virtual             ~uiTreeItemFactory()            {}
    virtual const char* name() const                    = 0;
    virtual uiTreeItem* create() const                  = 0;
};


mExpClass(uiTools) uiTreeFactorySet : public CallBacker
{
public:
                                        uiTreeFactorySet();
                                        ~uiTreeFactorySet();
    void                                addFactory(uiTreeItemFactory* ptr,
                                                   int placementindex=-1,
                                                   int pol2d=1);
    void                                remove( const char* );

    int                                 nrFactories() const;
    const uiTreeItemFactory*            getFactory(int) const;
    int                                 getPlacementIdx(int) const;
    int                                 getPol2D(int) const;

    CNotifier<uiTreeFactorySet,int>     addnotifier;
    CNotifier<uiTreeFactorySet,int>     removenotifier;

protected:

    ObjectSet<uiTreeItemFactory>        factories_;
    TypeSet<int>                        placementidxs_;
    TypeSet<int>                        pol2ds_;

};


template<class T>
bool inline uiTreeItem::getProperty( const char* propertykey, T& res ) const
{
    if ( properties_.get( propertykey, res ))
        return true;

    return parent_ ? parent_->getProperty( propertykey, res ) : false;
}


inline bool uiTreeItem::getPropertyPtr(const char* propertykey,void*& res) const
{
    if ( properties_.getPtr( propertykey, res ))
        return true;

    return parent_ ? parent_->getPropertyPtr( propertykey, res ) : false;
}


#include <typeinfo>

template<class T>
void inline uiTreeItem::setProperty( const char* propertykey, const T& val )
{
    if ( typeid(T)==typeid(void*) )
        properties_.set( propertykey, (od_int64)val );
    else
        properties_.set( propertykey, val );
}


void inline uiTreeItem::setPropertyPtr( const char* propertykey, void* val )
{
    properties_.setPtr( propertykey, val );
}