graph.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      Graph type definitions
 *
 *      Due to the use of STL and virtual functions, some parts of this
 *      interface might be incompatible with compilers other than Visual Studio
 *      on Windows and gcc on Unix systems
 */
 
#ifndef __GRAPH_DEF_HPP
#define __GRAPH_DEF_HPP
 
#include <math.h>
#include <pro.h>
#include <gdl.hpp>
#include <idp.hpp>
#include <kernwin.hpp>

 
//-------------------------------------------------------------------------
#define NIF_BG_COLOR    (1 << 0)  
#define NIF_FRAME_COLOR (1 << 1)  
#define NIF_EA          (1 << 2)  
#define NIF_TEXT        (1 << 3)  
#define NIF_FLAGS       (1 << 4)  
#define NIF_ALL         (NIF_BG_COLOR | NIF_FRAME_COLOR | NIF_EA | NIF_TEXT | NIF_FLAGS)
 
//-------------------------------------------------------------------------
#define GLICTL_CENTER   (1 << 0)  

struct node_info_t
{
private:
  size_t cb = sizeof(node_info_t);  
public:
  bgcolor_t bg_color = DEFCOLOR;    
  bgcolor_t frame_color = DEFCOLOR; 
#define NIFF_SHOW_CONTENTS (1 << 0) //< force show contents of huge node
  uint32 flags = 0;                 
  ea_t ea = BADADDR;                
  qstring text;                     

  inline bool valid_bg_color() const { return bg_color != DEFCOLOR; }
  inline bool valid_frame_color() const { return frame_color != DEFCOLOR; }
  inline bool valid_ea() const { return ea != BADADDR; }
  inline bool valid_text() const { return !text.empty(); }
  inline bool valid_flags() const { return flags != 0; }

  inline uint32 get_flags_for_valid() const
  {
    uint32 F = 0;
    if ( valid_bg_color() )
      F |= NIF_BG_COLOR;
    if ( valid_frame_color() )
      F |= NIF_FRAME_COLOR;
    if ( valid_ea() )
      F |= NIF_EA;
    if ( valid_text() )
      F |= NIF_TEXT;
    if ( valid_flags() )
      F |= NIF_FLAGS;
    return F;
  }
};

typedef ea_t graph_id_t;
 

 
idaman bool ida_export get_node_info(node_info_t *out, graph_id_t gid, int node);
 

 
idaman void ida_export set_node_info(graph_id_t gid, int node, const node_info_t &ni, uint32 flags);
 

 
idaman void ida_export del_node_info(graph_id_t gid, int node);
 

 
idaman void ida_export clr_node_info(graph_id_t gid, int node, uint32 flags);
 
 
//-------------------------------------------------------------------------
class graph_node_visitor_t
{
  node_set_t visited; 
public:
  void idaapi reinit(void) { visited.clear(); }
  void idaapi set_visited(int n) { visited.add(n); }
  bool idaapi is_visited(int n) const { return visited.has(n); }

  virtual int  idaapi visit_node(int /*node*/) { return 0; }
  virtual bool idaapi is_forbidden_edge(int /*n*/, int /*m*/) const { return false; }
 
  virtual ~graph_node_visitor_t() {}
};
 
//-------------------------------------------------------------------------
struct graph_path_visitor_t
{
  intvec_t path;                
  bool prune = false;           
 
 
  virtual int idaapi walk_forward(int /*node*/) { return 0; }
  virtual int idaapi walk_backward(int /*node*/) { return 0; }
 
  virtual ~graph_path_visitor_t() {}
};
 
//-------------------------------------------------------------------------
struct point_t
{
  int x = 0;
  int y = 0;
  point_t() {}
  point_t(int _x, int _y) : x(_x), y(_y) {}
  point_t &add(const point_t &r)
  {
    x += r.x;
    y += r.y;
    return *this;
  }
  point_t &sub(const point_t &r)
  {
    x -= r.x;
    y -= r.y;
    return *this;
  }
  template <class T> void div(T d)
  {
    x /= d;
    y /= d;
  }
  void negate(void)
  {
    x = -x;
    y = -y;
  }
#ifdef VCL_H
  point_t(const TPoint &p) : x(p.x), y(p.y) {}
#endif
  bool operator ==(const point_t &r) const { return x == r.x && y == r.y; }
  bool operator !=(const point_t &r) const { return !(*this == r); }
  const char *idaapi dstr(void) const;
  size_t idaapi print(char *buf, size_t bufsize) const;
};
DECLARE_TYPE_AS_MOVABLE(point_t);
typedef qvector<point_t> pointvec_t;

inline THREAD_SAFE double calc_dist(point_t p, point_t q)
{
  double dx = q.x - p.x;
  double dy = q.y - p.y;
  return sqrt(dx*dx+dy*dy);
}

class pointseq_t : public pointvec_t
{
public:
  const char *idaapi dstr(void) const;
  size_t idaapi print(char *buf, size_t bufsize) const;
};

