treenodeview.h

Go to the documentation of this file.

/* 
 * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
 *
 * 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; version 2 of the
 * License.
 * 
 * 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 _MFORMS_TREENODEVIEW_H_
#define _MFORMS_TREENODEVIEW_H_

#include <mforms/view.h>
#include <boost/cstdint.hpp>

namespace mforms {
  class TreeNodeView;
  class ContextMenu;
  
  enum TreeColumnType
  {
    StringColumnType,      
    StringLTColumnType,    
    IntegerColumnType,     
    LongIntegerColumnType, 
    CheckColumnType,       
    TriCheckColumnType,    
    IconColumnType,        
    IconStringColumnType = IconColumnType,
    NumberWithUnitColumnType, 
    FloatColumnType        
  };
  
  enum TreeOptions
  {
    TreeDefault          = 0,
    TreeNoColumns        = 1 << 3, 
    TreeAllowReorderRows = 1 << 4, 
    TreeShowColumnLines  = 1 << 5, 
    TreeShowRowLines     = 1 << 6, 
    TreeNoBorder         = 1 << 7, 
    TreeSidebar          = 1 << 8, 
    TreeNoHeader         = 1 << 9, 
    TreeShowHeader       = 0,      
    TreeFlatList         = 1 << 10, 
    TreeAltRowColors     = 1 << 11, 
    TreeSizeSmall        = 1 << 12, 
    TreeIndexOnTag       = 1 << 13, 

    TreeCanBeDragSource  = 1 << 14, 
  };
  
#ifndef SWIG
  inline TreeOptions operator| (TreeOptions a, TreeOptions b)
  {
    return (TreeOptions) ((int) a | (int) b);
  }
#endif

  enum TreeSelectionMode
  {
    TreeSelectSingle, // 0 or 1 item selected
    TreeSelectMultiple // 0+ items selection
  };

  typedef struct TextAttributes TreeNodeTextAttributes;  

  // This struct represents the data comprising a node
  // including a collection of child nodes.
  struct MFORMS_EXPORT TreeNodeSkeleton
  {
  public:
    TreeNodeSkeleton() {};
    TreeNodeSkeleton(const std::string& caption, const std::string& icon, const std::string& tag);
    std::string caption;
    std::string icon;
    std::string tag;
    std::vector<TreeNodeSkeleton> children;
  };

  // This struct represents a collection of nodes sharing tag, icon and structure
  struct MFORMS_EXPORT TreeNodeCollectionSkeleton
  {
  public:
    TreeNodeCollectionSkeleton() {};
    TreeNodeCollectionSkeleton(const std::string& icon);
    std::string icon;
    std::vector<TreeNodeSkeleton> children;
    std::vector<std::string> captions;
  };

  class MFORMS_EXPORT TreeNodeData {
  protected:
    int _refcount;
  public:
    TreeNodeData() : _refcount(0) {}
    virtual ~TreeNodeData() {}
    void retain() { _refcount++; }
    void release() { _refcount--; if (_refcount == 0) delete this; }
  };


  class TreeNode;
  struct MFORMS_EXPORT TreeNodeRef
  {
  private:
    TreeNode *node;

  public:
#ifndef SWIG
    TreeNodeRef(TreeNode *anode);
    TreeNode *ptr() { return node; }
#endif
  public:
    TreeNodeRef() : node(0) {}
    TreeNodeRef(const TreeNodeRef &other);
    ~TreeNodeRef();
#ifndef SWIG
    TreeNodeRef &operator= (const TreeNodeRef &other);
#endif
    TreeNode *operator->() const;
    TreeNode *operator->();

    operator bool () const { return node !=0; }
    bool operator == (const TreeNodeRef &other) const;
    bool operator != (const TreeNodeRef &other) const;

    bool is_valid();
  };

  class MFORMS_EXPORT TreeNode
  {
    friend struct TreeNodeRef;

  protected:
    virtual void release() = 0;
    virtual void retain() = 0;
  public:
    virtual ~TreeNode() {};
    
    virtual bool equals(const TreeNode &other) = 0;
#ifndef SWIG
    virtual bool is_valid() const = 0;
#endif
    virtual void set_icon_path(int column, const std::string &icon) = 0;

    virtual void set_string(int column, const std::string &value) = 0;
    virtual void set_int(int column, int value) = 0;
    virtual void set_long(int column, boost::int64_t value) = 0;
    virtual void set_bool(int column, bool value) = 0;
    virtual void set_float(int column, double value) = 0;

    virtual void set_attributes(int column, const TreeNodeTextAttributes &attrs) = 0;

    virtual std::string get_string(int column) const = 0;
    virtual int get_int(int column) const = 0;
    virtual boost::int64_t get_long(int column) const = 0;
    virtual bool get_bool(int column) const = 0;
    virtual double get_float(int column) const = 0;
    
    virtual int count() const = 0;
    virtual TreeNodeRef add_child() { return insert_child(-1); }
    virtual TreeNodeRef insert_child(int index) = 0;
    virtual void remove_from_parent() = 0;
    virtual void remove_children(); // default impl provided, subclasses may override to provide faster impl
    virtual TreeNodeRef get_child(int index) const = 0;
    virtual TreeNodeRef get_parent() const = 0;
    virtual TreeNodeRef find_child_with_tag(const std::string &tag); // this will search the subnodes sequentially
 
    virtual std::vector<mforms::TreeNodeRef> add_node_collection(const TreeNodeCollectionSkeleton &nodes, int position = -1) = 0;

    virtual void expand() = 0;
    virtual void collapse() = 0;
    virtual bool is_expanded() = 0;

    // Primitive check. Use TreeNodeView::can_expand() instead for potentially more sophisticated checks.
    virtual bool can_expand() { return count() > 0; };

    virtual void set_tag(const std::string &tag) = 0;
    virtual std::string get_tag() const = 0;

    virtual void set_data(TreeNodeData *data) = 0;
    virtual TreeNodeData *get_data() const = 0;
  };
  

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifndef SWIG
  struct TreeNodeViewImplPtrs
  {
    bool (*create)(TreeNodeView *self, TreeOptions options);
    
#if defined(_WIN32)
    int (*add_column)(TreeNodeView *self, TreeColumnType type, const std::string &name, int initial_width, bool editable);
#else
    int (*add_column)(TreeNodeView *self, TreeColumnType type, const std::string &name, int initial_width, bool editable, bool attributed);
#endif
    void (*end_columns)(TreeNodeView *self);
    
    void (*clear)(TreeNodeView *self);

    TreeNodeRef (*root_node)(TreeNodeView *self);

    void (*set_row_height)(TreeNodeView *self, int height);
    
    void (*set_allow_sorting)(TreeNodeView *self, bool);
    
    void (*freeze_refresh)(TreeNodeView *self, bool);
    
    void (*set_selection_mode)(TreeNodeView *self, TreeSelectionMode mode);
    TreeSelectionMode (*get_selection_mode)(TreeNodeView *self);
    
    std::list<TreeNodeRef> (*get_selection)(TreeNodeView *self);
    TreeNodeRef (*get_selected_node)(TreeNodeView *self);

    void (*clear_selection)(TreeNodeView *self);
    void (*set_selected)(TreeNodeView *self, TreeNodeRef node, bool state);
    
    int (*row_for_node)(TreeNodeView *self, TreeNodeRef node);
    TreeNodeRef (*node_at_row)(TreeNodeView *self, int row);
    TreeNodeRef (*node_with_tag)(TreeNodeView *self, const std::string &tag);

    void (*set_column_visible)(TreeNodeView *self, int column, bool flag);
    bool (*get_column_visible)(TreeNodeView *self, int column);
      
    void (*set_column_width)(TreeNodeView *self, int column, int width); // XXX linux
    int (*get_column_width)(TreeNodeView *self, int column); // XXX linux
  };
#endif
#endif
  
  class ContextMenu;
  
  class MFORMS_EXPORT TreeNodeView : public View
  {
  public:
    TreeNodeView(TreeOptions options);
    ~TreeNodeView();

    int add_column(TreeColumnType type, const std::string &name, int initial_width, bool editable = false, bool attributed = false);
    void end_columns();

    int get_column_count() const { return (int)_column_types.size(); }
    TreeColumnType get_column_type(int column);
    
    void clear();
    TreeNodeRef root_node();

    TreeNodeRef add_node();

    void set_selection_mode(TreeSelectionMode mode);
    TreeSelectionMode get_selection_mode();

    std::list<TreeNodeRef> get_selection();
    TreeNodeRef get_selected_node();
    int get_selected_row();
    void clear_selection();
    
    void select_node(TreeNodeRef node);
    void set_node_selected(TreeNodeRef node, bool flag);
    
    int row_for_node(TreeNodeRef node);
    TreeNodeRef node_at_row(int row);

    TreeNodeRef node_with_tag(const std::string &tag);

    void set_row_height(int height);
    
    void set_allow_sorting(bool flag);

    void freeze_refresh();
    
    void thaw_refresh();

    void set_column_visible(int column, bool flag);

    bool get_column_visible(int column);
    
#ifndef SWIG

    boost::signals2::signal<void ()>* signal_changed() {return &_signal_changed;}
    boost::signals2::signal<void (TreeNodeRef, int)>* signal_node_activated() {return &_signal_activated;}

    boost::signals2::signal<void (TreeNodeRef, bool)>* signal_expand_toggle() {return &_signal_expand_toggle;}
    
    boost::signals2::signal<void (int)>* signal_column_resized() {return &_signal_column_resized;}
    
    void set_cell_edit_handler(const boost::function<void (TreeNodeRef, int, std::string)> &handler);
#endif

    void set_context_menu(ContextMenu *menu);
    
    ContextMenu *get_context_menu() { return _context_menu; }
    
    int get_column_width(int column);
      
    void set_column_width(int column, int width);
      
  public:
    // backwards compatibility with TreeView
    
    int count() { return root_node()->count(); }
    
#ifndef DOXYGEN_SHOULD_SKIP_THIS   
#ifndef SWIG
  public: 
    // Following methods are for internal use.
    virtual void changed();
    virtual void node_activated(TreeNodeRef row, int column);
    virtual bool can_expand(TreeNodeRef row);
    
    // to be called BEFORE a node is expanded or AFTER its collapsed
    virtual void expand_toggle(TreeNodeRef row, bool expanded);

    // for use when sorting NumericWithUnitColumns in platform code
    static double parse_string_with_unit(const char *s);

    // To be called when user edits a cell. If this returns true, the cell value should be
    // updated by the caller, otherwise it should be left unchanged.
    virtual bool cell_edited(TreeNodeRef row, int column, const std::string &value);

    // Drag/drop support. The treeview has a different handling as dragging is initiated by the platform
    // and we call back to get data and formats (pull request). The general handling, in opposition,
    // is using a push request, initiating the drag in the backend.

    // Return format, data and other details for a drag operation that is about to start.
    // Called only if this tree can be a drag source at all (see create flags).
    // If the result of this call is false then no native drag operation is started.
    virtual bool get_drag_data(DragDetails &details, void **data, std::string &format);

    // Called only if get_drag_data returned true (and the tree can be a drag source).
    // The given operation tells what happened.
    virtual void drag_finished(DragOperation operation);
    
    virtual void column_resized(int column);

#endif
#endif

  private:
    TreeNodeViewImplPtrs *_treeview_impl;
    boost::signals2::signal<void ()>  _signal_changed;
    boost::signals2::signal<void (TreeNodeRef, int)>  _signal_activated;
    boost::signals2::signal<void (TreeNodeRef, bool)> _signal_expand_toggle;
    boost::function<void (TreeNodeRef, int, std::string)> _cell_edited;
    boost::signals2::signal<void (int)> _signal_column_resized;
    ContextMenu *_context_menu;
    std::vector<TreeColumnType> _column_types;
    int _update_count;
    bool _index_on_tag;
    bool _end_column_called;
  };
}

#endif /* _TREENODEVIEW_H_ */