Module index

# Module `ida_graph`

Graph view management.

## Global variables

`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 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 git_edge`

  edge (graph_item_t::e, graph_item_t::n. n is farthest edge endpoint)

`var git_elp`

  edge layout point (graph_item_t::elp)

`var git_node`

  node title (graph_item_t::n)

`var git_none`

  nothing

`var git_text`

  node text (graph_item_t::n, graph_item_t::p)

`var git_tool`

  node title button (graph_item_t::n, graph_item_t::b)

`var grcode_calculating_layout`

  calculating user-defined graph layout. @param g: (interactive_graph_t *) @retval 0: not implemented @retval 1: graph layout calculated by the plugin

`var grcode_center_on`

  use viewer_center_on()

`var grcode_change_group_visibility`

  use interactive_graph_t::change_group_visibility()

`var grcode_changed_graph`

  new graph has been set. @param g: (interactive_graph_t *) @retval 0: must return 0

`var grcode_clear`

  use interactive_graph_t::clear()

`var grcode_clicked`

  graph is being clicked. this callback allows you to ignore some clicks. it occurs too early, internal graph variables are not updated yet. current_item1, current_item2 point to the same thing. item2 has more information. see also: custom_viewer_click_t @param gv: (graph_viewer_t ) @param current_item1: (selection_item_t ) @param current_item2: (graph_item_t *) @retval 0: ok @retval 1: ignore click

`var grcode_create_circle_layout`

  use drawable_graph_t::create_circle_layout()

`var grcode_create_digraph_layout`

  use interactive_graph_t::create_digraph_layout()

`var grcode_create_disasm_graph1`

  use create_disasm_graph(ea_t ea)

`var grcode_create_disasm_graph2`

  use create_disasm_graph(const rangevec_t &ranges)

`var grcode_create_graph_viewer`

  use create_graph_viewer()

`var grcode_create_group`

  use interactive_graph_t::create_group()

`var grcode_create_interactive_graph`

  use create_interactive_graph()

`var grcode_create_tree_layout`

  use drawable_graph_t::create_tree_layout()

`var grcode_create_user_graph_place`

  use create_user_graph_place()

`var grcode_creating_group`

  a group is being created. this provides an opportunity for the graph to forbid creation of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. @param g: (interactive_graph_t ) @param nodes: (intvec_t ) @retval 0: ok @retval 1: forbid group creation

`var grcode_dblclicked`

  a graph node has been double clicked. @param gv: (graph_viewer_t ) @param current_item: (selection_item_t ) @retval 0: ok @retval 1: ignore click

`var grcode_del_custom_layout`

  use interactive_graph_t::del_custom_layout()

`var grcode_del_node_info`

  use viewer_del_node_info()

`var grcode_delete_group`

  use interactive_graph_t::delete_group()

`var grcode_delete_interactive_graph`

  use delete_interactive_graph()

`var grcode_deleting_group`

  a group is being deleted. this provides an opportunity for the graph to forbid deletion of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. @param g: (interactive_graph_t *) @param old_group: (int) @retval 0: ok @retval 1: forbid group deletion

`var grcode_destroyed`

  graph is being destroyed. Note that this doesn't mean the graph viewer is being destroyed; this only means that the graph that is being displayed by it is being destroyed, and that, e.g., any possibly cached data should be invalidated (this event can happen when, for example, the user decides to group nodes together: that operation will effectively create a new graph, that will replace the old one.) To be notified when the graph viewer itself is being destroyed, please see notification 'view_close', in kernwin.hpp @param g: (interactive_graph_t *) @retval 0: must return 0

`var grcode_edge_infos_wrapper_clear`

  use edge_infos_wrapper_t::clear()

`var grcode_edge_infos_wrapper_copy`

  use edge_infos_wrapper_t::operator=()

`var grcode_empty`

  use interactive_graph_t::empty()

`var grcode_find_subgraph_node`

  use interactive_graph_t::_find_subgraph_node()

`var grcode_fit_window`

  use viewer_fit_window()

`var grcode_get_curnode`

  use viewer_get_curnode()

`var grcode_get_custom_layout`

  use interactive_graph_t::get_custom_layout()

`var grcode_get_gli`

  use viewer_get_gli()

`var grcode_get_graph_groups`

  use interactive_graph_t::get_graph_groups()

`var grcode_get_graph_viewer`

  use get_graph_viewer()

`var grcode_get_node_info`

  use viewer_get_node_info()

`var grcode_get_node_representative`

  use interactive_graph_t::get_node_representative()

`var grcode_get_selection`

  use viewer_get_selection()

`var grcode_get_viewer_graph`

  use get_viewer_graph()

`var grcode_gotfocus`

  a graph viewer got focus. @param gv: (graph_viewer_t *) @retval 0: must return 0

`var grcode_group_visibility`

  a group is being collapsed/uncollapsed this provides an opportunity for the graph to forbid changing the visibility of the group. Note that groups management is done by the interactive_graph_t instance itself: there is no need to modify the graph in this callback. @param g: (interactive_graph_t *) @param group: (int) @param expand: (bool) @retval 0: ok @retval 1: forbid group modification

`var grcode_is_visible_node`

  use interactive_graph_t::is_visible_node()

`var grcode_layout_calculated`

  graph layout calculated. @param g: (interactive_graph_t *) @param layout_succeeded: (bool) @retval 0: must return 0

`var grcode_lostfocus`

  a graph viewer lost focus. @param gv: (graph_viewer_t *) @retval 0: must return 0

`var grcode_node_qty`

  use interactive_graph_t::node_qty()

`var grcode_nrect`

  use interactive_graph_t::nrect()

`var grcode_refresh_viewer`

  use refresh_viewer()

`var grcode_set_custom_layout`

  use interactive_graph_t::set_custom_layout()

`var grcode_set_edge`

  use interactive_graph_t::set_edge()

`var grcode_set_gli`

  use viewer_set_gli()

`var grcode_set_graph_groups`

  use interactive_graph_t::set_graph_groups()

`var grcode_set_node_info`

  use viewer_set_node_info()

`var grcode_set_titlebar_height`

  use viewer_set_titlebar_height()

`var grcode_set_viewer_graph`

  use set_viewer_graph()

`var grcode_user_draw`

  render node of a user-defined graph. NB: draw only on the specified DC and nowhere else! @param g: (interactive_graph_t ) @param node: (int) @param node_rect: (rect_t ) @param dc: (HDC) @retval 0: not rendered @retval 1: rendered

`var grcode_user_hint`

  retrieve hint for the user-defined graph. @param g: (interactive_graph_t ) @param mousenode: (int) @param mouseedge_src: (int) @param mouseedge_dst: (int) @param hint: (char *) must be allocated by qalloc() or qstrdup() @retval 0: use default hint @retval 1: use proposed hint

