Module index

Module ida_graph

IDA Plugin SDK API wrapper: graph

Global variables

var COLLAPSED_NODE
COLLAPSED_NODE = -2147483648
var GLICTL_CENTER
the gli should be set/get as center
var MTG_DOT_NODE
is dot node?
var MTG_GROUP_NODE
is group node?
var MTG_NON_DISPLAYABLE_NODE
for disassembly graphs - non-displayable nodes have a visible area that is too large to generate disassembly lines for without IDA slowing down significantly (see MAX_VISIBLE_NODE_AREA)
var NIFF_SHOW_CONTENTS
NIFF_SHOW_CONTENTS = 1
var NIF_ALL
NIF_ALL = 31
var NIF_BG_COLOR
'node_info_t::bg_color'
var NIF_EA
'node_info_t::ea'
var NIF_FLAGS
'node_info_t::flags'
var NIF_FRAME_COLOR
'node_info_t::frame_color'
var NIF_TEXT
'node_info_t::text'
var arrow_height
arrow_height = 10
var arrow_width
arrow_width = 8
var edge_back
edge_back = 3
var edge_cross
edge_cross = 4
var edge_error
edge_error = 0
var edge_forward
edge_forward = 2
var edge_subgraph
edge_subgraph = 5
var edge_tree
edge_tree = 1
var git_edge
git_edge = 1
var git_elp
git_elp = 5
var git_node
git_node = 2
var git_none
git_none = 0
var git_text
git_text = 4
var git_tool
git_tool = 3
var grcode_attach_menu_item
grcode_attach_menu_item = 301
var grcode_calculating_layout
grcode_calculating_layout = 0
var grcode_center_on
grcode_center_on = 264
var grcode_change_group_visibility
grcode_change_group_visibility = 281
var grcode_changed_graph
grcode_changed_graph = 2
var grcode_clear
grcode_clear = 269
var grcode_clicked
grcode_clicked = 4
var grcode_create_circle_layout
grcode_create_circle_layout = 272
var grcode_create_digraph_layout
grcode_create_digraph_layout = 270
var grcode_create_disasm_graph1
grcode_create_disasm_graph1 = 287
var grcode_create_disasm_graph2
grcode_create_disasm_graph2 = 288
var grcode_create_graph_viewer
grcode_create_graph_viewer = 256
var grcode_create_group
grcode_create_group = 275
var grcode_create_mutable_graph
grcode_create_mutable_graph = 259
var grcode_create_tree_layout
grcode_create_tree_layout = 271
var grcode_create_user_graph_place
grcode_create_user_graph_place = 286
var grcode_creating_group
grcode_creating_group = 6
var grcode_dblclicked
grcode_dblclicked = 5
var grcode_del_custom_layout
grcode_del_custom_layout = 266
var grcode_del_node_info
grcode_del_node_info = 291
var grcode_delete_group
grcode_delete_group = 280
var grcode_delete_mutable_graph
grcode_delete_mutable_graph = 298
var grcode_deleting_group
grcode_deleting_group = 7
var grcode_destroyed
grcode_destroyed = 18
var grcode_edge_infos_wrapper_clear
grcode_edge_infos_wrapper_clear = 300
var grcode_edge_infos_wrapper_copy
grcode_edge_infos_wrapper_copy = 299
var grcode_empty
grcode_empty = 278
var grcode_find_subgraph_node
grcode_find_subgraph_node = 274
var grcode_fit_window
grcode_fit_window = 262
var grcode_get_curnode
grcode_get_curnode = 263
var grcode_get_custom_layout
grcode_get_custom_layout = 276
var grcode_get_gli
grcode_get_gli = 303
var grcode_get_graph_groups
grcode_get_graph_groups = 277
var grcode_get_graph_viewer
grcode_get_graph_viewer = 257
var grcode_get_node_info
grcode_get_node_info = 290
var grcode_get_node_representative
grcode_get_node_representative = 273
var grcode_get_selection
grcode_get_selection = 265
var grcode_get_viewer_graph
grcode_get_viewer_graph = 258
var grcode_gotfocus
grcode_gotfocus = 9
var grcode_group_visibility
grcode_group_visibility = 8
var grcode_is_visible_node
grcode_is_visible_node = 279
var grcode_layout_calculated
grcode_layout_calculated = 1
var grcode_lostfocus
grcode_lostfocus = 10
var grcode_node_qty
grcode_node_qty = 283
var grcode_nrect
grcode_nrect = 284
var grcode_refresh_viewer
grcode_refresh_viewer = 261
var grcode_reserved
grcode_reserved = 3
var grcode_reserved2
grcode_reserved2 = 12
var grcode_set_custom_layout
grcode_set_custom_layout = 267
var grcode_set_edge
grcode_set_edge = 282
var grcode_set_gli
grcode_set_gli = 302
var grcode_set_graph_groups
grcode_set_graph_groups = 268
var grcode_set_node_info
grcode_set_node_info = 289
var grcode_set_titlebar_height
grcode_set_titlebar_height = 285
var grcode_set_viewer_graph
grcode_set_viewer_graph = 260
var grcode_user_draw
grcode_user_draw = 16
var grcode_user_hint
grcode_user_hint = 17
var grcode_user_refresh
grcode_user_refresh = 11
var grcode_user_size
grcode_user_size = 14
var grcode_user_text
grcode_user_text = 13
var grcode_user_title
grcode_user_title = 15
var grcode_viewer_create_groups
grcode_viewer_create_groups = 292
var grcode_viewer_create_groups_vec
grcode_viewer_create_groups_vec = 295
var grcode_viewer_delete_groups
grcode_viewer_delete_groups = 293
var grcode_viewer_delete_groups_vec
grcode_viewer_delete_groups_vec = 296
var grcode_viewer_groups_visibility
grcode_viewer_groups_visibility = 294
var grcode_viewer_groups_visibility_vec
grcode_viewer_groups_visibility_vec = 297
var layout_circle
layout_circle = 3
var layout_digraph
layout_digraph = 1
var layout_none
layout_none = 0
var layout_orthogonal
layout_orthogonal = 5
var layout_polar_tree
layout_polar_tree = 4
var layout_radial_tree
layout_radial_tree = 6
var layout_tree
layout_tree = 2
var xgap
xgap = 10
var ygap
ygap = 30