struct rect_t
{
  int left = 0;
  int top = 0;
  int right = 0;
  int bottom = 0;
  rect_t() {}
  rect_t(int l, int t, int r, int b) : left(l), top(t), right(r), bottom(b) { verify(); }
  rect_t(const point_t &p0, const point_t &p1)
    : left  (qmin(p0.x, p1.x)),
      top   (qmin(p0.y, p1.y)),
      right (qmax(p0.x, p1.x)),
      bottom(qmax(p0.y, p1.y))  { verify(); }
  void verify(void)
  {
    if ( left > right )
      qswap(left, right);
    if ( top > bottom )
      qswap(top, bottom);
  }
  int width(void) const { return right - left; }
  int height(void) const { return bottom - top; }
  void move_to(const point_t &p)
  {
    int dx  = p.x - left;
    int dy  = p.y - top;
    move_by(point_t(dx, dy));
  }
  void move_by(const point_t &p)
  {
    left   += p.x;
    right  += p.x;
    top    += p.y;
    bottom += p.y;
  }
  point_t center(void) const
  {
    return point_t((left+right)/2, (top+bottom)/2);
  }
  point_t topleft(void) const
  {
    return point_t(left, top);
  }
  point_t bottomright(void) const
  {
    return point_t(right, bottom);
  }
  void grow(int delta)
  {
    left   -= delta;
    right  += delta;
    top    -= delta;
    bottom += delta;
  }
  void intersect(const rect_t &r)
  {
    if ( left < r.left )
      left = r.left;
    if ( right > r.right )
      right = r.right;
    if ( top < r.top )
      top = r.top;
    if ( bottom > r.bottom )
      bottom = r.bottom;
  }
  void make_union(const rect_t &r)
  {
    if ( left > r.left )
      left = r.left;
    if ( right < r.right )
      right = r.right;
    if ( top > r.top )
      top = r.top;
    if ( bottom < r.bottom )
      bottom = r.bottom;
  }
  bool empty(void) const
  {
    return left >= right || top >= bottom;
  }
  bool is_intersection_empty(const rect_t &r) const
  {
    return left   >= r.right
        || right  <= r.left
        || top    >= r.bottom
        || bottom <= r.top;
  }
  bool contains(const point_t &p) const
  {
    return left <= p.x
        && right > p.x
        && top <= p.y
        && bottom > p.y;
  }
  int area(void) const { return width()*height(); }
  bool idaapi operator == (const rect_t &r) const
  {
    return left   == r.left
        && right  == r.right
        && top    == r.top
        && bottom == r.bottom;
  }
  bool idaapi operator != (const rect_t &r) const { return !(*this == r); }
  bool idaapi operator < (const rect_t &r) const;
#ifdef VCL_H
  const TRect &operator()(void) const { return *(TRect *)this; }
        TRect &operator()(void)       { return *(TRect *)this; }
  rect_t(const TRect &r) : left(r.left), top(r.top), right(r.right), bottom(r.bottom) {}
#endif
};
DECLARE_TYPE_AS_MOVABLE(rect_t);
 
//---------------------------------------------------------------------------
struct TPointDouble
{
  double x = 0.0;
  double y = 0.0;
  TPointDouble() {}
  TPointDouble(double a, double b) : x(a), y(b) {}
  TPointDouble(const point_t &r) : x(r.x), y(r.y) {}
  void add(const TPointDouble &r)
  {
    x += r.x;
    y += r.y;
  }
  void sub(const TPointDouble &r)
  {
    x -= r.x;
    y -= r.y;
  }
  void negate(void)
  {
    x = -x;
    y = -y;
  }
  template <class T> void div(T d)
  {
    x /= d;
    y /= d;
  }
  bool operator ==(const TPointDouble &r) const { return x == r.x && y == r.y; }
  bool operator !=(const TPointDouble &r) const { return !(*this == r); }
};
 
//---------------------------------------------------------------------------
typedef int layout_type_t; 
const layout_type_t
  layout_none        = 0,
  layout_digraph     = 1,
  layout_tree        = 2,
  layout_circle      = 3,
  layout_polar_tree  = 4,
  layout_orthogonal  = 5,
  layout_radial_tree = 6;

struct edge_info_t
{
  bgcolor_t color = DEFCOLOR; 
  int width = 1;              
  int srcoff = -1;            
  int dstoff = -1;            
  pointseq_t layout;  
#if !defined(_MSC_VER) || _MSC_VER >= 1600
  void idaapi reverse_layout(void) { std::reverse(layout.begin(), layout.end()); }
#endif
  void idaapi add_layout_point(point_t p);
};

struct edge_layout_point_t
{
  int pidx = -1;              
  edge_t e = edge_t(-1, -1);  
  idaapi edge_layout_point_t() {}
  idaapi edge_layout_point_t(const edge_t &_e, int _pidx) : pidx(_pidx), e(_e) {}
  int idaapi compare(const edge_layout_point_t &r) const
  {
    if ( e < r.e )
      return -1;
    if ( r.e < e )
      return 1;
    return ::compare(pidx, r.pidx);
  }
  bool idaapi operator == (const edge_layout_point_t &r) const
  {
    return pidx == r.pidx && e == r.e;
  }
  bool idaapi operator != (const edge_layout_point_t &r) const
  {
    return !(*this == r);
  }
};