`var grcode_user_refresh`

  refresh user-defined graph nodes and edges This is called when the UI considers that it is necessary to recreate the graph layout, and thus has to ensure that the 'interactive_graph_t' instance it is using, is up-to-date. For example: * at graph creation-time * if a refresh_viewer() call was made @param g: (interactive_graph_t *) @return: success

`var grcode_user_size`

  calculate node size for user-defined graph. @param g: (interactive_graph_t ) @param node: (int) @param cx: (int ) @param cy: (int *) @retval 0: did not calculate. ida will use node text size @retval 1: calculated. ida will add node title to the size

`var grcode_user_text`

  retrieve text for user-defined graph node. NB: do not use anything calling GDI! @param g: (interactive_graph_t ) @param node: (int) @param result: (const char ) @param bg_color: (bgcolor_t ) may be nullptr @return: success, result must be filled

`var grcode_user_title`

  render node title of a user-defined graph. @param g: (interactive_graph_t ) @param node: (int) @param title_rect: (rect_t ) @param title_bg_color: (int) @param dc: (HDC) @retval 0: did not render, ida will fill it with title_bg_color @retval 1: rendered node title

`var grcode_viewer_create_groups_vec`

  use viewer_create_groups()

`var grcode_viewer_delete_groups_vec`

  use viewer_delete_groups()

`var grcode_viewer_groups_visibility_vec`

  use viewer_set_groups_visibility()

## Functions

`def calc_dist(p: point_t, q: point_t)`

  calc_dist(p, q) -> double Calculate distance between p and q.

  @param p: (C++: point_t) @param q: (C++: point_t)

`def clr_node_info(gid: graph_id_t, node: int, flags: uint32)`

  clr_node_info(gid, node, flags) Clear node info for the given node.

  @param gid: (C++: graph_id_t) id of desired graph @param node: (C++: int) node number @param flags: (C++: uint32) combination of Node info flags, identifying which fields of node_info_t will be cleared

`def create_disasm_graph(*args)`

  create_disasm_graph(ea) -> interactive_graph_t Create a graph using an arbitrary set of ranges.

  @param ea: ea_t

  create_disasm_graph(ranges) -> interactive_graph_t

  @param ranges: rangevec_t const &

`def create_graph_viewer(title: char const *, id: uval_t, callback: hook_cb_t *, ud: void *, title_height: int, parent: TWidget * = None)`

  create_graph_viewer(title, id, callback, ud, title_height, parent=None) -> graph_viewer_t Create a custom graph viewer.

  @param title: (C++: const char ) the widget title @param id: (C++: uval_t) graph id @param callback: (C++: hook_cb_t ) callback to handle graph notifications (graph_notification_t) @param ud: (C++: void ) user data passed to callback @param title_height: (C++: int) node title height @param parent: (C++: TWidget ) the parent widget of the graph viewer @return: new viewer

`def create_interactive_graph(id: uval_t)`

  create_interactive_graph(id) -> interactive_graph_t Create a new empty graph with given id.

  @param id: (C++: uval_t)

`def create_mutable_graph(id: uval_t)`

  create_interactive_graph(id) -> interactive_graph_t Create a new empty graph with given id.

  @param id: (C++: uval_t)

`def create_user_graph_place(node: int, lnnum: int)`

  create_user_graph_place(node, lnnum) -> user_graph_place_t Get a copy of a user_graph_place_t (returns a pointer to static storage)

  @param node: (C++: int) @param lnnum: (C++: int)

`def del_node_info(gid: graph_id_t, node: int)`

  del_node_info(gid, node) Delete the node_info_t for the given node.

  @param gid: (C++: graph_id_t) @param node: (C++: int)

`def delete_interactive_graph(g: interactive_graph_t)`

  delete_interactive_graph(g) Delete graph object. @warning: use this only if you are dealing with interactive_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

  @param g: (C++: interactive_graph_t *)

`def delete_mutable_graph(g: interactive_graph_t)`

  delete_interactive_graph(g) Delete graph object. @warning: use this only if you are dealing with interactive_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

  @param g: (C++: interactive_graph_t *)

`def get_graph_viewer(parent: TWidget *)`

  get_graph_viewer(parent) -> graph_viewer_t * Get custom graph viewer for given form.

  @param parent: (C++: TWidget *)

`def get_node_info(out: node_info_t, gid: graph_id_t, node: int)`

  get_node_info(out, gid, node) -> bool Get node info.

  @param out: (C++: node_info_t *) result @param gid: (C++: graph_id_t) id of desired graph @param node: (C++: int) node number @return: success

`def get_viewer_graph(gv: graph_viewer_t *)`

  get_viewer_graph(gv) -> interactive_graph_t Get graph object for given custom graph viewer.

  @param gv: (C++: graph_viewer_t *)

`def pyg_close(_self: PyObject *)`

  pyg_close(_self)

  @param self: PyObject *

`def pyg_select_node(_self: PyObject *, nid: int)`

  pyg_select_node(_self, nid)

  @param self: PyObject * @param nid: int

`def pyg_show(_self: PyObject *)`

  pyg_show(_self) -> bool

  @param self: PyObject *

`def refresh_viewer(gv: graph_viewer_t *)`

  refresh_viewer(gv) Redraw the graph in the given view.

  @param gv: (C++: graph_viewer_t *)

`def set_node_info(gid: graph_id_t, node: int, ni: node_info_t, flags: uint32)`

  set_node_info(gid, node, ni, flags) Set node info.

  @param gid: (C++: graph_id_t) id of desired graph @param node: (C++: int) node number @param ni: (C++: const node_info_t &) node info to use @param flags: (C++: uint32) combination of Node info flags, identifying which fields of 'ni' will be used

`def set_viewer_graph(gv: graph_viewer_t *, g: interactive_graph_t)`

  set_viewer_graph(gv, g) Set the underlying graph object for the given viewer.

  @param gv: (C++: graph_viewer_t ) @param g: (C++: interactive_graph_t )

`def viewer_attach_menu_item(g: graph_viewer_t *, name: char const *)`

  viewer_attach_menu_item(g, name) -> bool Attach a previously-registered action to the view's context menu. See kernwin.hpp for how to register actions.

  @param g: (C++: graph_viewer_t ) graph viewer @param name: (C++: const char ) action name @return: success

`def viewer_center_on(gv: graph_viewer_t *, node: int)`

  viewer_center_on(gv, node) Center the graph view on the given node.

  @param gv: (C++: graph_viewer_t *) @param node: (C++: int)

`def viewer_create_groups(gv: graph_viewer_t *, out_group_nodes: intvec_t *, gi: groups_crinfos_t const &)`

  viewer_create_groups(gv, out_group_nodes, gi) -> 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 interactive_graph_t::create_group that will, in essence: * clone the current graph * for each group_crinfo_t, attempt creating group in that new graph * if all were successful, animate to that new graph. @note: this accepts parameters that allow creating of multiple groups at once; which means only one graph animation will be triggered.

  @param gv: (C++: graph_viewer_t ) @param out_group_nodes: (C++: intvec_t ) @param gi: (C++: const groups_crinfos_t &) groups_crinfos_t const &