Functions

def calc_dist(*args) ‑> double
Calculate distance between p and q.
calc_dist(p, q) -> double
p (C++: point_t)
q (C++: point_t)
def clr_node_info(*args) ‑> void
Clear node info for the given node.
clr_node_info(gid, node, flags)
gid: id of desired graph (C++: graph_id_t)
node: node number (C++: int)
flags: combination of Node info flags , identifying which
fields of node_info_t will be cleared (C++: uint32)
def create_disasm_graph(*args) ‑> mutable_graph_t *
Create a graph for the function that contains 'ea'.
create_disasm_graph(ea) -> mutable_graph_t
ea (C++: ea_t)
create_disasm_graph(ranges) -> mutable_graph_t
ranges: rangevec_t const &
def create_graph_viewer(*args) ‑> graph_viewer_t *
Create a custom graph viewer.
create_graph_viewer(title, id, callback, ud, title_height, parent=None) -> graph_viewer_t *
title: the widget title (C++: const char *)
id: graph id (C++: uval_t)
callback: callback to handle graph notifications (
graph_notification_t ) (C++: hook_cb_t *)
ud: user data passed to callback (C++: void *)
title_height: node title height (C++: int)
parent (C++: TWidget *)
return: new viewer
def create_mutable_graph(*args) ‑> mutable_graph_t *
Create a new empty graph with given id.
create_mutable_graph(id) -> mutable_graph_t
id (C++: uval_t)
def create_user_graph_place(*args) ‑> user_graph_place_t *
Get a copy of a 'user_graph_place_t' (returns a pointer to static storage)
create_user_graph_place(node, lnnum) -> user_graph_place_t
node (C++: int)
lnnum (C++: int)
def del_node_info(*args) ‑> void
Delete the 'node_info_t' for the given node.
del_node_info(gid, node)
gid (C++: graph_id_t)
node (C++: int)
def delete_mutable_graph(*args) ‑> void
Delete graph object.use this only if you are dealing with 'mutable_graph_t' instances that have not been used together with a 'graph_viewer_t' . If you have called 'set_viewer_graph()' with your graph, the graph's lifecycle will be managed by the viewer, and you shouldn't interfere with it
delete_mutable_graph(g)
g (C++: mutable_graph_t *)
def get_graph_viewer(*args) ‑> graph_viewer_t *
Get custom graph viewer for given form.
get_graph_viewer(parent) -> graph_viewer_t *
parent (C++: TWidget *)
def get_node_info(*args) ‑> bool
Get node info.
get_node_info(out, gid, node) -> bool
out: result (C++: node_info_t *)
gid: id of desired graph (C++: graph_id_t)
node: node number (C++: int)
return: success
def get_viewer_graph(*args) ‑> mutable_graph_t *
Get graph object for given custom graph viewer.
get_viewer_graph(gv) -> mutable_graph_t
gv (C++: graph_viewer_t *)
def pyg_close(*args) ‑> void
pyg_close(_self)
self: PyObject *
def pyg_select_node(*args) ‑> void
pyg_select_node(_self, nid)
self: PyObject * nid: int
def pyg_show(*args) ‑> bool
pyg_show(_self) -> bool
self: PyObject *
def refresh_viewer(*args) ‑> void
Redraw the graph in the given view.
refresh_viewer(gv)
gv (C++: graph_viewer_t *)
def set_node_info(*args) ‑> void
Set node info.
set_node_info(gid, node, ni, flags)
gid: id of desired graph (C++: graph_id_t)
node: node number (C++: int)
ni: node info to use (C++: const node_info_t &)
flags: combination of Node info flags , identifying which
fields of 'ni' will be used (C++: uint32)
def set_viewer_graph(*args) ‑> void
Set the underlying graph object for the given viewer.
set_viewer_graph(gv, g)
gv (C++: graph_viewer_t *)
g (C++: mutable_graph_t *)
def viewer_attach_menu_item(*args) ‑> bool
Attach a previously-registered action to the view's context menu. See 'kernwin.hpp' for how to register actions.
viewer_attach_menu_item(g, name) -> bool
g (C++: graph_viewer_t *)
name: action name (C++: const char *)
return: success
def viewer_center_on(*args) ‑> void
Center the graph view on the given node.
viewer_center_on(gv, node)
gv (C++: graph_viewer_t *)
node (C++: int)
def viewer_create_groups(*args) ‑> bool
This will perform an operation similar to what happens when a user manually selects a set of nodes, right-clicks and selects "Create group". This is a wrapper around 'mutable_graph_t::create_group' that will, in essence:clone the current graphfor each 'group_crinfo_t' , attempt creating group in that new graphif all were successful, animate to that new graph.this accepts parameters that allow creating of multiple groups at once; which means only one graph animation will be triggered.
viewer_create_groups(gv, out_group_nodes, gi) -> bool
gv (C++: graph_viewer_t *)
out_group_nodes (C++: intvec_t *)
gi (C++: const groups_crinfos_t &)
def viewer_del_node_info(*args) ‑> void
Delete node info for node in given viewer (see 'del_node_info()' )
viewer_del_node_info(gv, n)
gv (C++: graph_viewer_t *)
n (C++: int)
def viewer_delete_groups(*args) ‑> bool
Wrapper around 'mutable_graph_t::delete_group' . This function will:clone the current graphattempt deleting the groups in that new graphif successful, animate to that new graph.
viewer_delete_groups(gv, groups, new_current=-1) -> bool
gv (C++: graph_viewer_t *)
groups (C++: const intvec_t &)
new_current (C++: int)
def viewer_fit_window(*args) ‑> void
Fit graph viewer to its parent form.
viewer_fit_window(gv)
gv (C++: graph_viewer_t *)
def viewer_get_curnode(*args) ‑> int
Get number of currently selected node (-1 if none)
viewer_get_curnode(gv) -> int
gv (C++: graph_viewer_t *)
def viewer_get_gli(*args) ‑> bool
Get location info for given graph view If flags contains GLICTL_CENTER, then the gli that will be retrieved, will be the one at the center of the view. Otherwise it will be the top-left.
viewer_get_gli(out, gv, flags=0) -> bool
out (C++: graph_location_info_t *)
gv (C++: graph_viewer_t *)
flags (C++: uint32)
def viewer_get_node_info(*args) ‑> bool
Get node info for node in given viewer (see 'get_node_info()' )
viewer_get_node_info(gv, out, n) -> bool
gv (C++: graph_viewer_t *)
out (C++: node_info_t *)
n (C++: int)
def viewer_get_selection(*args) ‑> bool
Get currently selected items for graph viewer.
viewer_get_selection(gv, sgs) -> bool
gv (C++: graph_viewer_t *)
sgs (C++: screen_graph_selection_t *)
def viewer_set_gli(*args) ‑> void
Set location info for given graph view If flags contains GLICTL_CENTER, then the gli will be set to be the center of the view. Otherwise it will be the top-left.
viewer_set_gli(gv, gli, flags=0)
gv (C++: graph_viewer_t *)
gli (C++: const graph_location_info_t *)
flags (C++: uint32)
def viewer_set_groups_visibility(*args) ‑> bool
Wrapper around 'mutable_graph_t::change_visibility' . This function will:clone the current graphattempt changing visibility of the groups in that new graphif successful, animate to that new graph.
viewer_set_groups_visibility(gv, groups, expand, new_current=-1) -> bool
gv (C++: graph_viewer_t *)
groups (C++: const intvec_t &)
expand (C++: bool)
new_current (C++: int)
def viewer_set_node_info(*args) ‑> void
Set node info for node in given viewer (see 'set_node_info()' )
viewer_set_node_info(gv, n, ni, flags)
gv (C++: graph_viewer_t *)
n (C++: int)
ni (C++: const node_info_t &)
flags (C++: uint32)
def viewer_set_titlebar_height(*args) ‑> int
Set height of node title bars ( 'grcode_set_titlebar_height' )
viewer_set_titlebar_height(gv, height) -> int
gv (C++: graph_viewer_t *)
height (C++: int)