struct selection_item_t
{
  bool is_node = false;    
  int node = -1;           
  edge_layout_point_t elp; 
  idaapi selection_item_t() {}
  idaapi selection_item_t(int n) : is_node(true), node(n) {}
  idaapi selection_item_t(edge_layout_point_t &_elp)
    : is_node(false), node(-1), elp(_elp) {}
  idaapi selection_item_t(edge_t e, int idx)
    : is_node(false), node(-1), elp(e, idx) {}
  idaapi selection_item_t(class graph_item_t &);
  int idaapi compare(const selection_item_t &r) const
  {
    if ( is_node != r.is_node )
      return is_node - r.is_node;
    if ( is_node )
      return ::compare(node, r.node);
    return elp.compare(r.elp);
  }
  bool idaapi operator == (const selection_item_t &r) const
    { return compare(r) == 0; }
  bool idaapi operator != (const selection_item_t &r) const
    { return compare(r) != 0; }
  bool idaapi operator < (const selection_item_t &r) const
    { return compare(r) < 0; }
};
 

typedef qvector<selection_item_t> screen_graph_selection_base_t;
 
struct screen_graph_selection_t : public screen_graph_selection_base_t
{
  bool idaapi has(const selection_item_t &item) const
    { return (const_iterator)find(item) != end(); }
  void idaapi add(const screen_graph_selection_t &s)
  {
    for ( screen_graph_selection_t::const_iterator p=s.begin(); p != s.end(); ++p )
      add_unique(*p);
  }
  void idaapi sub(const screen_graph_selection_t &s)
  {
    for ( screen_graph_selection_t::const_iterator p=s.begin(); p != s.end(); ++p )
      del(*p);
  }
  void idaapi add_node(int node) { add_unique(selection_item_t(node)); }
  void idaapi del_node(int node) { del(selection_item_t(node)); }
  void idaapi add_point(edge_t e, int idx) { add_unique(selection_item_t(e, idx)); }
  void idaapi del_point(edge_t e, int idx) { del(selection_item_t(e, idx)); }
 
  size_t idaapi nodes_count() const { return items_count(true); }
  size_t idaapi points_count() const { return items_count(false); }
  size_t idaapi items_count(bool look_for_nodes) const
  {
    size_t cnt = 0;
    for ( size_t i = 0, sz = size(); i < sz; ++i )
      if ( at(i).is_node == look_for_nodes )
        ++cnt;
    return cnt;
  }
};

struct edge_segment_t
{
  edge_t e;
  int nseg;
  int x0, x1;
  size_t idaapi length() const { return abs(x1-x0); }
  bool idaapi toright() const { return x1 > x0; } // horizontal segment to the right
  bool idaapi operator < (const edge_segment_t &r) const
  {
    return e < r.e;
/*    // longest edges first
    int ll =   x1 -   x0; if ( ll < 0 ) ll = -ll;
    int rl = r.x1 - r.x0; if ( rl < 0 ) rl = -rl;
    if ( rl < ll )
      return true;
    if ( rl == ll )
      return e < r.e;
    return false;*/
  }
};
 
//---------------------------------------------------------------------------
enum graph_item_type_t
{           //                     valid graph_item_t fields:
  git_none, 
  git_edge, 
  git_node, 
  git_tool, 
  git_text, 
  git_elp,  
};

class graph_item_t
{
public:
  graph_item_type_t type;  
  edge_t e;                
  int n;                   
  int b;                   
  point_t p;               
  edge_layout_point_t elp; 
  bool operator == (const graph_item_t &r) const;
  bool is_node(void) const { return type >= git_node && type <= git_text; }
  bool is_edge(void) const { return type == git_edge || type == git_elp; }
};
 
//-------------------------------------------------------------------------
struct interval_t
{
  int x0 = 0, x1 = 0; // x0 always <= x1, otherwise the interval is empty
  bool empty(void) const { return x0 < x1; }
  void intersect(const interval_t &r)
  {
    if ( x0 < r.x0 )
      x0 = r.x0;
    if ( x1 > r.x1 )
      x1 = r.x1;
  }
  void make_union(const interval_t &r)
  {
    if ( x0 > r.x0 )
      x0 = r.x0;
    if ( x1 < r.x1 )
      x1 = r.x1;
  }
  void move_by(int shift)
  {
    x0 += shift;
    x1 += shift;
  }
  interval_t() {}
  interval_t(int y0, int y1)
  {
    x0 = qmin(y0, y1);
    x1 = qmax(y0, y1);
  }
  interval_t(const edge_segment_t &s)
  {
    x0 = qmin(s.x0, s.x1);
    x1 = qmax(s.x0, s.x1);
  }
  int length(void) const { return x1 - x0; }
  bool contains(int x) const { return x0 <= x && x <= x1; }
  bool operator ==(const interval_t &r) const { return x0 == r.x0 && x1 == r.x1; }
  bool operator !=(const interval_t &r) const { return !(*this == r); }
};
 
//-------------------------------------------------------------------------
struct row_info_t
{
  intvec_t nodes;  
  int top = 0;     
  int bottom = 0;  
 
  int height(void) const { return bottom - top; }
};
typedef qvector<row_info_t> graph_row_info_t; 
 
static const int ygap = 30;
static const int xgap = 10;
static const int arrow_height = 10;
static const int arrow_width = 8;
 