`def viewer_del_node_info(gv: graph_viewer_t *, n: int)`

  viewer_del_node_info(gv, n) Delete node info for node in given viewer (see del_node_info())

  @param gv: (C++: graph_viewer_t *) @param n: (C++: int)

`def viewer_delete_groups(gv: graph_viewer_t *, groups: intvec_t const &, new_current: int = -1)`

  viewer_delete_groups(gv, groups, new_current=-1) -> bool Wrapper around interactive_graph_t::delete_group. This function will: * clone the current graph * attempt deleting the groups in that new graph * if successful, animate to that new graph.

  @param gv: (C++: graph_viewer_t *) @param groups: (C++: const intvec_t &) intvec_t const & @param new_current: (C++: int)

`def viewer_fit_window(gv: graph_viewer_t *)`

  viewer_fit_window(gv) Fit graph viewer to its parent form.

  @param gv: (C++: graph_viewer_t *)

`def viewer_get_curnode(gv: graph_viewer_t *)`

  viewer_get_curnode(gv) -> int Get number of currently selected node (-1 if none)

  @param gv: (C++: graph_viewer_t *)

`def viewer_get_gli(out: graph_location_info_t *, gv: graph_viewer_t *, flags: uint32 = 0)`

  viewer_get_gli(out, gv, flags=0) -> 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.

  @param out: (C++: graph_location_info_t ) @param gv: (C++: graph_viewer_t ) @param flags: (C++: uint32)

`def viewer_get_node_info(gv: graph_viewer_t *, out: node_info_t, n: int)`

  viewer_get_node_info(gv, out, n) -> bool Get node info for node in given viewer (see get_node_info())

  @param gv: (C++: graph_viewer_t ) @param out: (C++: node_info_t ) @param n: (C++: int)

`def viewer_get_selection(gv: graph_viewer_t *, sgs: screen_graph_selection_t)`

  viewer_get_selection(gv, sgs) -> bool Get currently selected items for graph viewer.

  @param gv: (C++: graph_viewer_t ) @param sgs: (C++: screen_graph_selection_t )

`def viewer_set_gli(gv: graph_viewer_t *, gli: graph_location_info_t const *, flags: uint32 = 0)`

  viewer_set_gli(gv, gli, flags=0) 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.

  @param gv: (C++: graph_viewer_t ) @param gli: (C++: const graph_location_info_t ) graph_location_info_t const * @param flags: (C++: uint32)

`def viewer_set_groups_visibility(gv: graph_viewer_t *, groups: intvec_t const &, expand: bool, new_current: int = -1)`

  viewer_set_groups_visibility(gv, groups, expand, new_current=-1) -> bool Wrapper around interactive_graph_t::change_visibility. This function will: * clone the current graph * attempt changing visibility of the groups in that new graph * if successful, animate to that new graph.

  @param gv: (C++: graph_viewer_t *) @param groups: (C++: const intvec_t &) intvec_t const & @param expand: (C++: bool) @param new_current: (C++: int)

`def viewer_set_node_info(gv: graph_viewer_t *, n: int, ni: node_info_t, flags: uint32)`

  viewer_set_node_info(gv, n, ni, flags) Set node info for node in given viewer (see set_node_info())

  @param gv: (C++: graph_viewer_t *) @param n: (C++: int) @param ni: (C++: const node_info_t &) node_info_t const & @param flags: (C++: uint32)

`def viewer_set_titlebar_height(gv: graph_viewer_t *, height: int)`

  viewer_set_titlebar_height(gv, height) -> int Set height of node title bars (grcode_set_titlebar_height)

  @param gv: (C++: graph_viewer_t *) @param 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

  @param title: The title of the graph window @param close_open: Should it attempt to close an existing graph (with same title) before creating this graph?

  ### Ancestors

  - CustomIDAMemo
  - View_Hooks

  ### 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

  - `CustomIDAMemo`:
    - `CreateGroups`
    - `DelNodesInfos`
    - `DeleteGroups`
    - `GetNodeInfo`
    - `GetWidget`
    - `GetWidgetAsGraphViewer`
    - `Refresh`
    - `SetCurrentRendererType`
    - `SetGroupsVisibility`
    - `SetNodeInfo`
    - `SetNodesInfos`
    - `hook`
    - `thisown`
    - `unhook`
    - `view_activated`
    - `view_click`
    - `view_close`
    - `view_created`
    - `view_curpos`
    - `view_dblclick`
    - `view_deactivated`
    - `view_keydown`
    - `view_loc_changed`
    - `view_mouse_moved`
    - `view_mouse_over`
    - `view_switched`
`class TPointDouble (*args)`

  Proxy of C++ TPointDouble class.

  init(self) -> TPointDouble init(self, a, b) -> TPointDouble

  @param a: double @param b: double

  init(self, r) -> TPointDouble

  @param r: point_t const &

  ### Instance variables

  `var thisown`

    The membership flag

  `var x : double`

    x

  `var y : double`

    y

  ### Methods

  `def add(self, r: TPointDouble)`

    add(self, r)

    @param r: TPointDouble const &

  `def negate(self)`

    negate(self)

  `def sub(self, r: TPointDouble)`

    sub(self, r)

    @param r: TPointDouble const &

`class drawable_graph_t`

  Proxy of C++ drawable_graph_t class.

  init(self) -> drawable_graph_t

  @param self: PyObject *

  ### Ancestors

  - gdl_graph_t

  ### Subclasses

  - interactive_graph_t

  ### Instance variables

  `var callback_ud : void *`

    user data for callback

  `var circle_center : point_t`

    for layout_circle

  `var circle_radius : int`

    for layout_circle

  `var current_layout : layout_type_t`

    see Proximity view layouts

  `var rect_edges_made : bool`

    have create rectangular edges?

  `var thisown`

    The membership flag

  `var title : qstring`

    graph title

  ### Methods

  `def create_circle_layout(self, p: point_t, radius: int) ‑> bool`

    create_circle_layout(self, p, radius) -> bool

    @param p: point_t @param radius: int

  `def create_tree_layout(self) ‑> bool`

    create_tree_layout(self) -> bool

  `def get_edge(self, e: edge_t)`

    get_edge(self, e) -> edge_info_t

    @param e: edge_t

  `def grcall(self, code: int)`

    grcall(self, code) -> ssize_t

    @param code: int

  `def nrect(self, n: int) ‑> rect_t`

    nrect(self, n) -> rect_t

    @param n: int

  `def set_callback(self, _callback: hook_cb_t *, _ud: void *)`

    set_callback(self, _callback, _ud)

    @param _callback: hook_cb_t * @param _ud: void *