Classes

class GraphViewer (title, close_open=False)
Proxy of C++ View_Hooks class.
Constructs the GraphView object. Please do not remove or rename the private fields
title: The title of the graph window
close_open: Should it attempt to close an existing graph (with same title) before creating this graph?

Ancestors

Class variables

var UI_Hooks_Trampoline
Proxy of C++ UI_Hooks class.

Methods

def AddCommand(self, title, shortcut)
def AddEdge(self, src_node, dest_node)
Creates an edge between two given node ids
def AddNode(self, obj)
Creates a node associated with the given object and returns the node id
def Clear(self)
Clears all the nodes and edges
def Close(self)
Closes the graph. It is possible to call Show() again (which will recreate the graph)
def Count(self)
Returns the node count
def OnCommand(self, cmd_id)
def OnPopup(self, widget, popup_handle)
def OnRefresh(self)
Event called when the graph is refreshed or first created. From this event you are supposed to create nodes and edges. This callback is mandatory.
note: ***It is important to clear previous nodes before adding nodes.***
return: Returning True tells the graph viewer to use the items. Otherwise old items will be used.
def Select(self, node_id)
Selects a node on the graph
def Show(self)
Shows an existing graph or creates a new one
return: Boolean

Inherited members

class TPointDouble (*args)
Proxy of C++ TPointDouble class.
__init__(self) -> TPointDouble
a: double b: double
__init__(self, r) -> TPointDouble
r: point_t const &