struct graph_location_info_t;
class graph_visitor_t;
class edge_typer_t;
 
//-------------------------------------------------------------------------
class drawable_graph_t : public gdl_graph_t
{
  void idaapi find_entries(node_set_t &entries) const;
  void idaapi depth_first(int root, struct depth_first_info_t &di) const;
  size_t idaapi remove_reachable(int n, node_set_t *s) const;
  int    idaapi longest_path(int n, intvec_t &tops, int row_height) const;
  size_t idaapi sort_layer_nodes(
        const row_info_t &r1,
        const intmap_t &lpi1,
        row_info_t &r2,
        intmap_t &lpi2,
        bool ispred) const;
  size_t idaapi calc_cross_num(
        const intvec_t &r1,
        const intvec_t &r2,
        const intmap_t &lpi1,
        bool ispred) const;
  size_t idaapi num_crossings(const graph_row_info_t &gri, const array_of_intmap_t &nodepi) const;
  int    idaapi calc_x_coord(const row_info_t &ri, int idx, bool ispred, int first_added_node) const;
  void   idaapi try_move_down(intvec_t &tops, int n, int row_height) const;
 
protected:
  void idaapi get_connected_components(intvec_t &entries) const;

  int idaapi calc_longest_pathes(
        const node_set_t &entries,
        intvec_t &tops,
        int row_height) const;

  void idaapi move_nodes_down(
        intvec_t &tops,
        const node_ordering_t &post,
        int first_reverser_node,
        int row_height) const;

  void idaapi create_graph_row_info(
        const intvec_t &tops,
        graph_row_info_t &gri,
        int graph_height) const;

  void idaapi calc_row_heights(graph_row_info_t &gri) const;

  void idaapi minimize_crossings(graph_row_info_t &gri) const;

  void idaapi set_x_coords(
        const graph_row_info_t &gri,
        const node_set_t &selfrefs,
        int first_added_node);

  void idaapi gather_edge_segments(
        const graph_row_info_t &gri,
        edge_segs_vec_t &ges) const;

  void idaapi make_rect_edges(
        graph_row_info_t &gri,
        const edge_segs_vec_t &ges,
        int first_reverser_node);

  void idaapi assign_edge_ports(
        const graph_row_info_t &gri,
        const node_set_t &selfrefs);

  void idaapi recalc_edge_widths(
        const edgeset_t &back_edges,
        const edge_infos_t &self_edges);

  void idaapi clear_layout_info(void);
 
  void idaapi depth_first(
        node_ordering_t *pre,
        node_ordering_t *post,
        edge_typer_t *et) const;
 
  void idaapi create_spanning_tree(
        edge_typer_t *et,
        node_set_t *entries,
        edgeset_t *back_edges,
        node_ordering_t *pre,
        node_ordering_t *post) const;
 
  void idaapi tree_layout(edge_typer_t &et, const node_set_t &entries);

  bool idaapi path_back(const array_of_node_set_t &domin, int m, int n) const;
  bool idaapi path_back(edge_typer_t &et, int m, int n) const;

  int idaapi visit_nodes(int node, graph_node_visitor_t &gv) const;

  int idaapi visit_paths(int node, graph_path_visitor_t &gv) const;
 
public:
  qstring title;                        
  bool rect_edges_made = false;         
  layout_type_t current_layout = layout_none; 
  point_t circle_center;                
  int circle_radius = 0;                
  hook_cb_t *callback = nullptr;        
  void *callback_ud = nullptr;          
 
  virtual ~drawable_graph_t() {}
  void idaapi clear(void);
  void idaapi dump_graph(const char *header) const;
  bool idaapi calc_bounds(rect_t *r);
  void idaapi calc_fitting_params(
        const rect_t &area,
        const rect_t &r,
        graph_location_info_t *gli,
        double max_zoom);
  bool idaapi calc_fitting_params(
        const rect_t &area,
        graph_location_info_t *gli,
        double max_zoom);
  int idaapi for_all_nodes_edges(graph_visitor_t &nev, bool visit_nodes=true);
  // get edge ports - fills s, d arguments and returns edge_info_t
  const edge_info_t *idaapi get_edge_ports(
        edge_t e,
        point_t &s,
        point_t &d) const;
  // add edges from/to the node
  void idaapi add_node_edges(edgevec_t &dlist, int node);
  const rect_t &idaapi nrect(int n) const
    { return (CONST_CAST(drawable_graph_t *)(this))->nrect(n); }
  const edge_info_t *idaapi get_edge(edge_t e) const
    { return (CONST_CAST(drawable_graph_t *)(this))->get_edge(e); }
  virtual rect_t &idaapi nrect(int n) = 0;
  virtual edge_info_t *idaapi get_edge(edge_t e) = 0;
  virtual drawable_graph_t *idaapi clone(void) const = 0;
 
  bool idaapi create_tree_layout(void);
  bool idaapi create_circle_layout(point_t p, int radius);
  bool idaapi create_polar_tree_layout(point_t p, int radius);
  bool idaapi create_radial_tree_layout(point_t p, int radius);
  bool idaapi create_orthogonal_layout(void);
 