`class abstract_graph_t`

  Proxy of C++ drawable_graph_t class.

  init(self) -> drawable_graph_t

  @param self: PyObject *

  ### Ancestors

  - gdl_graph_t

  ### Subclasses

  - interactive_graph_t

  ### Instance variables

  `var callback_ud : void *`

    user data for callback

  `var circle_center : point_t`

    for layout_circle

  `var circle_radius : int`

    for layout_circle

  `var current_layout : layout_type_t`

    see Proximity view layouts

  `var rect_edges_made : bool`

    have create rectangular edges?

  `var title : qstring`

    graph title

  ### Methods

  `def create_circle_layout(self, p: point_t, radius: int) ‑> bool`

    create_circle_layout(self, p, radius) -> bool

    @param p: point_t @param radius: int

  `def create_tree_layout(self) ‑> bool`

    create_tree_layout(self) -> bool

  `def get_edge(self, e: edge_t)`

    get_edge(self, e) -> edge_info_t

    @param e: edge_t

  `def grcall(self, code: int)`

    grcall(self, code) -> ssize_t

    @param code: int

  `def nrect(self, n: int) ‑> rect_t`

    nrect(self, n) -> rect_t

    @param n: int

  `def set_callback(self, _callback: hook_cb_t *, _ud: void *)`

    set_callback(self, _callback, _ud)

    @param _callback: hook_cb_t * @param _ud: void *

  ### Inherited members

  - `gdl_graph_t`:
    - `begin`
    - `edge`
    - `empty`
    - `end`
    - `entry`
    - `exists`
    - `exit`
    - `front`
    - `get_edge_color`
    - `get_node_color`
    - `get_node_label`
    - `nedge`
    - `node_qty`
    - `npred`
    - `nsucc`
    - `pred`
    - `print_edge`
    - `print_graph_attributes`
    - `print_node`
    - `print_node_attributes`
    - `size`
    - `succ`
    - `thisown`
`class edge_info_t`

  Proxy of C++ edge_info_t class.

  init(self) -> edge_info_t

  ### Instance variables

  `var color : bgcolor_t`

    edge color

  `var dstoff : int`

    destination: edge port offset from the left

  `var layout : pointseq_t`

    describes geometry of edge

  `var srcoff : int`

    source: edge port offset from the left

  `var thisown`

    The membership flag

  `var width : int`

    edge width

  ### Methods

  `def reverse_layout(self)`

    reverse_layout(self)

`class edge_infos_wrapper_t (*args, **kwargs)`

  Proxy of C++ edge_infos_wrapper_t class.

  ### Instance variables

  `var ptr : edge_infos_t *`

    ptr

  `var thisown`

    The membership flag

  ### Methods

  `def clear(self)`

    clear(self)

`class edge_layout_point_t (*args)`

  Proxy of C++ edge_layout_point_t class.

  init(self) -> edge_layout_point_t init(self, _e, _pidx) -> edge_layout_point_t

  @param _e: edge_t const & @param _pidx: int

  ### Instance variables

  `var e : edge_t`

    parent edge

  `var pidx : int`

    index into edge_info_t::layout

  `var thisown`

    The membership flag

  ### Methods

  `def compare(self, r: edge_layout_point_t) ‑> int`

    compare(self, r) -> int

    @param r: edge_layout_point_t const &

`class edge_segment_t`

  Proxy of C++ edge_segment_t class.

  init(self) -> edge_segment_t

  ### Instance variables

  `var e : edge_t`

    e

  `var nseg : int`

    nseg

  `var thisown`

    The membership flag

  `var x0 : int`

    x0

  `var x1 : int`

    x1

  ### Methods

  `def length(self)`

    length(self) -> size_t

  `def toright(self) ‑> bool`

    toright(self) -> bool

`class graph_item_t`

  Proxy of C++ graph_item_t class.

  init(self) -> graph_item_t

  ### Instance variables

  `var b : int`

    button number

  `var e : edge_t`

    edge source and destination

  `var elp : edge_layout_point_t`

    edge layout point

  `var n : int`

    node number

  `var p : point_t`

    text coordinates in the node

  `var thisown`

    The membership flag

  `var type : graph_item_type_t`

    type

  ### Methods

  `def is_edge(self) ‑> bool`

    is_edge(self) -> bool

  `def is_node(self) ‑> bool`

    is_node(self) -> bool

`class graph_node_visitor_t`

  Proxy of C++ graph_node_visitor_t class.

  init(self) -> graph_node_visitor_t

  @param self: PyObject *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def is_forbidden_edge(self, arg0: int, arg1: int) ‑> bool`

    is_forbidden_edge(self, arg0, arg1) -> bool Should the edge between 'n' and 'm' be ignored?

    @param arg0: int @param arg1: int

  `def is_visited(self, n: int) ‑> bool`

    is_visited(self, n) -> bool Have we already visited the given node?

    @param n: (C++: int)

  `def reinit(self)`

    reinit(self) Reset visited nodes.

  `def set_visited(self, n: int)`

    set_visited(self, n) Mark node as visited.

    @param n: (C++: int)

  `def visit_node(self, arg0: int) ‑> int`

    visit_node(self, arg0) -> int Implements action to take when a node is visited.

    @param arg0: int

`class graph_path_visitor_t`

  Proxy of C++ graph_path_visitor_t class.

  init(self) -> graph_path_visitor_t

  @param self: PyObject *

  ### Instance variables

  `var path : intvec_t`

    current path

  `var prune : bool`

    walk_forward(): prune := true means to stop the current path

  `var thisown`

    The membership flag

  ### Methods

  `def walk_backward(self, arg0: int) ‑> int`

    walk_backward(self, arg0) -> int

    @param arg0: int

  `def walk_forward(self, arg0: int) ‑> int`

    walk_forward(self, arg0) -> int

    @param arg0: int

`class graph_visitor_t`

  Proxy of C++ graph_visitor_t class.

  init(self) -> graph_visitor_t

  @param self: PyObject *

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def visit_edge(self, arg2: edge_t, arg3: edge_info_t) ‑> int`

    visit_edge(self, arg2, arg3) -> int

    @param arg2: edge_t @param arg3: edge_info_t *

  `def visit_node(self, arg2: int, arg3: rect_t) ‑> int`

    visit_node(self, arg2, arg3) -> int

    @param arg2: int @param arg3: rect_t &

`class group_crinfo_t`

  Proxy of C++ group_crinfo_t class.

  init(self) -> group_crinfo_t

  ### Instance variables

  `var nodes : intvec_t`

    nodes

  `var text : qstring`

    text

  `var thisown`

    The membership flag