Instance variables

var x
TPointDouble_x_get(self) -> double
var y
TPointDouble_y_get(self) -> double

Methods

def add(self, *args) ‑> void
add(self, r)
r (C++: const TPointDouble &)
def negate(self, *args) ‑> void
negate(self)
def sub(self, *args) ‑> void
sub(self, r)
r (C++: const TPointDouble &)
class abstract_graph_t (*args)
Proxy of C++ abstract_graph_t class.
__init__(self) -> abstract_graph_t
self: PyObject *

Ancestors

Subclasses

Instance variables

var callback_ud
abstract_graph_t_callback_ud_get(self) -> void *
var circle_center
abstract_graph_t_circle_center_get(self) -> point_t
var circle_radius
abstract_graph_t_circle_radius_get(self) -> int
var current_layout
abstract_graph_t_current_layout_get(self) -> layout_type_t
var rect_edges_made
abstract_graph_t_rect_edges_made_get(self) -> bool
var title
abstract_graph_t_title_get(self) -> qstring *

Methods

def create_circle_layout(self, *args) ‑> bool
create_circle_layout(self, p, radius) -> bool
p (C++: point_t)
radius (C++: int)
def create_tree_layout(self, *args) ‑> bool
create_tree_layout(self) -> bool
def get_edge(self, *args) ‑> edge_info_t *
get_edge(self, e) -> edge_info_t
e (C++: edge_t)
def grcall(self, *args) ‑> ssize_t
grcall(self, code) -> ssize_t
code (C++: int)
def nrect(self, *args) ‑> rect_t
nrect(self, n) -> rect_t
n (C++: int)
def set_callback(self, *args) ‑> void
set_callback(self, _callback, _ud)
_callback (C++: hook_cb_t *)
_ud (C++: void *)

Inherited members

class edge_info_t (*args)
Proxy of C++ edge_info_t class.
__init__(self) -> edge_info_t

Instance variables

var color
edge_info_t_color_get(self) -> bgcolor_t
var dstoff
edge_info_t_dstoff_get(self) -> int
var layout
edge_info_t_layout_get(self) -> pointseq_t
var srcoff
edge_info_t_srcoff_get(self) -> int
var width
edge_info_t_width_get(self) -> int

Methods

def reverse_layout(self, *args) ‑> void
reverse_layout(self)
class edge_infos_wrapper_t (*args, **kwargs)
Proxy of C++ edge_infos_wrapper_t class.

Instance variables

var ptr
edge_infos_wrapper_t_ptr_get(self) -> edge_infos_t *

Methods

def clear(self, *args) ‑> void
clear(self)
class edge_layout_point_t (*args)
Proxy of C++ edge_layout_point_t class.
__init__(self) -> edge_layout_point_t
r: edge_layout_point_t const &
__init__(self, _e, _pidx) -> edge_layout_point_t
_e: edge_t const & _pidx: int

Instance variables

var e
edge_layout_point_t_e_get(self) -> edge_t
var pidx
edge_layout_point_t_pidx_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r (C++: const edge_layout_point_t &)
class edge_segment_t (*args)
Proxy of C++ edge_segment_t class.
__init__(self) -> edge_segment_t

Instance variables

var e
edge_segment_t_e_get(self) -> edge_t
var nseg
edge_segment_t_nseg_get(self) -> int
var x0
edge_segment_t_x0_get(self) -> int
var x1
edge_segment_t_x1_get(self) -> int

Methods

def length(self, *args) ‑> size_t
length(self) -> size_t
def toright(self, *args) ‑> bool
toright(self) -> bool
class edge_t (*args)
Proxy of C++ edge_t class.
__init__(self) -> edge_t
x: int y: int

Instance variables

var dst
edge_t_dst_get(self) -> int
var src
edge_t_src_get(self) -> int
class graph_item_t (*args)
Proxy of C++ graph_item_t class.
__init__(self) -> graph_item_t

Instance variables

var b
graph_item_t_b_get(self) -> int
var e
graph_item_t_e_get(self) -> edge_t
var elp
graph_item_t_elp_get(self) -> edge_layout_point_t
var n
graph_item_t_n_get(self) -> int
var p
graph_item_t_p_get(self) -> point_t
var type
graph_item_t_type_get(self) -> graph_item_type_t

Methods

def is_edge(self, *args) ‑> bool
is_edge(self) -> bool
def is_node(self, *args) ‑> bool
is_node(self) -> bool
class graph_node_visitor_t (*args)
Proxy of C++ graph_node_visitor_t class.
__init__(self) -> graph_node_visitor_t
self: PyObject *

Methods