  void set_callback(hook_cb_t *_callback, void *_ud)
  {
    callback = _callback;
    callback_ud = _ud;
  }
  ssize_t vgrcall(int code, va_list va)
  {
    if ( callback != nullptr )
      return callback(callback_ud, code, va);
    return 0;
  }
  ssize_t grcall(int code, ...)
  {
    va_list va;
    va_start(va, code);
    ssize_t result = vgrcall(code, va);
    va_end(va);
    return result;
  }
};

#if defined(__GNUC__) && (defined(__KERNEL__) || !defined(__UI__))  // compiling a plugin or the kernel with gcc?
#define GCC_PUREVIRT = 0
#else
#define GCC_PUREVIRT
#endif
 
//-------------------------------------------------------------------------
struct edge_infos_wrapper_t
{
  edge_infos_wrapper_t();
  edge_infos_wrapper_t(const edge_infos_wrapper_t &other);
  edge_infos_wrapper_t &idaapi operator=(const edge_infos_wrapper_t &other);
  ~edge_infos_wrapper_t() { clear(); }
  void clear();
 
  edge_infos_t *ptr;
};
 
#ifdef _DEBUG
#define CHKNODEIDX(n) QASSERT(1385, int(n) >= 0)
#else
#define CHKNODEIDX(n)
#endif

//
class interactive_graph_t : public drawable_graph_t
{
  typedef drawable_graph_t inherited;
  int idaapi _find_subgraph_node(int group, int n) const;
  void idaapi collapse_edges(const intvec_t &nodes, int group);
  void idaapi del_node_keep_edges(int n);
  void idaapi add_dest(destset_t &ne, edge_t e, int g);
  void idaapi reverse_edges(
        const edgeset_t &back_edges,
        edge_infos_t &self_edges,
        node_set_t &entries);
  void idaapi layout_self_reference_edges(const edge_infos_t &selfrefs);
  void idaapi restore_edges(int first_reserver_node, bool failed);
 
  void idaapi add_layer_nodes(graph_row_info_t &gri, intvec_t &tops);
  void idaapi del_layer_nodes(graph_row_info_t &gri, int first_added_node);
  void idaapi fix_collapsed_group_edges(void);
 
public:
  uval_t gid;                         
  intvec_t belongs;                   
  bytevec_t node_flags;               
#define MTG_GROUP_NODE           0x01 
#define MTG_DOT_NODE             0x02 
#define MTG_NON_DISPLAYABLE_NODE 0x08 
 
  // groups: original edges without considering any group info
  array_of_intvec_t org_succs;
  array_of_intvec_t org_preds;
 
  array_of_intvec_t succs;
  array_of_intvec_t preds;
  typedef qvector<rect_t> node_layout_t;
  node_layout_t nodes;
  edge_infos_wrapper_t edges;
 
  idaapi interactive_graph_t(uval_t id);
  idaapi interactive_graph_t(const drawable_graph_t &g, uval_t id);
  virtual ~interactive_graph_t() {}

  virtual int  idaapi size(void) const override { return int(succs.size()); }

  virtual int  idaapi node_qty(void) const override;

  void idaapi clear(void);

  virtual bool idaapi empty(void) const override;

  virtual bool idaapi exists(int node) const override { return is_visible_node(node); }
#define COLLAPSED_NODE 0x80000000

  //
  int  idaapi get_node_representative(int node);
 
  int  idaapi get_node_group(int node) const { CHKNODEIDX(node); return (belongs[node] & ~COLLAPSED_NODE); }
  void idaapi set_node_group(int node, int group) { CHKNODEIDX(node); belongs[node] = group | (belongs[node] & COLLAPSED_NODE); }
  bool idaapi is_deleted_node(int node) const { CHKNODEIDX(node); return belongs[node] == INT_MAX; }
  void idaapi set_deleted_node(int node) { CHKNODEIDX(node); belongs[node] = INT_MAX; }
  bool idaapi is_subgraph_node(int node) const { return get_node_group(node) != node; }
  bool idaapi is_dot_node(int node) const { CHKNODEIDX(node); return (node_flags[node] & MTG_DOT_NODE) != 0; }
  bool idaapi is_group_node(int node) const { CHKNODEIDX(node); return (node_flags[node] & MTG_GROUP_NODE) != 0; }
  bool idaapi is_displayable_node(int node) const { CHKNODEIDX(node); return (node_flags[node] & MTG_NON_DISPLAYABLE_NODE) == 0; }
  bool idaapi is_simple_node(int node) const { return !is_group_node(node); }
  bool idaapi is_collapsed_node(int node) const { CHKNODEIDX(node); return (belongs[node] & COLLAPSED_NODE) != 0; }
  bool idaapi is_uncollapsed_node(int node) const { return is_group_node(node) && !is_collapsed_node(node); }

  bool idaapi is_visible_node(int node) const;

  bool idaapi groups_are_present(void) const;
 
  // iterate subgraph nodes, return -1 at the end
  int  idaapi get_first_subgraph_node(int group) const { return _find_subgraph_node(group, 0); }
  int  idaapi get_next_subgraph_node(int group, int current) const { return _find_subgraph_node(group, current+1); }
  void idaapi insert_visible_nodes(intvec_t &nodes, int group) const;
  void idaapi insert_simple_nodes(intvec_t &nodes, int group) const;
  bool idaapi check_new_group(const intvec_t &nodes, intvec_t &refined);