`class interactive_graph_t (*args, **kwargs)`

  Proxy of C++ interactive_graph_t class.

  init(self) -> drawable_graph_t

  @param self: PyObject *

  ### Ancestors

  - drawable_graph_t
  - gdl_graph_t

  ### Instance variables

  `var belongs : intvec_t`

    the subgraph the node belongs to INT_MAX means that the node doesn't exist sign bit means collapsed node

  `var edges : edge_infos_wrapper_t`

    edges

  `var gid : uval_t`

    graph id - unique for the database for flowcharts it is equal to the function start_ea

  `var node_flags : bytevec_t`

    node flags

  `var nodes : interactive_graph_t::node_layout_t`

    nodes

  `var org_preds : array_of_intvec_t`

    org_preds

  `var org_succs : array_of_intvec_t`

    org_succs

  `var preds : array_of_intvec_t`

    preds

  `var succs : array_of_intvec_t`

    succs

  `var thisown`

    The membership flag

  ### Methods

  `def add_edge(self, i: int, j: int, ei: edge_info_t) ‑> bool`

    add_edge(self, i, j, ei) -> bool

    @param i: int @param j: int @param ei: edge_info_t const *

  `def add_node(self, r: rect_t) ‑> int`

    add_node(self, r) -> int Add a node, possibly with a specific geometry

    @param r: (C++: const rect_t *) the node geometry (can be nullptr) @return: the new node

  `def calc_group_ea(self, arg2: intvec_t const &)`

    calc_group_ea(self, arg2) -> ea_t

    @param arg2: intvec_t const &

  `def change_group_visibility(self, group: int, expand: bool) ‑> bool`

    change_group_visibility(self, group, expand) -> bool Expand/collapse a group node

    @param group: (C++: int) the group node @param expand: (C++: bool) whether to expand or collapse @return: success

  `def create_digraph_layout(self) ‑> bool`

    create_digraph_layout(self) -> bool

  `def create_group(self, nodes: intvec_t const &)`

    create_group(self, nodes) -> int Create a new group node, that will contain all the nodes in 'nodes'.

    @param nodes: (C++: const intvec_t &) the nodes that will be part of the group @return: the group node, or -1 in case of error

  `def del_custom_layout(self)`

    del_custom_layout(self)

  `def del_edge(self, i: int, j: int) ‑> bool`

    del_edge(self, i, j) -> bool

    @param i: int @param j: int

  `def del_node(self, n: int)`

    del_node(self, n) -> ssize_t Delete a node

    @param n: (C++: int) the node to delete @return: the number of deleted edges

  `def delete_group(self, group: int) ‑> bool`

    delete_group(self, group) -> bool Delete a group node.

    This deletes the group node only; it does not delete nodes that are part of the group.

    @param group: (C++: int) the group node @return: success

  `def empty(self) ‑> bool`

    empty(self) -> bool Is the graph (visually) empty?

    @return: true if there are no visible nodes

  `def exists(self, node: int) ‑> bool`

    exists(self, node) -> bool Is the node visible?

    @param node: (C++: int) the node number @return: success

  `def get_custom_layout(self) ‑> bool`

    get_custom_layout(self) -> bool

  `def get_first_subgraph_node(self, group: int) ‑> int`

    get_first_subgraph_node(self, group) -> int

    @param group: int

  `def get_graph_groups(self) ‑> bool`

    get_graph_groups(self) -> bool

  `def get_next_subgraph_node(self, group: int, current: int) ‑> int`

    get_next_subgraph_node(self, group, current) -> int

    @param group: int @param current: int

  `def get_node_group(self, node: int) ‑> int`

    get_node_group(self, node) -> int

    @param node: int

  `def get_node_representative(self, node: int) ‑> int`

    get_node_representative(self, node) -> 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()

    @param node: (C++: int) the node @return: the node that represents 'node', or 'node' if it's not part of any group

  `def is_collapsed_node(self, node: int) ‑> bool`

    is_collapsed_node(self, node) -> bool

    @param node: int

  `def is_deleted_node(self, node: int) ‑> bool`

    is_deleted_node(self, node) -> bool

    @param node: int

  `def is_displayable_node(self, node: int) ‑> bool`

    is_displayable_node(self, node) -> bool

    @param node: int

  `def is_dot_node(self, node: int) ‑> bool`

    is_dot_node(self, node) -> bool

    @param node: int

  `def is_group_node(self, node: int) ‑> bool`

    is_group_node(self, node) -> bool

    @param node: int

  `def is_simple_node(self, node: int) ‑> bool`

    is_simple_node(self, node) -> bool

    @param node: int

  `def is_subgraph_node(self, node: int) ‑> bool`

    is_subgraph_node(self, node) -> bool

    @param node: int

  `def is_uncollapsed_node(self, node: int) ‑> bool`

    is_uncollapsed_node(self, node) -> bool

    @param node: int

  `def is_user_graph(self) ‑> bool`

    is_user_graph(self) -> bool

  `def is_visible_node(self, node: int) ‑> bool`

    is_visible_node(self, node) -> bool Is the node currently visible?

    An invisible node is a node that's part of a group that's currently collapsed.

    @param node: (C++: int) the node @return: success

  `def node_qty(self) ‑> int`

    node_qty(self) -> int Get the number of visible nodes (the list can be retrieved using gdl.hpp's node_iterator)

    See also size()

    @return: the number of visible nodes

  `def npred(self, b: int) ‑> int`

    npred(self, b) -> int

    @param b: int

  `def nsucc(self, b: int) ‑> int`

    nsucc(self, b) -> int

    @param b: int

  `def pred(self, b: int, i: int) ‑> int`

    pred(self, b, i) -> int

    @param b: int @param i: int

  `def predset(self, b: int)`

    predset(self, b) -> intvec_t const &

    @param b: int

  `def redo_layout(self) ‑> bool`

    redo_layout(self) -> bool Recompute the layout, according to the value of 'current_layout'.

    @return: success

  `def refresh(self) ‑> bool`

    refresh(self) -> bool Refresh the graph

    A 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 interactive_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 far * re-create internal rendering information, and * repaint the view

    @return: success

  `def replace_edge(self, i: int, j: int, x: int, y: int) ‑> bool`

    replace_edge(self, i, j, x, y) -> bool

    @param i: int @param j: int @param x: int @param y: int

  `def reset(self)`

    reset(self)

  `def resize(self, n: int)`

    resize(self, n) Resize the graph to 'n' nodes

    @param n: (C++: int) the new size

  `def set_custom_layout(self)`

    set_custom_layout(self)

  `def set_deleted_node(self, node: int)`

    set_deleted_node(self, node)

    @param node: int

  `def set_edge(self, e: edge_t, ei: edge_info_t) ‑> bool`

    set_edge(self, e, ei) -> bool

    @param e: edge_t @param ei: edge_info_t const *

  `def set_graph_groups(self)`

    set_graph_groups(self)

  `def set_node_group(self, node: int, group: int)`

    set_node_group(self, node, group)

    @param node: int @param group: int

  `def set_nrect(self, n: int, r: rect_t) ‑> bool`

    set_nrect(self, n, r) -> bool

    @param n: int @param r: rect_t const &

  `def size(self) ‑> int`

    size(self) -> int Get the total number of nodes (including group nodes, and including hidden nodes.)

    See also node_qty()

    @return: the total number of nodes in the graph

  `def succ(self, b: int, i: int) ‑> int`

    succ(self, b, i) -> int

    @param b: int @param i: int

  `def succset(self, b: int)`

    succset(self, b) -> intvec_t const &

    @param b: int

`class mutable_graph_t (*args, **kwargs)`

  Proxy of C++ interactive_graph_t class.

  init(self) -> drawable_graph_t

  @param self: PyObject *

  ### Ancestors

  - drawable_graph_t
  - gdl_graph_t

  ### Instance variables

  `var belongs : intvec_t`

    the subgraph the node belongs to INT_MAX means that the node doesn't exist sign bit means collapsed node

  `var edges : edge_infos_wrapper_t`

    edges

  `var gid : uval_t`

    graph id - unique for the database for flowcharts it is equal to the function start_ea

  `var node_flags : bytevec_t`

    node flags

  `var nodes : interactive_graph_t::node_layout_t`

    nodes

  `var org_preds : array_of_intvec_t`

    org_preds

  `var org_succs : array_of_intvec_t`

    org_succs

  `var preds : array_of_intvec_t`

    preds

  `var succs : array_of_intvec_t`

    succs

  ### Methods

  `def add_edge(self, i: int, j: int, ei: edge_info_t) ‑> bool`

    add_edge(self, i, j, ei) -> bool

    @param i: int @param j: int @param ei: edge_info_t const *

  `def add_node(self, r: rect_t) ‑> int`

    add_node(self, r) -> int Add a node, possibly with a specific geometry

    @param r: (C++: const rect_t *) the node geometry (can be nullptr) @return: the new node

  `def calc_group_ea(self, arg2: intvec_t const &)`

    calc_group_ea(self, arg2) -> ea_t

    @param arg2: intvec_t const &

  `def change_group_visibility(self, group: int, expand: bool) ‑> bool`

    change_group_visibility(self, group, expand) -> bool Expand/collapse a group node

    @param group: (C++: int) the group node @param expand: (C++: bool) whether to expand or collapse @return: success

  `def create_digraph_layout(self) ‑> bool`

    create_digraph_layout(self) -> bool

  `def create_group(self, nodes: intvec_t const &)`

    create_group(self, nodes) -> int Create a new group node, that will contain all the nodes in 'nodes'.

    @param nodes: (C++: const intvec_t &) the nodes that will be part of the group @return: the group node, or -1 in case of error

  `def del_custom_layout(self)`

    del_custom_layout(self)

  `def del_edge(self, i: int, j: int) ‑> bool`

    del_edge(self, i, j) -> bool

    @param i: int @param j: int

  `def del_node(self, n: int)`

    del_node(self, n) -> ssize_t Delete a node

    @param n: (C++: int) the node to delete @return: the number of deleted edges

  `def delete_group(self, group: int) ‑> bool`

    delete_group(self, group) -> bool Delete a group node.

    This deletes the group node only; it does not delete nodes that are part of the group.

    @param group: (C++: int) the group node @return: success

  `def empty(self) ‑> bool`

    empty(self) -> bool Is the graph (visually) empty?

    @return: true if there are no visible nodes

  `def exists(self, node: int) ‑> bool`

    exists(self, node) -> bool Is the node visible?

    @param node: (C++: int) the node number @return: success

  `def get_custom_layout(self) ‑> bool`

    get_custom_layout(self) -> bool

  `def get_first_subgraph_node(self, group: int) ‑> int`

    get_first_subgraph_node(self, group) -> int

    @param group: int

  `def get_graph_groups(self) ‑> bool`

    get_graph_groups(self) -> bool

  `def get_next_subgraph_node(self, group: int, current: int) ‑> int`

    get_next_subgraph_node(self, group, current) -> int

    @param group: int @param current: int

  `def get_node_group(self, node: int) ‑> int`

    get_node_group(self, node) -> int

    @param node: int

  `def get_node_representative(self, node: int) ‑> int`

    get_node_representative(self, node) -> 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()

    @param node: (C++: int) the node @return: the node that represents 'node', or 'node' if it's not part of any group

  `def is_collapsed_node(self, node: int) ‑> bool`

    is_collapsed_node(self, node) -> bool

    @param node: int

  `def is_deleted_node(self, node: int) ‑> bool`

    is_deleted_node(self, node) -> bool

    @param node: int

  `def is_displayable_node(self, node: int) ‑> bool`

    is_displayable_node(self, node) -> bool

    @param node: int

  `def is_dot_node(self, node: int) ‑> bool`

    is_dot_node(self, node) -> bool

    @param node: int

  `def is_group_node(self, node: int) ‑> bool`

    is_group_node(self, node) -> bool

    @param node: int

  `def is_simple_node(self, node: int) ‑> bool`

    is_simple_node(self, node) -> bool

    @param node: int

  `def is_subgraph_node(self, node: int) ‑> bool`

    is_subgraph_node(self, node) -> bool

    @param node: int

  `def is_uncollapsed_node(self, node: int) ‑> bool`

    is_uncollapsed_node(self, node) -> bool

    @param node: int

  `def is_user_graph(self) ‑> bool`

    is_user_graph(self) -> bool

  `def is_visible_node(self, node: int) ‑> bool`

    is_visible_node(self, node) -> bool Is the node currently visible?

    An invisible node is a node that's part of a group that's currently collapsed.

    @param node: (C++: int) the node @return: success

  `def node_qty(self) ‑> int`

    node_qty(self) -> int Get the number of visible nodes (the list can be retrieved using gdl.hpp's node_iterator)

    See also size()

    @return: the number of visible nodes

  `def npred(self, b: int) ‑> int`

    npred(self, b) -> int

    @param b: int

  `def nsucc(self, b: int) ‑> int`

    nsucc(self, b) -> int

    @param b: int

  `def pred(self, b: int, i: int) ‑> int`

    pred(self, b, i) -> int

    @param b: int @param i: int

  `def predset(self, b: int)`

    predset(self, b) -> intvec_t const &

    @param b: int

  `def redo_layout(self) ‑> bool`

    redo_layout(self) -> bool Recompute the layout, according to the value of 'current_layout'.

    @return: success

  `def refresh(self) ‑> bool`

    refresh(self) -> bool Refresh the graph

    A 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 interactive_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 far * re-create internal rendering information, and * repaint the view

    @return: success

  `def replace_edge(self, i: int, j: int, x: int, y: int) ‑> bool`

    replace_edge(self, i, j, x, y) -> bool

    @param i: int @param j: int @param x: int @param y: int

  `def reset(self)`

    reset(self)

  `def resize(self, n: int)`

    resize(self, n) Resize the graph to 'n' nodes

    @param n: (C++: int) the new size

  `def set_custom_layout(self)`

    set_custom_layout(self)

  `def set_deleted_node(self, node: int)`

    set_deleted_node(self, node)

    @param node: int

  `def set_edge(self, e: edge_t, ei: edge_info_t) ‑> bool`

    set_edge(self, e, ei) -> bool

    @param e: edge_t @param ei: edge_info_t const *

  `def set_graph_groups(self)`

    set_graph_groups(self)

  `def set_node_group(self, node: int, group: int)`

    set_node_group(self, node, group)

    @param node: int @param group: int

  `def set_nrect(self, n: int, r: rect_t) ‑> bool`

    set_nrect(self, n, r) -> bool

    @param n: int @param r: rect_t const &

  `def size(self) ‑> int`

    size(self) -> int Get the total number of nodes (including group nodes, and including hidden nodes.)

    See also node_qty()

    @return: the total number of nodes in the graph

  `def succ(self, b: int, i: int) ‑> int`

    succ(self, b, i) -> int

    @param b: int @param i: int

  `def succset(self, b: int)`

    succset(self, b) -> intvec_t const &

    @param b: int

  ### Inherited members

  - `drawable_graph_t`:
    - `begin`
    - `callback_ud`
    - `circle_center`
    - `circle_radius`
    - `create_circle_layout`
    - `create_tree_layout`
    - `current_layout`
    - `edge`
    - `end`
    - `entry`
    - `exit`
    - `front`
    - `get_edge`
    - `get_edge_color`
    - `get_node_color`
    - `get_node_label`
    - `grcall`
    - `nedge`
    - `nrect`
    - `print_edge`
    - `print_graph_attributes`
    - `print_node`
    - `print_node_attributes`
    - `rect_edges_made`
    - `set_callback`
    - `thisown`
    - `title`
`class interval_t (*args)`

  Proxy of C++ interval_t class.

  init(self) -> interval_t init(self, y0, y1) -> interval_t

  @param y0: int @param y1: int

  init(self, s) -> interval_t

  @param s: edge_segment_t const &

  ### Instance variables

  `var thisown`

    The membership flag

  `var x0 : int`

    x0

  `var x1 : int`

    x1

  ### Methods

  `def contains(self, x: int) ‑> bool`

    contains(self, x) -> bool

    @param x: int

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def intersect(self, r: interval_t)`

    intersect(self, r)

    @param r: interval_t const &

  `def length(self) ‑> int`

    length(self) -> int

  `def make_union(self, r: interval_t)`

    make_union(self, r)

    @param r: interval_t const &

  `def move_by(self, shift: int)`

    move_by(self, shift)

    @param shift: int

`class node_info_t`

  Proxy of C++ node_info_t class.

  init(self) -> node_info_t

  ### Instance variables

  `var bg_color : bgcolor_t`

    background color

  `var ea : ea_t`

    address

  `var flags : uint32`

    flags

  `var frame_color : bgcolor_t`

    color of enclosing frame

  `var text : qstring`

    node contents

  `var thisown`

    The membership flag

  ### Methods

  `def get_flags_for_valid(self)`

    get_flags_for_valid(self) -> uint32 Get combination of Node info flags describing which attributes are valid.

  `def valid_bg_color(self) ‑> bool`

    valid_bg_color(self) -> bool Has valid bg_color?

  `def valid_ea(self) ‑> bool`

    valid_ea(self) -> bool Has valid ea?

  `def valid_flags(self) ‑> bool`

    valid_flags(self) -> bool Has valid flags?

  `def valid_frame_color(self) ‑> bool`

    valid_frame_color(self) -> bool Has valid frame_color?

  `def valid_text(self) ‑> bool`

    valid_text(self) -> bool Has non-empty text?

`class node_layout_t (*args)`

  Proxy of C++ qvector< rect_t > class.

  init(self) -> node_layout_t init(self, x) -> node_layout_t

  @param x: qvector< rect_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: rect_t) ‑> bool`

    add_unique(self, x) -> bool

    @param x: rect_t const &

  `def at(self, _idx: size_t)`

    at(self, _idx) -> rect_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> rect_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> rect_t

  `def erase(self, *args)`

    erase(self, it) -> rect_t

    @param it: qvector< rect_t >::iterator

    erase(self, first, last) -> rect_t

    @param first: qvector< rect_t >::iterator @param last: qvector< rect_t >::iterator

  `def extract(self)`

    extract(self) -> rect_t

  `def find(self, *args)`

    find(self, x) -> rect_t

    @param x: rect_t const &

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=rect_t())

    @param x: rect_t const &

  `def has(self, x: rect_t) ‑> bool`

    has(self, x) -> bool

    @param x: rect_t const &

  `def inject(self, s: rect_t, len: size_t)`

    inject(self, s, len)

    @param s: rect_t * @param len: size_t

  `def insert(self, it: rect_t, x: rect_t)`

    insert(self, it, x) -> rect_t

    @param it: qvector< rect_t >::iterator @param x: rect_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: rect_t const &

    push_back(self) -> rect_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: rect_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: node_layout_t)`

    swap(self, r)

    @param r: qvector< rect_t > &

  `def truncate(self)`

    truncate(self)

`class point_t (*args)`

  Proxy of C++ point_t class.

  init(self) -> point_t init(self, _x, _y) -> point_t

  @param _x: int @param _y: int

  ### Instance variables

  `var thisown`

    The membership flag

  `var x : int`

    x

  `var y : int`

    y

  ### Methods

  `def add(self, r: point_t)`

    add(self, r) -> point_t

    @param r: point_t const &

  `def negate(self)`

    negate(self)

  `def sub(self, r: point_t)`

    sub(self, r) -> point_t

    @param r: point_t const &

`class pointseq_t`

  Proxy of C++ pointseq_t class.

  init(self) -> pointseq_t

  ### Ancestors

  - pointvec_t

  ### Inherited members

  - `pointvec_t`:
    - `add_unique`
    - `at`
    - `begin`
    - `capacity`
    - `clear`
    - `empty`
    - `end`
    - `erase`
    - `extract`
    - `find`
    - `grow`
    - `has`
    - `inject`
    - `insert`
    - `pop_back`
    - `push_back`
    - `qclear`
    - `reserve`
    - `resize`
    - `size`
    - `swap`
    - `thisown`
    - `truncate`
`class pointvec_t (*args)`

  Proxy of C++ qvector< point_t > class.

  init(self) -> pointvec_t init(self, x) -> pointvec_t

  @param x: qvector< point_t > const &

  ### Subclasses

  - pointseq_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: point_t) ‑> bool`

    add_unique(self, x) -> bool

    @param x: point_t const &

  `def at(self, _idx: size_t)`

    at(self, _idx) -> point_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> point_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> point_t

  `def erase(self, *args)`

    erase(self, it) -> point_t

    @param it: qvector< point_t >::iterator

    erase(self, first, last) -> point_t

    @param first: qvector< point_t >::iterator @param last: qvector< point_t >::iterator

  `def extract(self)`

    extract(self) -> point_t

  `def find(self, *args)`

    find(self, x) -> point_t

    @param x: point_t const &

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=point_t())

    @param x: point_t const &

  `def has(self, x: point_t) ‑> bool`

    has(self, x) -> bool

    @param x: point_t const &

  `def inject(self, s: point_t, len: size_t)`

    inject(self, s, len)

    @param s: point_t * @param len: size_t

  `def insert(self, it: point_t, x: point_t)`

    insert(self, it, x) -> point_t

    @param it: qvector< point_t >::iterator @param x: point_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: point_t const &

    push_back(self) -> point_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: point_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: pointvec_t)`

    swap(self, r)

    @param r: qvector< point_t > &

  `def truncate(self)`

    truncate(self)

`class rect_t (*args)`

  Proxy of C++ rect_t class.

  init(self) -> rect_t init(self, l, t, r, b) -> rect_t

  @param l: int @param t: int @param r: int @param b: int

  init(self, p0, p1) -> rect_t

  @param p0: point_t const & @param p1: point_t const &

  ### Instance variables

  `var bottom : int`

    bottom

  `var left : int`

    left

  `var right : int`

    right

  `var thisown`

    The membership flag

  `var top : int`

    top

  ### Methods

  `def area(self) ‑> int`

    area(self) -> int

  `def bottomright(self) ‑> point_t`

    bottomright(self) -> point_t

  `def center(self) ‑> point_t`

    center(self) -> point_t

  `def contains(self, p: point_t) ‑> bool`

    contains(self, p) -> bool

    @param p: point_t const &

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def grow(self, delta: int)`

    grow(self, delta)

    @param delta: int

  `def height(self) ‑> int`

    height(self) -> int

  `def intersect(self, r: rect_t)`

    intersect(self, r)

    @param r: rect_t const &

  `def is_intersection_empty(self, r: rect_t) ‑> bool`

    is_intersection_empty(self, r) -> bool

    @param r: rect_t const &

  `def make_union(self, r: rect_t)`

    make_union(self, r)

    @param r: rect_t const &

  `def move_by(self, p: point_t)`

    move_by(self, p)

    @param p: point_t const &

  `def move_to(self, p: point_t)`

    move_to(self, p)

    @param p: point_t const &

  `def topleft(self) ‑> point_t`

    topleft(self) -> point_t

  `def verify(self)`

    verify(self)

  `def width(self) ‑> int`

    width(self) -> int