def is_forbidden_edge(self, *args) ‑> bool
Should the edge between 'n' and 'm' be ignored?
is_forbidden_edge(self, arg0, arg1) -> bool
arg0: int arg1: int
def is_visited(self, *args) ‑> bool
Have we already visited the given node?
is_visited(self, n) -> bool
n (C++: int)
def reinit(self, *args) ‑> void
Reset visited nodes.
def set_visited(self, *args) ‑> void
Mark node as visited.
set_visited(self, n)
n (C++: int)
def visit_node(self, *args) ‑> int
Implements action to take when a node is visited.
visit_node(self, arg0) -> int
arg0: int
class graph_path_visitor_t (*args)
Proxy of C++ graph_path_visitor_t class.
__init__(self) -> graph_path_visitor_t
self: PyObject *

Instance variables

var path
graph_path_visitor_t_path_get(self) -> intvec_t *
var prune
graph_path_visitor_t_prune_get(self) -> bool

Methods

def walk_backward(self, *args) ‑> int
walk_backward(self, arg0) -> int
arg0: int
def walk_forward(self, *args) ‑> int
walk_forward(self, arg0) -> int
arg0: int
class graph_visitor_t (*args)
Proxy of C++ graph_visitor_t class.
__init__(self) -> graph_visitor_t
self: PyObject *

Methods

def visit_edge(self, *args) ‑> int
visit_edge(self, arg2, arg3) -> int
arg2: edge_t arg3: edge_info_t *
def visit_node(self, *args) ‑> int
visit_node(self, arg2, arg3) -> int
arg2: int arg3: rect_t &
class group_crinfo_t (*args)
Proxy of C++ group_crinfo_t class.
__init__(self) -> group_crinfo_t

Instance variables

var nodes
group_crinfo_t_nodes_get(self) -> intvec_t *
var text
group_crinfo_t_text_get(self) -> qstring *
class interval_t (*args)
Proxy of C++ interval_t class.
__init__(self) -> interval_t
y0: int y1: int
__init__(self, s) -> interval_t
s: edge_segment_t const &

Instance variables

var x0
interval_t_x0_get(self) -> int
var x1
interval_t_x1_get(self) -> int

Methods

def contains(self, *args) ‑> bool
contains(self, x) -> bool
x (C++: int)
def empty(self, *args) ‑> bool
empty(self) -> bool
def intersect(self, *args) ‑> void
intersect(self, r)
r (C++: const interval_t &)
def length(self, *args) ‑> int
length(self) -> int
def make_union(self, *args) ‑> void
make_union(self, r)
r (C++: const interval_t &)
def move_by(self, *args) ‑> void
move_by(self, shift)
shift (C++: int)
class mutable_graph_t (*args, **kwargs)
Proxy of C++ mutable_graph_t class.
__init__(self) -> abstract_graph_t
self: PyObject *

Ancestors

Instance variables

var belongs
mutable_graph_t_belongs_get(self) -> intvec_t *
var edges
mutable_graph_t_edges_get(self) -> edge_infos_wrapper_t
var gid
mutable_graph_t_gid_get(self) -> uval_t
var node_flags
mutable_graph_t_node_flags_get(self) -> bytevec_t *
var nodes
mutable_graph_t_nodes_get(self) -> node_layout_t
var org_preds
mutable_graph_t_org_preds_get(self) -> array_of_intvec_t *
var org_succs
mutable_graph_t_org_succs_get(self) -> array_of_intvec_t *
var preds
mutable_graph_t_preds_get(self) -> array_of_intvec_t *
var succs
mutable_graph_t_succs_get(self) -> array_of_intvec_t *

Methods