  int  idaapi create_group(const intvec_t &nodes);

  bool idaapi delete_group(int group);

  bool idaapi change_group_visibility(int group, bool expand);

  bool idaapi change_visibility(const intvec_t &nodes, bool expand);
 
  virtual int  idaapi nsucc(int b) const override { CHKNODEIDX(b); return (int)succs[b].size(); }
  virtual int  idaapi npred(int b) const override { CHKNODEIDX(b); return (int)preds[b].size(); }
  virtual int  idaapi succ(int b, int i) const override { CHKNODEIDX(b); return succs[b][i]; }
  virtual int  idaapi pred(int b, int i) const override { CHKNODEIDX(b); return preds[b][i]; }
  const intvec_t &idaapi succset(int b) const { CHKNODEIDX(b); return succs[b]; }
  const intvec_t &idaapi predset(int b) const { CHKNODEIDX(b); return preds[b]; }
 
  void idaapi reset(void) { resize(0); }

  virtual bool idaapi redo_layout(void) GCC_PUREVIRT;

  virtual void idaapi resize(int n) GCC_PUREVIRT;

  virtual int  idaapi add_node(const rect_t *r) GCC_PUREVIRT;

  virtual ssize_t idaapi del_node(int n) GCC_PUREVIRT;  // returns number of deleted edges
 
  virtual bool idaapi add_edge(int i, int j, const edge_info_t *ei) GCC_PUREVIRT;
  virtual bool idaapi del_edge(int i, int j) GCC_PUREVIRT;  // true: found and deleted the edge
  virtual bool idaapi replace_edge(int i, int j, int x, int y) GCC_PUREVIRT;

  virtual bool idaapi refresh(void) GCC_PUREVIRT;
 
  virtual interactive_graph_t *idaapi clone(void) const override GCC_PUREVIRT;
 
  // get node rectangle
  const rect_t &idaapi nrect(int n) const
    { return (CONST_CAST(interactive_graph_t *)(this))->nrect(n); }
  virtual rect_t &idaapi nrect(int n) override;
  virtual edge_info_t *idaapi get_edge(edge_t e) override GCC_PUREVIRT;
 
  virtual bool idaapi set_nrect(int n, const rect_t &r) GCC_PUREVIRT;
  virtual bool idaapi set_edge(edge_t e, const edge_info_t *ei) GCC_PUREVIRT;
 
  bool idaapi create_digraph_layout(void);
 
  void idaapi del_custom_layout(void);
  bool idaapi get_custom_layout(void);
  void idaapi set_custom_layout(void) const;
  bool idaapi get_graph_groups(void);
  void idaapi set_graph_groups(void) const;
  virtual ea_t idaapi calc_group_ea(const intvec_t & /*nodes*/) newapi { return BADADDR; }
 
  point_t idaapi calc_center_of(const intvec_t &nodes) const;
  void idaapi move_to_same_place(const intvec_t &collapsing_nodes, point_t p);
  void idaapi move_grouped_nodes(const intvec_t &groups, const interactive_graph_t *ng);
 
  virtual bool idaapi is_user_graph() newapi { return false; }
};
 
//-------------------------------------------------------------------------
class graph_visitor_t
{
public:
  virtual ~graph_visitor_t() {}
protected:
  drawable_graph_t *g;
  virtual int idaapi visit_node(int n, rect_t &r) = 0;
  virtual int idaapi visit_edge(edge_t e, edge_info_t *ei) = 0;
  friend int idaapi drawable_graph_t::for_all_nodes_edges(graph_visitor_t &nev, bool visit_nodes);
};
 
//-------------------------------------------------------------------------
enum graph_notification_t
{
  // Callbacks called by IDA (plugins can hook to them):
 
  grcode_calculating_layout,  
 
  grcode_layout_calculated,   
 
  grcode_changed_graph,       
 
  grcode_reserved,
 
  grcode_clicked,             
 
  grcode_dblclicked,          
 
  grcode_creating_group,      
 
  grcode_deleting_group,      
 
  grcode_group_visibility,    
 
  grcode_gotfocus,            
 
  grcode_lostfocus,           
 
  grcode_user_refresh,        
 
  grcode_reserved2,
 
  grcode_user_text,           
 
  grcode_user_size,           
 
  grcode_user_title,          
 
  grcode_user_draw,           
 
  grcode_user_hint,           
 
  grcode_destroyed,           
 
  //-------------------------------------------------------------------------
  // Callbacks callable from plugins (see inline functions below):
  //-------------------------------------------------------------------------
 
  // graph_viewer_t (or IDA View graph) manipulation.
  grcode_create_graph_viewer = 256,   
  grcode_get_graph_viewer,            
  grcode_get_viewer_graph,            
  grcode_create_interactive_graph,    
  grcode_set_viewer_graph,            
  grcode_refresh_viewer,              
  grcode_fit_window,                  
  grcode_get_curnode,                 
  grcode_center_on,                   
  grcode_get_selection,               
 