`class row_info_t`

  Proxy of C++ row_info_t class.

  init(self) -> row_info_t

  ### Instance variables

  `var bottom : int`

    bottom y coord of the row

  `var nodes : intvec_t`

    list of nodes at the row

  `var thisown`

    The membership flag

  `var top : int`

    top y coord of the row

  ### Methods

  `def height(self) ‑> 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 init(self, x) -> screen_graph_selection_base_t

  @param x: qvector< selection_item_t > const &

  ### Subclasses

  - screen_graph_selection_t

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def add_unique(self, x: selection_item_t) ‑> bool`

    add_unique(self, x) -> bool

    @param x: selection_item_t const &

  `def at(self, _idx: size_t)`

    at(self, _idx) -> selection_item_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> selection_item_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> selection_item_t

  `def erase(self, *args)`

    erase(self, it) -> selection_item_t

    @param it: qvector< selection_item_t >::iterator

    erase(self, first, last) -> selection_item_t

    @param first: qvector< selection_item_t >::iterator @param last: qvector< selection_item_t >::iterator

  `def extract(self)`

    extract(self) -> selection_item_t

  `def find(self, *args)`

    find(self, x) -> selection_item_t

    @param x: selection_item_t const &

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=selection_item_t())

    @param x: selection_item_t const &

  `def has(self, x: selection_item_t) ‑> bool`

    has(self, x) -> bool

    @param x: selection_item_t const &

  `def inject(self, s: selection_item_t, len: size_t)`

    inject(self, s, len)

    @param s: selection_item_t * @param len: size_t

  `def insert(self, it: selection_item_t, x: selection_item_t)`

    insert(self, it, x) -> selection_item_t

    @param it: qvector< selection_item_t >::iterator @param x: selection_item_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: selection_item_t const &

    push_back(self) -> selection_item_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: selection_item_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: screen_graph_selection_base_t)`

    swap(self, r)

    @param r: qvector< selection_item_t > &

  `def truncate(self)`

    truncate(self)

`class screen_graph_selection_t`

  Proxy of C++ screen_graph_selection_t class.

  init(self) -> screen_graph_selection_t

  ### Ancestors

  - screen_graph_selection_base_t

  ### Methods

  `def add(self, s: screen_graph_selection_t)`

    add(self, s)

    @param s: screen_graph_selection_t const &

  `def add_node(self, node: int)`

    add_node(self, node)

    @param node: int

  `def add_point(self, e: edge_t, idx: int)`

    add_point(self, e, idx)

    @param e: edge_t @param idx: int

  `def del_node(self, node: int)`

    del_node(self, node)

    @param node: int

  `def del_point(self, e: edge_t, idx: int)`

    del_point(self, e, idx)

    @param e: edge_t @param idx: int

  `def has(self, item: selection_item_t) ‑> bool`

    has(self, item) -> bool

    @param item: selection_item_t const &

  `def items_count(self, look_for_nodes: bool)`

    items_count(self, look_for_nodes) -> size_t

    @param look_for_nodes: bool

  `def nodes_count(self)`

    nodes_count(self) -> size_t

  `def points_count(self)`

    points_count(self) -> size_t

  `def sub(self, s: screen_graph_selection_t)`

    sub(self, s)

    @param s: screen_graph_selection_t const &

  ### Inherited members

  - `screen_graph_selection_base_t`:
    - `add_unique`
    - `at`
    - `begin`
    - `capacity`
    - `clear`
    - `empty`
    - `end`
    - `erase`
    - `extract`
    - `find`
    - `grow`
    - `inject`
    - `insert`
    - `pop_back`
    - `push_back`
    - `qclear`
    - `reserve`
    - `resize`
    - `size`
    - `swap`
    - `thisown`
    - `truncate`
`class selection_item_t (*args)`

  Proxy of C++ selection_item_t class.

  init(self) -> selection_item_t init(self, n) -> selection_item_t

  @param n: int

  init(self, _elp) -> selection_item_t

  @param _elp: edge_layout_point_t &

  init(self, e, idx) -> selection_item_t

  @param e: edge_t @param idx: int

  ### Instance variables

  `var elp : edge_layout_point_t`

    edge layout point (is_node = false)

  `var is_node : bool`

    represents a selected node?

  `var node : int`

    node number (is_node = true)

  `var thisown`

    The membership flag

  ### Methods

  `def compare(self, r: selection_item_t) ‑> int`

    compare(self, r) -> int

    @param r: selection_item_t const &

`class user_graph_place_t (*args, **kwargs)`

  Proxy of C++ user_graph_place_t class.

  ### Instance variables

  `var node : int`

    node

  `var thisown`

    The membership flag