def add_edge(self, *args) ‑> bool
add_edge(self, i, j, ei) -> bool
i (C++: int)
j (C++: int)
ei (C++: const edge_info_t *)
def add_node(self, *args) ‑> int
Add a node, possibly with a specific geometry
add_node(self, r) -> int
r: the node geometry (can be nullptr) (C++: const rect_t *)
return: the new node
def calc_group_ea(self, *args) ‑> ea_t
calc_group_ea(self, arg2) -> ea_t
arg2: intvec_t const &
def change_group_visibility(self, *args) ‑> bool
Expand/collapse a group node
change_group_visibility(self, group, expand) -> bool
group: the group node (C++: int)
expand: whether to expand or collapse (C++: bool)
return: success
def create_digraph_layout(self, *args) ‑> bool
create_digraph_layout(self) -> bool
def create_group(self, *args) ‑> int
Create a new group node, that will contain all the nodes in 'nodes'.
create_group(self, nodes) -> int
nodes: the nodes that will be part of the group (C++: const
intvec_t &)
return: the group node, or -1 in case of error
def del_custom_layout(self, *args) ‑> void
del_custom_layout(self)
def del_edge(self, *args) ‑> bool
del_edge(self, i, j) -> bool
i (C++: int)
j (C++: int)
def del_node(self, *args) ‑> ssize_t
Delete a node
del_node(self, n) -> ssize_t
n: the node to delete (C++: int)
return: the number of deleted edges
def delete_group(self, *args) ‑> bool
Delete a group node.This deletes the group node only; it does not delete nodes that are part of the group.
delete_group(self, group) -> bool
group: the group node (C++: int)
return: success
def empty(self, *args) ‑> bool
Is the graph (visually) empty?
def exists(self, *args) ‑> bool
Is the node visible?
exists(self, node) -> bool
node: the node number (C++: int)
return: success
def get_custom_layout(self, *args) ‑> bool
get_custom_layout(self) -> bool
def get_first_subgraph_node(self, *args) ‑> int
get_first_subgraph_node(self, group) -> int
group (C++: int)
def get_graph_groups(self, *args) ‑> bool
get_graph_groups(self) -> bool
def get_next_subgraph_node(self, *args) ‑> int
get_next_subgraph_node(self, group, current) -> int
group (C++: int)
current (C++: int)
def get_node_group(self, *args) ‑> int
get_node_group(self, node) -> int
node (C++: int)
def get_node_representative(self, *args) ‑> int
Get the node that currently visually represents 'node'. This will find the "closest" parent group node that's visible, by attempting to walk up the group nodes that contain 'node', and will stop when it finds a node that is currently visible.See also get_group_node()
get_node_representative(self, node) -> int
node: the node (C++: int)
return: the node that represents 'node', or 'node' if it's not part
of any group
def is_collapsed_node(self, *args) ‑> bool
is_collapsed_node(self, node) -> bool
node (C++: int)
def is_deleted_node(self, *args) ‑> bool
is_deleted_node(self, node) -> bool
node (C++: int)
def is_displayable_node(self, *args) ‑> bool
is_displayable_node(self, node) -> bool
node (C++: int)
def is_dot_node(self, *args) ‑> bool
is_dot_node(self, node) -> bool
node (C++: int)
def is_group_node(self, *args) ‑> bool
is_group_node(self, node) -> bool
node (C++: int)
def is_simple_node(self, *args) ‑> bool
is_simple_node(self, node) -> bool
node (C++: int)
def is_subgraph_node(self, *args) ‑> bool
is_subgraph_node(self, node) -> bool
node (C++: int)
def is_uncollapsed_node(self, *args) ‑> bool
is_uncollapsed_node(self, node) -> bool
node (C++: int)
def is_user_graph(self, *args) ‑> bool
is_user_graph(self) -> bool
def is_visible_node(self, *args) ‑> bool
Is the node currently visible?An invisible node is a node that's part of a group that's currently collapsed.
is_visible_node(self, node) -> bool
node: the node (C++: int)
return: success
def node_qty(self, *args) ‑> int
Get the number of visible nodes (the list can be retrieved using 'gdl.hpp' 's 'node_iterator' )See also size()
def npred(self, *args) ‑> int
npred(self, b) -> int
b (C++: int)
def nsucc(self, *args) ‑> int
nsucc(self, b) -> int
b (C++: int)
def pred(self, *args) ‑> int
pred(self, b, i) -> int
b (C++: int)
i (C++: int)
def predset(self, *args) ‑> intvec_t const &
predset(self, b) -> intvec_t const &
b (C++: int)
def redo_layout(self, *args) ‑> bool
Recompute the layout, according to the value of 'current_layout'.
def refresh(self, *args) ‑> bool
Refresh the graphA graph needs refreshing when it's "backing data". E.g., if the number (or contents) of the objects in the above example, change.Let's say the user's plugin ends up finding a 5th piece of scattered data. It should then add it to its internal list of known objects, and tell IDA that the graph needs to be refreshed, using 'refresh_viewer()' . This will cause IDA to:discard all its internal rendering information,call 'mutable_graph_t::refresh()' on the graph so that the user's plugin has a chance to "sync" the number of nodes & edges that this graph contains, to the information that the plugin has collected so farre-create internal rendering information, andrepaint the view
def replace_edge(self, *args) ‑> bool
replace_edge(self, i, j, x, y) -> bool
i (C++: int)
j (C++: int)
x (C++: int)
y (C++: int)
def reset(self, *args) ‑> void
reset(self)
def resize(self, *args) ‑> void
Resize the graph to 'n' nodes
resize(self, n)
n: the new size (C++: int)
def set_custom_layout(self, *args) ‑> void
set_custom_layout(self)
def set_deleted_node(self, *args) ‑> void
set_deleted_node(self, node)
node (C++: int)
def set_edge(self, *args) ‑> bool
set_edge(self, e, ei) -> bool
e (C++: edge_t)
ei (C++: const edge_info_t *)
def set_graph_groups(self, *args) ‑> void
set_graph_groups(self)
def set_node_group(self, *args) ‑> void
set_node_group(self, node, group)
node (C++: int)
group (C++: int)
def set_nrect(self, *args) ‑> bool
set_nrect(self, n, r) -> bool
n (C++: int)
r (C++: const rect_t &)
def size(self, *args) ‑> int
Get the total number of nodes (including group nodes, and including hidden nodes.)See also node_qty()
def succ(self, *args) ‑> int
succ(self, b, i) -> int
b (C++: int)
i (C++: int)
def succset(self, *args) ‑> intvec_t const &
succset(self, b) -> intvec_t const &
b (C++: int)

Inherited members

class node_info_t (*args)
Proxy of C++ node_info_t class.
__init__(self) -> node_info_t

Instance variables

var bg_color
node_info_t_bg_color_get(self) -> bgcolor_t
var ea
node_info_t_ea_get(self) -> ea_t
var flags
node_info_t_flags_get(self) -> uint32
var frame_color
node_info_t_frame_color_get(self) -> bgcolor_t
var text
node_info_t_text_get(self) -> qstring *

Methods

def get_flags_for_valid(self, *args) ‑> uint32
Get combination of 'Node info flags' describing which attributes are valid.
def valid_bg_color(self, *args) ‑> bool
Has valid 'bg_color' ?
def valid_ea(self, *args) ‑> bool
Has valid 'ea' ?
def valid_flags(self, *args) ‑> bool
Has valid 'flags' ?
def valid_frame_color(self, *args) ‑> bool
Has valid 'frame_color' ?
def valid_text(self, *args) ‑> bool
Has non-empty 'text' ?
class node_layout_t (*args)
Proxy of C++ qvector< rect_t > class.
__init__(self) -> node_layout_t
x: qvector< rect_t > const &

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: rect_t const &
def at(self, *args) ‑> rect_t const &
at(self, _idx) -> rect_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< rect_t >::const_iterator
begin(self) -> rect_t
begin(self) -> rect_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< rect_t >::const_iterator
end(self) -> rect_t
end(self) -> rect_t
def erase(self, *args) ‑> qvector< rect_t >::iterator
erase(self, it) -> rect_t
it: qvector< rect_t >::iterator
erase(self, first, last) -> rect_t
first: qvector< rect_t >::iterator last: qvector< rect_t >::iterator
def extract(self, *args) ‑> rect_t *
extract(self) -> rect_t
def find(self, *args) ‑> qvector< rect_t >::const_iterator
find(self, x) -> rect_t
x: rect_t const &
find(self, x) -> rect_t
x: rect_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=rect_t())
x: rect_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: rect_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: rect_t * len: size_t
def insert(self, *args) ‑> qvector< rect_t >::iterator
insert(self, it, x) -> rect_t
it: qvector< rect_t >::iterator x: rect_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> rect_t &
push_back(self, x)
x: rect_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: rect_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< rect_t > &
def truncate(self, *args) ‑> void
truncate(self)
class node_ordering_t (*args)
Proxy of C++ node_ordering_t class.
__init__(self) -> node_ordering_t