  // interactive_graph_t (and drawable_graph_t) manipulation.
  grcode_del_custom_layout,           
  grcode_set_custom_layout,           
  grcode_set_graph_groups,            
  grcode_clear,                       
  grcode_create_digraph_layout,       
  grcode_create_tree_layout,          
  grcode_create_circle_layout,        
  grcode_get_node_representative,     
  grcode_find_subgraph_node,          
  grcode_create_group,                
  grcode_get_custom_layout,           
  grcode_get_graph_groups,            
  grcode_empty,                       
  grcode_is_visible_node,             
  grcode_delete_group,                
  grcode_change_group_visibility,     
  grcode_set_edge,                    
  grcode_node_qty,                    
  grcode_nrect,                       
 
  // More graph_viewer_t manipulation.
  grcode_set_titlebar_height,         
  grcode_create_user_graph_place,     
  grcode_create_disasm_graph1,        
  grcode_create_disasm_graph2,        
  grcode_set_node_info,               
  grcode_get_node_info,               
  grcode_del_node_info,               
 
  // Deprecated. Those were meant to work with intset_t, that we now got rid of.
  grcode_viewer_create_groups,
  grcode_viewer_delete_groups,
  grcode_viewer_groups_visibility,
 
  //
  grcode_viewer_create_groups_vec,    
  grcode_viewer_delete_groups_vec,    
  grcode_viewer_groups_visibility_vec,
  grcode_delete_interactive_graph,    
  grcode_edge_infos_wrapper_copy,     
  grcode_edge_infos_wrapper_clear,    
 
  //
  grcode_attach_menu_item,
 
  //
  grcode_set_gli,                     
  grcode_get_gli,                     
};
 
 
//-------------------------------------------------------------------------
#ifndef SWIG
 
 
inline ssize_t grentry(graph_notification_t event_code, ...)
{
  va_list va;
  va_start(va, event_code);
  ssize_t code = invoke_callbacks(HT_GRAPH, event_code, va);
  va_end(va);
  return code;
}

#endif
 
 
//-------------------------------------------------------------------------
struct group_crinfo_t
{
  intvec_t nodes;
  qstring text;
};
typedef qvector<group_crinfo_t> groups_crinfos_t;
 
#ifndef __UI__
 
typedef TWidget graph_viewer_t; 
 

 
inline graph_viewer_t *idaapi create_graph_viewer(
        const char *title,
        uval_t id,
        hook_cb_t *callback,
        void *ud,
        int title_height,
        TWidget *parent=nullptr)
{
  graph_viewer_t *gv = nullptr;
  grentry(grcode_create_graph_viewer, title, &gv, id, callback, ud, title_height, parent);
  return gv;
}
 

 
inline graph_viewer_t *idaapi get_graph_viewer(TWidget *parent)              { graph_viewer_t *gv = nullptr; grentry(grcode_get_graph_viewer, parent, &gv); return gv; }
 

 
inline interactive_graph_t *idaapi create_interactive_graph(uval_t id)               { interactive_graph_t *g = nullptr; grentry(grcode_create_interactive_graph, id, &g); return g; }
 

 
inline interactive_graph_t *idaapi create_disasm_graph(ea_t ea)                  { interactive_graph_t *g = nullptr; grentry(grcode_create_disasm_graph1, ea, &g); return g; }
 

 
inline interactive_graph_t *idaapi create_disasm_graph(const rangevec_t &ranges) { interactive_graph_t *g = nullptr; grentry(grcode_create_disasm_graph2, &ranges, &g); return g; }
 

 
inline interactive_graph_t *idaapi get_viewer_graph(graph_viewer_t *gv)          { interactive_graph_t *g = nullptr; grentry(grcode_get_viewer_graph, gv, &g); return g; }
 

 
inline void idaapi set_viewer_graph(graph_viewer_t *gv, interactive_graph_t *g)  {        grentry(grcode_set_viewer_graph, gv, g); }
 

 
inline void idaapi refresh_viewer(graph_viewer_t *gv)                        {        grentry(grcode_refresh_viewer, gv); }
 

 
inline void idaapi viewer_fit_window(graph_viewer_t *gv)                     {        grentry(grcode_fit_window, gv); }
 

 
inline int  idaapi viewer_get_curnode(graph_viewer_t *gv)                    { return grentry(grcode_get_curnode, gv); }
 

 
inline void idaapi viewer_center_on(graph_viewer_t *gv, int node)            {        grentry(grcode_center_on, gv, node); }

 
inline void idaapi viewer_set_gli(
        graph_viewer_t *gv,
        const graph_location_info_t *gli,
        uint32 flags = 0)
{
  grentry(grcode_set_gli, gv, gli, flags);
}
 

 
inline bool idaapi viewer_get_gli(
        graph_location_info_t *out,
        graph_viewer_t *gv,
        uint32 flags = 0)
{
  return grentry(grcode_get_gli, out, gv, flags) == 0;
}
 

 
inline void idaapi viewer_set_node_info(
        graph_viewer_t *gv,
        int n,
        const node_info_t &ni,
        uint32 flags)
{
  grentry(grcode_set_node_info, gv, n, &ni, flags);
}
 

 
inline bool idaapi viewer_get_node_info(
        graph_viewer_t *gv,
        node_info_t *out,
        int n)
{
  return grentry(grcode_get_node_info, gv, out, n) == 1;
}
 

 
inline void idaapi viewer_del_node_info(graph_viewer_t *gv, int n)
{
  grentry(grcode_del_node_info, gv, n);
}
 

 
inline bool idaapi viewer_create_groups(
        graph_viewer_t *gv,
        intvec_t *out_group_nodes,
        const groups_crinfos_t &gi)
{
  return grentry(grcode_viewer_create_groups_vec, gv, out_group_nodes, &gi) == 1;
}
 

 
inline bool idaapi viewer_delete_groups(
        graph_viewer_t *gv,
        const intvec_t &groups,
        int new_current = -1)
{
  return grentry(grcode_viewer_delete_groups_vec, gv, &groups, new_current) == 1;
}
 

 
inline bool idaapi viewer_set_groups_visibility(
        graph_viewer_t *gv,
        const intvec_t &groups,
        bool expand,
        int new_current = -1)
{
  return grentry(grcode_viewer_groups_visibility_vec, gv, &groups,
                 expand, new_current) == 1;
}
 

 
inline bool idaapi viewer_attach_menu_item(graph_viewer_t *g, const char *name)
{
  return grentry(grcode_attach_menu_item, g, name) != 0;
}
 

 
inline bool idaapi viewer_get_selection(
        graph_viewer_t *gv,
        screen_graph_selection_t *sgs)
{
  return grentry(grcode_get_selection, gv, sgs) != 0;
}
 

 
inline int idaapi viewer_set_titlebar_height(graph_viewer_t *gv, int height)
{
  return grentry(grcode_set_titlebar_height, gv, height);
}
 

 
inline void idaapi delete_interactive_graph(interactive_graph_t *g)
{
  grentry(grcode_delete_interactive_graph, g);
}
 
 
inline void idaapi interactive_graph_t::del_custom_layout(void)                   {        grentry(grcode_del_custom_layout, this); }
inline void idaapi interactive_graph_t::set_custom_layout(void) const             {        grentry(grcode_set_custom_layout, this); }
inline void idaapi interactive_graph_t::set_graph_groups(void) const              {        grentry(grcode_set_graph_groups, this); }
inline void idaapi interactive_graph_t::clear(void)                               {        grentry(grcode_clear, this); }
inline bool idaapi interactive_graph_t::create_digraph_layout(void)               { return grentry(grcode_create_digraph_layout, this) != 0; }
inline bool idaapi drawable_graph_t::create_tree_layout(void)                 { return grentry(grcode_create_tree_layout, this) != 0; }
inline bool idaapi drawable_graph_t::create_circle_layout(point_t c, int radius) { return grentry(grcode_create_circle_layout, this, c.x, c.y, radius) != 0; }
inline int  idaapi interactive_graph_t::get_node_representative(int node)         { return grentry(grcode_get_node_representative, this, node); }
inline int  idaapi interactive_graph_t::_find_subgraph_node(int gr, int n) const  { return grentry(grcode_find_subgraph_node, this, gr, n); }
inline int  idaapi interactive_graph_t::create_group(const intvec_t &_nodes)      { return grentry(grcode_create_group, this, &_nodes); }
inline bool idaapi interactive_graph_t::get_custom_layout(void)                   { return grentry(grcode_get_custom_layout, this) != 0; }
inline bool idaapi interactive_graph_t::get_graph_groups(void)                    { return grentry(grcode_get_graph_groups, this) != 0; }
inline bool idaapi interactive_graph_t::empty(void) const                         { return grentry(grcode_empty, this) != 0; }
inline bool idaapi interactive_graph_t::is_visible_node(int node) const           { return grentry(grcode_is_visible_node, this, node) != 0; }
inline bool idaapi interactive_graph_t::delete_group(int group)                   { return grentry(grcode_delete_group, this, group) != 0; }
inline bool idaapi interactive_graph_t::change_group_visibility(int gr, bool exp) { return grentry(grcode_change_group_visibility, this, gr, exp) != 0; }
inline bool idaapi interactive_graph_t::set_edge(edge_t e, const edge_info_t *ei) { return grentry(grcode_set_edge, this, e.src, e.dst, ei) != 0; }
inline int  idaapi interactive_graph_t::node_qty(void) const                      { return grentry(grcode_node_qty, this); }
inline rect_t &idaapi interactive_graph_t::nrect(int n)                           { rect_t *r; grentry(grcode_nrect, this, n, &r); return *r; }
 
inline edge_infos_wrapper_t &idaapi edge_infos_wrapper_t::operator=(
        const edge_infos_wrapper_t &other)
{
  grentry(grcode_edge_infos_wrapper_copy, this, &other); return *this;
}
 
inline void edge_infos_wrapper_t::clear()
{
  grentry(grcode_edge_infos_wrapper_clear, this);
}
 

struct user_graph_place_t : public place_t
{
  int node;
};
 

 
inline user_graph_place_t *create_user_graph_place(int node, int lnnum)      { user_graph_place_t *r; grentry(grcode_create_user_graph_place, node, lnnum, &r); return r; }
 
#endif  // UI
 
#endif // __GRAPH_DEF_HPP