Methods

def clear(self, *args) ‑> void
clear(self)
def clr(self, *args) ‑> bool
clr(self, _node) -> bool
_node (C++: int)
def node(self, *args) ‑> int
node(self, _order) -> int
_order (C++: size_t)
def order(self, *args) ‑> int
order(self, _node) -> int
_node (C++: int)
def resize(self, *args) ‑> void
resize(self, n)
n (C++: int)
def set(self, *args) ‑> void
set(self, _node, num)
_node (C++: int)
num (C++: int)
def size(self, *args) ‑> size_t
size(self) -> size_t
class point_t (*args)
Proxy of C++ point_t class.
__init__(self) -> point_t
_x: int _y: int

Instance variables

var x
point_t_x_get(self) -> int
var y
point_t_y_get(self) -> int

Methods

def add(self, *args) ‑> point_t &
add(self, r) -> point_t
r (C++: const point_t &)
def negate(self, *args) ‑> void
negate(self)
def sub(self, *args) ‑> point_t &
sub(self, r) -> point_t
r (C++: const point_t &)
class pointseq_t (*args)
Proxy of C++ pointseq_t class.
__init__(self) -> pointseq_t

Ancestors

Inherited members

class pointvec_t (*args)
Proxy of C++ qvector< point_t > class.
__init__(self) -> pointvec_t
x: qvector< point_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: point_t const &
def at(self, *args) ‑> point_t const &
at(self, _idx) -> point_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< point_t >::const_iterator
begin(self) -> point_t
begin(self) -> point_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< point_t >::const_iterator
end(self) -> point_t
end(self) -> point_t
def erase(self, *args) ‑> qvector< point_t >::iterator
erase(self, it) -> point_t
it: qvector< point_t >::iterator
erase(self, first, last) -> point_t
first: qvector< point_t >::iterator last: qvector< point_t >::iterator
def extract(self, *args) ‑> point_t *
extract(self) -> point_t
def find(self, *args) ‑> qvector< point_t >::const_iterator
find(self, x) -> point_t
x: point_t const &
find(self, x) -> point_t
x: point_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=point_t())
x: point_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: point_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: point_t * len: size_t
def insert(self, *args) ‑> qvector< point_t >::iterator
insert(self, it, x) -> point_t
it: qvector< point_t >::iterator x: point_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> point_t &
push_back(self, x)
x: point_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: point_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< point_t > &
def truncate(self, *args) ‑> void
truncate(self)
class rect_t (*args)
Proxy of C++ rect_t class.
__init__(self) -> rect_t
l: int t: int r: int b: int
__init__(self, p0, p1) -> rect_t
p0: point_t const & p1: point_t const &

Instance variables

var bottom
rect_t_bottom_get(self) -> int
var left
rect_t_left_get(self) -> int
var right
rect_t_right_get(self) -> int
var top
rect_t_top_get(self) -> int

Methods

def area(self, *args) ‑> int
area(self) -> int
def bottomright(self, *args) ‑> point_t
bottomright(self) -> point_t
def center(self, *args) ‑> point_t
center(self) -> point_t
def contains(self, *args) ‑> bool
contains(self, p) -> bool
p (C++: const point_t &)
def empty(self, *args) ‑> bool
empty(self) -> bool
def grow(self, *args) ‑> void
grow(self, delta)
delta (C++: int)
def height(self, *args) ‑> int
height(self) -> int
def intersect(self, *args) ‑> void
intersect(self, r)
r (C++: const rect_t &)
def is_intersection_empty(self, *args) ‑> bool
is_intersection_empty(self, r) -> bool
r (C++: const rect_t &)
def make_union(self, *args) ‑> void
make_union(self, r)
r (C++: const rect_t &)
def move_by(self, *args) ‑> void
move_by(self, p)
p (C++: const point_t &)
def move_to(self, *args) ‑> void
move_to(self, p)
p (C++: const point_t &)
def topleft(self, *args) ‑> point_t
topleft(self) -> point_t
def width(self, *args) ‑> int
width(self) -> int
class row_info_t (*args)
Proxy of C++ row_info_t class.
__init__(self) -> row_info_t

Instance variables

var bottom
row_info_t_bottom_get(self) -> int
var nodes
row_info_t_nodes_get(self) -> intvec_t *
var top
row_info_t_top_get(self) -> int

Methods

def height(self, *args) ‑> int
height(self) -> int
class screen_graph_selection_base_t (*args)
Proxy of C++ qvector< selection_item_t > class.
__init__(self) -> screen_graph_selection_base_t
x: qvector< selection_item_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: selection_item_t const &
def at(self, *args) ‑> selection_item_t const &
at(self, _idx) -> selection_item_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< selection_item_t >::const_iterator
begin(self) -> selection_item_t
begin(self) -> selection_item_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< selection_item_t >::const_iterator
end(self) -> selection_item_t
end(self) -> selection_item_t
def erase(self, *args) ‑> qvector< selection_item_t >::iterator
erase(self, it) -> selection_item_t
it: qvector< selection_item_t >::iterator
erase(self, first, last) -> selection_item_t
first: qvector< selection_item_t >::iterator last: qvector< selection_item_t >::iterator
def extract(self, *args) ‑> selection_item_t *
extract(self) -> selection_item_t
def find(self, *args) ‑> qvector< selection_item_t >::const_iterator
find(self, x) -> selection_item_t
x: selection_item_t const &
find(self, x) -> selection_item_t
x: selection_item_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=selection_item_t())
x: selection_item_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: selection_item_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: selection_item_t * len: size_t
def insert(self, *args) ‑> qvector< selection_item_t >::iterator
insert(self, it, x) -> selection_item_t
it: qvector< selection_item_t >::iterator x: selection_item_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> selection_item_t &
push_back(self, x)
x: selection_item_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: selection_item_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< selection_item_t > &
def truncate(self, *args) ‑> void
truncate(self)
class screen_graph_selection_t (*args)
Proxy of C++ screen_graph_selection_t class.
__init__(self) -> screen_graph_selection_t

Ancestors

Methods

def add(self, *args) ‑> void
add(self, s)
s (C++: const screen_graph_selection_t &)
def add_node(self, *args) ‑> void
add_node(self, node)
node (C++: int)
def add_point(self, *args) ‑> void
add_point(self, e, idx)
e (C++: edge_t)
idx (C++: int)
def del_node(self, *args) ‑> void
del_node(self, node)
node (C++: int)
def del_point(self, *args) ‑> void
del_point(self, e, idx)
e (C++: edge_t)
idx (C++: int)
def has(self, *args) ‑> bool
has(self, item) -> bool
item (C++: const selection_item_t &)
def items_count(self, *args) ‑> size_t
items_count(self, look_for_nodes) -> size_t
look_for_nodes (C++: bool)
def nodes_count(self, *args) ‑> size_t
nodes_count(self) -> size_t
def points_count(self, *args) ‑> size_t
points_count(self) -> size_t
def sub(self, *args) ‑> void
sub(self, s)
s (C++: const screen_graph_selection_t &)

Inherited members

class selection_item_t (*args)
Proxy of C++ selection_item_t class.
__init__(self) -> selection_item_t
n: int
__init__(self, _elp) -> selection_item_t
_elp: edge_layout_point_t &
__init__(self, e, idx) -> selection_item_t
e: edge_t idx: int

Instance variables

var elp
selection_item_t_elp_get(self) -> edge_layout_point_t
var is_node
selection_item_t_is_node_get(self) -> bool
var node
selection_item_t_node_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r (C++: const selection_item_t &)
class user_graph_place_t (*args, **kwargs)
Proxy of C++ user_graph_place_t class.

Instance variables

var node
user_graph_place_t_node_get(self) -> int