ida_kernwin

Defines the interface between the kernel and the UI.

It contains: * the UI dispatcher notification codes (ui_notification_t) * convenience functions for UI services * structures which hold information about the lines (disassembly, structures, enums) generated by the kernel * functions to interact with the user (dialog boxes) * some string and conversion functions.

Attributes

`SWIG_PYTHON_LEGACY_BOOL`
`MAX_SPACES_ADDED`
`mbox_internal`	internal error
`mbox_info`
`mbox_warning`
`mbox_error`
`mbox_nomem`
`mbox_feedback`
`mbox_readerror`
`mbox_writeerror`
`mbox_filestruct`
`mbox_wait`
`mbox_hide`
`mbox_replace`
`chtype_generic`	the generic choose() function
`chtype_idasgn`	see choose_idasgn()
`chtype_entry`	see choose_entry()
`chtype_name`	see choose_name()
`chtype_stkvar_xref`	see choose_stkvar_xref()
`chtype_xref`	see choose_xref()
`chtype_func`	see choose_func()
`chtype_segm`	see choose_segm()
`chtype_strpath`	see choose_struc_path()
`chtype_idatil`	see choose_til()
`chtype_srcp`	see choose_srcp()
`chtype_struct`	see choose_struct()
`chtype_enum`	see choose_enum()
`chtype_enum_by_value_and_size`	see choose_enum_by_value()
`beep_default`
`TCCRT_INVALID`	invalid
`TCCRT_FLAT`	flat view
`TCCRT_GRAPH`	graph view
`TCCRT_PROXIMITY`	proximity view
`TCCPT_INVALID`	invalid
`TCCPT_PLACE`	place_t
`TCCPT_SIMPLELINE_PLACE`	simpleline_place_t
`TCCPT_IDAPLACE`	idaplace_t
`TCCPT_TIPLACE`	tiplace_t
`VME_UNKNOWN`	unknown mouse button
`VME_LEFT_BUTTON`	left mouse button
`VME_RIGHT_BUTTON`	right mouse button
`VME_MID_BUTTON`	middle mouse button
`SETMENU_POSMASK`
`SETMENU_INS`	add menu item before the specified path (default)
`SETMENU_APP`	add menu item after the specified path
`SETMENU_FIRST`	add item to the beginning of menu
`SETMENU_ENSURE_SEP`	make sure there is a separator before the action
`CREATETB_ADV`	toolbar is for 'advanced mode' only
`HIF_IDENTIFIER`	text is an identifier (i.e., when searching for the current highlight, SEARCH_IDENT will be used)
`HIF_REGISTER`	text represents a register (aliases/subregisters will be highlit as well)
`HIF_LOCKED`	locked; clicking/moving the cursor around doesn't change the highlight
`HIF_NOCASE`	case insensitive
`HIF_USE_SLOT`	use the given number, or just use the "floating" highlight
`HIF_SLOT_SHIFT`	position of the 3 top bits specifying which highlight to use
`HIF_SLOT_0`	operate on slot 0
`HIF_SLOT_1`	operate on slot 1
`HIF_SLOT_2`	operate on slot 2
`HIF_SLOT_3`	operate on slot 3
`HIF_SLOT_4`	operate on slot 4
`HIF_SLOT_5`	operate on slot 5
`HIF_SLOT_6`	operate on slot 6
`HIF_SLOT_7`	operate on slot 7
`REG_HINTS_MARKER`
`REG_HINTS_MARKER_LEN`
`SRCDBG_HINTS_MARKER`
`SRCDBG_HINTS_MARKER_LEN`
`CDVF_NOLINES`	don't show line numbers
`CDVF_LINEICONS`	icons can be drawn over the line control
`CDVF_STATUSBAR`	keep the status bar in the custom viewer
`IDCHK_OK`	ok
`IDCHK_ARG`	bad argument(s)
`IDCHK_KEY`	bad hotkey name
`IDCHK_MAX`	too many IDC hotkeys
`WCLS_SAVE`	save state in desktop config
`WCLS_NO_CONTEXT`	don't change the current context (useful for toolbars)
`WCLS_DONT_SAVE_SIZE`	don't save size of the window
`WCLS_DELETE_LATER`	assign the deletion of the widget to the UI loop ///<
`WCLS_CLOSE_LATER`
`DP_LEFT`	Dock src_form to the left of dest_form.
`DP_TOP`	Dock src_form above dest_form.
`DP_RIGHT`	Dock src_form to the right of dest_form.
`DP_BOTTOM`	Dock src_form below dest_form.
`DP_INSIDE`	Create a new tab bar with both src_form and dest_form.
`DP_TAB`	Place src_form into a tab next to dest_form, if dest_form is in a tab bar (otherwise the same as DP_INSIDE)
`DP_BEFORE`	Place src_form before dst_form in the tab bar instead of after; used with DP_INSIDE or DP_TAB.
`DP_FLOATING`	Make src_form floating.
`DP_SZHINT`	When floating or in a splitter (i.e., not tabbed), use the widget's size hint to determine the best geometry (Qt only)
`SVF_COPY_LINES`	keep a local copy of '*lines'
`SVF_LINES_BYPTR`	remember the 'lines' ptr. do not make a copy of '*lines'
`CVNF_LAZY`	try and move the cursor to a line displaying the place_t if possible. This might disregard the Y position in case of success
`CVNF_JUMP`	push the current position in this viewer's lochist_t before going to the new location
`CVNF_ACT`	activate (i.e., switch to) the viewer. Activation is performed before the new lochist_entry_t instance is actually copied to the viewer's lochist_t (otherwise, if the viewer was invisible its on_location_changed() handler wouldn't be called.)
`WOPN_RESTORE`	if the widget was the only widget in a floating area the last time it was closed, it will be restored as floating, with the same position+size as before
`WOPN_PERSIST`	widget will remain available when starting or stopping debugger sessions
`WOPN_CLOSED_BY_ESC`	override idagui.cfg:CLOSED_BY_ESC: esc will close
`WOPN_NOT_CLOSED_BY_ESC`	override idagui.cfg:CLOSED_BY_ESC: esc will not close
`WOPN_DP_MASK`
`WOPN_DP_SHIFT`
`WOPN_DP_LEFT`	Dock widget to the left of dest_ctrl.
`WOPN_DP_TOP`	Dock widget above dest_ctrl.
`WOPN_DP_RIGHT`	Dock widget to the right of dest_ctrl.
`WOPN_DP_BOTTOM`	Dock widget below dest_ctrl.
`WOPN_DP_INSIDE`	Create a new tab bar with both widget and dest_ctrl.
`WOPN_DP_TAB`	Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar (otherwise the same as WOPN_DP_INSIDE)
`WOPN_DP_BEFORE`	Place widget before dst_form in the tab bar instead of after; used with WOPN_DP_INSIDE and WOPN_DP_TAB
`WOPN_DP_FLOATING`	Make widget floating.
`WOPN_DP_SZHINT`	when floating or in a splitter (i.e., not tabbed), use the widget's size hint to determine the best geometry (Qt only)
`WOPN_DP_INSIDE_BEFORE`
`WOPN_DP_TAB_BEFORE`
`RENADDR_IDA`	dialog for "IDA View"
`RENADDR_HR`	dialog for "Pseudocode"; additional flags:
`CVLF_USE_MOUSE`	Fetch the location from the mouse, instead of caret in the listing.
`cvar`
`IDALIB_API_MAGIC`
`DEFAULT_PLACE_LNNUM`
`PCF_EA_CAPABLE`	toea() implementation returns meaningful data
`PCF_MAKEPLACE_ALLOCATES`	makeplace() returns a freshly allocated (i.e., non-static) instance. All new code should pass that flag to register_place_class(), and the corresponding makeplace() class implementation should return new instances.
`LECVT_CANCELED`
`LECVT_ERROR`
`LECVT_OK`
`LECVT_WITHIN_LISTING`
`CK_TRACE`	traced address
`CK_TRACE_OVL`	overlay trace address
`CK_EXTRA1`	extra background overlay #1
`CK_EXTRA2`	extra background overlay #2
`CK_EXTRA3`	extra background overlay #3
`CK_EXTRA4`	extra background overlay #4
`CK_EXTRA5`	extra background overlay #5
`CK_EXTRA6`	extra background overlay #6
`CK_EXTRA7`	extra background overlay #7
`CK_EXTRA8`	extra background overlay #8
`CK_EXTRA9`	extra background overlay #9
`CK_EXTRA10`	extra background overlay #10
`CK_EXTRA11`	extra background overlay #11
`CK_EXTRA12`	extra background overlay #12
`CK_EXTRA13`	extra background overlay #13
`CK_EXTRA14`	extra background overlay #14
`CK_EXTRA15`	extra background overlay #15
`CK_EXTRA16`	extra background overlay #16
`LROEF_MASK`
`LROEF_FULL_LINE`	full line background
`LROEF_CPS_RANGE`	background for range of chars
`BWN_UNKNOWN`	unknown window
`BWN_EXPORTS`	exports
`BWN_IMPORTS`	imports
`BWN_NAMES`	names
`BWN_FUNCS`	functions
`BWN_STRINGS`	strings
`BWN_SEGS`	segments
`BWN_SEGREGS`	segment registers
`BWN_SELS`	selectors
`BWN_SIGNS`	signatures
`BWN_TILS`	type libraries
`BWN_TICSR`	type library widget's (e.g., "Local types") chooser
`BWN_CALLS`	function calls
`BWN_PROBS`	problems
`BWN_BPTS`	breakpoints
`BWN_THREADS`	threads
`BWN_MODULES`	modules
`BWN_TRACE`	tracing view
`BWN_CALL_STACK`	call stack
`BWN_XREFS`	xrefs
`BWN_SEARCH`	search results
`BWN_FRAME`	function frame
`BWN_NAVBAND`	navigation band
`BWN_DISASM`	disassembly views
`BWN_HEXVIEW`	hex view
`BWN_NOTEPAD`	notepad
`BWN_OUTPUT`	the text area, in the output window
`BWN_CLI`	the command-line, in the output window
`BWN_WATCH`	the 'watches' debugger window
`BWN_LOCALS`	the 'locals' debugger window
`BWN_STKVIEW`	the 'Stack view' debugger window
`BWN_CHOOSER`	a non-builtin chooser
`BWN_SHORTCUTCSR`	the shortcuts chooser (Qt version only)
`BWN_SHORTCUTWIN`	the shortcuts window (Qt version only)
`BWN_CPUREGS`	one of the 'General registers', 'FPU register', ... debugger windows
`BWN_SO_STRUCTS`	the 'Structure offsets' dialog's 'Structures and Unions' panel
`BWN_SO_OFFSETS`	the 'Structure offsets' dialog's offset panel
`BWN_CMDPALCSR`	the command palette chooser (Qt version only)
`BWN_CMDPALWIN`	the command palette window (Qt version only)
`BWN_SNIPPETS`	the 'Execute script' window
`BWN_CUSTVIEW`	custom viewers
`BWN_ADDRWATCH`	the 'Watch List' window
`BWN_PSEUDOCODE`	hexrays decompiler views
`BWN_CALLS_CALLERS`	function calls, callers
`BWN_CALLS_CALLEES`	function calls, callees
`BWN_MDVIEWCSR`	lumina metadata view chooser
`BWN_DISASM_ARROWS`	disassembly arrows widget
`BWN_CV_LINE_INFOS`	custom viewers' lineinfo widget
`BWN_SRCPTHMAP_CSR`	"Source paths..."'s path mappings chooser
`BWN_SRCPTHUND_CSR`	"Source paths..."'s undesired paths chooser
`BWN_UNDOHIST`	Undo history.
`BWN_SNIPPETS_CSR`	the list of snippets in the 'Execute script' window
`BWN_SCRIPTS_CSR`	the "Recent scripts" chooser
`BWN_BOOKMARKS`	a persistent 'Bookmarks' widget
`BWN_TILIST`	a type listing widget
`BWN_TIL_VIEW`	a type library's toplevel widget
`BWN_TYPE_EDITOR`	a type editor
`BWN_MICROCODE`	microcode view (part of hexrays decompiler)
`BWN_XREF_TREE`	xref tree widget
`IWID_EXPORTS`	exports
`IWID_IMPORTS`	imports
`IWID_NAMES`	names
`IWID_FUNCS`	functions
`IWID_STRINGS`	strings
`IWID_SEGS`	segments
`IWID_SEGREGS`	segment registers
`IWID_SELS`	selectors
`IWID_SIGNS`	signatures
`IWID_TILS`	type libraries
`IWID_TICSR`	type library widget's (e.g., "Local types") chooser
`IWID_CALLS`	function calls
`IWID_PROBS`	problems
`IWID_BPTS`	breakpoints
`IWID_THREADS`	threads
`IWID_MODULES`	modules
`IWID_TRACE`	tracing view
`IWID_CALL_STACK`	call stack
`IWID_XREFS`	xrefs
`IWID_SEARCH`	search results
`IWID_FRAME`	function frame
`IWID_NAVBAND`	navigation band
`IWID_DISASM`	disassembly views
`IWID_HEXVIEW`	hex views
`IWID_NOTEPAD`	notepad
`IWID_OUTPUT`	output
`IWID_CLI`	input line
`IWID_WATCH`	watches
`IWID_LOCALS`	locals
`IWID_STKVIEW`	stack view
`IWID_CHOOSER`	chooser
`IWID_SHORTCUTCSR`	shortcuts chooser
`IWID_SHORTCUTWIN`	shortcuts window
`IWID_CPUREGS`	registers
`IWID_SO_STRUCTS`	stroff
`IWID_SO_OFFSETS`	stroff
`IWID_CMDPALCSR`	command palette
`IWID_CMDPALWIN`	command palette
`IWID_SNIPPETS`	snippets
`IWID_CUSTVIEW`	custom viewers
`IWID_ADDRWATCH`	address watches
`IWID_PSEUDOCODE`	decompiler
`IWID_CALLS_CALLERS`	funcalls, callers
`IWID_CALLS_CALLEES`	funcalls, callees
`IWID_MDVIEWCSR`	lumina md view
`IWID_DISASM_ARROWS`	arrows widget
`IWID_CV_LINE_INFOS`	lineinfo widget
`IWID_SRCPTHMAP_CSR`	mappings chooser
`IWID_SRCPTHUND_CSR`	undesired chooser
`IWID_UNDOHIST`	Undo history.
`IWID_SNIPPETS_CSR`	snippets chooser
`IWID_SCRIPTS_CSR`	recent scripts
`IWID_BOOKMARKS`	bookmarks list
`IWID_TILIST`	type listing
`IWID_TIL_VIEW`	type library's toplevel widget
`IWID_TYPE_EDITOR`	a type editor
`IWID_XREF_TREE`	xref tree widget
`IWID_ANY_LISTING`	anything that uses a listing widget
`IWID_EA_LISTING`	anything that can be used to represent data/code at an address
`IWID_ALL`	mask
`IDA_DEBUG_DREFS`	drefs
`IDA_DEBUG_OFFSET`	offsets
`IDA_DEBUG_FLIRT`	flirt
`IDA_DEBUG_IDP`	idp module
`IDA_DEBUG_LDR`	ldr module
`IDA_DEBUG_PLUGIN`	plugin module
`IDA_DEBUG_IDS`	ids files
`IDA_DEBUG_CONFIG`	config file
`IDA_DEBUG_CHECKMEM`	check heap consistency
`IDA_DEBUG_LICENSE`	licensing
`IDA_DEBUG_DEMANGLE`	demangler
`IDA_DEBUG_QUEUE`	queue
`IDA_DEBUG_ROLLBACK`	rollback
`IDA_DEBUG_ALREADY`	already data or code
`IDA_DEBUG_TIL`	type system
`IDA_DEBUG_NOTIFY`	show all notifications
`IDA_DEBUG_DEBUGGER`	debugger
`IDA_DEBUG_APPCALL`	appcall
`IDA_DEBUG_SRCDBG`	source debugging
`IDA_DEBUG_ACCESSIBILITY`	accessibility
`IDA_DEBUG_NETWORK`	network
`IDA_DEBUG_INTERNET`	internet connection (for API backward compatibility)
`IDA_DEBUG_SIMPLEX`	full stack analysis
`IDA_DEBUG_DBGINFO`	handling of debug info (e.g. pdb, dwarf)
`IDA_DEBUG_LUMINA`	lumina related
`IDA_DEBUG_THEMES`	themes
`IDA_DEBUG_REGEX`	regular expression
`IDA_DEBUG_SUBPROC`	sub process
`IDA_DEBUG_RANGECB`	range-based entities like segments, functions and so on
`IDA_DEBUG_ALWAYS`	everything
`AST_ENABLE_ALWAYS`	enable action and do not call action_handler_t::update() anymore
`AST_ENABLE_FOR_IDB`	enable action for the current idb. call action_handler_t::update() when a database is opened/closed
`AST_ENABLE_FOR_WIDGET`	enable action for the current widget. call action_handler_t::update() when a widget gets/loses focus
`AST_ENABLE`	enable action - call action_handler_t::update() when anything changes
`AST_DISABLE_ALWAYS`	disable action and do not call action_handler_t::action() anymore
`AST_DISABLE_FOR_IDB`	analog of AST_ENABLE_FOR_IDB
`AST_DISABLE_FOR_WIDGET`	analog of AST_ENABLE_FOR_WIDGET
`AST_DISABLE`	analog of AST_ENABLE
`CH_MODAL`	Modal chooser.
`CH_KEEP`	The chooser instance's lifecycle is not tied to the lifecycle of the widget showing its contents. Closing the widget will not destroy the chooser structure. This allows for, e.g., static global chooser instances that don't need to be allocated on the heap. Also stack-allocated chooser instances must set this bit.
`CH_MULTI`	The chooser will allow multi-selection (only for GUI choosers). This bit is set when using the chooser_multi_t structure.
`CH_MULTI_EDIT`	Obsolete.
`CH_NOBTNS`	do not display ok/cancel/help/search buttons. Meaningful only for gui modal windows because non-modal windows do not have any buttons anyway. Text mode does not have them neither.
`CH_ATTRS`	generate ui_get_chooser_item_attrs (gui only)
`CH_UNUSED`
`CH_FORCE_DEFAULT`	if a non-modal chooser was already open, change selection to the default one
`CH_CAN_INS`	allow to insert new items
`CH_CAN_DEL`	allow to delete existing item(s)
`CH_CAN_EDIT`	allow to edit existing item(s)
`CH_CAN_REFRESH`	allow to refresh chooser
`CH_QFLT`	open with quick filter enabled and focused
`CH_QFTYP_SHIFT`
`CH_QFTYP_DEFAULT`	set quick filtering type to the possible existing default for this chooser
`CH_QFTYP_NORMAL`	normal (i.e., lexicographical) quick filter type
`CH_QFTYP_WHOLE_WORDS`	whole words quick filter type
`CH_QFTYP_REGEX`	regex quick filter type
`CH_QFTYP_FUZZY`	fuzzy search quick filter type
`CH_QFTYP_MASK`
`CH_NO_STATUS_BAR`	don't show a status bar
`CH_RESTORE`	restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only)
`CH_RENAME_IS_EDIT`	triggering a 'edit/rename' (i.e., F2 shortcut) on a cell, should call the edit() callback for the corresponding row.
`CH_BUILTIN_SHIFT`
`CH_BUILTIN_MASK`	Mask for builtin chooser numbers. Plugins should not use them.
`CH_HAS_DIRTREE`	The chooser can provide a dirtree_t, meaning a tree-like structure can be provided to the user (instead of a flat table)
`CH_TM_NO_TREE`	chooser will show in no-tree mode
`CH_TM_FOLDERS_ONLY`	chooser will show in folders-only mode
`CH_TM_FULL_TREE`	chooser will show in full-tree mode
`CH_TM_SHIFT`
`CH_TM_MASK`
`CH_HAS_DIFF`	The chooser can be used in a diffing/merging workflow.
`CH_NO_SORT`	The chooser will not have sorting abilities.
`CH_NO_FILTER`	The chooser will not have filtering abilities.
`CH_NON_PERSISTED_TREE`	the chooser tree is not persisted (it is not loaded on startup and is not saved on exit)
`CH2_LAZY_LOADED`	The chooser is lazy-loaded; it receives the callback do_lazy_load_dir() (only meaningful when CH_HAS_DIRTREE is set)
`CH2_HAS_INODE2INDEX`
`CHCOL_PLAIN`	plain string
`CHCOL_PATH`	file path. TUI IDA will truncate excessive cell lengths starting at their beginning, and prepending the resulting text with "..." order to leave the filename visible
`CHCOL_HEX`	hexadecimal number
`CHCOL_DEC`	decimal number
`CHCOL_EA`	address
`CHCOL_FNAME`	function name. If a chooser column has this flag set and implements chooser_base_t::get_ea(), rows background colors will be automatically set to match the navigator's "Library function", "Lumina function" and "External symbol" colors
`CHCOL_FORMAT`	column format mask
`CHCOL_DEFHIDDEN`	column should be hidden by default
`CHCOL_DRAGHINT`	the column number that will be used to build hints for the dragging undo label. This should be provided for at most one column for any given chooser.
`CHCOL_INODENAME`	if CH_HAS_DIRTREE has been specified, this instructs the chooser that this column shows the inode name. This should be provided for at most one column for any given chooser.
`CHITEM_BOLD`	display the item in bold
`CHITEM_ITALIC`	display the item in italic
`CHITEM_UNDER`	underline the item
`CHITEM_STRIKE`	strikeout the item
`CHITEM_GRAY`	gray out the item
`CHOOSER_NOMAINMENU`	do not display main menu
`CHOOSER_NOSTATUSBAR`	do not display status bar (obsolete. Use CH_NO_STATUS_BAR instead)
`GCRF_HIGH_BIT`
`GCRF_HEADER`	Return header texts.
`GCRF_SELECTION`	Return selected rows.
`GCRF_CURRENT`	Return the current row.
`GCRF_ALL`	Return all rows.
`nat_lib`
`nat_fun`
`nat_cod`
`nat_dat`
`nat_und`
`nat_ext`
`nat_err`
`nat_gap`
`nat_cur`
`nat_auto`
`nat_lum`
`nat_hlo`
`nat_last`
`CVH_USERDATA`
`CVH_KEYDOWN`	see custom_viewer_keydown_t
`CVH_POPUP`	see custom_viewer_popup_t
`CVH_DBLCLICK`	see custom_viewer_dblclick_t
`CVH_CURPOS`	see custom_viewer_curpos_t
`CVH_CLOSE`	see custom_viewer_close_t
`CVH_CLICK`	see custom_viewer_click_t
`CVH_QT_AWARE`	see set_custom_viewer_qt_aware()
`CVH_HELP`	see custom_viewer_help_t
`CVH_MOUSEMOVE`	see custom_viewer_mouse_moved_t
`CDVH_USERDATA`	see set_code_viewer_user_data()
`CDVH_SRCVIEW`	see set_code_viewer_is_source()
`CDVH_LINES_CLICK`	see code_viewer_lines_click_t
`CDVH_LINES_DBLCLICK`	see code_viewer_lines_click_t
`CDVH_LINES_POPUP`	see code_viewer_lines_click_t
`CDVH_LINES_DRAWICON`	see code_viewer_lines_icon_t
`CDVH_LINES_LINENUM`	see code_viewer_lines_linenum_t
`CDVH_LINES_ICONMARGIN`	see set_code_viewer_lines_icon_margin()
`CDVH_LINES_RADIX`	see set_code_viewer_lines_radix()
`CDVH_LINES_ALIGNMENT`	see set_code_viewer_lines_alignment()
`VES_SHIFT`	state & 1 => Shift is pressed
`VES_ALT`
`VES_CTRL`
`VES_MOUSE_LEFT`
`VES_MOUSE_RIGHT`
`VES_MOUSE_MIDDLE`
`VES_META`
`msg_activated`	The message window is activated.
`msg_deactivated`	The message window is deactivated.
`msg_click`	Click event.
`msg_dblclick`	Double click event.
`msg_closed`	View closed.
`msg_keydown`	Key down event.
`view_activated`	A view is activated
`view_deactivated`	A view is deactivated
`view_keydown`	Key down event
`view_click`	Click event
`view_dblclick`	Double click event
`view_curpos`	Cursor position changed
`view_created`	A view is being created.
`view_close`	View closed
`view_switched`	A view's renderer has changed.
`view_mouse_over`	The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view.
`view_loc_changed`	The location for the view has changed (can be either the place_t, the renderer_info_t, or both.)
`view_mouse_moved`	The mouse moved on the view
`iek_unknown`
`iek_shortcut`
`iek_key_press`
`iek_key_release`
`iek_mouse_button_press`
`iek_mouse_button_release`
`iek_mouse_wheel`
`MFF_FAST`	Execute code as soon as possible. this mode is ok for calling ui related functions that do not query the database.
`MFF_READ`	Execute code only when ida is idle and it is safe to query the database. This mode is recommended only for code that does not modify the database. (nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box)
`MFF_WRITE`	Execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is a modal dialog box on the screen. this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ
`MFF_NOWAIT`	Do not wait for the request to be executed. the caller should ensure that the request is not destroyed until the execution completes. if not, the request will be ignored. the request must be created using the 'new' operator to use it with this flag. it can be used in cancel_exec_request(). This flag can be used to delay the code execution until the next UI loop run even from the main thread.
`UIJMP_ACTIVATE`	activate the new window
`UIJMP_DONTPUSH`	do not remember the current address in the navigation history
`UIJMP_VIEWMASK`
`UIJMP_ANYVIEW`	jump in any ea_t-capable view
`UIJMP_IDAVIEW`	jump in idaview
`UIJMP_IDAVIEW_NEW`	jump in new idaview
`ACF_HAS_SELECTION`	there is currently a valid selection
`ACF_XTRN_EA`	cur_ea is in 'externs' segment
`ACF_HAS_FIELD_DIRTREE_SELECTION`	'dirtree_selection' field is present
`ACF_HAS_SOURCE`	'source' field is present
`ACF_HAS_TYPE_REF`	'type_ref' field is present
`AHF_VERSION`	action handler version (used by action_handler_t::flags)
`AHF_VERSION_MASK`	mask for action_handler_t::flags
`ADF_OWN_HANDLER`	handler is owned by the action; it'll be destroyed when the action is unregistered. Use DYNACTION_DESC_LITERAL to set this bit.
`ADF_NO_UNDO`	the action does not create an undo point. useful for actions that do not modify the database.
`ADF_OT_MASK`	Owner type mask.
`ADF_OT_PLUGIN`	Owner is a plugin_t.
`ADF_OT_PLUGMOD`	Owner is a plugmod_t.
`ADF_OT_PROCMOD`	Owner is a procmod_t.
`ADF_GLOBAL`	Register the action globally, so that it's available even if no IDB is present
`ADF_NO_HIGHLIGHT`	After activating, do not update the highlight according to what's under the cursor (listings only.)
`ADF_CHECKABLE`	action is checkable
`ADF_CHECKED`	starts in a checked state (requires ADF_CHECKABLE)
`AA_NONE`	no effect
`AA_LABEL`	see update_action_label()
`AA_SHORTCUT`	see update_action_shortcut()
`AA_TOOLTIP`	see update_action_tooltip()
`AA_ICON`	see update_action_icon()
`AA_STATE`	see update_action_state()
`AA_CHECKABLE`	see update_action_checkable()
`AA_CHECKED`	see update_action_checked()
`AA_VISIBILITY`	see update_action_visibility()
`ASKBTN_YES`	Yes button.
`ASKBTN_NO`	No button.
`ASKBTN_CANCEL`	Cancel button.
`ASKBTN_BTN1`	First (Yes) button.
`ASKBTN_BTN2`	Second (No) button.
`ASKBTN_BTN3`	Third (Cancel) button.
`HIST_SEG`	segment names
`HIST_CMT`	comments
`HIST_SRCH`	search substrings
`HIST_IDENT`	identifiers. usually CPU register names are forbidden
`HIST_FILE`	file names
`HIST_TYPE`	type declarations
`HIST_CMD`	commands
`HIST_DIR`	directory names (text version only)
`HIST_IDENT2`	identifiers, including CPU register names
`CLNL_RTRIM`	Remove trailing space characters.
`CLNL_LTRIM`	Remove leading space characters.
`CLNL_FINDCMT`	Search for the comment symbol everywhere in the line, not only at the beginning.
`CLNL_TRIM`
`S2EAOPT_NOCALC`	don't try to interpret string as IDC (or current extlang) expression
`IK_CANCEL`
`IK_BACK`
`IK_TAB`
`IK_CLEAR`
`IK_RETURN`
`IK_SHIFT`
`IK_CONTROL`
`IK_MENU`
`IK_PAUSE`
`IK_CAPITAL`
`IK_KANA`
`IK_ESCAPE`
`IK_MODECHANGE`
`IK_SPACE`
`IK_PRIOR`
`IK_NEXT`
`IK_END`
`IK_HOME`
`IK_LEFT`
`IK_UP`
`IK_RIGHT`
`IK_DOWN`
`IK_SELECT`
`IK_PRINT`
`IK_EXECUTE`
`IK_SNAPSHOT`
`IK_INSERT`
`IK_DELETE`
`IK_HELP`
`IK_LWIN`
`IK_RWIN`
`IK_APPS`
`IK_SLEEP`
`IK_NUMPAD0`
`IK_NUMPAD1`
`IK_NUMPAD2`
`IK_NUMPAD3`
`IK_NUMPAD4`
`IK_NUMPAD5`
`IK_NUMPAD6`
`IK_NUMPAD7`
`IK_NUMPAD8`
`IK_NUMPAD9`
`IK_MULTIPLY`
`IK_ADD`
`IK_SEPARATOR`
`IK_SUBTRACT`
`IK_DECIMAL`
`IK_DIVIDE`
`IK_F1`
`IK_F2`
`IK_F3`
`IK_F4`
`IK_F5`
`IK_F6`
`IK_F7`
`IK_F8`
`IK_F9`
`IK_F10`
`IK_F11`
`IK_F12`
`IK_F13`
`IK_F14`
`IK_F15`
`IK_F16`
`IK_F17`
`IK_F18`
`IK_F19`
`IK_F20`
`IK_F21`
`IK_F22`
`IK_F23`
`IK_F24`
`IK_NUMLOCK`
`IK_SCROLL`
`IK_OEM_FJ_MASSHOU`
`IK_OEM_FJ_TOUROKU`
`IK_LSHIFT`
`IK_RSHIFT`
`IK_LCONTROL`
`IK_RCONTROL`
`IK_LMENU`
`IK_RMENU`
`IK_BROWSER_BACK`
`IK_BROWSER_FORWARD`
`IK_BROWSER_REFRESH`
`IK_BROWSER_STOP`
`IK_BROWSER_SEARCH`
`IK_BROWSER_FAVORITES`
`IK_BROWSER_HOME`
`IK_VOLUME_MUTE`
`IK_VOLUME_DOWN`
`IK_VOLUME_UP`
`IK_MEDIA_NEXT_TRACK`
`IK_MEDIA_PREV_TRACK`
`IK_MEDIA_STOP`
`IK_MEDIA_PLAY_PAUSE`
`IK_LAUNCH_MAIL`
`IK_LAUNCH_MEDIA_SELECT`
`IK_LAUNCH_APP1`
`IK_LAUNCH_APP2`
`IK_OEM_1`
`IK_OEM_PLUS`
`IK_OEM_COMMA`
`IK_OEM_MINUS`
`IK_OEM_PERIOD`
`IK_OEM_2`
`IK_OEM_3`
`IK_OEM_4`
`IK_OEM_5`
`IK_OEM_6`
`IK_OEM_7`
`IK_OEM_102`
`IK_PLAY`
`IK_ZOOM`
`IK_OEM_CLEAR`
`CB_INIT`
`CB_YES`
`CB_CLOSE`
`CB_INVISIBLE`
`CB_DESTROYING`
`CB_NO`
`CB_CANCEL`
`SETMENU_IF_ENABLED`
`CH_NOIDB`
`BWN_TILVIEW`
`IWID_TILVIEW`
`BWN_LOCTYPS`
`IWID_LOCTYPS`
`BWN_DISASMS`
`IWID_DISASMS`
`CHOOSER_NO_SELECTION`
`CHOOSER_MULTI_SELECTION`
`CHOOSER_POPUP_MENU`
`CHOOSER_MENU_EDIT`
`CHOOSER_MENU_JUMP`
`CHOOSER_MENU_SEARCH`
`CH_NOIDB`
`place_t_as_idaplace_t`
`place_t_as_simpleline_place_t`
`place_t_as_tiplace_t`

Classes

`chooser_row_info_vec_t`
`tagged_line_section_vec_t`
`jobj_wrapper_t`
`UI_Hooks`
`disasm_line_t`
`line_rendering_output_entries_refs_t`
`section_lines_refs_t`
`sections_lines_refs_t`
`text_t`
`sync_source_vec_t`
`place_t`
`simpleline_t`
`simpleline_place_t`
`idaplace_t`
`tiplace_t`
`sync_source_t`
`synced_group_t`
`twinpos_t`
`twinline_t`
`linearray_t`
`lines_rendering_input_t`
`line_rendering_output_entry_t`
`lines_rendering_output_t`
`line_section_t`
`tagged_line_section_t`
`tagged_line_sections_t`
`listing_location_t`
`chooser_item_attrs_t`
`chooser_row_info_t`
`chooser_stdact_desc_t`
`chooser_base_t`
`renderer_pos_info_t`
`view_mouse_event_location_t`
`view_mouse_event_t`
`input_event_t`
`input_event_shortcut_data_t`
`input_event_keyboard_data_t`
`input_event_mouse_data_t`
`ui_requests_t`
`action_ctx_base_cur_sel_t`
`action_ctx_base_t`
`action_desc_t`
`addon_info_t`
`strarray_t`
`disasm_text_t`
`action_handler_t`
`quick_widget_commands_t`
`disabled_script_timeout_t`
`Choose`	Chooser wrapper class.
`textctrl_info_t`	Class representing textctrl_info_t
`Form`
`cli_t`	cli_t wrapper class.
`View_Hooks`
`CustomIDAMemo`
`IDAViewWrapper`	Deprecated. Use View_Hooks instead.
`simplecustviewer_t`	The base class for implementing simple custom viewers
`PluginForm`	PluginForm class.

Functions

`refresh_choosers`(→ None)
`textctrl_info_t_create`(→ PyObject *)
`textctrl_info_t_destroy`(→ bool)
`textctrl_info_t_get_clink`(→ textctrl_info_t *)
`textctrl_info_t_get_clink_ptr`(→ PyObject *)
`register_timer`(interval, callback)	Register a timer
`unregister_timer`(timer_obj)	Unregister a timer
`choose_idasgn`()	Opens the signature chooser
`get_highlight`(v[, flags])	Returns the currently highlighted identifier and flags
`py_load_custom_icon_fn`(→ int)
`py_load_custom_icon_data`(→ int)
`msg`(message)	Display a message in the message window
`warning`(message)	Display a message in a warning message box
`error`(message)	Display a fatal message in a message box and quit IDA
`ask_text`(→ Union[str, None])	Asks for a long text
`ask_str`(defval, hist, prompt)	Asks for a long text
`process_ui_action`(name[, flags])	Invokes an IDA UI action by name
`del_hotkey`(ctx)	Deletes a previously registered function hotkey
`add_hotkey`(hotkey, callable)	Associates a function call with a hotkey.
`take_database_snapshot`(→ Tuple[bool, str])	Take a database snapshot.
`restore_database_snapshot`(→ bool)	Restore a database snapshot.
`execute_sync`(callable, reqf)	Executes a function in the context of the main thread.
`execute_ui_requests`(callable_list)	Inserts a list of callables into the UI message processing queue.
`register_action`(→ bool)	Create a new action (ui_register_action). After an action has been created, it is possible to attach it to menu items (attach_action_to_menu()), or to popup menus (attach_action_to_popup()).
`get_registered_actions`(→ List[str])	Get a list with the names of all currently-registered actions.
`attach_dynamic_action_to_popup`(unused, popup_handle, desc)	Create & insert an action into the widget's popup menu
`py_chooser_base_t_get_row`(→ PyObject *)
`gen_disasm_text`(→ None)	Generate disassembly text for a range.
`set_nav_colorizer`(callback)	Set a new colorizer for the navigation band.
`call_nav_colorizer`(colorizer, ea, nbytes)	To be used with the IDA-provided colorizer, that is
`msg_get_lines`(→ PyObject *)	Retrieve the last 'count' lines from the output window, in reverse order (from most recent, to least recent)
`TWidget__from_ptrval__`(→ TWidget *)
`add_spaces`(→ str)	Add space characters to the colored string so that its length will be at least 'len' characters. Don't trim the string if it is longer than 'len'.
`show_wait_box`(→ None)	Display a dialog box with "Please wait...". The behavior of the dialog box can be configured with well-known
`hide_wait_box`(→ None)	Hide the "Please wait dialog box".
`get_kernel_version`(→ str)	Get IDA kernel version (in a string like "5.1").
`is_ida_library`(→ bool)
`l_compare2`(→ int)
`l_equals`(→ bool)
`is_tif_cursor_header`(→ bool)
`is_tif_cursor_footer`(→ bool)
`is_tif_cursor_index`(→ bool)
`internal_register_place_class`(→ int)
`get_place_class`(→ place_t const *)	Get information about a previously-registered place_t class. See also register_place_class().
`get_place_class_template`(→ place_t const *)	See get_place_class()
`is_place_class_ea_capable`(→ bool)	See get_place_class()
`get_place_class_id`(→ int)	Get the place class ID for the place that has been registered as 'name'.
`request_refresh`(→ None)	Request a refresh of a builtin window.
`clear_refresh_request`(→ None)
`is_refresh_requested`(→ bool)	Get a refresh request state
`is_chooser_widget`(→ bool)	Does the given widget type specify a chooser widget?
`is_action_enabled`(→ bool)	Check if the given action state is one of AST_ENABLE*.
`cancel_exec_request`(→ bool)	Try to cancel an asynchronous exec request (::ui_cancel_exec_request).
`cancel_thread_exec_requests`(→ int)	Try to cancel asynchronous exec requests created by the specified thread.
`set_execute_sync_availability`(...)	Set the availability of the execute_sync functionality for the given thread
`get_synced_group`(→ synced_group_t const *)	Get the group of widgets/registers this view is synchronized with
`banner`(→ bool)	Show a banner dialog box (ui_banner).
`is_msg_inited`(→ bool)	Can we use msg() functions?
`refresh_idaview`(→ None)	Refresh marked windows (ui_refreshmarked)
`refresh_idaview_anyway`(→ None)	Refresh all disassembly views (ui_refresh), forces an immediate refresh. Please consider request_refresh() instead
`analyzer_options`(→ None)	Allow the user to set analyzer options. (show a dialog box) (ui_analyzer_options)
`get_screen_ea`(→ ida_idaapi.ea_t)	Get the address at the screen cursor (ui_screenea)
`get_opnum`(→ int)	Get current operand number, -1 means no operand (ui_get_opnum)
`get_cursor`(→ int , int )	Get the cursor position on the screen (ui_get_cursor).
`get_output_cursor`(→ int , int )	Get coordinates of the output window's cursor (ui_get_output_cursor).
`get_curline`(→ str)	Get current line from the disassemble window (ui_get_curline).
`open_url`(→ None)	Open the given url (ui_open_url)
`get_hexdump_ea`(→ ida_idaapi.ea_t)	Get the current address in a hex view.
`get_key_code`(→ ushort)	Get keyboard key code by its name (ui_get_key_code)
`lookup_key_code`(→ ushort)	Get shortcut code previously created by ui_get_key_code.
`refresh_navband`(→ None)	Refresh navigation band if changed (ui_refresh_navband).
`refresh_chooser`(→ bool)	Mark a non-modal custom chooser for a refresh (ui_refresh_chooser).
`close_chooser`(→ bool)	Close a non-modal chooser (ui_close_chooser).
`set_dock_pos`(src_ctrl, dest_ctrl, orient[, left, top, ...])	Sets the dock orientation of a window relatively to another window.
`get_icon_id_by_name`(→ int)	Retrieve the id of the icon by name (ui_get_icon_id_by_name).
`free_custom_icon`(icon_id)	Frees an icon loaded with load_custom_icon()
`unregister_action`(→ bool)	Delete a previously-registered action (ui_unregister_action).
`create_toolbar`(→ bool)	Create a toolbar with the given name, label and optional position
`delete_toolbar`(→ bool)	Delete an existing toolbar
`create_menu`(→ bool)	Create a menu with the given name, label and optional position, either in the menubar, or as a submenu. If 'menupath' is non-nullptr, it provides information about where the menu should be positioned. First, IDA will try and resolve the corresponding menu by its name. If such an existing menu is found and is present in the menubar, then the new menu will be inserted in the menubar before it. Otherwise, IDA will try to resolve 'menupath' as it would for attach_action_to_menu() and, if found, add the new menu like so:
`delete_menu`(→ bool)	Delete an existing menu
`attach_action_to_menu`(→ bool)	Attach a previously-registered action to the menu (ui_attach_action_to_menu).
`detach_action_from_menu`(→ bool)	Detach an action from the menu (ui_detach_action_from_menu).
`attach_action_to_toolbar`(→ bool)	Attach an action to an existing toolbar (ui_attach_action_to_toolbar).
`detach_action_from_toolbar`(→ bool)	Detach an action from the toolbar (ui_detach_action_from_toolbar).
`register_and_attach_to_menu`(→ bool)	Helper.
`display_widget`(→ None)	Display a widget, dock it if not done before
`close_widget`(→ None)	Close widget (ui_close_widget, only gui version).
`activate_widget`(→ None)	Activate widget (only gui version) (ui_activate_widget).
`find_widget`(→ TWidget *)	Find widget with the specified caption (only gui version) (ui_find_widget). NB: this callback works only with the tabbed widgets!
`get_current_widget`(→ TWidget *)	Get a pointer to the current widget (ui_get_current_widget).
`get_widget_type`(→ twidget_type_t)	Get the type of the TWidget * (ui_get_widget_type).
`get_widget_title`(→ str)	Get the TWidget's title (ui_get_widget_title).
`custom_viewer_jump`(→ bool)	Append 'loc' to the viewer's history, and cause the viewer to display it.
`ea_viewer_history_push_and_jump`(→ bool)	Push current location in the history and jump to the given location (ui_ea_viewer_history_push_and_jump). This will jump in the given ea viewer and also in other synchronized views.
`get_ea_viewer_history_info`(→ bool)	Get information about what's in the history (ui_ea_viewer_history_info).
`refresh_custom_viewer`(→ None)	Refresh custom ida viewer (ui_refresh_custom_viewer)
`repaint_custom_viewer`(→ None)	Repaint the given widget immediately (ui_repaint_qwidget)
`jumpto`(→ bool)	This function has the following signatures:
`get_custom_viewer_place`(→ int , int )	Get current place in a custom viewer (ui_get_curplace).
`get_custom_viewer_location`(→ bool)	Get information about the current location in a listing
`is_idaq`()	Returns True or False depending if IDAPython is hosted by IDAQ
`attach_action_to_popup`(→ bool)	Insert a previously-registered action into the widget's popup menu (ui_attach_action_to_popup). This function has two "modes": 'single-shot', and 'permanent'.
`detach_action_from_popup`(→ bool)	Remove a previously-registered action, from the list of 'permanent' context menu actions for this widget (ui_detach_action_from_popup). This only makes sense if the action has been added to 'widget's list of permanent popup actions by calling attach_action_to_popup in 'permanent' mode.
`update_action_label`(→ bool)	Update an action's label (ui_update_action_attr).
`update_action_shortcut`(→ bool)	Update an action's shortcut (ui_update_action_attr).
`update_action_tooltip`(→ bool)	Update an action's tooltip (ui_update_action_attr).
`update_action_icon`(→ bool)	Update an action's icon (ui_update_action_attr).
`update_action_state`(→ bool)	Update an action's state (ui_update_action_attr).
`update_action_checkable`(→ bool)	Update an action's checkability (ui_update_action_attr).
`update_action_checked`(→ bool)	Update an action's checked state (ui_update_action_attr).
`update_action_visibility`(→ bool)	Update an action's visibility (ui_update_action_attr).
`get_action_label`(→ str)	Get an action's label (ui_get_action_attr).
`get_action_shortcut`(→ str)	Get an action's shortcut (ui_get_action_attr).
`get_action_tooltip`(→ str)	Get an action's tooltip (ui_get_action_attr).
`get_action_icon`(→ int *)	Get an action's icon (ui_get_action_attr).
`get_action_state`(→ action_state_t *)	Get an action's state (ui_get_action_attr).
`get_action_checkable`(→ bool *)	Get an action's checkability (ui_get_action_attr).
`get_action_checked`(→ bool *)	Get an action's checked state (ui_get_action_attr).
`get_action_visibility`(→ bool *)	Get an action's visibility (ui_get_action_attr).
`set_custom_viewer_qt_aware`(→ bool)	Allow the given viewer to interpret Qt events (ui_set_custom_viewer_handler)
`get_custom_viewer_curline`(→ str)	Get current line of custom viewer (ui_get_custom_viewer_curline). The returned line contains color codes
`get_custom_viewer_place_xcoord`(→ int)	Get the X position of the item, in the line
`get_user_input_event`(→ bool)	Get the current user input event (mouse button press, key press, ...) It is sometimes desirable to be able to tell when a certain situation happens (e.g., 'view_curpos' gets triggered); this function exists to provide that context (GUI version only)
`get_output_curline`(→ str)	Get current line of output window (ui_get_output_curline).
`get_output_selected_text`(→ str)	Returns selected text from output window (ui_get_output_selected_text).
`get_current_viewer`(→ TWidget *)	Get current ida viewer (idaview or custom viewer) (ui_get_current_viewer)
`get_last_widget`(→ TWidget *)	Get last ida viewer (idaview or custom viewer) (ui_get_last_widget)
`prompt_function_prototype`(→ str)	Open function prototype editor to edit function type and create new type. Allows to change the function prototype either in the "old" one-liner mode or in the new multi-line editor, which supports shortcuts, etc. Note: changes will not apply! It is the caller's job to apply the resulting out_tif. Parameters:
`parse_tagged_line_sections`(→ bool)	Collect tagged sections in a color-tagged line (produced by place_t::generate)
`get_view_renderer_type`(→ tcc_renderer_type_t)	Get the type of renderer currently in use in the given view (ui_get_renderer_type)
`set_view_renderer_type`(→ None)	Set the type of renderer to use in a view (ui_set_renderer_type)
`create_empty_widget`(→ TWidget *)	Create an empty widget, serving as a container for custom user widgets
`msg_clear`(→ None)	Clear the "Output" window.
`msg_save`(→ bool)	Save the "Output" window contents into a file
`get_active_modal_widget`(→ TWidget *)	Get the current, active modal TWidget instance. Note that in this context, the "wait dialog" is not considered: this function will return nullptr even if it is currently shown.
`get_navband_pixel`(ea)	Maps an address, onto a pixel coordinate within the navigation band
`get_navband_ea`(→ ida_idaapi.ea_t)	Translate the pixel position on the navigation band, into an address.
`get_window_id`(→ void *)	Get the system-specific window ID (GUI version only)
`is_idaview`(→ bool)	Is the given custom view an idaview? (ui_is_idaview)
`read_selection`(v, p1, p2)	Read the user selection, and store its information in p1 (from) and p2 (to).
`read_range_selection`(→ ea_t , ea_t )	Get the address range for the selected range boundaries, this is the convenient function for read_selection()
`unmark_selection`(→ None)	Unmark selection (ui_unmarksel)
`create_code_viewer`(→ TWidget *)	Create a code viewer (ui_create_code_viewer). A code viewer contains on the left side a widget representing the line numbers, and on the right side, the child widget passed as parameter. It will inherit its title from the child widget.
`set_code_viewer_handler`(→ void *)	Set a handler for a code viewer event (ui_set_custom_viewer_handler).
`set_code_viewer_user_data`(→ bool)	Set the user data on a code viewer (ui_set_custom_viewer_handler).
`get_viewer_user_data`(→ void *)	Get the user data from a custom viewer (ui_get_viewer_user_data)
`get_viewer_place_type`(→ tcc_place_type_t)	Get the type of place_t instances a viewer uses & creates (ui_get_viewer_place_type).
`set_code_viewer_line_handlers`(→ None)	Set handlers for code viewer line events. Any of these handlers may be nullptr
`set_code_viewer_lines_icon_margin`(→ bool)	Set space allowed for icons in the margin of a code viewer (ui_set_custom_viewer_handler).
`set_code_viewer_lines_alignment`(→ bool)	Set alignment for lines in a code viewer (ui_set_custom_viewer_handler).
`set_code_viewer_lines_radix`(→ bool)	Set radix for values displayed in a code viewer (ui_set_custom_viewer_handler).
`set_code_viewer_is_source`(→ bool)	Specify that the given code viewer is used to display source code (ui_set_custom_viewer_handler).
`get_tab_size`(→ int)	Get the size of a tab in spaces (ui_get_tab_size).
`clr_cancelled`(→ None)	Clear "Cancelled" flag (ui_clr_cancelled)
`set_cancelled`(→ None)	Set "Cancelled" flag (ui_set_cancelled)
`user_cancelled`(→ bool)	Test the cancellation flag (ui_test_cancelled).
`ui_load_new_file`(→ bool)	Display a load file dialog and load file (ui_load_file).
`ui_run_debugger`(→ bool)	Load a debugger plugin and run the specified program (ui_run_dbg).
`load_dbg_dbginfo`(→ bool)	Load debugging information from a file.
`add_idc_hotkey`(→ int)	Add hotkey for IDC function (ui_add_idckey).
`set_highlight`(→ bool)	Set the highlighted identifier in the viewer (ui_set_highlight).
`open_exports_window`(→ TWidget *)	Open the exports window (ui_open_builtin).
`open_imports_window`(→ TWidget *)	Open the exports window (ui_open_builtin).
`open_names_window`(→ TWidget *)	Open the names window (ui_open_builtin).
`open_funcs_window`(→ TWidget *)	Open the 'Functions' window (ui_open_builtin).
`open_strings_window`(→ TWidget *)	Open the 'Strings' window (ui_open_builtin).
`open_segments_window`(→ TWidget *)	Open the segments window (ui_open_builtin).
`open_segregs_window`(→ TWidget *)	Open the segment registers window (ui_open_builtin).
`open_selectors_window`(→ TWidget *)	Open the selectors window (ui_open_builtin).
`open_signatures_window`(→ TWidget *)	Open the signatures window (ui_open_builtin).
`open_tils_window`(→ TWidget *)	Open the type libraries window (ui_open_builtin).
`open_loctypes_window`(→ TWidget *)	Open the local types window (ui_open_builtin2).
`open_til_view_window`(→ TWidget *)	Open the sub-til window (ui_open_builtin2).
`open_calls_window`(→ TWidget *)	Open the function calls window (ui_open_builtin).
`open_problems_window`(→ TWidget *)	Open the problems window (ui_open_builtin).
`open_bpts_window`(→ TWidget *)	Open the breakpoints window (ui_open_builtin).
`open_threads_window`(→ TWidget *)	Open the threads window (ui_open_builtin).
`open_modules_window`(→ TWidget *)	Open the modules window (ui_open_builtin).
`open_trace_window`(→ TWidget *)	Open the tracing window (ui_open_builtin).
`open_stack_window`(→ TWidget *)	Open the call stack window (ui_open_builtin).
`open_xrefs_window`(→ TWidget *)	Open the cross references window (ui_open_builtin).
`open_frame_window`(→ TWidget *)	Open the frame window for the given function (ui_open_builtin).
`open_navband_window`(→ TWidget *)	Open the navigation band window (ui_open_builtin).
`open_disasm_window`(→ TWidget *)	Open a disassembly view (ui_open_builtin).
`open_hexdump_window`(→ TWidget *)	Open a hexdump view (ui_open_builtin).
`open_notepad_window`(→ TWidget *)	Open the notepad window (ui_open_builtin).
`open_bookmarks_window`(→ TWidget *)	Open the bookmarks window (ui_open_builtin).
`sync_sources`(→ bool)	[Un]synchronize sources
`choose_til`(→ str)	Choose a type library (ui_choose, chtype_idatil).
`choose_entry`(→ ida_idaapi.ea_t)	Choose an entry point (ui_choose, chtype_entry).
`choose_name`(→ ida_idaapi.ea_t)	Choose a name (ui_choose, chtype_name).
`choose_stkvar_xref`(→ ida_idaapi.ea_t)	Choose an xref to a stack variable (ui_choose, chtype_name).
`choose_xref`(→ ida_idaapi.ea_t)	Choose an xref to an address (ui_choose, chtype_xref).
`choose_enum`(→ bool)	Choose an enum (ui_choose, chtype_enum).
`choose_enum_by_value`(→ uchar *)	Choose an enum, restricted by value & size (ui_choose, chtype_enum_by_value_and_size). If the given value cannot be found initially, this function will ask if the user would like to import a standard enum.
`choose_func`(→ func_t *)	Choose a function (ui_choose, chtype_func).
`choose_segm`(→ segment_t *)	Choose a segment (ui_choose, chtype_segm).
`choose_struct`(→ bool)	Choose a structure (ui_choose, chtype_struct).
`choose_srcp`(→ sreg_range_t *)	Choose a segment register change point (ui_choose, chtype_srcp).
`get_chooser_obj`(→ void *)	Get the underlying object of the specified chooser (ui_get_chooser_obj).
`get_chooser_rows`(→ bool)	Get the chooser contents corresponding to the rows indicated by "what".
`enable_chooser_item_attrs`(→ bool)	Enable item-specific attributes for chooser items (ui_enable_chooser_item_attrs). For example: color list items differently depending on a criterium.
`replace_wait_box`(→ None)	Replace the label of "Please wait dialog box".
`beep`(→ None)	Issue a beeping sound (ui_beep).
`display_copyright_warning`(→ bool)	Display copyright warning (ui_copywarn).
`ask_for_feedback`(→ None)	Show a message box asking to send the input file to [support@hex-rays.com](mailto:support@hex-rays.com).
`info`(→ ssize_t)
`nomem`(→ None)
`ask_yn`(→ int)	Display a dialog box and get choice from "Yes", "No", "Cancel".
`ask_buttons`(→ int)	Display a dialog box and get choice from maximum three possibilities (ui_ask_buttons).
`ask_ident2`(→ bool)	Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are permitted.
`ask_file`(→ char *)
`register_addon`(→ int)	Register an add-on. Show its info in the About box. For plugins, should be called from init() function (repeated calls with the same product code overwrite previous entries) returns: index of the add-on in the list, or -1 on error
`addon_count`(→ int)	Get number of installed addons.
`get_addon_info`(→ bool)	Get info about a registered addon with a given product code. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info
`get_addon_info_idx`(→ bool)	Get info about a registered addon with specific index. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info
`qcleanline`(→ str)	Performs some cleanup operations to a line.
`strarray`(→ str)	Find a line with the specified code in the strarray_t array. If the last element of the array has code==0 then it is considered as the default entry.
`ea2str`(→ str)	Convert linear address to UTF-8 string.
`str2ea`(→ uint64 *)	Convert string to linear address. Tries to interpret the string as:
`str2ea_ex`(→ uint64 *)	Same as str2ea() but possibly with some steps skipped.
`atoea`(→ uint64 *)	Convert a number in C notation to an address. decimal: 1234
`get_user_strlist_options`(→ None)
`del_idc_hotkey`(→ bool)
`load_custom_icon`([file_name, data, format])	Load an icon from a file (ui_load_custom_icon_file). Also see load_custom_icon(const void , unsigned int, const char )
`ask_long`(→ Union[int, None])	Display a dialog box and wait for the user to input a number
`ask_addr`(→ Union[ida_idaapi.ea_t, None])	Display a dialog box and wait for the user to input an address
`ask_seg`(→ Union[int, None])	Display a dialog box and wait for the user to input an segment name.
`ask_ident`(→ bool)	Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are usually forbidden.
`choose_find`(→ Union[object, None])	Retrieve the chooser object by title
`choose_refresh`(→ None)
`choose_close`(→ None)
`choose_get_widget`(→ TWidget *)
`choose_choose`(→ PyObject *)
`choose_activate`(→ None)
`choose_create_embedded_chobj`(→ PyObject *)
`get_chooser_data`(→ List[str])	Get the text corresponding to the index N in the chooser data.
`textctrl_info_t_assign`(→ bool)
`textctrl_info_t_set_text`(→ bool)
`textctrl_info_t_get_text`(→ str)
`textctrl_info_t_set_flags`(→ bool)
`textctrl_info_t_get_flags`(→ unsigned int)
`textctrl_info_t_set_tabsize`(→ bool)
`textctrl_info_t_get_tabsize`(→ unsigned int)
`formchgcbfa_enable_field`(→ bool)
`formchgcbfa_show_field`(→ bool)
`formchgcbfa_move_field`(→ bool)
`formchgcbfa_get_focused_field`(→ int)
`formchgcbfa_set_focused_field`(→ bool)
`formchgcbfa_refresh_field`(→ None)
`formchgcbfa_close`(→ None)
`formchgcbfa_get_field_value`(→ PyObject *)
`formchgcbfa_set_field_value`(→ bool)
`py_get_ask_form`(→ size_t)
`py_get_open_form`(→ size_t)
`py_register_compiled_form`(→ None)
`py_unregister_compiled_form`(→ None)
`ask_form`(*args)	Display a dialog box and wait for the user. If the form contains the "BUTTON NO <title>" keyword, then the return values are the same as in the ask_yn() function (Button IDs)
`open_form`(*args)	Display a dockable modeless dialog box and return a handle to it. The modeless form can be closed in the following ways:
`install_command_interpreter`(→ int)	Install command line interpreter (ui_install_cli)
`remove_command_interpreter`(→ None)	Remove command line interpreter (ui_install_cli)
`pyidag_bind`(→ bool)
`pyidag_unbind`(→ bool)
`pyscv_init`(→ PyObject *)
`pyscv_refresh`(→ bool)
`pyscv_get_current_line`(→ PyObject *)
`pyscv_is_focused`(→ bool)
`pyscv_count`(→ size_t)
`pyscv_show`(→ bool)
`pyscv_close`(→ None)
`pyscv_jumpto`(→ bool)
`pyscv_get_line`(→ PyObject *)
`pyscv_get_pos`(→ PyObject *)
`pyscv_clear_lines`(→ PyObject *)
`pyscv_add_line`(→ bool)
`pyscv_insert_line`(→ bool)
`pyscv_patch_line`(→ bool)
`pyscv_del_line`(→ bool)
`pyscv_get_selection`(→ PyObject *)
`pyscv_get_current_word`(→ PyObject *)
`pyscv_edit_line`(→ bool)
`pyscv_get_widget`(→ TWidget *)
`plgform_new`(→ PyObject *)
`plgform_show`(→ bool)
`plgform_close`(→ None)
`plgform_get_widget`(→ TWidget *)

Module Contents

ida_kernwin.SWIG_PYTHON_LEGACY_BOOL

class ida_kernwin.chooser_row_info_vec_t(*args)

Bases: object

thisown

push_back(*args) → chooser_row_info_t &

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → chooser_row_info_t const &

qclear() → None

clear() → None

resize(*args) → None

grow(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: chooser_row_info_vec_t) → None

extract() → chooser_row_info_t *

inject(s: chooser_row_info_t, len: size_t) → None

begin(*args) → qvector< chooser_row_info_t >::const_iterator

end(*args) → qvector< chooser_row_info_t >::const_iterator

insert(it: chooser_row_info_t, x: chooser_row_info_t) → qvector< chooser_row_info_t >::iterator

erase(*args) → qvector< chooser_row_info_t >::iterator

find(*args) → qvector< chooser_row_info_t >::const_iterator

has(x: chooser_row_info_t) → bool

add_unique(x: chooser_row_info_t) → bool

append(x: chooser_row_info_t) → None

extend(x: chooser_row_info_vec_t) → None

front

back

class ida_kernwin.tagged_line_section_vec_t(*args)

Bases: object

thisown

push_back(*args) → tagged_line_section_t &

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → tagged_line_section_t const &

qclear() → None

clear() → None

resize(*args) → None

grow(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: tagged_line_section_vec_t) → None

extract() → tagged_line_section_t *

inject(s: tagged_line_section_t, len: size_t) → None

begin(*args) → qvector< tagged_line_section_t >::const_iterator

end(*args) → qvector< tagged_line_section_t >::const_iterator

insert(it: tagged_line_section_t, x: tagged_line_section_t) → qvector< tagged_line_section_t >::iterator

erase(*args) → qvector< tagged_line_section_t >::iterator

find(*args) → qvector< tagged_line_section_t >::const_iterator

has(x: tagged_line_section_t) → bool

add_unique(x: tagged_line_section_t) → bool

append(x: tagged_line_section_t) → None

extend(x: tagged_line_section_vec_t) → None

front

back

ida_kernwin.refresh_choosers() → None

ida_kernwin.textctrl_info_t_create() → PyObject *

ida_kernwin.textctrl_info_t_destroy(py_obj: PyObject *) → bool

ida_kernwin.textctrl_info_t_get_clink(_self: PyObject *) → textctrl_info_t *

ida_kernwin.textctrl_info_t_get_clink_ptr(_self: PyObject *) → PyObject *

ida_kernwin.register_timer(interval, callback)

Register a timer

Parameters:

interval – Interval in milliseconds
callback – A Python callable that takes no parameters and returns an integer. The callback may return: -1 : to unregister the timer >= 0 : the new or same timer interval

Returns:

None or a timer object

ida_kernwin.unregister_timer(timer_obj)

Unregister a timer

NOTE: After the timer has been deleted, the timer_obj will become invalid.

Parameters:: timer_obj – a timer object previously returned by a register_timer()
Returns:: Boolean

ida_kernwin.choose_idasgn()

Opens the signature chooser

Returns:: None or the selected signature name

ida_kernwin.get_highlight(v, flags=0)

Returns the currently highlighted identifier and flags

Parameters:

v – The UI widget to operate on
flags – Optionally specify a slot (see kernwin.hpp), current otherwise

Returns:

a tuple (text, flags), or None if nothing is highlighted or in case of error.

ida_kernwin.py_load_custom_icon_fn(filename: str) → int

ida_kernwin.py_load_custom_icon_data(data: PyObject *, format: str) → int

ida_kernwin.msg(message)

Display a message in the message window

Parameters:: message – message to print

ida_kernwin.warning(message)

Display a message in a warning message box

Parameters:: message – message to print

ida_kernwin.error(message)

Display a fatal message in a message box and quit IDA

Parameters:: format – message to print

ida_kernwin.ask_text(max_size: int, defval: str, prompt: str) → str | None

Asks for a long text

Parameters:

max_size – Maximum text length, 0 for unlimited
defval – The default value
prompt – The prompt value

Returns:

None or the entered string

ida_kernwin.ask_str(defval, hist, prompt)

Asks for a long text

Parameters:

defval – The default value
hist – history id
prompt – The prompt value

Returns:

None or the entered string

ida_kernwin.process_ui_action(name: str, flags: int = 0)

Invokes an IDA UI action by name

Parameters:

name – action name
flags – reserved

Returns:

Boolean

ida_kernwin.del_hotkey(ctx)

Deletes a previously registered function hotkey

Parameters:: ctx – Hotkey context previously returned by add_hotkey()
Returns:: Boolean.

ida_kernwin.add_hotkey(hotkey, callable)

Associates a function call with a hotkey. Callable ‘callable’ will be called each time the hotkey is pressed

Parameters:

hotkey – The hotkey
callable – Callable

Returns:

Context object on success or None on failure.

ida_kernwin.take_database_snapshot(snapshot) → Tuple[bool, str]

Take a database snapshot.

Parameters:: snapshot – the snapshot object
Returns:: a tuple (success, error-message)

ida_kernwin.restore_database_snapshot(snapshot, callback, userdata) → bool

Restore a database snapshot.

Note: This call is asynchronous. When it is completed, the callback will be triggered.

Parameters:

snapshot – the snapshot object
callback – a callback function
userdata – payload to pass to the callback

Returns:

success

ida_kernwin.execute_sync(callable, reqf)

Executes a function in the context of the main thread. If the current thread not the main thread, then the call is queued and executed afterwards.

Parameters:

callable – A python callable object, must return an integer value
reqf – one of MFF_ flags

Returns:

-1 or the return value of the callable

ida_kernwin.execute_ui_requests(callable_list)

Inserts a list of callables into the UI message processing queue. When the UI is ready it will call one callable. A callable can request to be called more than once if it returns True.

NOTE: A callable should return True if it wants to be called more than once.

Parameters:: callable_list – A list of python callable objects.
Returns:: Boolean. False if the list contains a non callable item

class ida_kernwin.jobj_wrapper_t(*args, **kwargs)

Bases: object

thisown

get_dict() → dict

Retrieve the contents of this object, as a dict

Returns:: a dict containing all kvp’s in this object

class ida_kernwin.UI_Hooks(_flags: int = 0, _hkcb_flags: int = 1)

Bases: object

thisown

hook() → bool

unhook() → bool

range() → None

The disassembly range has been changed ( idainfo::min_ea … idainfo::max_ea). UI should redraw the scrollbars. See also: ui_lock_range_refresh

Returns:: void

idcstart() → None

Start of IDC engine work.

Returns:: void

idcstop() → None

Stop of IDC engine work.

Returns:: void

suspend() → None

Suspend graphical interface. Only the text version. Interface should respond to it.

Returns:: void

resume() → None

Resume the suspended graphical interface. Only the text version. Interface should respond to it

Returns:: void

saving() → None: The kernel is flushing its buffers to the disk. The user interface should save its state. Parameters: none Returns: none

saved(path: str) → None

The kernel has saved the database. This callback just informs the interface. Note that at the time this notification is sent, the internal paths are not updated yet, and calling get_path(PATH_TYPE_IDB) will return the previous path.

Parameters:: path – (const char *) the database path
Returns:: void

database_closed() → None

The database has been closed. See also processor_t::closebase, it occurs earlier. See also ui_initing_database. This is not the same as IDA exiting. If you need to perform cleanup at the exiting time, use qatexit().

Returns:: void

debugger_menu_change(enable: bool) → None

debugger menu modification detected

Parameters:: enable – (bool) true: debugger menu has been added, or a different debugger has been selected false: debugger menu will be removed (user switched to “No debugger”)
Returns:: void

widget_visible(widget: TWidget *) → None

TWidget is displayed on the screen. Use this event to populate the window with controls

Parameters:: widget – (TWidget *)
Returns:: void

widget_closing(widget: TWidget *) → None

TWidget is about to close. This event precedes ui_widget_invisible. Use this to perform some possible actions relevant to the lifecycle of this widget

Parameters:: widget – (TWidget *)
Returns:: void

widget_invisible(widget: TWidget *) → None

TWidget is being closed. Use this event to destroy the window controls

Parameters:: widget – (TWidget *)
Returns:: void

get_ea_hint(ea: ida_idaapi.ea_t) → PyObject *

ui wants to display a simple hint for an address. Use this event to generate a custom hint See also more generic ui_get_item_hint

Parameters:: ea – (::ea_t)
Returns:: true if generated a hint

get_item_hint(ea: ida_idaapi.ea_t, max_lines: int) → PyObject *

ui wants to display multiline hint for an item. See also more generic ui_get_custom_viewer_hint

Parameters:

ea – (ea_t) or item id like a structure or enum member
max_lines – (int) maximal number of lines

Returns:

true if generated a hint

get_custom_viewer_hint(viewer: TWidget *, place: place_t) → PyObject *

ui wants to display a hint for a viewer (idaview or custom). Every subscriber is supposed to append the hint lines to HINT and increment IMPORTANT_LINES accordingly. Completely overwriting the existing lines in HINT is possible but not recommended. If the REG_HINTS_MARKER sequence is found in the returned hints string, it will be replaced with the contents of the “regular” hints. If the SRCDBG_HINTS_MARKER sequence is found in the returned hints string, it will be replaced with the contents of the source-level debugger-generated hints. The following keywords might appear at the beginning of the returned hints: HIGHLIGHT text: where text will be highlighted CAPTION caption caption for the hint widget

Parameters:

viewer – (TWidget*) viewer
place – (place_t *) current position in the viewer

Returns:

0: continue collecting hints with other subscribers

Returns:

1: stop collecting hints

database_inited(is_new_database: int, idc_script: str) → None

database initialization has completed. the kernel is about to run idc scripts

Parameters:

is_new_database – (int)
idc_script – (const char *) - may be nullptr

Returns:

void See also ui_initing_database. This event is called for both new and old databases.

ready_to_run() → None

all UI elements have been initialized. Automatic plugins may hook to this event to perform their tasks.

Returns:: void

preprocess_action(name: str) → int

ida ui is about to handle a user action.

Parameters:: name – (const char *) ui action name. these names can be looked up in ida[tg]ui.cfg
Returns:: 0: ok
Returns:: nonzero: a plugin has handled the command

postprocess_action() → None: an ida ui action has been handled

get_chooser_item_attrs(chooser: chooser_base_t, n: size_t, attrs: chooser_item_attrs_t) → None

get item-specific attributes for a chooser. This callback is generated only after enable_chooser_attrs()

Parameters:

chooser – (const chooser_base_t *)
n – (::size_t)
attrs – (chooser_item_attrs_t *)

Returns:

void

updating_actions(ctx: action_ctx_base_t) → None

IDA is about to update all actions. If your plugin needs to perform expensive operations more than once (e.g., once per action it registers), you should do them only once, right away.

Parameters:: ctx – (action_update_ctx_t *)
Returns:: void

updated_actions() → None

IDA is done updating actions.

Returns:: void

populating_widget_popup(widget: TWidget *, popup_handle: TPopupMenu *, ctx: action_ctx_base_t = None) → None

IDA is populating the context menu for a widget. This is your chance to attach_action_to_popup(). Have a look at ui_finish_populating_widget_popup, if you want to augment the context menu with your own actions after the menu has had a chance to be properly populated by the owning component or plugin (which typically does it on ui_populating_widget_popup.)

Parameters:

widget – (TWidget *)
popup_handle – (TPopupMenu *)
ctx – (const action_activation_ctx_t *)

Returns:

void

finish_populating_widget_popup(widget: TWidget *, popup_handle: TPopupMenu *, ctx: action_ctx_base_t = None) → None

IDA is about to be done populating the context menu for a widget. This is your chance to attach_action_to_popup().

Parameters:

widget – (TWidget *)
popup_handle – (TPopupMenu *)
ctx – (const action_activation_ctx_t *)

Returns:

void

plugin_loaded(plugin_info: plugin_info_t const *) → None

The plugin was loaded in memory.

Parameters:: plugin_info – (const plugin_info_t *)

plugin_unloading(plugin_info: plugin_info_t const *) → None

The plugin is about to be unloaded

Parameters:: plugin_info – (const plugin_info_t *)

current_widget_changed(widget: TWidget *, prev_widget: TWidget *) → None

The currently-active TWidget changed.

Parameters:

widget – (TWidget *)
prev_widget – (TWidget *)

Returns:

void

screen_ea_changed(ea: ida_idaapi.ea_t, prev_ea: ida_idaapi.ea_t) → None

The “current address” changed

Parameters:

ea – (ea_t)
prev_ea – (ea_t)

Returns:

void

create_desktop_widget(title: str, cfg: jobj_wrapper_t) → PyObject *

create a widget, to be placed in the widget tree (at desktop-creation time.)

Parameters:

title – (const char *)
cfg – (const jobj_t *)

Returns:

TWidget * the created widget, or null

get_lines_rendering_info(out: lines_rendering_output_t, widget: TWidget const *, info: lines_rendering_input_t) → None

get lines rendering information

Parameters:

out – (lines_rendering_output_t *)
widget – (const TWidget *)
info – (const lines_rendering_input_t *)

Returns:

void

get_widget_config(widget: TWidget const *, cfg: jobj_t *) → PyObject *

retrieve the widget configuration (it will be passed back at ui_create_desktop_widget-, and ui_set_widget_config-time)

Parameters:

widget – (const TWidget *)
cfg – (jobj_t *)

Returns:

void

set_widget_config(widget: TWidget const *, cfg: jobj_wrapper_t) → None

set the widget configuration

Parameters:

widget – (const TWidget *)
cfg – (const jobj_t *)

Returns:

void

initing_database() → None

database initialization has started.

Returns:: void See also ui_database_inited. This event is called for both new and old databases.

destroying_procmod(procmod: procmod_t) → None

The processor module is about to be destroyed

Parameters:: procmod – (const procmod_t *)

destroying_plugmod(plugmod: plugmod_t, entry: plugin_t const *) → None

The plugin object is about to be destroyed

Parameters:

plugmod – (const plugmod_t *)
entry – (const plugin_t *)

desktop_applied(name: str, from_idb: bool, type: int) → None

a desktop has been applied

Parameters:

name – (const char *) the desktop name
from_idb – (bool) the desktop was stored in the IDB (false if it comes from the registry)
type – (int) the desktop type (1-disassembly, 2-debugger, 3-merge)

ida_kernwin.register_action(desc: action_desc_t) → bool

Create a new action (ui_register_action). After an action has been created, it is possible to attach it to menu items (attach_action_to_menu()), or to popup menus (attach_action_to_popup()). Because the actions will need to call the handler’s activate() and update() methods at any time, you shouldn’t build your action handler on the stack. Please see the SDK’s “ht_view” plugin for an example how to register actions.

Parameters:: desc – action to register
Returns:: success

ida_kernwin.get_registered_actions() → List[str]

Get a list with the names of all currently-registered actions.

Returns:: the list of action names

ida_kernwin.attach_dynamic_action_to_popup(unused, popup_handle, desc, popuppath=None, flags=0)

Create & insert an action into the widget’s popup menu (::ui_attach_dynamic_action_to_popup). Note: The action description in the ‘desc’ parameter is modified by

this call so you should prepare a new description for each call.

For example:: desc = ida_kernwin.action_desc_t(None, ‘Dynamic popup action’, Handler()) ida_kernwin.attach_dynamic_action_to_popup(form, popup, desc)

Parameters:

unused – deprecated; should be None
popup_handle – target popup
desc – action description of type action_desc_t
popuppath – can be None
flags – a combination of SETMENU_ constants

Returns:

success

class ida_kernwin.disasm_line_t(*args)

Bases: object

thisown

at: place_t *

line: str

prefix_color: color_t

bg_color: bgcolor_t

is_default: bool

ida_kernwin.py_chooser_base_t_get_row(chobj: chooser_base_t, n: size_t) → PyObject *

ida_kernwin.gen_disasm_text(text: disasm_text_t, ea1: ida_idaapi.ea_t, ea2: ida_idaapi.ea_t, truncate_lines: bool) → None

Generate disassembly text for a range.

Parameters:

text – result
ea1 – start address
ea2 – end address
truncate_lines – (on idainfo::margin)

ida_kernwin.set_nav_colorizer(callback)

Set a new colorizer for the navigation band.

The ‘callback’ is a function of 2 arguments:

ea (the EA to colorize for)
nbytes (the number of bytes at that EA)

and must return a ‘long’ value.

The previous colorizer is returned, allowing the new ‘callback’ to use ‘call_nav_colorizer’ with it.

Note that the previous colorizer is returned only the first time set_nav_colorizer() is called: due to the way the colorizers API is defined in C, it is impossible to chain more than 2 colorizers in IDAPython: the original, IDA-provided colorizer, and a user-provided one.

Example: colorizer inverting the color provided by the IDA colorizer:

def my_colorizer(ea, nbytes):: global ida_colorizer orig = ida_kernwin.call_nav_colorizer(ida_colorizer, ea, nbytes) return long(~orig)

ida_colorizer = ida_kernwin.set_nav_colorizer(my_colorizer)

Parameters:: callback – the new colorizer

ida_kernwin.call_nav_colorizer(colorizer, ea: ida_idaapi.ea_t, nbytes: int)

To be used with the IDA-provided colorizer, that is returned as result of the first call to set_nav_colorizer().

Parameters:

colorizer – the Python colorizer to call
ea – the address to colorize
nbytes – the size of the range to colorize

ida_kernwin.msg_get_lines(count: int = -1) → PyObject *

Retrieve the last ‘count’ lines from the output window, in reverse order (from most recent, to least recent)

Parameters:: count – The number of lines to retrieve. -1 means: all

ida_kernwin.TWidget__from_ptrval__(ptrval: size_t) → TWidget *

ida_kernwin.MAX_SPACES_ADDED

ida_kernwin.add_spaces(s: str, len: size_t) → str

Add space characters to the colored string so that its length will be at least ‘len’ characters. Don’t trim the string if it is longer than ‘len’.

Parameters:: len – the desired length of the string
Returns:: pointer to the end of input string

ida_kernwin.show_wait_box(message: str) → None

Display a dialog box with “Please wait…”. The behavior of the dialog box can be configured with well-known tokens, that should be placed at the start of the format string:

“NODELAYn”: the dialog will show immediately, instead of appearing after usual grace threshold “HIDECANCELn”: the cancel button won’t be added to the dialog box and user_cancelled() will always return false (but can be called to refresh UI) Using “HIDECANCEL” implies “NODELAY”

Plugins must call hide_wait_box() to close the dialog box, otherwise the user interface will remain disabled.

Note that, if the wait dialog is already visible, show_wait_box() will 1) push the currently-displayed text on a stack 2) display the new text

Then, when hide_wait_box() is called, if that stack isn’t empty its top label will be popped and restored in the wait dialog. This implies that a plugin should call hide_wait_box() exactly as many times as it called show_wait_box(), or the wait dialog might remain visible and block the UI. Also, in case the plugin knows the wait dialog is currently displayed, alternatively it can call replace_wait_box(), to replace the text of the dialog without pushing the currently-displayed text on the stack.

ida_kernwin.hide_wait_box() → None: Hide the “Please wait dialog box”.

class ida_kernwin.line_rendering_output_entries_refs_t(*args)

Bases: object

thisown

push_back(*args) → line_rendering_output_entry_t *&

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → line_rendering_output_entry_t *const &

qclear() → None

clear() → None

resize(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: line_rendering_output_entries_refs_t) → None

extract() → line_rendering_output_entry_t **

inject(s: line_rendering_output_entry_t **, len: size_t) → None

begin(*args) → qvector< line_rendering_output_entry_t * >::const_iterator

end(*args) → qvector< line_rendering_output_entry_t * >::const_iterator

insert(it: qvector< line_rendering_output_entry_t * >::iterator, x: line_rendering_output_entry_t) → qvector< line_rendering_output_entry_t * >::iterator

erase(*args) → qvector< line_rendering_output_entry_t * >::iterator

find(*args) → qvector< line_rendering_output_entry_t * >::const_iterator

has(x: line_rendering_output_entry_t) → bool

add_unique(x: line_rendering_output_entry_t) → bool

append(x: line_rendering_output_entry_t) → None

extend(x: line_rendering_output_entries_refs_t) → None

front

back

class ida_kernwin.section_lines_refs_t(*args)

Bases: object

thisown

push_back(*args) → twinline_t const *&

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → twinline_t const *const &

qclear() → None

clear() → None

resize(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: section_lines_refs_t) → None

extract() → twinline_t const **

inject(s: twinline_t const **, len: size_t) → None

begin(*args) → qvector< twinline_t const * >::const_iterator

end(*args) → qvector< twinline_t const * >::const_iterator

insert(it: qvector< twinline_t const * >::iterator, x: twinline_t) → qvector< twinline_t const * >::iterator

erase(*args) → qvector< twinline_t const * >::iterator

find(*args) → qvector< twinline_t const * >::const_iterator

has(x: twinline_t) → bool

add_unique(x: twinline_t) → bool

append(x: twinline_t) → None

extend(x: section_lines_refs_t) → None

front

back

class ida_kernwin.sections_lines_refs_t(*args)

Bases: object

thisown

push_back(*args) → section_lines_refs_t &

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → section_lines_refs_t const &

qclear() → None

clear() → None

resize(*args) → None

grow(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: sections_lines_refs_t) → None

extract() → section_lines_refs_t *

inject(s: section_lines_refs_t, len: size_t) → None

begin(*args) → qvector< section_lines_refs_t >::const_iterator

end(*args) → qvector< section_lines_refs_t >::const_iterator

insert(it: qvector< section_lines_refs_t >::iterator, x: section_lines_refs_t) → qvector< section_lines_refs_t >::iterator

erase(*args) → qvector< section_lines_refs_t >::iterator

find(*args) → qvector< section_lines_refs_t >::const_iterator

has(x: section_lines_refs_t) → bool

add_unique(x: section_lines_refs_t) → bool

append(x: section_lines_refs_t) → None

extend(x: sections_lines_refs_t) → None

front

back

class ida_kernwin.text_t(*args)

Bases: object

thisown

push_back(*args) → twinline_t &

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → twinline_t const &

qclear() → None

clear() → None

resize(*args) → None

grow(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: text_t) → None

extract() → twinline_t *

inject(s: twinline_t, len: size_t) → None

begin(*args) → qvector< twinline_t >::const_iterator

end(*args) → qvector< twinline_t >::const_iterator

insert(it: twinline_t, x: twinline_t) → qvector< twinline_t >::iterator

erase(*args) → qvector< twinline_t >::iterator

append(x: twinline_t) → None

extend(x: text_t) → None

front

back

class ida_kernwin.sync_source_vec_t(*args)

Bases: object

thisown

push_back(x: sync_source_t) → None

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → sync_source_t const &

qclear() → None

clear() → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: sync_source_vec_t) → None

extract() → sync_source_t *

inject(s: sync_source_t, len: size_t) → None

begin(*args) → qvector< sync_source_t >::const_iterator

end(*args) → qvector< sync_source_t >::const_iterator

insert(it: sync_source_t, x: sync_source_t) → qvector< sync_source_t >::iterator

erase(*args) → qvector< sync_source_t >::iterator

find(*args) → qvector< sync_source_t >::const_iterator

has(x: sync_source_t) → bool

add_unique(x: sync_source_t) → bool

append(x: sync_source_t) → None

extend(x: sync_source_vec_t) → None

front

back

ida_kernwin.mbox_internal: internal error

ida_kernwin.mbox_info

ida_kernwin.mbox_warning

ida_kernwin.mbox_error

ida_kernwin.mbox_nomem

ida_kernwin.mbox_feedback

ida_kernwin.mbox_readerror

ida_kernwin.mbox_writeerror

ida_kernwin.mbox_filestruct

ida_kernwin.mbox_wait

ida_kernwin.mbox_hide

ida_kernwin.mbox_replace

ida_kernwin.chtype_generic: the generic choose() function

ida_kernwin.chtype_idasgn: see choose_idasgn()

ida_kernwin.chtype_entry: see choose_entry()

ida_kernwin.chtype_name: see choose_name()

ida_kernwin.chtype_stkvar_xref: see choose_stkvar_xref()

ida_kernwin.chtype_xref: see choose_xref()

ida_kernwin.chtype_func: see choose_func()

ida_kernwin.chtype_segm: see choose_segm()

ida_kernwin.chtype_strpath: see choose_struc_path()

ida_kernwin.chtype_idatil: see choose_til()

ida_kernwin.chtype_srcp: see choose_srcp()

ida_kernwin.chtype_struct: see choose_struct()

ida_kernwin.chtype_enum: see choose_enum()

ida_kernwin.chtype_enum_by_value_and_size: see choose_enum_by_value()

ida_kernwin.beep_default

ida_kernwin.TCCRT_INVALID: invalid

ida_kernwin.TCCRT_FLAT: flat view

ida_kernwin.TCCRT_GRAPH: graph view

ida_kernwin.TCCRT_PROXIMITY: proximity view

ida_kernwin.TCCPT_INVALID: invalid

ida_kernwin.TCCPT_PLACE: place_t

ida_kernwin.TCCPT_SIMPLELINE_PLACE: simpleline_place_t

ida_kernwin.TCCPT_IDAPLACE: idaplace_t

ida_kernwin.TCCPT_TIPLACE: tiplace_t

ida_kernwin.VME_UNKNOWN: unknown mouse button

ida_kernwin.VME_LEFT_BUTTON: left mouse button

ida_kernwin.VME_RIGHT_BUTTON: right mouse button

ida_kernwin.VME_MID_BUTTON: middle mouse button

ida_kernwin.SETMENU_POSMASK

ida_kernwin.SETMENU_INS: add menu item before the specified path (default)

ida_kernwin.SETMENU_APP: add menu item after the specified path

ida_kernwin.SETMENU_FIRST: add item to the beginning of menu

ida_kernwin.SETMENU_ENSURE_SEP: make sure there is a separator before the action

ida_kernwin.CREATETB_ADV: toolbar is for ‘advanced mode’ only

ida_kernwin.HIF_IDENTIFIER: text is an identifier (i.e., when searching for the current highlight, SEARCH_IDENT will be used)

ida_kernwin.HIF_REGISTER: text represents a register (aliases/subregisters will be highlit as well)

ida_kernwin.HIF_LOCKED: locked; clicking/moving the cursor around doesn’t change the highlight

ida_kernwin.HIF_NOCASE: case insensitive

ida_kernwin.HIF_USE_SLOT: use the given number, or just use the “floating” highlight

ida_kernwin.HIF_SLOT_SHIFT: position of the 3 top bits specifying which highlight to use

ida_kernwin.HIF_SLOT_0: operate on slot 0

ida_kernwin.HIF_SLOT_1: operate on slot 1

ida_kernwin.HIF_SLOT_2: operate on slot 2

ida_kernwin.HIF_SLOT_3: operate on slot 3

ida_kernwin.HIF_SLOT_4: operate on slot 4

ida_kernwin.HIF_SLOT_5: operate on slot 5

ida_kernwin.HIF_SLOT_6: operate on slot 6

ida_kernwin.HIF_SLOT_7: operate on slot 7

ida_kernwin.REG_HINTS_MARKER

ida_kernwin.REG_HINTS_MARKER_LEN

ida_kernwin.SRCDBG_HINTS_MARKER

ida_kernwin.SRCDBG_HINTS_MARKER_LEN

ida_kernwin.CDVF_NOLINES: don’t show line numbers

ida_kernwin.CDVF_LINEICONS: icons can be drawn over the line control

ida_kernwin.CDVF_STATUSBAR: keep the status bar in the custom viewer

ida_kernwin.IDCHK_OK: ok

ida_kernwin.IDCHK_ARG: bad argument(s)

ida_kernwin.IDCHK_KEY: bad hotkey name

ida_kernwin.IDCHK_MAX: too many IDC hotkeys

ida_kernwin.WCLS_SAVE: save state in desktop config

ida_kernwin.WCLS_NO_CONTEXT: don’t change the current context (useful for toolbars)

ida_kernwin.WCLS_DONT_SAVE_SIZE: don’t save size of the window

ida_kernwin.WCLS_DELETE_LATER: assign the deletion of the widget to the UI loop ///<

ida_kernwin.WCLS_CLOSE_LATER

ida_kernwin.DP_LEFT: Dock src_form to the left of dest_form.

ida_kernwin.DP_TOP: Dock src_form above dest_form.

ida_kernwin.DP_RIGHT: Dock src_form to the right of dest_form.

ida_kernwin.DP_BOTTOM: Dock src_form below dest_form.

ida_kernwin.DP_INSIDE: Create a new tab bar with both src_form and dest_form.

ida_kernwin.DP_TAB: Place src_form into a tab next to dest_form, if dest_form is in a tab bar (otherwise the same as DP_INSIDE)

ida_kernwin.DP_BEFORE: Place src_form before dst_form in the tab bar instead of after; used with DP_INSIDE or DP_TAB.

ida_kernwin.DP_FLOATING: Make src_form floating.

ida_kernwin.DP_SZHINT: When floating or in a splitter (i.e., not tabbed), use the widget’s size hint to determine the best geometry (Qt only)

ida_kernwin.SVF_COPY_LINES: keep a local copy of ‘*lines’

ida_kernwin.SVF_LINES_BYPTR: remember the ‘lines’ ptr. do not make a copy of ‘*lines’

ida_kernwin.CVNF_LAZY: try and move the cursor to a line displaying the place_t if possible. This might disregard the Y position in case of success

ida_kernwin.CVNF_JUMP: push the current position in this viewer’s lochist_t before going to the new location

ida_kernwin.CVNF_ACT: activate (i.e., switch to) the viewer. Activation is performed before the new lochist_entry_t instance is actually copied to the viewer’s lochist_t (otherwise, if the viewer was invisible its on_location_changed() handler wouldn’t be called.)

ida_kernwin.WOPN_RESTORE: if the widget was the only widget in a floating area the last time it was closed, it will be restored as floating, with the same position+size as before

ida_kernwin.WOPN_PERSIST: widget will remain available when starting or stopping debugger sessions

ida_kernwin.WOPN_CLOSED_BY_ESC: override idagui.cfg:CLOSED_BY_ESC: esc will close

ida_kernwin.WOPN_NOT_CLOSED_BY_ESC: override idagui.cfg:CLOSED_BY_ESC: esc will not close

ida_kernwin.WOPN_DP_MASK

ida_kernwin.WOPN_DP_SHIFT

ida_kernwin.WOPN_DP_LEFT: Dock widget to the left of dest_ctrl.

ida_kernwin.WOPN_DP_TOP: Dock widget above dest_ctrl.

ida_kernwin.WOPN_DP_RIGHT: Dock widget to the right of dest_ctrl.

ida_kernwin.WOPN_DP_BOTTOM: Dock widget below dest_ctrl.

ida_kernwin.WOPN_DP_INSIDE: Create a new tab bar with both widget and dest_ctrl.

ida_kernwin.WOPN_DP_TAB: Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar (otherwise the same as WOPN_DP_INSIDE)

ida_kernwin.WOPN_DP_BEFORE: Place widget before dst_form in the tab bar instead of after; used with WOPN_DP_INSIDE and WOPN_DP_TAB

ida_kernwin.WOPN_DP_FLOATING: Make widget floating.

ida_kernwin.WOPN_DP_SZHINT: when floating or in a splitter (i.e., not tabbed), use the widget’s size hint to determine the best geometry (Qt only)

ida_kernwin.WOPN_DP_INSIDE_BEFORE

ida_kernwin.WOPN_DP_TAB_BEFORE

ida_kernwin.RENADDR_IDA: dialog for “IDA View”

ida_kernwin.RENADDR_HR: dialog for “Pseudocode”; additional flags: * 0x01 Library function * 0x02 Mark as decompiled

ida_kernwin.CVLF_USE_MOUSE: Fetch the location from the mouse, instead of caret in the listing.

ida_kernwin.get_kernel_version() → str: Get IDA kernel version (in a string like “5.1”).

ida_kernwin.is_ida_library(path: char * = None, pathsize: size_t = 0, handle: void ** = None) → bool

class ida_kernwin.place_t(*args, **kwargs)

Bases: object

thisown

lnnum: int: Number of line within the current object.

touval(ud: void *) → int

Map the location to a number. This mapping is used to draw the vertical scrollbar.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t

clone() → place_t *

Clone the location.

Returns:: a pointer to a copy of the current location in dynamic memory

copyfrom(_from: place_t) → None: Copy the specified location object to the current object.

makeplace(ud: void *, x: int, lnnum: int) → place_t *

Map a number to a location. When the user clicks on the scrollbar and drags it, we need to determine the location corresponding to the new scrollbar position. This function is used to determine it. It builds a location object for the specified ‘x’ and returns a pointer to it.

Parameters:

ud – pointer to user-defined context data. Is supplied by linearray_t
x – number to map
lnnum – line number to initialize ‘lnnum’

Returns:

a freshly allocated object. See also PCF_MAKEPLACE_ALLOCATES

compare(t2: place_t) → int: Deprecated. Please consider compare2(const place_t *, void *) instead.

adjust(ud: void *) → None

Adjust the current location to point to a displayable object. This function validates the location and makes sure that it points to an existing object. For example, if the location points to the middle of an instruction, it will be adjusted to point to the beginning of the instruction.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t

prev(ud: void *) → bool

Move to the previous displayable location.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t
Returns:: success

next(ud: void *) → bool

Move to the next displayable location.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t
Returns:: success

beginning(ud: void *) → bool

Are we at the first displayable object?.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t
Returns:: true if the current location points to the first displayable object

ending(ud: void *) → bool

Are we at the last displayable object?.

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t
Returns:: true if the current location points to the last displayable object

serialize() → None: Serialize this instance. It is fundamental that all instances of a particular subclass of of place_t occupy the same number of bytes when serialized.

id() → int

Get the place’s ID (i.e., the value returned by register_place_class())

Returns:: the id

name() → str

Get this place type name. All instances of a given class must return the same string.

Returns:: the place type name. Please try and pick something that is not too generic, as it might clash w/ other plugins. A good practice is to prefix the class name with the name of your plugin. E.g., “myplugin:srcplace_t”.

toea() → ida_idaapi.ea_t

Map the location to an ea_t.

Returns:: the corresponding ea_t, or BADADDR;

rebase(arg2: segm_move_infos_t const &) → bool

Rebase the place instance

Returns:: true if place was rebased, false otherwise

enter(arg2: uint32 *) → place_t *

Visit this place, possibly ‘unhiding’ a section of text. If entering that place required some expanding, a place_t should be returned that represents that section, plus some flags for later use by ‘leave()’.

Returns:: a place_t corresponding to the beginning of the section of text that had to be expanded. That place_t’s leave() will be called with the flags contained in ‘out_flags’ when the user navigates away from it.

leave(arg2: int) → None: Leave this place, possibly ‘hiding’ a section of text that was previously expanded (at enter()-time.)

compare2(t2: place_t, arg3: void *) → int

Compare two locations except line numbers (lnnum). This function is used to organize loops. For example, if the user has selected an range, its boundaries are remembered as location objects. Any operation within the selection will have the following look: for ( loc=starting_location; loc < ending_location; loc.next() ) In this loop, the comparison function is used.

Parameters:: t2 – the place to compare this one to.
Returns:: -1: if the current location is less than ‘t2’
Returns:: 0: if the current location is equal to than ‘t2’
Returns:: 1: if the current location is greater than ‘t2’

equals(t2: place_t, ud: void *) → bool

Compare two places for equality, ignoring line numbers (lnnum). This is semantically different than compare2, although by default it is implemented in terms of it for backwards-compatibility. compare2 implements a three-way comparison to see if two places sort less than, equal to, or grater than. This method actually looks for equality. Thus, t1->equals(t2, ud) implies t1->compare2(t2, ud) == 0, but the reverse is not always true. An example of this is for adjustable places that are sensitive to the x-cursor position, and need to compare differently as a result.

Returns:: true if the two places match / are equal.

deserialize(_in: bytevec_t const &) → bool

De-serialize into this instance. ‘pptr’ should be incremented by as many bytes as de-serialization consumed.

Returns:: whether de-serialization was successful

static as_idaplace_t(p: place_t) → idaplace_t *

static as_simpleline_place_t(p: place_t) → simpleline_place_t *

static as_tiplace_t(p: place_t) → tiplace_t *

generate(ud, maxsize: int) → Tuple[List[str], int, int, int]

Generate text lines for the current location.

Parameters:

ud – The user data object
maxsize – The maximum number of lines to generate

Returns:

a tuple (lines-of-text, default-line-number, prefix-color, background-color)

ida_kernwin.cvar

ida_kernwin.IDALIB_API_MAGIC

ida_kernwin.DEFAULT_PLACE_LNNUM

ida_kernwin.l_compare2(t1: place_t, t2: place_t, ud: void *) → int

ida_kernwin.l_equals(t1: place_t, t2: place_t, ud: void *) → bool

class ida_kernwin.simpleline_t(*args)

Bases: object

thisown

line: str: line text

color: color_t: line prefix color

bgcolor: bgcolor_t: line background color

class ida_kernwin.simpleline_place_t(*args, **kwargs)

Bases: place_t

thisown

n: int: line number

class ida_kernwin.idaplace_t(*args, **kwargs)

Bases: place_t

thisown

ea: ida_idaapi.ea_t: address

ida_kernwin.is_tif_cursor_header(c: tif_cursor_t) → bool

ida_kernwin.is_tif_cursor_footer(c: tif_cursor_t) → bool

ida_kernwin.is_tif_cursor_index(c: tif_cursor_t) → bool

class ida_kernwin.tiplace_t(*args, **kwargs)

Bases: place_t

thisown

ordinal: int

cursor: tif_cursor_t

valid_ord() → bool

reset() → None

is_header() → bool

is_footer() → bool

is_index() → bool

set_header() → None

set_footer() → None

calc_udm_offset(ud: void const *, p_udmidx: ssize_t * = None, p_bitoff: int * = None) → uint64

for structs: calculate the offset that corresponds to the tiplace.

Parameters:

ud – pointer to user-defined context data. Is supplied by linearray_t
p_udmidx – place to return the index of the current udt member, if any. if there is no member at the current offset, return -1
p_bitoff – place to return the bit offset of the item from the beginning of the bit bucket if there no bitfields, return -1

Returns:

the current offset or uint64(-1)

set_index_by_offset(ud: void *, offset: uint64) → None

for structs: calculate the index that corresponds to the offset and set it.

Parameters:

ud – pointer to user-defined context data. Is supplied by linearray_t
offset – offset of udt member

get_kind(ud: void const *) → type_t

get the kind of type this place represents

Parameters:: ud – pointer to user-defined context data. Is supplied by linearray_t
Returns:: one of BTF_TYPEDEF, BTF_STRUCT, BTF_UNION, BTF_ENUM or BT_UNK

fill_type_ref(out: til_type_ref_t, ud: void const *) → bool

fill the type information for use in actions

Parameters:

out – pointer to storage
ud – pointer to user-defined context data. Is supplied by linearray_t

Returns:

success

ida_kernwin.PCF_EA_CAPABLE: toea() implementation returns meaningful data

ida_kernwin.PCF_MAKEPLACE_ALLOCATES: makeplace() returns a freshly allocated (i.e., non-static) instance. All new code should pass that flag to register_place_class(), and the corresponding makeplace() class implementation should return new instances.

ida_kernwin.internal_register_place_class(tmplate: place_t, flags: int, owner: plugin_t const *, sdk_version: int) → int

ida_kernwin.get_place_class(out_flags: int *, out_sdk_version: int *, id: int) → place_t const *

Get information about a previously-registered place_t class. See also register_place_class().

Parameters:

out_flags – output flags (can be nullptr)
out_sdk_version – sdk version the place was created with (can be nullptr)
id – place class ID

Returns:

the place_t template, or nullptr if not found

ida_kernwin.get_place_class_template(id: int) → place_t const *: See get_place_class()

ida_kernwin.is_place_class_ea_capable(id: int) → bool: See get_place_class()

ida_kernwin.get_place_class_id(name: str) → int

Get the place class ID for the place that has been registered as ‘name’.

Parameters:: name – the class name
Returns:: the place class ID, or -1 if not found

class ida_kernwin.sync_source_t(*args)

Bases: object

thisown

is_register() → bool

is_widget() → bool

get_widget() → TWidget const *

get_register() → str

class ida_kernwin.synced_group_t

Bases: sync_source_vec_t

thisown

has_widget(v: TWidget const *) → bool

has_register(r: str) → bool

has(ss: sync_source_t) → bool

ida_kernwin.LECVT_CANCELED

ida_kernwin.LECVT_ERROR

ida_kernwin.LECVT_OK

ida_kernwin.LECVT_WITHIN_LISTING

class ida_kernwin.twinpos_t(t: place_t = None, x0: int = 0)

Bases: object

thisown

at: place_t *: location in view

x: int: cursor x

place_as_idaplace_t()

place_as_simpleline_place_t()

place_as_tiplace_t()

place(view)

class ida_kernwin.twinline_t(*args)

Bases: object

thisown

at: place_t *: location in view

line: str: line contents

prefix_color: color_t: line prefix color

bg_color: bgcolor_t: line background color

is_default: bool: is this the default line of the current location?

class ida_kernwin.linearray_t(_ud: void *)

Bases: object

thisown

set_place(new_at: place_t) → int

Position the array. This function must be called before calling any other member functions.

Parameters:: new_at – new position of the array. linearray will make a clone of this object.
Returns:: the delta of lines that the linearray_t had to adjust the place by.

For example, if the place_t has a lnnum of 5, but it turns out, upon generating lines, that the number of lines for that particular place is only 2, then 3 will be returned.

copy_from(src: linearray_t) → None: Copy information from one linearray to another. Only linearray objects with compatible ‘ud’ fields can be copied.

get_place() → place_t *: Get the current place. If called before down(), then returns place of line which will be returned by down(). If called after up(), then returns place if line returned by up().

get_bg_color() → bgcolor_t: Get current background color. (the same behavior as with get_place(): good before down() and after up())

get_pfx_color() → bgcolor_t: Get current prefix color. (the same behavior as with get_place(): good before down() and after up())

get_dlnnum() → int: Get default line number. (the same behavior as with get_place(): good before down() and after up())

get_linecnt() → int: Get number of lines for the current place. (the same behavior as with get_place(): good before down() and after up())

userdata() → void *: Get pointer to user data.

set_userdata(userd: void *) → None: Change the user data.

beginning() → bool: Are we at the beginning?

ending() → bool

down() → str: Get the next line going downwards. ‘at’ for the retrieved line is correct BEFORE calling this function.

up() → str: Get the next line going upwards. ‘at’ for the retrieved line is correct AFTER calling this function.

set_max_lines(n: int) → None: Set max number of lines to generate for a place. 0 means to use the default value, MAX_ITEM_LINES from ida.cfg

class ida_kernwin.lines_rendering_input_t

Bases: object

thisown

cb: int

sections_lines: sections_lines_refs_t: references to the lines that are used for rendering

sync_group: synced_group_t const *: the ‘synced’ group ‘widget’ (see ui_get_lines_rendering_info) belongs to, or nullptr

ida_kernwin.CK_TRACE: traced address

ida_kernwin.CK_TRACE_OVL: overlay trace address

ida_kernwin.CK_EXTRA1: extra background overlay #1

ida_kernwin.CK_EXTRA2: extra background overlay #2

ida_kernwin.CK_EXTRA3: extra background overlay #3

ida_kernwin.CK_EXTRA4: extra background overlay #4

ida_kernwin.CK_EXTRA5: extra background overlay #5

ida_kernwin.CK_EXTRA6: extra background overlay #6

ida_kernwin.CK_EXTRA7: extra background overlay #7

ida_kernwin.CK_EXTRA8: extra background overlay #8

ida_kernwin.CK_EXTRA9: extra background overlay #9

ida_kernwin.CK_EXTRA10: extra background overlay #10

ida_kernwin.CK_EXTRA11: extra background overlay #11

ida_kernwin.CK_EXTRA12: extra background overlay #12

ida_kernwin.CK_EXTRA13: extra background overlay #13

ida_kernwin.CK_EXTRA14: extra background overlay #14

ida_kernwin.CK_EXTRA15: extra background overlay #15

ida_kernwin.CK_EXTRA16: extra background overlay #16

ida_kernwin.LROEF_MASK

ida_kernwin.LROEF_FULL_LINE: full line background

ida_kernwin.LROEF_CPS_RANGE: background for range of chars

class ida_kernwin.line_rendering_output_entry_t(*args)

Bases: object

thisown

line: twinline_t const *

flags: int: line_rendering_output_entry_t flags

bg_color: bgcolor_t

cpx: int: number of char to start from, valid if LROEF_CPS_RANGE

nchars: int: chars count, valid if LROEF_CPS_RANGE

is_bg_color_empty() → bool

is_bg_color_key() → bool

is_bg_color_direct() → bool

class ida_kernwin.lines_rendering_output_t

Bases: object

thisown

entries: line_rendering_output_entries_refs_t

flags: int

clear() → None

swap(r: lines_rendering_output_t) → None

class ida_kernwin.line_section_t

Bases: object

thisown

start: cpidx_t

length: cplen_t

contains(x: cpidx_t) → bool

is_open() → bool

is_closed() → bool

valid() → bool

class ida_kernwin.tagged_line_section_t

Bases: line_section_t

thisown

tag: color_t

valid() → bool

valid_in(_in: str) → bool

substr(_in: str, end: tagged_line_section_t = None) → bool

class ida_kernwin.tagged_line_sections_t

Bases: tagged_line_section_vec_t

thisown

first(tag: color_t) → tagged_line_section_t const *

sections_at(out: tagged_line_sections_t, x: cpidx_t, tag: color_t = 0) → None

nearest_at(x: cpidx_t, tag: color_t = 0) → tagged_line_section_t const *

nearest_before(range: tagged_line_section_t, start: cpidx_t, tag: color_t = 0) → tagged_line_section_t const *

nearest_after(range: tagged_line_section_t, start: cpidx_t, tag: color_t = 0) → tagged_line_section_t const *

class ida_kernwin.listing_location_t

Bases: object

thisown

cb: int

loc: lochist_entry_t const *

text: str

tagged_sections: tagged_line_sections_t const *

ida_kernwin.request_refresh(mask: uint64, cnd: bool = True) → None

Request a refresh of a builtin window.

Parameters:

mask – Window refresh flags
cnd – set if true or clear flag otherwise

ida_kernwin.clear_refresh_request(mask: uint64) → None

ida_kernwin.is_refresh_requested(mask: uint64) → bool

Get a refresh request state

Parameters:: mask – Window refresh flags
Returns:: the state (set or cleared)

ida_kernwin.BWN_UNKNOWN: unknown window

ida_kernwin.BWN_EXPORTS: exports

ida_kernwin.BWN_IMPORTS: imports

ida_kernwin.BWN_NAMES: names

ida_kernwin.BWN_FUNCS: functions

ida_kernwin.BWN_STRINGS: strings

ida_kernwin.BWN_SEGS: segments

ida_kernwin.BWN_SEGREGS: segment registers

ida_kernwin.BWN_SELS: selectors

ida_kernwin.BWN_SIGNS: signatures

ida_kernwin.BWN_TILS: type libraries

ida_kernwin.BWN_TICSR: type library widget’s (e.g., “Local types”) chooser

ida_kernwin.BWN_CALLS: function calls

ida_kernwin.BWN_PROBS: problems

ida_kernwin.BWN_BPTS: breakpoints

ida_kernwin.BWN_THREADS: threads

ida_kernwin.BWN_MODULES: modules

ida_kernwin.BWN_TRACE: tracing view

ida_kernwin.BWN_CALL_STACK: call stack

ida_kernwin.BWN_XREFS: xrefs

ida_kernwin.BWN_SEARCH: search results

ida_kernwin.BWN_FRAME: function frame

ida_kernwin.BWN_NAVBAND: navigation band

ida_kernwin.BWN_DISASM: disassembly views

ida_kernwin.BWN_HEXVIEW: hex view

ida_kernwin.BWN_NOTEPAD: notepad

ida_kernwin.BWN_OUTPUT: the text area, in the output window

ida_kernwin.BWN_CLI: the command-line, in the output window

ida_kernwin.BWN_WATCH: the ‘watches’ debugger window

ida_kernwin.BWN_LOCALS: the ‘locals’ debugger window

ida_kernwin.BWN_STKVIEW: the ‘Stack view’ debugger window

ida_kernwin.BWN_CHOOSER: a non-builtin chooser

ida_kernwin.BWN_SHORTCUTCSR: the shortcuts chooser (Qt version only)

ida_kernwin.BWN_SHORTCUTWIN: the shortcuts window (Qt version only)

ida_kernwin.BWN_CPUREGS: one of the ‘General registers’, ‘FPU register’, … debugger windows

ida_kernwin.BWN_SO_STRUCTS: the ‘Structure offsets’ dialog’s ‘Structures and Unions’ panel

ida_kernwin.BWN_SO_OFFSETS: the ‘Structure offsets’ dialog’s offset panel

ida_kernwin.BWN_CMDPALCSR: the command palette chooser (Qt version only)

ida_kernwin.BWN_CMDPALWIN: the command palette window (Qt version only)

ida_kernwin.BWN_SNIPPETS: the ‘Execute script’ window

ida_kernwin.BWN_CUSTVIEW: custom viewers

ida_kernwin.BWN_ADDRWATCH: the ‘Watch List’ window

ida_kernwin.BWN_PSEUDOCODE: hexrays decompiler views

ida_kernwin.BWN_CALLS_CALLERS: function calls, callers

ida_kernwin.BWN_CALLS_CALLEES: function calls, callees

ida_kernwin.BWN_MDVIEWCSR: lumina metadata view chooser

ida_kernwin.BWN_DISASM_ARROWS: disassembly arrows widget

ida_kernwin.BWN_CV_LINE_INFOS: custom viewers’ lineinfo widget

ida_kernwin.BWN_SRCPTHMAP_CSR: “Source paths…“‘s path mappings chooser

ida_kernwin.BWN_SRCPTHUND_CSR: “Source paths…“‘s undesired paths chooser

ida_kernwin.BWN_UNDOHIST: Undo history.

ida_kernwin.BWN_SNIPPETS_CSR: the list of snippets in the ‘Execute script’ window

ida_kernwin.BWN_SCRIPTS_CSR: the “Recent scripts” chooser

ida_kernwin.BWN_BOOKMARKS: a persistent ‘Bookmarks’ widget

ida_kernwin.BWN_TILIST: a type listing widget

ida_kernwin.BWN_TIL_VIEW: a type library’s toplevel widget

ida_kernwin.BWN_TYPE_EDITOR: a type editor

ida_kernwin.BWN_MICROCODE: microcode view (part of hexrays decompiler)

ida_kernwin.BWN_XREF_TREE: xref tree widget

ida_kernwin.IWID_EXPORTS: exports

ida_kernwin.IWID_IMPORTS: imports

ida_kernwin.IWID_NAMES: names

ida_kernwin.IWID_FUNCS: functions

ida_kernwin.IWID_STRINGS: strings

ida_kernwin.IWID_SEGS: segments

ida_kernwin.IWID_SEGREGS: segment registers

ida_kernwin.IWID_SELS: selectors

ida_kernwin.IWID_SIGNS: signatures

ida_kernwin.IWID_TILS: type libraries

ida_kernwin.IWID_TICSR: type library widget’s (e.g., “Local types”) chooser

ida_kernwin.IWID_CALLS: function calls

ida_kernwin.IWID_PROBS: problems

ida_kernwin.IWID_BPTS: breakpoints

ida_kernwin.IWID_THREADS: threads

ida_kernwin.IWID_MODULES: modules

ida_kernwin.IWID_TRACE: tracing view

ida_kernwin.IWID_CALL_STACK: call stack

ida_kernwin.IWID_XREFS: xrefs

ida_kernwin.IWID_SEARCH: search results

ida_kernwin.IWID_FRAME: function frame

ida_kernwin.IWID_NAVBAND: navigation band

ida_kernwin.IWID_DISASM: disassembly views

ida_kernwin.IWID_HEXVIEW: hex views

ida_kernwin.IWID_NOTEPAD: notepad

ida_kernwin.IWID_OUTPUT: output

ida_kernwin.IWID_CLI: input line

ida_kernwin.IWID_WATCH: watches

ida_kernwin.IWID_LOCALS: locals

ida_kernwin.IWID_STKVIEW: stack view

ida_kernwin.IWID_CHOOSER: chooser

ida_kernwin.IWID_SHORTCUTCSR: shortcuts chooser

ida_kernwin.IWID_SHORTCUTWIN: shortcuts window

ida_kernwin.IWID_CPUREGS: registers

ida_kernwin.IWID_SO_STRUCTS: stroff

ida_kernwin.IWID_SO_OFFSETS: stroff

ida_kernwin.IWID_CMDPALCSR: command palette

ida_kernwin.IWID_CMDPALWIN: command palette

ida_kernwin.IWID_SNIPPETS: snippets

ida_kernwin.IWID_CUSTVIEW: custom viewers

ida_kernwin.IWID_ADDRWATCH: address watches

ida_kernwin.IWID_PSEUDOCODE: decompiler

ida_kernwin.IWID_CALLS_CALLERS: funcalls, callers

ida_kernwin.IWID_CALLS_CALLEES: funcalls, callees

ida_kernwin.IWID_MDVIEWCSR: lumina md view

ida_kernwin.IWID_DISASM_ARROWS: arrows widget

ida_kernwin.IWID_CV_LINE_INFOS: lineinfo widget

ida_kernwin.IWID_SRCPTHMAP_CSR: mappings chooser

ida_kernwin.IWID_SRCPTHUND_CSR: undesired chooser

ida_kernwin.IWID_UNDOHIST: Undo history.

ida_kernwin.IWID_SNIPPETS_CSR: snippets chooser

ida_kernwin.IWID_SCRIPTS_CSR: recent scripts

ida_kernwin.IWID_BOOKMARKS: bookmarks list

ida_kernwin.IWID_TILIST: type listing

ida_kernwin.IWID_TIL_VIEW: type library’s toplevel widget

ida_kernwin.IWID_TYPE_EDITOR: a type editor

ida_kernwin.IWID_XREF_TREE: xref tree widget

ida_kernwin.IWID_ANY_LISTING: anything that uses a listing widget

ida_kernwin.IWID_EA_LISTING: anything that can be used to represent data/code at an address

ida_kernwin.IWID_ALL: mask

ida_kernwin.is_chooser_widget(t: twidget_type_t) → bool: Does the given widget type specify a chooser widget?

ida_kernwin.IDA_DEBUG_DREFS: drefs

ida_kernwin.IDA_DEBUG_OFFSET: offsets

ida_kernwin.IDA_DEBUG_FLIRT: flirt

ida_kernwin.IDA_DEBUG_IDP: idp module

ida_kernwin.IDA_DEBUG_LDR: ldr module

ida_kernwin.IDA_DEBUG_PLUGIN: plugin module

ida_kernwin.IDA_DEBUG_IDS: ids files

ida_kernwin.IDA_DEBUG_CONFIG: config file

ida_kernwin.IDA_DEBUG_CHECKMEM: check heap consistency

ida_kernwin.IDA_DEBUG_LICENSE: licensing

ida_kernwin.IDA_DEBUG_DEMANGLE: demangler

ida_kernwin.IDA_DEBUG_QUEUE: queue

ida_kernwin.IDA_DEBUG_ROLLBACK: rollback

ida_kernwin.IDA_DEBUG_ALREADY: already data or code

ida_kernwin.IDA_DEBUG_TIL: type system

ida_kernwin.IDA_DEBUG_NOTIFY: show all notifications

ida_kernwin.IDA_DEBUG_DEBUGGER: debugger

ida_kernwin.IDA_DEBUG_APPCALL: appcall

ida_kernwin.IDA_DEBUG_SRCDBG: source debugging

ida_kernwin.IDA_DEBUG_ACCESSIBILITY: accessibility

ida_kernwin.IDA_DEBUG_NETWORK: network

ida_kernwin.IDA_DEBUG_INTERNET: internet connection (for API backward compatibility)

ida_kernwin.IDA_DEBUG_SIMPLEX: full stack analysis

ida_kernwin.IDA_DEBUG_DBGINFO: handling of debug info (e.g. pdb, dwarf)

ida_kernwin.IDA_DEBUG_LUMINA: lumina related

ida_kernwin.IDA_DEBUG_THEMES: themes

ida_kernwin.IDA_DEBUG_REGEX: regular expression

ida_kernwin.IDA_DEBUG_SUBPROC: sub process

ida_kernwin.IDA_DEBUG_RANGECB: range-based entities like segments, functions and so on

ida_kernwin.IDA_DEBUG_ALWAYS: everything

ida_kernwin.AST_ENABLE_ALWAYS: enable action and do not call action_handler_t::update() anymore

ida_kernwin.AST_ENABLE_FOR_IDB: enable action for the current idb. call action_handler_t::update() when a database is opened/closed

ida_kernwin.AST_ENABLE_FOR_WIDGET: enable action for the current widget. call action_handler_t::update() when a widget gets/loses focus

ida_kernwin.AST_ENABLE: enable action - call action_handler_t::update() when anything changes

ida_kernwin.AST_DISABLE_ALWAYS: disable action and do not call action_handler_t::action() anymore

ida_kernwin.AST_DISABLE_FOR_IDB: analog of AST_ENABLE_FOR_IDB

ida_kernwin.AST_DISABLE_FOR_WIDGET: analog of AST_ENABLE_FOR_WIDGET

ida_kernwin.AST_DISABLE: analog of AST_ENABLE

ida_kernwin.is_action_enabled(s: action_state_t) → bool: Check if the given action state is one of AST_ENABLE*.

ida_kernwin.CH_MODAL: Modal chooser.

ida_kernwin.CH_KEEP: The chooser instance’s lifecycle is not tied to the lifecycle of the widget showing its contents. Closing the widget will not destroy the chooser structure. This allows for, e.g., static global chooser instances that don’t need to be allocated on the heap. Also stack-allocated chooser instances must set this bit.

ida_kernwin.CH_MULTI: The chooser will allow multi-selection (only for GUI choosers). This bit is set when using the chooser_multi_t structure.

ida_kernwin.CH_MULTI_EDIT: Obsolete.

ida_kernwin.CH_NOBTNS: do not display ok/cancel/help/search buttons. Meaningful only for gui modal windows because non-modal windows do not have any buttons anyway. Text mode does not have them neither.

ida_kernwin.CH_ATTRS: generate ui_get_chooser_item_attrs (gui only)

ida_kernwin.CH_UNUSED

ida_kernwin.CH_FORCE_DEFAULT: if a non-modal chooser was already open, change selection to the default one

ida_kernwin.CH_CAN_INS: allow to insert new items

ida_kernwin.CH_CAN_DEL: allow to delete existing item(s)

ida_kernwin.CH_CAN_EDIT: allow to edit existing item(s)

ida_kernwin.CH_CAN_REFRESH: allow to refresh chooser

ida_kernwin.CH_QFLT: open with quick filter enabled and focused

ida_kernwin.CH_QFTYP_SHIFT

ida_kernwin.CH_QFTYP_DEFAULT: set quick filtering type to the possible existing default for this chooser

ida_kernwin.CH_QFTYP_NORMAL: normal (i.e., lexicographical) quick filter type

ida_kernwin.CH_QFTYP_WHOLE_WORDS: whole words quick filter type

ida_kernwin.CH_QFTYP_REGEX: regex quick filter type

ida_kernwin.CH_QFTYP_FUZZY: fuzzy search quick filter type

ida_kernwin.CH_QFTYP_MASK

ida_kernwin.CH_NO_STATUS_BAR: don’t show a status bar

ida_kernwin.CH_RESTORE: restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only)

ida_kernwin.CH_RENAME_IS_EDIT: triggering a ‘edit/rename’ (i.e., F2 shortcut) on a cell, should call the edit() callback for the corresponding row.

ida_kernwin.CH_BUILTIN_SHIFT

ida_kernwin.CH_BUILTIN_MASK: Mask for builtin chooser numbers. Plugins should not use them.

ida_kernwin.CH_HAS_DIRTREE: The chooser can provide a dirtree_t, meaning a tree-like structure can be provided to the user (instead of a flat table)

ida_kernwin.CH_TM_NO_TREE: chooser will show in no-tree mode

ida_kernwin.CH_TM_FOLDERS_ONLY: chooser will show in folders-only mode

ida_kernwin.CH_TM_FULL_TREE: chooser will show in full-tree mode

ida_kernwin.CH_TM_SHIFT

ida_kernwin.CH_TM_MASK

ida_kernwin.CH_HAS_DIFF: The chooser can be used in a diffing/merging workflow.

ida_kernwin.CH_NO_SORT: The chooser will not have sorting abilities.

ida_kernwin.CH_NO_FILTER: The chooser will not have filtering abilities.

ida_kernwin.CH_NON_PERSISTED_TREE: the chooser tree is not persisted (it is not loaded on startup and is not saved on exit)

ida_kernwin.CH2_LAZY_LOADED: The chooser is lazy-loaded; it receives the callback do_lazy_load_dir() (only meaningful when CH_HAS_DIRTREE is set)

ida_kernwin.CH2_HAS_INODE2INDEX

ida_kernwin.CHCOL_PLAIN: plain string

ida_kernwin.CHCOL_PATH: file path. TUI IDA will truncate excessive cell lengths starting at their beginning, and prepending the resulting text with “…” order to leave the filename visible

ida_kernwin.CHCOL_HEX: hexadecimal number

ida_kernwin.CHCOL_DEC: decimal number

ida_kernwin.CHCOL_EA: address

ida_kernwin.CHCOL_FNAME: function name. If a chooser column has this flag set and implements chooser_base_t::get_ea(), rows background colors will be automatically set to match the navigator’s “Library function”, “Lumina function” and “External symbol” colors

ida_kernwin.CHCOL_FORMAT: column format mask

ida_kernwin.CHCOL_DEFHIDDEN: column should be hidden by default

ida_kernwin.CHCOL_DRAGHINT: the column number that will be used to build hints for the dragging undo label. This should be provided for at most one column for any given chooser.

ida_kernwin.CHCOL_INODENAME: if CH_HAS_DIRTREE has been specified, this instructs the chooser that this column shows the inode name. This should be provided for at most one column for any given chooser.

ida_kernwin.CHITEM_BOLD: display the item in bold

ida_kernwin.CHITEM_ITALIC: display the item in italic

ida_kernwin.CHITEM_UNDER: underline the item

ida_kernwin.CHITEM_STRIKE: strikeout the item

ida_kernwin.CHITEM_GRAY: gray out the item

ida_kernwin.CHOOSER_NOMAINMENU: do not display main menu

ida_kernwin.CHOOSER_NOSTATUSBAR: do not display status bar (obsolete. Use CH_NO_STATUS_BAR instead)

class ida_kernwin.chooser_item_attrs_t

Bases: object

thisown

flags: int: Chooser item property bits

color: bgcolor_t: item color

reset() → None

class ida_kernwin.chooser_row_info_t

Bases: object

thisown

texts: qstrvec_t: texts, one per chooser column

attrs: chooser_item_attrs_t: styling attributes

icon: int: icon number

ida_kernwin.GCRF_HIGH_BIT

ida_kernwin.GCRF_HEADER: Return header texts.

ida_kernwin.GCRF_SELECTION: Return selected rows.

ida_kernwin.GCRF_CURRENT: Return the current row.

ida_kernwin.GCRF_ALL: Return all rows.

class ida_kernwin.chooser_stdact_desc_t(_label: str = None, _tooltip: str = None, _icon: int = -1)

Bases: object

thisown

version: int: to support the backward compatibility

label: str: see action_desc_t

tooltip: str

icon: int

ucb(arg0: action_ctx_base_t) → action_state_t: the update callback, see action_handler_t::update() When the update callback is called from the chooser UI engine, it can be sure that ctx.source.chooser is a valid pointer to chooser_base_t and that there are selected items for the Delete and Edit actions.

class ida_kernwin.chooser_base_t(*args, **kwargs)

Bases: object

thisown

x0: int: screen position, Functions: generic list choosers

y0: int

x1: int

y1: int

width: int: (in chars)

height: int: (in chars)

title: str: menu title (includes ptr to help). May have chooser title prefixes (see “Chooser title” above).

columns: int: number of columns

widths: int const *: column widths * low 16 bits of each value hold the column width * high 16 bits are flags (see Chooser column flags)

header: char const *const *: header line; contains the tooltips, and column name for each of ‘columns’ columns. When tooltips need to be provided, the syntax should be: “#tooltip#column-name”. (Otherwise, the syntax is simply “column-name”.)

icon: int: default icon

POPUP_INS

POPUP_DEL

POPUP_EDIT

POPUP_REFRESH

NSTDPOPUPS

popup_names: qstring [chooser_base_t::NSTDPOPUPS]: array of custom labels of the standard actions. Used to replace labels for these actions. An empty name means that the default name will be used.

deflt_col: int: Column that will have focus.

is_same(other: chooser_base_t) → bool: do the current and the given objects hold the same data?

can_ins() → bool: is an operation allowed?

can_del() → bool

can_edit() → bool

can_refresh() → bool

popup_allowed(stdact_idx: int) → bool: is a standard action allowed?

is_status_bar_hidden() → bool

should_restore_geometry() → bool

is_modal() → bool: is choose modal?

has_widget_lifecycle() → bool: should chooser object be deleted when the widget gets destroyed?

is_multi() → bool: is multi-selection allowed?

ask_item_attrs() → bool: should chooser generate ui_get_chooser_item_attrs events?

is_force_default() → bool: should selection of the already opened non-modal chooser be changed?

get_builtin_number() → uint: get number of the built-in chooser

is_quick_filter_visible_initially() → bool

get_quick_filter_initial_mode() → int

has_dirtree() → bool

has_diff_capability() → bool

can_sort() → bool

can_filter() → bool

should_rename_trigger_edit() → bool

is_dirtree_persisted() → bool

is_lazy_loaded() → bool

has_inode_to_index() → bool

get_count() → size_t: get the number of elements in the chooser

get_ea(arg2: size_t) → ida_idaapi.ea_t

get the address of an element. When this function returns valid addresses: * If any column has the CHCOL_FNAME flag, rows will be colored according to the attributes of the functions who own those addresses (extern, library function, Lumina, … - similar to what the “Functions” widget does) * When a selection is present and the user presses <Enter> (<Shift+Enter> if the chooser is modal), IDA will jump to that address (through jumpto())

Returns:: the effective address, BADADDR if the element has no address

get_row(n: int) → Tuple[List[str], int, chooser_item_attrs_t]

Get data & attributes for a row in a chooser.

Parameters:: n – The row number
Returns:: a tuple (list-of-strings, icon-id, row-attributes)

ida_kernwin.nat_lib

ida_kernwin.nat_fun

ida_kernwin.nat_cod

ida_kernwin.nat_dat

ida_kernwin.nat_und

ida_kernwin.nat_ext

ida_kernwin.nat_err

ida_kernwin.nat_gap

ida_kernwin.nat_cur

ida_kernwin.nat_auto

ida_kernwin.nat_lum

ida_kernwin.nat_hlo

ida_kernwin.nat_last

ida_kernwin.CVH_USERDATA

ida_kernwin.CVH_KEYDOWN: see custom_viewer_keydown_t

ida_kernwin.CVH_POPUP: see custom_viewer_popup_t

ida_kernwin.CVH_DBLCLICK: see custom_viewer_dblclick_t

ida_kernwin.CVH_CURPOS: see custom_viewer_curpos_t

ida_kernwin.CVH_CLOSE: see custom_viewer_close_t

ida_kernwin.CVH_CLICK: see custom_viewer_click_t

ida_kernwin.CVH_QT_AWARE: see set_custom_viewer_qt_aware()

ida_kernwin.CVH_HELP: see custom_viewer_help_t

ida_kernwin.CVH_MOUSEMOVE: see custom_viewer_mouse_moved_t

ida_kernwin.CDVH_USERDATA: see set_code_viewer_user_data()

ida_kernwin.CDVH_SRCVIEW: see set_code_viewer_is_source()

ida_kernwin.CDVH_LINES_CLICK: see code_viewer_lines_click_t

ida_kernwin.CDVH_LINES_DBLCLICK: see code_viewer_lines_click_t

ida_kernwin.CDVH_LINES_POPUP: see code_viewer_lines_click_t

ida_kernwin.CDVH_LINES_DRAWICON: see code_viewer_lines_icon_t

ida_kernwin.CDVH_LINES_LINENUM: see code_viewer_lines_linenum_t

ida_kernwin.CDVH_LINES_ICONMARGIN: see set_code_viewer_lines_icon_margin()

ida_kernwin.CDVH_LINES_RADIX: see set_code_viewer_lines_radix()

ida_kernwin.CDVH_LINES_ALIGNMENT: see set_code_viewer_lines_alignment()

ida_kernwin.VES_SHIFT: state & 1 => Shift is pressed state & 2 => Alt is pressed state & 4 => Ctrl is pressed state & 8 => Mouse left button is pressed state & 16 => Mouse right button is pressed state & 32 => Mouse middle button is pressed state & 128 => Meta is pressed (OSX only)

ida_kernwin.VES_ALT

ida_kernwin.VES_CTRL

ida_kernwin.VES_MOUSE_LEFT

ida_kernwin.VES_MOUSE_RIGHT

ida_kernwin.VES_MOUSE_MIDDLE

ida_kernwin.VES_META

ida_kernwin.msg_activated: The message window is activated.

ida_kernwin.msg_deactivated: The message window is deactivated.

ida_kernwin.msg_click: Click event.

ida_kernwin.msg_dblclick: Double click event.

ida_kernwin.msg_closed: View closed.

ida_kernwin.msg_keydown: Key down event.

class ida_kernwin.renderer_pos_info_t

Bases: object

thisown

node: int: the node, or -1 if the current renderer is not a graph renderer.

cx: short: the X coords of the character in the current line. When in graph mode: X coords of the character in ‘node’. When in flat mode: X coords of the character in the line, w/o taking scrolling into consideration.

cy: short: the Y coords of the character. When in graph mode: Y coords of the character in ‘node’. When in flat mode: Line number, starting from the top.

sx: short: the number of chars that are scrolled (flat mode only)

class ida_kernwin.view_mouse_event_location_t

Bases: object

thisown

ea: ida_idaapi.ea_t: flat view (rtype == TCCRT_FLAT)

item: selection_item_t const *: graph views (rtype != TCCRT_FLAT). nullptr if mouse is not currently over an item.

class ida_kernwin.view_mouse_event_t

Bases: object

thisown

rtype: tcc_renderer_type_t: type of renderer that received the event

x: int: screen x coordinate

y: int: screen y coordinate

location: view_mouse_event_t::location_t: location where event was generated

state: view_event_state_t: contains information about what buttons are CURRENTLY pressed on the keyboard and mouse. view_mouse_event_t instances created in functions like mouseReleaseEvent() won’t contain any information about the mouse, because it has been released.

button: vme_button_t: represents which mouse button was responsible for generating the event. This field does not care about the current state of the mouse.

renderer_pos: renderer_pos_info_t: position where event was generated, relative to the renderer

ida_kernwin.view_activated: A view is activated

ida_kernwin.view_deactivated: A view is deactivated

ida_kernwin.view_keydown: Key down event

ida_kernwin.view_click: Click event

ida_kernwin.view_dblclick: Double click event

ida_kernwin.view_curpos: Cursor position changed

ida_kernwin.view_created: A view is being created.

ida_kernwin.view_close: View closed

ida_kernwin.view_switched: A view’s renderer has changed.

ida_kernwin.view_mouse_over: The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view.

ida_kernwin.view_loc_changed: The location for the view has changed (can be either the place_t, the renderer_info_t, or both.)

ida_kernwin.view_mouse_moved: The mouse moved on the view

ida_kernwin.iek_unknown

ida_kernwin.iek_shortcut

ida_kernwin.iek_key_press

ida_kernwin.iek_key_release

ida_kernwin.iek_mouse_button_press

ida_kernwin.iek_mouse_button_release

ida_kernwin.iek_mouse_wheel

class ida_kernwin.input_event_t

Bases: object

thisown

cb: int: size marker

kind: input_event_kind_t: the kind of event

modifiers: input_event_modifiers_t: current keyboard (and mouse) modifiers

target: TWidget *: the target widget

source: void *: the source event, should it be required for detailed inform (e.g., a QEvent in the GUI version of IDA)

shortcut: input_event_t::input_event_shortcut_data_t

keyboard: input_event_t::input_event_keyboard_data_t

mouse: input_event_t::input_event_mouse_data_t

get_source_QEvent()

get_target_QWidget()

class ida_kernwin.input_event_shortcut_data_t

Bases: object

thisown

action_name: str

class ida_kernwin.input_event_keyboard_data_t

Bases: object

thisown

key: int

text: char[8]

class ida_kernwin.input_event_mouse_data_t

Bases: object

thisown

x: int

y: int

button: vme_button_t

ida_kernwin.MFF_FAST: Execute code as soon as possible. this mode is ok for calling ui related functions that do not query the database.

ida_kernwin.MFF_READ: Execute code only when ida is idle and it is safe to query the database. This mode is recommended only for code that does not modify the database. (nb: ida may be in the middle of executing another user request, for example it may be waiting for him to enter values into a modal dialog box)

ida_kernwin.MFF_WRITE: Execute code only when ida is idle and it is safe to modify the database. in particular, this flag will suspend execution if there is a modal dialog box on the screen. this mode can be used to call any ida api function. MFF_WRITE implies MFF_READ

ida_kernwin.MFF_NOWAIT: Do not wait for the request to be executed. the caller should ensure that the request is not destroyed until the execution completes. if not, the request will be ignored. the request must be created using the ‘new’ operator to use it with this flag. it can be used in cancel_exec_request(). This flag can be used to delay the code execution until the next UI loop run even from the main thread.

class ida_kernwin.ui_requests_t

Bases: object

thisown

ida_kernwin.UIJMP_ACTIVATE: activate the new window

ida_kernwin.UIJMP_DONTPUSH: do not remember the current address in the navigation history

ida_kernwin.UIJMP_VIEWMASK

ida_kernwin.UIJMP_ANYVIEW: jump in any ea_t-capable view

ida_kernwin.UIJMP_IDAVIEW: jump in idaview

ida_kernwin.UIJMP_IDAVIEW_NEW: jump in new idaview

class ida_kernwin.action_ctx_base_cur_sel_t

Bases: object

thisown

to: twinpos_t: end of selection

reset() → None

class ida_kernwin.action_ctx_base_t

Bases: object

thisown

reset() → None: Invalidate all context info.

widget: TWidget *

widget_type: twidget_type_t: type of current widget

widget_title: str: title of current widget

chooser: chooser_base_t *: the underlying chooser_base_t (if ‘widget’ is a chooser widget)

chooser_selection: sizevec_t: current chooser selection (0-based)

action: str: action name

cur_flags: int: Current address information. see Action context property bits.

has_flag(flag: int) → bool: Check if the given flag is set.

cur_ea: ida_idaapi.ea_t: the current EA of the position in the view

cur_value: int: the possible address, or value the cursor is positioned on

cur_func: func_t *: the current function

cur_fchunk: func_t *: the current function chunk

cur_seg: segment_t *: the current segment

cur_sel: action_ctx_base_cur_sel_t: the currently selected range. also see ACF_HAS_SELECTION

regname: str: register name (if widget_type == BWN_CPUREGS and context menu opened on register)

focus: TWidget *: The focused widget in case it is not the ‘form’ itself (e.g., the ‘quick filter’ input in choosers.)

graph: interactive_graph_t *: the current graph (if in a graph view)

graph_selection: screen_graph_selection_t *: the current graph selection (if in a graph view)

hovered: selection_item_t const *: the current item being hovered (if in a graph view)

dirtree_selection: dirtree_selection_t *: the current dirtree_t selection (if applicable)

type_ref: til_type_ref_t *: a reference to the current type (if ‘widget’ is a type listing widget; nullptr otherwise)

cur_extracted_ea

form

form_type

form_title

ida_kernwin.ACF_HAS_SELECTION: there is currently a valid selection

ida_kernwin.ACF_XTRN_EA: cur_ea is in ‘externs’ segment

ida_kernwin.ACF_HAS_FIELD_DIRTREE_SELECTION: ‘dirtree_selection’ field is present

ida_kernwin.ACF_HAS_SOURCE: ‘source’ field is present

ida_kernwin.ACF_HAS_TYPE_REF: ‘type_ref’ field is present

ida_kernwin.AHF_VERSION: action handler version (used by action_handler_t::flags)

ida_kernwin.AHF_VERSION_MASK: mask for action_handler_t::flags

class ida_kernwin.action_desc_t(name: str, label: str, handler: PyObject *, shortcut: str = None, tooltip: str = None, icon: int = -1, flags: int = 0)

Bases: object

thisown

cb: int: size of this structure

name: str: the internal name of the action; must be unique. a way to reduce possible conflicts is to prefix it with some specific prefix. E.g., “myplugin:doSthg”.

label: str: the label of the action, possibly with an accelerator key definition (e.g., “~J~ump to operand”)

owner: void const *: either the plugin_t, or plugmod_t responsible for registering the action. Can be nullptr Please see ACTION_DESC_LITERAL_PLUGMOD

shortcut: str: an optional shortcut definition. E.g., “Ctrl+Enter”

tooltip: str: an optional tooltip for the action

icon: int: an optional icon ID to use

flags: int: See Action flags.

ida_kernwin.ADF_OWN_HANDLER: handler is owned by the action; it’ll be destroyed when the action is unregistered. Use DYNACTION_DESC_LITERAL to set this bit.

ida_kernwin.ADF_NO_UNDO: the action does not create an undo point. useful for actions that do not modify the database.

ida_kernwin.ADF_OT_MASK: Owner type mask.

ida_kernwin.ADF_OT_PLUGIN: Owner is a plugin_t.

ida_kernwin.ADF_OT_PLUGMOD: Owner is a plugmod_t.

ida_kernwin.ADF_OT_PROCMOD: Owner is a procmod_t.

ida_kernwin.ADF_GLOBAL: Register the action globally, so that it’s available even if no IDB is present

ida_kernwin.ADF_NO_HIGHLIGHT: After activating, do not update the highlight according to what’s under the cursor (listings only.)

ida_kernwin.ADF_CHECKABLE: action is checkable

ida_kernwin.ADF_CHECKED: starts in a checked state (requires ADF_CHECKABLE)

ida_kernwin.AA_NONE: no effect

ida_kernwin.AA_LABEL: see update_action_label()

ida_kernwin.AA_SHORTCUT: see update_action_shortcut()

ida_kernwin.AA_TOOLTIP: see update_action_tooltip()

ida_kernwin.AA_ICON: see update_action_icon()

ida_kernwin.AA_STATE: see update_action_state()

ida_kernwin.AA_CHECKABLE: see update_action_checkable()

ida_kernwin.AA_CHECKED: see update_action_checked()

ida_kernwin.AA_VISIBILITY: see update_action_visibility()

ida_kernwin.cancel_exec_request(req_id: int) → bool

Try to cancel an asynchronous exec request (::ui_cancel_exec_request).

Parameters:: req_id – request id
Returns:: true: successfully canceled
Returns:: false: request has already been processed.

ida_kernwin.cancel_thread_exec_requests(tid: __qthread_t) → int

Try to cancel asynchronous exec requests created by the specified thread.

Parameters:: tid – thread id
Returns:: number of the canceled requests.

ida_kernwin.set_execute_sync_availability(tid: __qthread_t, availability: execute_sync_availability_t) → execute_sync_availability_t

Set the availability of the execute_sync functionality for the given thread Setting it to esa_unavailable will cause the existing requests for this thread to be cancelled. Setting it to esa_release will clear the status for this thread, and should be issued right before a call to qthread_free is issued.

Parameters:

tid – thread id
availability – the availability

Returns:

the previous availability

ida_kernwin.get_synced_group(w: TWidget const *) → synced_group_t const *

Get the group of widgets/registers this view is synchronized with

Parameters:: w – the widget
Returns:: the group of widgets/registers, or nullptr

ida_kernwin.banner(wait: int) → bool

Show a banner dialog box (ui_banner).

Parameters:: wait – time to wait before closing
Returns:: 1: ok
Returns:: 0: esc was pressed

ida_kernwin.is_msg_inited() → bool: Can we use msg() functions?

ida_kernwin.refresh_idaview() → None: Refresh marked windows (ui_refreshmarked)

ida_kernwin.refresh_idaview_anyway() → None: Refresh all disassembly views (ui_refresh), forces an immediate refresh. Please consider request_refresh() instead

ida_kernwin.analyzer_options() → None: Allow the user to set analyzer options. (show a dialog box) (ui_analyzer_options)

ida_kernwin.get_screen_ea() → ida_idaapi.ea_t: Get the address at the screen cursor (ui_screenea)

ida_kernwin.get_opnum() → int: Get current operand number, -1 means no operand (ui_get_opnum)

ida_kernwin.get_cursor() → int *, int *

Get the cursor position on the screen (ui_get_cursor).

Returns:: true: pointers are filled
Returns:: false: no disassembly window open

ida_kernwin.get_output_cursor() → int *, int *

Get coordinates of the output window’s cursor (ui_get_output_cursor).

Returns:: false: the output window has been destroyed.
Returns:: true: pointers are filled

ida_kernwin.get_curline() → str

Get current line from the disassemble window (ui_get_curline).

Returns:: cptr current line with the color codes (use tag_remove() to remove the color codes)

ida_kernwin.open_url(url: str) → None: Open the given url (ui_open_url)

ida_kernwin.get_hexdump_ea(hexdump_num: int) → ida_idaapi.ea_t

Get the current address in a hex view.

Parameters:: hexdump_num – number of hexview window

ida_kernwin.get_key_code(keyname: str) → ushort: Get keyboard key code by its name (ui_get_key_code)

ida_kernwin.lookup_key_code(key: int, shift: int, is_qt: bool) → ushort

Get shortcut code previously created by ui_get_key_code.

Parameters:

key – key constant
shift – modifiers
is_qt – are we using gui version?

ida_kernwin.refresh_navband(force: bool) → None

Refresh navigation band if changed (ui_refresh_navband).

Parameters:: force – refresh regardless

ida_kernwin.refresh_chooser(title: str) → bool

Mark a non-modal custom chooser for a refresh (ui_refresh_chooser).

Parameters:: title – title of chooser
Returns:: success

ida_kernwin.close_chooser(title: str) → bool

Close a non-modal chooser (ui_close_chooser).

Parameters:: title – window title of chooser to close
Returns:: success

ida_kernwin.set_dock_pos(src_ctrl, dest_ctrl, orient, left=0, top=0, right=0, bottom=0)

Sets the dock orientation of a window relatively to another window.

Use the left, top, right, bottom parameters if DP_FLOATING is used, or if you want to specify the width of docked windows.

Parameters:

src_ctrl – Source docking control
dest_ctrl – Destination docking control
orient – One of DP_XXXX constants

Returns:

Boolean

Example:: set_dock_pos(‘Structures’, ‘Enums’, DP_RIGHT) <- docks the Structures window to the right of Enums window

ida_kernwin.get_icon_id_by_name(icon_name: str) → int

Retrieve the id of the icon by name (ui_get_icon_id_by_name).

Parameters:: icon_name – full name of the icon
Returns:: icon id

ida_kernwin.free_custom_icon(icon_id)

Frees an icon loaded with load_custom_icon()

Parameters:: icon_id – The ID of the icon to free

ida_kernwin.unregister_action(name: str) → bool

Delete a previously-registered action (ui_unregister_action).

Parameters:: name – name of action
Returns:: success

ida_kernwin.create_toolbar(name: str, label: str, before: str = None, flags: int = 0) → bool

Create a toolbar with the given name, label and optional position

Parameters:

name – name of toolbar (must be unique)
label – label of toolbar
before – if non-nullptr, the toolbar before which the new toolbar will be inserted
flags – a combination of create toolbar flags, to determine toolbar position

Returns:

success

ida_kernwin.delete_toolbar(name: str) → bool

Delete an existing toolbar

Parameters:: name – name of toolbar
Returns:: success

ida_kernwin.create_menu(name: str, label: str, menupath: str = None) → bool

Create a menu with the given name, label and optional position, either in the menubar, or as a submenu. If ‘menupath’ is non-nullptr, it provides information about where the menu should be positioned. First, IDA will try and resolve the corresponding menu by its name. If such an existing menu is found and is present in the menubar, then the new menu will be inserted in the menubar before it. Otherwise, IDA will try to resolve ‘menupath’ as it would for attach_action_to_menu() and, if found, add the new menu like so:

The new ‘My menu’ submenu will appear in the ‘Comments’ submenu before the ‘Enter comment…” command “My menu”, “Edit/Comments/Enter comment…”);

The new ‘My menu’ submenu will appear at the end of the ‘Comments’ submenu. “My menu”, “Edit/Comments/”);

Parameters:

name – name of menu (must be unique)
label – label of menu
menupath – where should the menu be inserted

Returns:

success

ida_kernwin.delete_menu(name: str) → bool

Delete an existing menu

Parameters:: name – name of menu
Returns:: success

ida_kernwin.attach_action_to_menu(menupath: str, name: str, flags: int = 0) → bool

Attach a previously-registered action to the menu (ui_attach_action_to_menu).

Parameters:: menupath – path to the menu item after or before which the insertion will take place.

Example: Debug/StartProcess
Whitespace, punctuation are ignored.
It is allowed to specify only the prefix of the menu item.
Comparison is case insensitive.
menupath may start with the following prefixes:
[S] - modify the main menu of the structure window
[E] - modify the main menu of the enum window

Parameters:

name – the action name
flags – a combination of Set menu flags, to determine menu item position

Returns:

success

ida_kernwin.detach_action_from_menu(menupath: str, name: str) → bool

Detach an action from the menu (ui_detach_action_from_menu).

Parameters:

menupath – path to the menu item
name – the action name

Returns:

success

ida_kernwin.attach_action_to_toolbar(toolbar_name: str, name: str) → bool

Attach an action to an existing toolbar (ui_attach_action_to_toolbar).

Parameters:

toolbar_name – the name of the toolbar
name – the action name

Returns:

success

ida_kernwin.detach_action_from_toolbar(toolbar_name: str, name: str) → bool

Detach an action from the toolbar (ui_detach_action_from_toolbar).

Parameters:

toolbar_name – the name of the toolbar
name – the action name

Returns:

success

ida_kernwin.register_and_attach_to_menu(menupath: str, name: str, label: str, shortcut: str, flags: int, handler: action_handler_t *, owner: void *, action_desc_t_flags: int) → bool: Helper. You are not encouraged to use this, as it mixes flags for both register_action(), and attach_action_to_menu(). The only reason for its existence is to make it simpler to port existing plugins to the new actions API.

ida_kernwin.display_widget(widget: TWidget *, options: int, dest_ctrl: str = None) → None

Display a widget, dock it if not done before

Parameters:

widget – widget to display
options – Widget open flags
dest_ctrl – where to dock: if nullptr or invalid then use the active docker if there is not create a new tab relative to current active tab

ida_kernwin.close_widget(widget: TWidget *, options: int) → None

Close widget (ui_close_widget, only gui version).

Parameters:

widget – pointer to the widget to close
options – Form close flags

ida_kernwin.activate_widget(widget: TWidget *, take_focus: bool) → None

Activate widget (only gui version) (ui_activate_widget).

Parameters:

widget – existing widget to display
take_focus – give focus to given widget

ida_kernwin.find_widget(caption: str) → TWidget *

Find widget with the specified caption (only gui version) (ui_find_widget). NB: this callback works only with the tabbed widgets!

Parameters:: caption – title of tab, or window title if widget is not tabbed
Returns:: pointer to the TWidget, nullptr if none is found

ida_kernwin.get_current_widget() → TWidget *: Get a pointer to the current widget (ui_get_current_widget).

ida_kernwin.get_widget_type(widget: TWidget *) → twidget_type_t: Get the type of the TWidget * (ui_get_widget_type).

ida_kernwin.get_widget_title(widget: TWidget *) → str: Get the TWidget’s title (ui_get_widget_title).

ida_kernwin.custom_viewer_jump(v: TWidget *, loc: lochist_entry_t const &, flags: int = 0) → bool

Append ‘loc’ to the viewer’s history, and cause the viewer to display it.

Parameters:

v – (TWidget *)
loc – (const lochist_entry_t &)
flags – (uint32) or’ed combination of CVNF_* values

Returns:

success

ida_kernwin.ea_viewer_history_push_and_jump(v: TWidget *, ea: ida_idaapi.ea_t, x: int, y: int, lnnum: int) → bool

Push current location in the history and jump to the given location (ui_ea_viewer_history_push_and_jump). This will jump in the given ea viewer and also in other synchronized views.

Parameters:

v – ea viewer
ea – jump destination
x – coords on screen
y – coords on screen
lnnum – desired line number of given address

ida_kernwin.get_ea_viewer_history_info(nback: int *, nfwd: int *, v: TWidget *) → bool

Get information about what’s in the history (ui_ea_viewer_history_info).

Parameters:

nback – number of available back steps
nfwd – number of available forward steps
v – ea viewer

Returns:

false: if the given ea viewer does not exist

Returns:

true: otherwise

ida_kernwin.refresh_custom_viewer(custom_viewer: TWidget *) → None: Refresh custom ida viewer (ui_refresh_custom_viewer)

ida_kernwin.repaint_custom_viewer(custom_viewer: TWidget *) → None: Repaint the given widget immediately (ui_repaint_qwidget)

ida_kernwin.jumpto(*args) → bool

This function has the following signatures:

jumpto(ea: ida_idaapi.ea_t, opnum: int=-1, uijmp_flags: int=UIJMP_ACTIVATE) -> bool

jumpto(custom_viewer: TWidget *, place: place_t *, x: int, y: int) -> bool

# 0: jumpto(ea: ida_idaapi.ea_t, opnum: int=-1, uijmp_flags: int=UIJMP_ACTIVATE) -> bool

Jump to the specified address (ui_jumpto).

Returns:: success

# 1: jumpto(custom_viewer: TWidget *, place: place_t *, x: int, y: int) -> bool

Set cursor position in custom ida viewer.

Returns:: success

ida_kernwin.get_custom_viewer_place(custom_viewer: TWidget *, mouse: bool) → int *, int *

Get current place in a custom viewer (ui_get_curplace). See also the more complete get_custom_viewer_location()

Parameters:

custom_viewer – view
mouse – mouse position (otherwise cursor position)

ida_kernwin.get_custom_viewer_location(*args) → bool

Get information about the current location in a listing

This function has the following signatures:

get_custom_viewer_location(out_entry: ida_moves.lochist_entry_t, widget: TWidget, mouse: bool=False) -> bool

get_custom_viewer_location(out_entry: ida_kernwin.listing_location_t, widget: TWidget, flags: int=0) -> bool

The 2nd form is a superset of the 1st, and retrieves the text (and tags) of the text.

ida_kernwin.is_idaq(): Returns True or False depending if IDAPython is hosted by IDAQ

ida_kernwin.attach_action_to_popup(widget: TWidget *, popup_handle: TPopupMenu *, name: str, popuppath: str = None, flags: int = 0) → bool

Insert a previously-registered action into the widget’s popup menu (ui_attach_action_to_popup). This function has two “modes”: ‘single-shot’, and ‘permanent’.

Parameters:

widget – target widget
popup_handle – target popup menu

if non-nullptr, the action is added to this popup menu invocation (i.e., ‘single-shot’)
if nullptr, the action is added to a list of actions that should always be present in context menus for this widget (i.e., ‘permanent’.)

Parameters:

name – action name
popuppath – can be nullptr
flags – a combination of SETMENU_ flags (see Set menu flags)

Returns:

success

ida_kernwin.detach_action_from_popup(widget: TWidget *, name: str) → bool

Remove a previously-registered action, from the list of ‘permanent’ context menu actions for this widget (ui_detach_action_from_popup). This only makes sense if the action has been added to ‘widget’s list of permanent popup actions by calling attach_action_to_popup in ‘permanent’ mode.

Parameters:

widget – target widget
name – action name

ida_kernwin.update_action_label(name: str, label: str) → bool

Update an action’s label (ui_update_action_attr).

Parameters:

name – action name
label – new label

Returns:

success

ida_kernwin.update_action_shortcut(name: str, shortcut: str) → bool

Update an action’s shortcut (ui_update_action_attr).

Parameters:

name – action name
shortcut – new shortcut

Returns:

success

ida_kernwin.update_action_tooltip(name: str, tooltip: str) → bool

Update an action’s tooltip (ui_update_action_attr).

Parameters:

name – action name
tooltip – new tooltip

Returns:

success

ida_kernwin.update_action_icon(name: str, icon: int) → bool

Update an action’s icon (ui_update_action_attr).

Parameters:

name – action name
icon – new icon id

Returns:

success

ida_kernwin.update_action_state(name: str, state: action_state_t) → bool

Update an action’s state (ui_update_action_attr).

Parameters:

name – action name
state – new state

Returns:

success

ida_kernwin.update_action_checkable(name: str, checkable: bool) → bool

Update an action’s checkability (ui_update_action_attr).

Parameters:

name – action name
checkable – new checkability

Returns:

success

ida_kernwin.update_action_checked(name: str, checked: bool) → bool

Update an action’s checked state (ui_update_action_attr).

Parameters:

name – action name
checked – new checked state

Returns:

success

ida_kernwin.update_action_visibility(name: str, visible: bool) → bool

Update an action’s visibility (ui_update_action_attr).

Parameters:

name – action name
visible – new visibility

Returns:

success

ida_kernwin.get_action_label(name: str) → str

Get an action’s label (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_shortcut(name: str) → str

Get an action’s shortcut (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_tooltip(name: str) → str

Get an action’s tooltip (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_icon(name: str) → int *

Get an action’s icon (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_state(name: str) → action_state_t *

Get an action’s state (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_checkable(name: str) → bool *

Get an action’s checkability (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_checked(name: str) → bool *

Get an action’s checked state (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.get_action_visibility(name: str) → bool *

Get an action’s visibility (ui_get_action_attr).

Parameters:: name – the action name
Returns:: success

ida_kernwin.set_custom_viewer_qt_aware(custom_viewer: TWidget *) → bool: Allow the given viewer to interpret Qt events (ui_set_custom_viewer_handler)

ida_kernwin.get_custom_viewer_curline(custom_viewer: TWidget *, mouse: bool) → str

Get current line of custom viewer (ui_get_custom_viewer_curline). The returned line contains color codes See also the more powerful get_custom_viewer_location()

Parameters:

custom_viewer – view
mouse – mouse position (otherwise cursor position)

Returns:

pointer to contents of current line

ida_kernwin.get_custom_viewer_place_xcoord(custom_viewer: TWidget *, pline: place_t, pitem: place_t) → int

Get the X position of the item, in the line

Parameters:

custom_viewer – the widget
pline – a place corresponding to the line
pitem – a place corresponding to the item

Returns:

-1: if ‘pitem’ is not included in the line

Returns:

-2: if ‘pitem’ points at the entire line

Returns:

>=: 0 for the X coordinate within the pline, where pitem points

ida_kernwin.get_user_input_event(out: input_event_t) → bool

Get the current user input event (mouse button press, key press, …) It is sometimes desirable to be able to tell when a certain situation happens (e.g., ‘view_curpos’ gets triggered); this function exists to provide that context (GUI version only)

Parameters:: out – the input event data
Returns:: false if we are not currently processing a user input event

ida_kernwin.get_output_curline(mouse: bool) → str

Get current line of output window (ui_get_output_curline).

Parameters:: mouse – current for mouse pointer?
Returns:: false if output contains no text

ida_kernwin.get_output_selected_text() → str

Returns selected text from output window (ui_get_output_selected_text).

Returns:: true if there is a selection

ida_kernwin.get_current_viewer() → TWidget *: Get current ida viewer (idaview or custom viewer) (ui_get_current_viewer)

ida_kernwin.get_last_widget(*args) → TWidget *

Get last ida viewer (idaview or custom viewer) (ui_get_last_widget)

Parameters:: mask – an OR’ed set of IWID_* to limit the search to
Returns:: the viewer, if found

ida_kernwin.prompt_function_prototype(out_tif: tinfo_t, pfn: func_t *, tif: tinfo_t, name: str) → str

Open function prototype editor to edit function type and create new type. Allows to change the function prototype either in the “old” one-liner mode or in the new multi-line editor, which supports shortcuts, etc. Note: changes will not apply! It is the caller’s job to apply the resulting out_tif. Parameters:

Parameters:

out_tif –
- (tinfo_t *) tif for created type
pfn –
- (func_t *) editing function
tif –
- (tinfo_t *) current function type
name –
- (const char *) function name

Returns:

true if new type created successfully

ida_kernwin.parse_tagged_line_sections(out: tagged_line_sections_t, line: str) → bool

Collect tagged sections in a color-tagged line (produced by place_t::generate)

Parameters:

out – sections storage
line – input line

Returns:

success

ida_kernwin.get_view_renderer_type(v: TWidget *) → tcc_renderer_type_t: Get the type of renderer currently in use in the given view (ui_get_renderer_type)

ida_kernwin.set_view_renderer_type(v: TWidget *, rt: tcc_renderer_type_t) → None: Set the type of renderer to use in a view (ui_set_renderer_type)

ida_kernwin.create_empty_widget(title: str, icon: int = -1) → TWidget *: Create an empty widget, serving as a container for custom user widgets

ida_kernwin.msg_clear() → None: Clear the “Output” window.

ida_kernwin.msg_save(path: str) → bool

Save the “Output” window contents into a file

Parameters:: path – The path of the file to save the contents into. An empty path means that the user will be prompted for the destination and, if the file already exists, the user will be asked to confirm before overriding its contents. Upon return, ‘path’ will contain the path that the user chose.
Returns:: success

ida_kernwin.get_active_modal_widget() → TWidget *

Get the current, active modal TWidget instance. Note that in this context, the “wait dialog” is not considered: this function will return nullptr even if it is currently shown.

Returns:: TWidget * the active modal widget, or nullptr

ida_kernwin.get_navband_pixel(ea)

Maps an address, onto a pixel coordinate within the navigation band

Parameters:: ea – The address to map
Returns:: a list [pixel, is_vertical]

ida_kernwin.get_navband_ea(pixel: int) → ida_idaapi.ea_t: Translate the pixel position on the navigation band, into an address.

ida_kernwin.get_window_id(name: str = None) → void *

Get the system-specific window ID (GUI version only)

Parameters:: name – name of the window (nullptr means the main IDA window)
Returns:: the low-level window ID

ida_kernwin.is_idaview(v: TWidget *) → bool: Is the given custom view an idaview? (ui_is_idaview)

ida_kernwin.read_selection(v, p1, p2)

Read the user selection, and store its information in p1 (from) and p2 (to).

This can be used as follows:

>>> p1 = ida_kernwin.twinpos_t()
p2 = ida_kernwin.twinpos_t()
view = ida_kernwin.get_current_viewer()
ida_kernwin.read_selection(view, p1, p2)

At that point, p1 and p2 hold information for the selection. But, the ‘at’ property of p1 and p2 is not properly typed. To specialize it, call #place() on it, passing it the view they were retrieved from. Like so:

>>> place0 = p1.place(view)
place1 = p2.place(view)

This will effectively “cast” the place into a specialized type, holding proper information, depending on the view type (e.g., disassembly, structures, enums, …)

Parameters:

v – The view to retrieve the selection for.
p1 – Storage for the “from” part of the selection.
p2 – Storage for the “to” part of the selection.

Returns:

a bool value indicating success.

ida_kernwin.read_range_selection(v: TWidget *) → ea_t *, ea_t *

Get the address range for the selected range boundaries, this is the convenient function for read_selection()

Parameters:: v – view, nullptr means the last active window containing addresses
Returns:: 0: no range is selected
Returns:: 1: ok, start ea and end ea are filled

ida_kernwin.unmark_selection() → None: Unmark selection (ui_unmarksel)

ida_kernwin.create_code_viewer(custview: TWidget *, flags: int = 0, parent: TWidget * = None) → TWidget *

Create a code viewer (ui_create_code_viewer). A code viewer contains on the left side a widget representing the line numbers, and on the right side, the child widget passed as parameter. It will inherit its title from the child widget.

Parameters:

custview – the custom view to be added
flags – Code viewer flags
parent – widget to contain the new code viewer

ida_kernwin.set_code_viewer_handler(code_viewer: TWidget *, handler_id: custom_viewer_handler_id_t, handler_or_data: void *) → void *

Set a handler for a code viewer event (ui_set_custom_viewer_handler).

Parameters:

code_viewer – the code viewer
handler_id – one of CDVH_ in custom_viewer_handler_id_t
handler_or_data – can be a handler or data. see examples in Functions: custom viewer handlers

Returns:

old value of the handler or data

ida_kernwin.set_code_viewer_user_data(code_viewer: TWidget *, ud: void *) → bool: Set the user data on a code viewer (ui_set_custom_viewer_handler).

ida_kernwin.get_viewer_user_data(viewer: TWidget *) → void *: Get the user data from a custom viewer (ui_get_viewer_user_data)

ida_kernwin.get_viewer_place_type(viewer: TWidget *) → tcc_place_type_t: Get the type of place_t instances a viewer uses & creates (ui_get_viewer_place_type).

ida_kernwin.set_code_viewer_line_handlers(code_viewer: TWidget *, click_handler: code_viewer_lines_click_t *, popup_handler: code_viewer_lines_click_t *, dblclick_handler: code_viewer_lines_click_t *, drawicon_handler: code_viewer_lines_icon_t *, linenum_handler: code_viewer_lines_linenum_t *) → None: Set handlers for code viewer line events. Any of these handlers may be nullptr

ida_kernwin.set_code_viewer_lines_icon_margin(code_viewer: TWidget *, margin: int) → bool: Set space allowed for icons in the margin of a code viewer (ui_set_custom_viewer_handler).

ida_kernwin.set_code_viewer_lines_alignment(code_viewer: TWidget *, align: int) → bool: Set alignment for lines in a code viewer (ui_set_custom_viewer_handler).

ida_kernwin.set_code_viewer_lines_radix(code_viewer: TWidget *, radix: int) → bool: Set radix for values displayed in a code viewer (ui_set_custom_viewer_handler).

ida_kernwin.set_code_viewer_is_source(code_viewer: TWidget *) → bool: Specify that the given code viewer is used to display source code (ui_set_custom_viewer_handler).

ida_kernwin.get_tab_size(path: str) → int

Get the size of a tab in spaces (ui_get_tab_size).

Parameters:: path – the path of the source view for which the tab size is requested.

if nullptr, the default size is returned.

ida_kernwin.clr_cancelled() → None: Clear “Cancelled” flag (ui_clr_cancelled)

ida_kernwin.set_cancelled() → None: Set “Cancelled” flag (ui_set_cancelled)

ida_kernwin.user_cancelled() → bool

Test the cancellation flag (ui_test_cancelled).

Returns:: true: Cancelled, a message is displayed
Returns:: false: Not cancelled

ida_kernwin.ui_load_new_file(temp_file: str, filename: str, pli: linput_t **, neflags: ushort, ploaders: load_info_t **) → bool

Display a load file dialog and load file (ui_load_file).

Parameters:

temp_file – name of the file with the extracted archive member.
filename – the name of input file as is, library or archive name
pli – loader input source, may be changed to point to temp_file
neflags – combination of NEF_… bits (see Load file flags)
ploaders – list of loaders which accept file, may be changed for loaders of temp_file

Returns:

true: file was successfully loaded

Returns:

false: otherwise

ida_kernwin.ui_run_debugger(dbgopts: str, exename: str, argc: int, argv: char const *const *) → bool

Load a debugger plugin and run the specified program (ui_run_dbg).

Parameters:

dbgopts – value of the -r command line switch
exename – name of the file to run
argc – number of arguments for the executable
argv – argument vector

Returns:

success

ida_kernwin.load_dbg_dbginfo(*args) → bool

Load debugging information from a file.

Parameters:

path – path to file
li – loader input. if nullptr, check DBG_NAME_KEY
base – loading address
verbose – dump status to message window

ida_kernwin.add_idc_hotkey(hotkey: str, idcfunc: str) → int

Add hotkey for IDC function (ui_add_idckey).

Parameters:

hotkey – hotkey name
idcfunc – IDC function name

Returns:

IDC hotkey error codes

ida_kernwin.set_highlight(viewer: TWidget *, str: set_highlight.str, flags: int) → bool

Set the highlighted identifier in the viewer (ui_set_highlight).

Parameters:

viewer – the viewer
str – the text to match, or nullptr to remove current
flags – combination of HIF_… bits (see set_highlight flags)

Returns:

false if an error occurred

ida_kernwin.open_exports_window(ea: ida_idaapi.ea_t) → TWidget *

Open the exports window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_imports_window(ea: ida_idaapi.ea_t) → TWidget *

Open the exports window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_names_window(ea: ida_idaapi.ea_t) → TWidget *

Open the names window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_funcs_window(ea: ida_idaapi.ea_t) → TWidget *

Open the ‘Functions’ window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_strings_window(*args) → TWidget *

Open the ‘Strings’ window (ui_open_builtin).

Parameters:

ea – index of entry to select by default
selstart – only display strings that occur within this range
selend – only display strings that occur within this range

Returns:

pointer to resulting window

ida_kernwin.open_segments_window(ea: ida_idaapi.ea_t) → TWidget *

Open the segments window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_segregs_window(ea: ida_idaapi.ea_t) → TWidget *

Open the segment registers window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_selectors_window() → TWidget *

Open the selectors window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_signatures_window() → TWidget *

Open the signatures window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_tils_window() → TWidget *

Open the type libraries window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_loctypes_window(ordinal: int, cursor: tif_cursor_t const * = None) → TWidget *

Open the local types window (ui_open_builtin2).

Parameters:

ordinal – ordinal of type to select by default
cursor – cursor to the type member

Returns:

pointer to resulting window

ida_kernwin.open_til_view_window(tif: tinfo_t, cursor: tif_cursor_t const * = None) → TWidget *

Open the sub-til window (ui_open_builtin2).

Parameters:

tif – tif to open
cursor – cursor to the type member

Returns:

pointer to resulting window

ida_kernwin.open_calls_window(ea: ida_idaapi.ea_t) → TWidget *

Open the function calls window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_problems_window(ea: ida_idaapi.ea_t) → TWidget *

Open the problems window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_bpts_window(ea: ida_idaapi.ea_t) → TWidget *

Open the breakpoints window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_threads_window() → TWidget *

Open the threads window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_modules_window() → TWidget *

Open the modules window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_trace_window() → TWidget *

Open the tracing window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_stack_window() → TWidget *

Open the call stack window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_xrefs_window(ea: ida_idaapi.ea_t) → TWidget *

Open the cross references window (ui_open_builtin).

Parameters:: ea – index of entry to select by default
Returns:: pointer to resulting window

ida_kernwin.open_frame_window(pfn: func_t *, offset: int) → TWidget *

Open the frame window for the given function (ui_open_builtin).

Parameters:

pfn – function to analyze
offset – offset where the cursor is placed

Returns:

pointer to resulting window if ‘pfn’ is a valid function and the window was displayed, nullptr otherwise

ida_kernwin.open_navband_window(ea: ida_idaapi.ea_t, zoom: int) → TWidget *

Open the navigation band window (ui_open_builtin).

Parameters:

ea – sets the address of the navband arrow
zoom – sets the navband zoom level

Returns:

pointer to resulting window

ida_kernwin.open_disasm_window(window_title: str, ranges: rangevec_t = None) → TWidget *

Open a disassembly view (ui_open_builtin).

Parameters:

window_title – title of view to open
ranges – if != nullptr, then display a flow chart with the specified ranges

Returns:

pointer to resulting window

ida_kernwin.open_hexdump_window(window_title: str) → TWidget *

Open a hexdump view (ui_open_builtin).

Parameters:: window_title – title of view to open
Returns:: pointer to resulting window

ida_kernwin.open_notepad_window() → TWidget *

Open the notepad window (ui_open_builtin).

Returns:: pointer to resulting window

ida_kernwin.open_bookmarks_window(w: TWidget *) → TWidget *

Open the bookmarks window (ui_open_builtin).

Parameters:: w – The widget for which the bookmarks will open. For example, this can be an IDAView, or Enums view, etc.
Returns:: pointer to resulting window

ida_kernwin.sync_sources(what: sync_source_t, _with: sync_source_t, sync: bool) → bool

[Un]synchronize sources

Returns:: success

ida_kernwin.choose_til() → str

Choose a type library (ui_choose, chtype_idatil).

Returns:: true: ‘buf’ was filled with the name of the selected til
Returns:: false: otherwise

ida_kernwin.choose_entry(title: str) → ida_idaapi.ea_t

Choose an entry point (ui_choose, chtype_entry).

Parameters:: title – chooser title
Returns:: ea of selected entry point, BADADDR if none selected

ida_kernwin.choose_name(title: str) → ida_idaapi.ea_t

Choose a name (ui_choose, chtype_name).

Parameters:: title – chooser title
Returns:: ea of selected name, BADADDR if none selected

ida_kernwin.choose_stkvar_xref(pfn: func_t *, srkvar_tid: tid_t) → ida_idaapi.ea_t

Choose an xref to a stack variable (ui_choose, chtype_name).

Parameters:

pfn – function
srkvar_tid – frame variable TID

Returns:

ea of the selected xref, BADADDR if none selected

ida_kernwin.choose_xref(to: ida_idaapi.ea_t) → ida_idaapi.ea_t

Choose an xref to an address (ui_choose, chtype_xref).

Parameters:: to – referenced address
Returns:: ea of selected xref, BADADDR if none selected

ida_kernwin.choose_enum(out: tinfo_t, title: str, default_ord: int) → bool

Choose an enum (ui_choose, chtype_enum).

Parameters:

out – the selected enum type
title – chooser title
default_ord – ordinal of enum to select by default

Returns:

true: the selected type is in OUT

Returns:

false: nothing was selected

ida_kernwin.choose_enum_by_value(out: tinfo_t, title: str, default_ord: int, value: uint64, nbytes: int) → uchar *

Choose an enum, restricted by value & size (ui_choose, chtype_enum_by_value_and_size). If the given value cannot be found initially, this function will ask if the user would like to import a standard enum.

Parameters:

out – the selected enum type
title – chooser title
default_ord – ordinal of enum to select by default
value – value to search for
nbytes – size of value

Returns:

true: the selected type is in OUT

Returns:

false: nothing was selected

ida_kernwin.choose_func(title: str, default_ea: ida_idaapi.ea_t) → func_t *

Choose a function (ui_choose, chtype_func).

Parameters:

title – chooser title
default_ea – ea of function to select by default

Returns:

pointer to function that was selected, nullptr if none selected

ida_kernwin.choose_segm(title: str, default_ea: ida_idaapi.ea_t) → segment_t *

Choose a segment (ui_choose, chtype_segm).

Parameters:

title – chooser title
default_ea – ea of segment to select by default

Returns:

pointer to segment that was selected, nullptr if none selected

ida_kernwin.choose_struct(out: tinfo_t, title: str) → bool

Choose a structure (ui_choose, chtype_struct).

Parameters:

out – the selected structure type
title – chooser title

Returns:

true: the selected type is in OUT

Returns:

false: nothing was selected

ida_kernwin.choose_srcp(title: str) → sreg_range_t *

Choose a segment register change point (ui_choose, chtype_srcp).

Parameters:: title – chooser title
Returns:: pointer to segment register range of selected change point, nullptr if none selected

ida_kernwin.get_chooser_obj(chooser_caption: str) → void *

Get the underlying object of the specified chooser (ui_get_chooser_obj). This attemps to find the choser by its title and, if found, returns the result of calling its chooser_base_t::get_chooser_obj() method.

Returns:: the object that was used to create the chooser

ida_kernwin.get_chooser_rows(out: chooser_row_info_vec_t, chooser_caption: str, what: size_t) → bool

Get the chooser contents corresponding to the rows indicated by “what”.

Parameters:

out – A vector of chooser_row_info_t, one entry per returned row.
chooser_caption – The caption that identifies the desired chooser.
what – Either one of the GCRF_ flags, or a row index.

Returns:

Success.

ida_kernwin.enable_chooser_item_attrs(chooser_caption: str, enable: bool) → bool

Enable item-specific attributes for chooser items (ui_enable_chooser_item_attrs). For example: color list items differently depending on a criterium. If enabled, the chooser will generate ui_get_chooser_item_attrs events that can be intercepted by a plugin to modify the item attributes. This event is generated only in the GUI version of IDA. Specifying CH_ATTRS bit at the chooser creation time has the same effect.

Returns:: success

ida_kernwin.replace_wait_box(*args) → None: Replace the label of “Please wait dialog box”.

ida_kernwin.beep(beep_type: beep_t = beep_default) → None

Issue a beeping sound (ui_beep).

Parameters:: beep_type – beep_t

ida_kernwin.display_copyright_warning() → bool

Display copyright warning (ui_copywarn).

Returns:: yes/no

ida_kernwin.ask_for_feedback(*args) → None

Show a message box asking to send the input file to [support@hex-rays.com](mailto:support@hex-rays.com).

Parameters:: format – the reason why the input file is bad

ida_kernwin.info(*args) → ssize_t

ida_kernwin.nomem(*args) → None

ida_kernwin.ASKBTN_YES: Yes button.

ida_kernwin.ASKBTN_NO: No button.

ida_kernwin.ASKBTN_CANCEL: Cancel button.

ida_kernwin.ASKBTN_BTN1: First (Yes) button.

ida_kernwin.ASKBTN_BTN2: Second (No) button.

ida_kernwin.ASKBTN_BTN3: Third (Cancel) button.

ida_kernwin.ask_yn(*args) → int

Display a dialog box and get choice from “Yes”, “No”, “Cancel”.

Parameters:

deflt – default choice: one of Button IDs
format – The question in printf() style format

Returns:

the selected button (one of Button IDs). Esc key returns ASKBTN_CANCEL.

ida_kernwin.ask_buttons(*args) → int

Display a dialog box and get choice from maximum three possibilities (ui_ask_buttons).

Parameters:

Yes – text for the first button
No – text for the second button
Cancel – text for the third button
deflt – default choice: one of Button IDs
format – printf-style format string for question. It may have some prefixes, see below.

Returns:

one of Button IDs specifying the selected button (Esc key returns Cancel/3rd button value)

ida_kernwin.HIST_SEG: segment names

ida_kernwin.HIST_CMT: comments

ida_kernwin.HIST_SRCH: search substrings

ida_kernwin.HIST_IDENT: identifiers. usually CPU register names are forbidden

ida_kernwin.HIST_FILE: file names

ida_kernwin.HIST_TYPE: type declarations

ida_kernwin.HIST_CMD: commands

ida_kernwin.HIST_DIR: directory names (text version only)

ida_kernwin.HIST_IDENT2: identifiers, including CPU register names

ida_kernwin.ask_ident2(*args) → bool

Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are permitted.

Parameters:

str – qstring to fill. Can contain the default value. Cannot be nullptr.
format – printf() style format string with the question

Returns:

false if the user cancelled the dialog, otherwise returns true.

ida_kernwin.ask_file(*args) → char *

class ida_kernwin.addon_info_t

Bases: object

thisown

cb: size_t

id: str

name: str

producer: str

version: str

url: str

freeform: str

custom_data: void const *

custom_size: size_t

ida_kernwin.register_addon(info: addon_info_t) → int: Register an add-on. Show its info in the About box. For plugins, should be called from init() function (repeated calls with the same product code overwrite previous entries) returns: index of the add-on in the list, or -1 on error

ida_kernwin.addon_count() → int: Get number of installed addons.

ida_kernwin.get_addon_info(id: str, info: addon_info_t) → bool

Get info about a registered addon with a given product code. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info

Returns:: false if not found

ida_kernwin.get_addon_info_idx(index: int, info: addon_info_t) → bool

Get info about a registered addon with specific index. info->cb must be valid! NB: all pointers are invalidated by next call to register_addon or get_addon_info

Returns:: false if index is out of range

class ida_kernwin.strarray_t

Bases: object

thisown

code: int

text: str

ida_kernwin.CLNL_RTRIM: Remove trailing space characters.

ida_kernwin.CLNL_LTRIM: Remove leading space characters.

ida_kernwin.CLNL_FINDCMT: Search for the comment symbol everywhere in the line, not only at the beginning.

ida_kernwin.CLNL_TRIM

ida_kernwin.qcleanline(*args) → str

Performs some cleanup operations to a line.

Parameters:

buf – string to modify
cmt_char – character that denotes the start of a comment:

the entire text is removed if the line begins with this character (ignoring leading spaces)
all text after (and including) this character is removed if flag CLNL_FINDCMT is set

Parameters:: flags – a combination of line cleanup flags. defaults to CLNL_TRIM
Returns:: length of line

ida_kernwin.strarray(array: strarray_t, array_size: size_t, code: int) → str: Find a line with the specified code in the strarray_t array. If the last element of the array has code==0 then it is considered as the default entry. If no default entry exists and the code is not found, strarray() returns “”.

ida_kernwin.ea2str(ea: ida_idaapi.ea_t) → str: Convert linear address to UTF-8 string.

ida_kernwin.str2ea(*args) → uint64 *

Convert string to linear address. Tries to interpret the string as: 1) “current IP” keyword if supported by assembler (e.g. “$” in x86) 2) segment:offset expression, where “segment” may be a name or a fixed segment register (e.g. cs, ds) 3) just segment name/register (translated to segment’s start address) 4) a name in the database (or debug name during debugging) 5) hexadecimal value without prefix or suffix 6) +delta or -delta, where numerical ‘delta’ is added to or subtracted from ‘screen_ea’ 7) register name (only during debugging) 8) if all else fails, try to evaluate ‘str’ as an IDC expression

Parameters:

str – string to parse
screen_ea – the current address in the disassembly/pseudocode view

Returns:

success

ida_kernwin.str2ea_ex(*args) → uint64 *

Same as str2ea() but possibly with some steps skipped.

Parameters:

out – the buffer to put the result
str – string to parse
screen_ea – the current address in the disassembly/pseudocode view
flags – see String to address conversion flags

Returns:

success

ida_kernwin.S2EAOPT_NOCALC: don’t try to interpret string as IDC (or current extlang) expression

ida_kernwin.atoea(str: atoea.str) → uint64 *

Convert a number in C notation to an address. decimal: 1234 octal: 0123 hexadecimal: 0xabcd binary: 0b00101010

Parameters:: str – the string to parse

ida_kernwin.IK_CANCEL

ida_kernwin.IK_BACK

ida_kernwin.IK_TAB

ida_kernwin.IK_CLEAR

ida_kernwin.IK_RETURN

ida_kernwin.IK_SHIFT

ida_kernwin.IK_CONTROL

ida_kernwin.IK_MENU

ida_kernwin.IK_PAUSE

ida_kernwin.IK_CAPITAL

ida_kernwin.IK_KANA

ida_kernwin.IK_ESCAPE

ida_kernwin.IK_MODECHANGE

ida_kernwin.IK_SPACE

ida_kernwin.IK_PRIOR

ida_kernwin.IK_NEXT

ida_kernwin.IK_END

ida_kernwin.IK_HOME

ida_kernwin.IK_LEFT

ida_kernwin.IK_UP

ida_kernwin.IK_RIGHT

ida_kernwin.IK_DOWN

ida_kernwin.IK_SELECT

ida_kernwin.IK_PRINT

ida_kernwin.IK_EXECUTE

ida_kernwin.IK_SNAPSHOT

ida_kernwin.IK_INSERT

ida_kernwin.IK_DELETE

ida_kernwin.IK_HELP

ida_kernwin.IK_LWIN

ida_kernwin.IK_RWIN

ida_kernwin.IK_APPS

ida_kernwin.IK_SLEEP

ida_kernwin.IK_NUMPAD0

ida_kernwin.IK_NUMPAD1

ida_kernwin.IK_NUMPAD2

ida_kernwin.IK_NUMPAD3

ida_kernwin.IK_NUMPAD4

ida_kernwin.IK_NUMPAD5

ida_kernwin.IK_NUMPAD6

ida_kernwin.IK_NUMPAD7

ida_kernwin.IK_NUMPAD8

ida_kernwin.IK_NUMPAD9

ida_kernwin.IK_MULTIPLY

ida_kernwin.IK_ADD

ida_kernwin.IK_SEPARATOR

ida_kernwin.IK_SUBTRACT

ida_kernwin.IK_DECIMAL

ida_kernwin.IK_DIVIDE

ida_kernwin.IK_F1

ida_kernwin.IK_F2

ida_kernwin.IK_F3

ida_kernwin.IK_F4

ida_kernwin.IK_F5

ida_kernwin.IK_F6

ida_kernwin.IK_F7

ida_kernwin.IK_F8

ida_kernwin.IK_F9

ida_kernwin.IK_F10

ida_kernwin.IK_F11

ida_kernwin.IK_F12

ida_kernwin.IK_F13

ida_kernwin.IK_F14

ida_kernwin.IK_F15

ida_kernwin.IK_F16

ida_kernwin.IK_F17

ida_kernwin.IK_F18

ida_kernwin.IK_F19

ida_kernwin.IK_F20

ida_kernwin.IK_F21

ida_kernwin.IK_F22

ida_kernwin.IK_F23

ida_kernwin.IK_F24

ida_kernwin.IK_NUMLOCK

ida_kernwin.IK_SCROLL

ida_kernwin.IK_OEM_FJ_MASSHOU

ida_kernwin.IK_OEM_FJ_TOUROKU

ida_kernwin.IK_LSHIFT

ida_kernwin.IK_RSHIFT

ida_kernwin.IK_LCONTROL

ida_kernwin.IK_RCONTROL

ida_kernwin.IK_LMENU

ida_kernwin.IK_RMENU

ida_kernwin.IK_BROWSER_BACK

ida_kernwin.IK_BROWSER_FORWARD

ida_kernwin.IK_BROWSER_REFRESH

ida_kernwin.IK_BROWSER_STOP

ida_kernwin.IK_BROWSER_SEARCH

ida_kernwin.IK_BROWSER_FAVORITES

ida_kernwin.IK_BROWSER_HOME

ida_kernwin.IK_VOLUME_MUTE

ida_kernwin.IK_VOLUME_DOWN

ida_kernwin.IK_VOLUME_UP

ida_kernwin.IK_MEDIA_NEXT_TRACK

ida_kernwin.IK_MEDIA_PREV_TRACK

ida_kernwin.IK_MEDIA_STOP

ida_kernwin.IK_MEDIA_PLAY_PAUSE

ida_kernwin.IK_LAUNCH_MAIL

ida_kernwin.IK_LAUNCH_MEDIA_SELECT

ida_kernwin.IK_LAUNCH_APP1

ida_kernwin.IK_LAUNCH_APP2

ida_kernwin.IK_OEM_1

ida_kernwin.IK_OEM_PLUS

ida_kernwin.IK_OEM_COMMA

ida_kernwin.IK_OEM_MINUS

ida_kernwin.IK_OEM_PERIOD

ida_kernwin.IK_OEM_2

ida_kernwin.IK_OEM_3

ida_kernwin.IK_OEM_4

ida_kernwin.IK_OEM_5

ida_kernwin.IK_OEM_6

ida_kernwin.IK_OEM_7

ida_kernwin.IK_OEM_102

ida_kernwin.IK_PLAY

ida_kernwin.IK_ZOOM

ida_kernwin.IK_OEM_CLEAR

ida_kernwin.CB_INIT

ida_kernwin.CB_YES

ida_kernwin.CB_CLOSE

ida_kernwin.CB_INVISIBLE

ida_kernwin.CB_DESTROYING

ida_kernwin.CB_NO

ida_kernwin.CB_CANCEL

ida_kernwin.get_user_strlist_options(out: strwinsetup_t *) → None

ida_kernwin.del_idc_hotkey(hotkey: str) → bool

class ida_kernwin.disasm_text_t(*args)

Bases: object

thisown

push_back(*args) → disasm_line_t &

pop_back() → None

size() → size_t

empty() → bool

at(_idx: size_t) → disasm_line_t const &

qclear() → None

clear() → None

resize(*args) → None

grow(*args) → None

capacity() → size_t

reserve(cnt: size_t) → None

truncate() → None

swap(r: disasm_text_t) → None

extract() → disasm_line_t *

inject(s: disasm_line_t, len: size_t) → None

begin(*args) → qvector< disasm_line_t >::const_iterator

end(*args) → qvector< disasm_line_t >::const_iterator

insert(it: disasm_line_t, x: disasm_line_t) → qvector< disasm_line_t >::iterator

erase(*args) → qvector< disasm_line_t >::iterator

append(x: disasm_line_t) → None

extend(x: disasm_text_t) → None

front

back

ida_kernwin.load_custom_icon(file_name=None, data=None, format=None)

Load an icon from a file (ui_load_custom_icon_file). Also see load_custom_icon(const void *, unsigned int, const char *)

Parameters:: file_name – path to file
Returns:: icon id

ida_kernwin.ask_long(defval: int, prompt: str) → int | None

Display a dialog box and wait for the user to input a number

Parameters:

defval – The placeholder value
prompt – The prompt to show

Returns:

the number entered by the user, or None if the dialog was canceled

ida_kernwin.ask_addr(defval: ida_idaapi.ea_t, prompt: str) → ida_idaapi.ea_t | None

Display a dialog box and wait for the user to input an address

Parameters:

defval – The placeholder value
prompt – The prompt to show

Returns:

the address entered by the user, or None if the dialog was canceled

ida_kernwin.ask_seg(defval: int, prompt: str) → int | None

Display a dialog box and wait for the user to input an segment name. This function allows to enter segment register names, segment base paragraphs, segment names to denote a segment.

Parameters:

defval – The placeholder value
prompt – The prompt to show

Returns:

the selector of the segment entered by the user, or None if the dialog was canceled

ida_kernwin.ask_ident(defval: str, prompt: str) → bool

Display a dialog box and wait for the user to input an identifier. If the user enters a non-valid identifier, this function displays a warning and allows the user to correct it. CPU register names are usually forbidden.

Returns:: false if the user cancelled the dialog, otherwise returns true.

class ida_kernwin.action_handler_t

Bases: object

activate(ctx)

Activate an action. This function implements the core behavior of an action. It is called when the action is triggered, from a menu, from a popup menu, from the toolbar, or programmatically.

Returns:: non-zero: all IDA windows will be refreshed

update(ctx): Update an action. This is called when the context of the UI changed, and we need to let the action update some of its properties if needed (label, icon, …) In addition, this lets IDA know whether the action is enabled, and when it should be queried for availability again. Note: This callback is not meant to change anything in the application’s state, except by calling one (or many) of the “update_action_*()” functions on this very action.

class ida_kernwin.quick_widget_commands_t(callback)

callback

cmds = []

add(caption, flags, menu_index, icon, emb, shortcut)

populate_popup(widget, popup)

class ida_kernwin.disabled_script_timeout_t: Bases: object

ida_kernwin.SETMENU_IF_ENABLED = 4

ida_kernwin.CH_NOIDB

ida_kernwin.BWN_TILVIEW

ida_kernwin.IWID_TILVIEW

ida_kernwin.BWN_LOCTYPS

ida_kernwin.IWID_LOCTYPS

ida_kernwin.BWN_DISASMS

ida_kernwin.IWID_DISASMS

ida_kernwin.CHOOSER_NO_SELECTION

ida_kernwin.CHOOSER_MULTI_SELECTION

ida_kernwin.CHOOSER_POPUP_MENU

ida_kernwin.CHOOSER_MENU_EDIT

ida_kernwin.CHOOSER_MENU_JUMP

ida_kernwin.CHOOSER_MENU_SEARCH

ida_kernwin.choose_find(title: str) → object | None

Retrieve the chooser object by title

Parameters:: title – the chooser title
Returns:: the chooser, or None

ida_kernwin.choose_refresh(_self: PyObject *) → None

ida_kernwin.choose_close(_self: PyObject *) → None

ida_kernwin.choose_get_widget(_self: PyObject *) → TWidget *

ida_kernwin.choose_choose(_self: PyObject *) → PyObject *

ida_kernwin.choose_activate(_self: PyObject *) → None

ida_kernwin.choose_create_embedded_chobj(_self: PyObject *) → PyObject *

ida_kernwin.get_chooser_data(title: str, n: int) → List[str]

Get the text corresponding to the index N in the chooser data. Use -1 to get the header.

Parameters:: title – The chooser title
Returns:: a list of strings, or None

ida_kernwin.CH_NOIDB

class ida_kernwin.Choose(title, cols, flags=0, popup_names=None, icon=-1, x1=-1, y1=-1, x2=-1, y2=-1, deflt=None, embedded=False, width=None, height=None, forbidden_cb=0, flags2=0)

Bases: object

Chooser wrapper class.

Some constants are defined in this class. Please refer to kernwin.hpp for more information.

CH_MODAL: Modal chooser.

CH_MULTI: The chooser will allow multi-selection (only for GUI choosers). This bit is set when using the chooser_multi_t structure.

CH_NOBTNS: do not display ok/cancel/help/search buttons. Meaningful only for gui modal windows because non-modal windows do not have any buttons anyway. Text mode does not have them neither.

CH_ATTRS: generate ui_get_chooser_item_attrs (gui only)

CH_NOIDB: use the chooser even without an open database, same as x0=-2

CH_FORCE_DEFAULT: if a non-modal chooser was already open, change selection to the default one

CH_CAN_INS: allow to insert new items

CH_CAN_DEL: allow to delete existing item(s)

CH_CAN_EDIT: allow to edit existing item(s)

CH_CAN_REFRESH: allow to refresh chooser

CH_QFLT: open with quick filter enabled and focused

CH_QFTYP_SHIFT

CH_QFTYP_DEFAULT: set quick filtering type to the possible existing default for this chooser

CH_QFTYP_NORMAL: normal (i.e., lexicographical) quick filter type

CH_QFTYP_WHOLE_WORDS: whole words quick filter type

CH_QFTYP_REGEX: regex quick filter type

CH_QFTYP_FUZZY: fuzzy search quick filter type

CH_QFTYP_MASK

CH_NO_STATUS_BAR: don’t show a status bar

CH_RESTORE: restore floating position if present (equivalent of WOPN_RESTORE) (GUI version only)

CH_RENAME_IS_EDIT: triggering a ‘edit/rename’ (i.e., F2 shortcut) on a cell, should call the edit() callback for the corresponding row.

CH_BUILTIN_SHIFT

CH_BUILTIN_MASK: Mask for builtin chooser numbers. Plugins should not use them.

CH_HAS_DIRTREE: The chooser can provide a dirtree_t, meaning a tree-like structure can be provided to the user (instead of a flat table)

CH_HAS_DIFF: The chooser can be used in a diffing/merging workflow.

CHCOL_PLAIN: plain string

CHCOL_PATH: file path. TUI IDA will truncate excessive cell lengths starting at their beginning, and prepending the resulting text with “…” order to leave the filename visible

CHCOL_HEX: hexadecimal number

CHCOL_DEC: decimal number

CHCOL_EA: address

CHCOL_FNAME: function name. If a chooser column has this flag set and implements chooser_base_t::get_ea(), rows background colors will be automatically set to match the navigator’s “Library function”, “Lumina function” and “External symbol” colors

CHCOL_FORMAT: column format mask

CHCOL_DEFHIDDEN: column should be hidden by default

CHCOL_DRAGHINT: the column number that will be used to build hints for the dragging undo label. This should be provided for at most one column for any given chooser.

CHCOL_INODENAME: if CH_HAS_DIRTREE has been specified, this instructs the chooser that this column shows the inode name. This should be provided for at most one column for any given chooser.

NO_SELECTION = -1: there is no selected item

EMPTY_CHOOSER = -2: the chooser is initialized

ALREADY_EXISTS = -3: the non-modal chooser with the same data is already open

NO_ATTR = -4: some mandatory attribute is missing

NOTHING_CHANGED = 0

ALL_CHANGED = 1

SELECTION_CHANGED = 2

class UI_Hooks_Trampoline(v)

Bases: UI_Hooks

v

populating_widget_popup(widget, popup_handle)

IDA is populating the context menu for a widget. This is your chance to attach_action_to_popup(). Have a look at ui_finish_populating_widget_popup, if you want to augment the context menu with your own actions after the menu has had a chance to be properly populated by the owning component or plugin (which typically does it on ui_populating_widget_popup.)

Parameters:

widget – (TWidget *)
popup_handle – (TPopupMenu *)
ctx – (const action_activation_ctx_t *)

Returns:

void

title

flags = 0

flags2 = 0

cols

deflt = None

popup_names = None

icon = -1

x1 = -1

y1 = -1

x2 = -1

y2 = -1

embedded = False

width = None

height = None

forbidden_cb = 0

ui_hooks_trampoline = None

Embedded(create_chobj=False): Creates an embedded chooser (as opposed to Show()) :returns: Returns 0 on success or NO_ATTR

GetEmbSelection(): Deprecated. For embedded choosers, the selection is available through ‘Form.EmbeddedChooserControl.selection’

Show(modal=False): Activates or creates a chooser window :param modal: Display as modal dialog :returns: For all choosers it will return NO_ATTR if some mandatory

attribute is missing. The mandatory attributes are: flags, title, cols, OnGetSize(), OnGetLine(); For modal choosers it will return the selected item index (0-based), or NO_SELECTION if no selection, or EMPTY_CHOOSER if the OnRefresh() callback returns EMPTY_CHOOSER; For non-modal choosers it will return 0 or ALREADY_EXISTS if the chooser was already open and is active now;

Activate(): Activates a visible chooser

Refresh(): Causes the refresh callback to trigger

Close(): Closes the chooser

GetWidget()

Return the TWidget underlying this view.

Returns:: The TWidget underlying this view, or None.

adjust_last_item(n): Helper for OnDeleteLine() and OnRefresh() callbacks. They can be finished by the following line: return [Choose.ALL_CHANGED] + self.adjust_last_item(n) :param n: line number of the remaining select item :returns: list of selected lines numbers (one element or empty)

AddCommand(caption, flags=_ida_kernwin.CHOOSER_POPUP_MENU, menu_index=-1, icon=-1, emb=None, shortcut=None)

OnPopup(widget, popup_handle)

OnInit()

Initialize the chooser and populate it.

This callback is optional

OnGetSize()

Get the number of elements in the chooser.

This callback is mandatory

Returns:: the number of elements

OnGetLine(n)

Get data for an element

This callback is mandatory

Parameters:: n – the index to fetch data for
Returns:: a list of strings

OnGetIcon(n)

Get an icon to associate with the first cell of an element

Parameters:: n – index of the element
Returns:: an icon ID

OnGetLineAttr(n)

Get attributes for an element

Parameters:: n – index of the element
Returns:: a tuple (color, flags)

OnInsertLine(sel)

User asked to insert an element

Parameters:: sel – the current selection
Returns:: a tuple (changed, selection)

OnDeleteLine(sel)

User deleted an element

Parameters:: sel – the current selection
Returns:: a tuple (changed, selection)

OnEditLine(sel)

User asked to edit an element.

Parameters:: sel – the current selection
Returns:: a tuple (changed, selection)

OnSelectLine(sel)

User pressed the enter key, or double-clicked a selection

Parameters:: sel – the current selection
Returns:: a tuple (changed, selection)

OnSelectionChange(sel)

Selection changed

Parameters:: sel – the new selection

OnRefresh(sel)

The chooser needs to be refreshed. It returns the new positions of the selected items.

Parameters:: sel – the current selection
Returns:: a tuple (changed, selection)

OnClose(): The chooser window is closed.

OnGetEA(n)

Get the address of an element

When this function returns valid addresses:

If any column has the CHCOL_FNAME flag, rows will be colored according to the attributes of the functions who own those addresses (extern, library function, Lumina, … - similar to what the “Functions” widget does)
When a selection is present and the user presses <Enter> (<Shift+Enter> if the chooser is modal), IDA will jump to that address (through jumpto())

Parameters:: n – element number (0-based)
Returns:: the effective address, ida_idaapi.BADADDR if the element has no address

OnGetDirTree()

Get the dirtree_t that will be used to present a tree-like structure to the user (see CH_HAS_DIRTREE)

Returns:: the dirtree_t, or None

OnIndexToInode(n)

Map an element index to a dirtree_t inode

This callback is mandatory if CH_HAS_DIRTREE is specified

Parameters:: n – index of the element
Returns:: the inode number

OnIndexToDiffpos(n)

Map an element index to a diffpos_t

This callback is mandatory if CH_HAS_DIFF is specified

Parameters:: n – index of the element
Returns:: the diffpos

OnLazyLoadDir(path)

Callback for lazy-loaded, dirtree-based choosers; the function will be called when a folder is expanded and it has not been loaded before. The implementation should use the given dirtree’s link() or mkdir() methods to add the folder contents.

Parameters:: path – an absolute dirtree path to the directory that is being expanded
Returns:: success

ida_kernwin.textctrl_info_t_assign(_self: PyObject *, other: PyObject *) → bool

ida_kernwin.textctrl_info_t_set_text(_self: PyObject *, s: str) → bool

ida_kernwin.textctrl_info_t_get_text(_self: PyObject *) → str

ida_kernwin.textctrl_info_t_set_flags(_self: PyObject *, flags: unsigned int) → bool

ida_kernwin.textctrl_info_t_get_flags(_self: PyObject *) → unsigned int

ida_kernwin.textctrl_info_t_set_tabsize(_self: PyObject *, tabsize: unsigned int) → bool

ida_kernwin.textctrl_info_t_get_tabsize(_self: PyObject *) → unsigned int

ida_kernwin.formchgcbfa_enable_field(p_fa: size_t, fid: int, enable: bool) → bool

ida_kernwin.formchgcbfa_show_field(p_fa: size_t, fid: int, show: bool) → bool

ida_kernwin.formchgcbfa_move_field(p_fa: size_t, fid: int, x: int, y: int, w: int, h: int) → bool

ida_kernwin.formchgcbfa_get_focused_field(p_fa: size_t) → int

ida_kernwin.formchgcbfa_set_focused_field(p_fa: size_t, fid: int) → bool

ida_kernwin.formchgcbfa_refresh_field(p_fa: size_t, fid: int) → None

ida_kernwin.formchgcbfa_close(p_fa: size_t, close_normally: int) → None

ida_kernwin.formchgcbfa_get_field_value(p_fa: size_t, fid: int, ft: int, sz: size_t) → PyObject *

ida_kernwin.formchgcbfa_set_field_value(p_fa: size_t, fid: int, ft: int, py_val: PyObject *) → bool

ida_kernwin.py_get_ask_form() → size_t

ida_kernwin.py_get_open_form() → size_t

ida_kernwin.py_register_compiled_form(py_form: PyObject *) → None

ida_kernwin.py_unregister_compiled_form(py_form: PyObject *) → None

class ida_kernwin.textctrl_info_t(text='', flags=0, tabsize=0)

Bases: ida_idaapi.py_clinked_object_t

Class representing textctrl_info_t

TXTF_AUTOINDENT = 1: Auto-indent on new line

TXTF_ACCEPTTABS = 2: Tab key inserts ‘tabsize’ spaces

TXTF_READONLY = 4: Text cannot be edited (but can be selected and copied)

TXTF_SELECTED = 8: Shows the field with its text selected

TXTF_MODIFIED = 16: Gets/sets the modified status

TXTF_FIXEDFONT = 32: The control uses IDA’s fixed font

assign(other): Copies the contents of ‘other’ to ‘self’

value: Alias for the text property

text: in, out: text control value

flags: Text control property bits

tabsize: how many spaces a single tab will indent

class ida_kernwin.Form(form, controls)

Bases: object

FT_ASCII = 'A': Ascii string - char *

FT_SEG = 'S': Segment - sel_t *

FT_HEX = 'N': Hex number - uval_t *

FT_SHEX = 'n': Signed hex number - sval_t *

FT_COLOR = 'K': Color button - bgcolor_t *

FT_ADDR = '$': Address - ea_t *

FT_UINT64 = 'L': default base uint64 - uint64

FT_INT64 = 'l': default base int64 - int64

FT_RAWHEX = 'M': Hex number, no 0x prefix - uval_t *

FT_FILE = 'f': File browse - char * at least QMAXPATH

FT_DEC = 'D': Decimal number - sval_t *

FT_OCT = 'O': Octal number, C notation - sval_t *

FT_BIN = 'Y': Binary number, 0b prefix - sval_t *

FT_CHAR = 'H': Char value – sval_t *

FT_IDENT = 'I': Identifier - char * at least MAXNAMELEN

FT_BUTTON = 'B': Button - def handler(code)

FT_DIR = 'F': Path to directory - char * at least QMAXPATH

FT_TYPE = 'T': Type declaration - char * at least MAXSTR

FT_FORMCHG = '%/': Form change callback - formchgcb_t

FT_ECHOOSER = 'E': Embedded chooser - idaapi.Choose

FT_MULTI_LINE_TEXT = 't': Multi text control - textctrl_info_t

FT_DROPDOWN_LIST = 'b': Dropdown list control - Form.DropdownControl

FT_HTML_LABEL = 'h': HTML label to display (only for GUI version, and for dynamic labels; no input)

FT_CHKGRP = 'C'

FT_CHKGRP2 = 'c'

FT_RADGRP = 'R'

FT_RADGRP2 = 'r'

static create_string_buffer(value, size=None)

static fieldtype_to_ctype(tp, i64=False): Factory method returning a ctype class corresponding to the field type string

class NumericArgument(tp, value, i64=None)

Bases: object

Argument representing various integer arguments (ushort, uint32, uint64, etc…) :param tp: One of Form.FT_XXX

DefI64 = False

arg

value

class StringArgument(size=None, value=None)

Bases: object

Argument representing a character buffer

size = None

arg

value

class Control

Bases: object

id = 0: Automatically assigned control ID

input_field_index = None: If this control is an input field, once Compile() returns this will hold its index. This is used only to compute the possible STARTITEM index

arg = None: Control argument value. This could be one element or a list/tuple (for multiple args per control)

form = None: Reference to the parent form. It is filled by Form.Add()

form_hasattr = False

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

get_arg(): Control returns the parameter to be pushed on the stack (Of ask_form())

free(): Free the control

is_input_field(): Return True if this field acts as an input

class LabelControl(tp)

Bases: Control

Base class for static label control

tp

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

class StringLabel(value, tp=None, size=ida_pro.MAXSTR)

Bases: LabelControl

String label control

size

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

class NumericLabel(value, tp=None)

Bases: LabelControl, NumericArgument

Numeric label control

class GroupItemControl(tag, parent)

Bases: Control

Base class for group control items

tag

parent

pos = 0

assign_pos()

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

is_input_field(): Return True if this field acts as an input

class ChkGroupItemControl(tag, parent)

Bases: GroupItemControl

Checkbox group item control

checked: Get/Sets checkbox item check status

class RadGroupItemControl(tag, parent)

Bases: GroupItemControl

Radiobox group item control

selected: Get/Sets radiobox item selection status

class GroupControl(children_names, tag, value=0)

Bases: Control, NumericArgument

Base class for group controls

children_names

tag

next_child_pos()

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

class ChkGroupControl(children_names, value=0, secondary=False)

Bases: GroupControl

Checkbox group control class. It holds a set of checkbox controls

ItemClass = None: Group control item factory class instance We need this because later we won’t be treating ChkGroupControl or RadGroupControl individually, instead we will be working with GroupControl in general.

class RadGroupControl(children_names, value=0, secondary=False)

Bases: GroupControl

Radiobox group control class. It holds a set of radiobox controls

ItemClass = None

class InputControl(tp, width, swidth, hlp=None, is_relative_offset=False)

Bases: Control

Generic form input control. It could be numeric control, string control, directory/file browsing, etc…

tp

width

swidth

hlp = None

is_relative_offset = False

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

is_input_field(): Return True if this field acts as an input

class NumericInput(tp=None, value=0, width=50, swidth=10, hlp=None, is_relative_offset=False, i64=None)

Bases: InputControl, NumericArgument

A composite class serving as a base numeric input control class

class ColorInput(value=0)

Bases: NumericInput

Color button input control

class StringInput(tp=None, width=ida_pro.MAXSTR, swidth=40, hlp=None, value=None, size=None)

Bases: InputControl, StringArgument

Base string input control class. This class also constructs a StringArgument

class FileInput(width=512, swidth=80, save=False, open=False, hlp=None, value=None)

Bases: StringInput

File Open/Save input control

class DirInput(width=512, swidth=80, hlp=None, value=None)

Bases: StringInput

Directory browsing control

class ButtonInput(handler, code='', swidth='', hlp=None)

Bases: InputControl

Button control. A handler along with a ‘code’ (numeric value) can be associated with the button. This way one handler can handle many buttons based on the button code (or in other terms id or tag)

handler

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

helper_cb(button_code, p_fa)

is_input_field(): Return True if this field acts as an input

class FormChangeCb(handler)

Bases: Control

Form change handler. This can be thought of like a dialog procedure. Everytime a form action occurs, this handler will be called along with the control id. The programmer can then call various form actions accordingly:

EnableField

ShowField

MoveField

GetFieldValue

etc…

Special control IDs: -1 (The form is initialized) and -2 (Ok has been clicked)

handler

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

helper_cb(fid, p_fa)

get_tag(): Control tag character. One of Form.FT_XXXX. The form class will expand the {} notation and replace them with the tags

free(): Free the control

class EmbeddedChooserControl(chooser=None, swidth=40, hlp=None)

Bases: InputControl

Embedded chooser control. This control links to a Chooser2 control created with the ‘embedded=True’

selobj

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

chooser = None

size = 0

value: Returns the embedded chooser instance

selection: Returns the selection

free(): Frees the embedded chooser data

class DropdownListControl(items=[], readonly=True, selval=0, width=50, swidth=50, hlp=None)

Bases: InputControl, ida_pro._qstrvec_t

Dropdown control This control allows manipulating a dropdown control

readonly = True

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

value

selval: Read/write the selection value. The value is used as an item index in readonly mode or text value in editable mode This value can be used only after the form has been closed.

free(): Free the control

set_items(items): Sets the dropdown list items

class MultiLineTextControl(text='', flags=0, tabsize=0, width=50, swidth=50, hlp=None)

Bases: InputControl, textctrl_info_t

Multi line text control. This class inherits from textctrl_info_t. Thus the attributes are also inherited This control allows manipulating a multilinetext control

arg: Control argument value. This could be one element or a list/tuple (for multiple args per control)

free(): Free the control

form: Form string

controls: Dictionary of controls

title = None: The Form title. It will be filled when the form is compiled

modal = True: By default, forms are modal

openform_flags = 0: If non-modal, these flags will be passed to open_form. This is an OR’ed combination of the PluginForm.FORM_* values.

Free(): Frees all resources associated with a compiled form. Make sure you call this function when you finish using the form.

Add(name, ctrl, mkattr=True)

Low level function. Prefer AddControls() to this function. This function adds one control to the form.

Parameters:

name – Control name
ctrl – Control object
mkattr – Create control name / control object as a form attribute

FindControlById(id): Finds a control instance given its id

AddControls(controls, mkattr=True): Adds controls from a dictionary. The dictionary key is the control name and the value is a Form.Control object :param controls: The control dictionary

CompileEx(form)

Low level function. Compiles (parses the form syntax and adds the control) the form string and returns the argument list to be passed the argument list to ask_form().

The form controls are wrapped inside curly braces: {ControlName}.

A special operator can be used to return the index of a given control by its name: {id:ControlName}. This is useful when you use the STARTITEM form keyword to set the initially focused control. (note that, technically, the index is not the same as the ID; that’s because STARTITEM uses raw, 0-based indexes rather than control IDs to determine the focused widget.)

Parameters:: form – Compiles the form and returns the arguments needed to be passed to ask_form()

Compile()

Compiles a form and returns the form object (self) and the argument list. The form object will contain object names corresponding to the form elements

Returns:: It will raise an exception on failure. Otherwise the return value is ignored

Compiled()

Checks if the form has already been compiled

Returns:: Boolean

Execute(): Displays a modal dialog containing the compiled form. :returns: 1 - ok ; 0 - cancel

Open(): Opens a widget containing the compiled form.

EnableField(ctrl, enable): Enable or disable an input field :returns: False - no such control

ShowField(ctrl, show): Show or hide an input field :returns: False - no such control

MoveField(ctrl, x, y, w, h)

Move/resize an input field

Returns:: False - no such fiel

GetFocusedField(): Get currently focused input field. :returns: None if no field is selected otherwise the control ID

SetFocusedField(ctrl): Set currently focused input field :returns: False - no such control

RefreshField(ctrl): Refresh a field :returns: False - no such control

Close(close_normally): Close the form :param close_normally: 1: form is closed normally as if the user pressed Enter. 0: form is closed abnormally as if the user pressed Esc :returns: None

GetControlValue(ctrl): Returns the control’s value depending on its type :param ctrl: Form control instance :returns: color button, radio controls: integer :returns: file/dir input, string input and string label: string :returns: embedded chooser control (0-based indices of selected items): integer list :returns: for multilinetext control: textctrl_info_t :returns: dropdown list controls: string (when editable) or index (when readonly) :returns: None: on failure

SetControlValue(ctrl, value)

Set the control’s value depending on its type :param ctrl: Form control instance :param value: embedded chooser: a 0-base indices list to select embedded chooser items :param value: multilinetext: a textctrl_info_t :param value: dropdown list: an integer designating the selection index if readonly

a string designating the edit control value if not readonly

Returns:: Boolean true on success

static ControlToFieldTypeIdAndSize(ctrl): Converts a control object to a tuple containing the field id and the associated buffer size

ida_kernwin.ask_form(*args)

Display a dialog box and wait for the user. If the form contains the “BUTTON NO <title>” keyword, then the return values are the same as in the ask_yn() function (Button IDs)

Parameters:: form – dialog box as a string. see ask_form()/open_form()
Returns:: 0: no memory to display or form syntax error (a warning is displayed in this case). the user pressed the ‘No’ button (if the form has it) or the user cancelled the dialog otherwise. all variables retain their original values.
Returns:: 1: ok, all input fields are filled and validated.
Returns:: -1: the form has the ‘No’ button and the user cancelled the dialog

ida_kernwin.open_form(*args)

Display a dockable modeless dialog box and return a handle to it. The modeless form can be closed in the following ways: * by pressing the small ‘x’ in the window title * by calling form_actions_t::close() from the form callback (form_actions_t)

Parameters:

form – dialog box as a string. see ask_form()/open_form()
flags – Widget open flags

Returns:

handle to the form or nullptr. the handle can be used with TWidget functions: close_widget()/activate_widget()/etc

ida_kernwin.install_command_interpreter(py_obj: PyObject *) → int: Install command line interpreter (ui_install_cli)

ida_kernwin.remove_command_interpreter(cli_idx: int) → None: Remove command line interpreter (ui_install_cli)

class ida_kernwin.cli_t

Bases: ida_idaapi.pyidc_opaque_object_t

cli_t wrapper class.

This class allows you to implement your own command line interface handlers.

register(flags=0, sname=None, lname=None, hint=None)

Registers the CLI.

Parameters:

flags – Feature bits. No bits are defined yet, must be 0
sname – Short name (displayed on the button)
lname – Long name (displayed in the menu)
hint – Hint for the input line

Returns:

Boolean: True-Success, False-Failed

unregister(): Unregisters the CLI (if it was registered)

OnExecuteLine(line)

The user pressed Enter. The CLI is free to execute the line immediately or ask for more lines.

This callback is mandatory.

Parameters:: line – typed line(s)
Returns:: Boolean: True-executed line, False-ask for more lines

OnKeydown(line, x, sellen, vkey, shift)

A keyboard key has been pressed This is a generic callback and the CLI is free to do whatever it wants.

This callback is optional.

Parameters:

line – current input line
x – current x coordinate of the cursor
sellen – current selection length (usually 0)
vkey – virtual key code. if the key has been handled, it should be returned as zero
shift – shift state

Returns:

None - Nothing was changed

Returns:

tuple(line, x, sellen, vkey): if either of the input line or the x coordinate or the selection length has been modified.

Returns:

It is possible to return a tuple with None elements to preserve old values. Example: tuple(new_line, None, None, None) or tuple(new_line)

OnFindCompletions(line, x)

The user pressed Tab. Return a list of completions

This callback is optional.

Parameters:

line – the current line (string)
x – the index where the cursor is (int)

Returns:

None if no completion could be generated, otherwise a tuple: (completions : Sequence[str], hints : Sequence[str], docs: Sequence[str],

match_start: int, match_end: int)

class ida_kernwin.View_Hooks(_flags: int = 0, _hkcb_flags: int = 1)

Bases: object

thisown

hook() → bool

unhook() → bool

view_activated(view: TWidget *) → None

A view is activated

Parameters:: view – (TWidget *)

view_deactivated(view: TWidget *) → None

A view is deactivated

Parameters:: view – (TWidget *)

view_keydown(view: TWidget *, key: int, state: view_event_state_t) → None

Key down event

Parameters:

view – (TWidget *)
key – (int)
state – (::view_event_state_t)

view_click(view: TWidget *, event: view_mouse_event_t) → None

Click event

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_dblclick(view: TWidget *, event: view_mouse_event_t) → None

Double click event

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_curpos(view: TWidget *) → None

Cursor position changed

Parameters:: view – (TWidget *)

view_created(view: TWidget *) → None

A view is being created.

Parameters:: view – (TWidget *)

view_close(view: TWidget *) → None

View closed

Parameters:: view – (TWidget *)

view_switched(view: TWidget *, rt: tcc_renderer_type_t) → None

A view’s renderer has changed.

Parameters:

view – (TWidget *)
rt – (tcc_renderer_type_t)

view_mouse_over(view: TWidget *, event: view_mouse_event_t) → None

The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view.

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_loc_changed(view: TWidget *, now: lochist_entry_t const *, was: lochist_entry_t const *) → None

The location for the view has changed (can be either the place_t, the renderer_info_t, or both.)

Parameters:

view – (TWidget *)
now – (const lochist_entry_t *)
was – (const lochist_entry_t *)

view_mouse_moved(view: TWidget *, event: view_mouse_event_t) → None

The mouse moved on the view

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

class ida_kernwin.CustomIDAMemo

Bases: View_Hooks

view_activated(view)

A view is activated

Parameters:: view – (TWidget *)

view_deactivated(view)

A view is deactivated

Parameters:: view – (TWidget *)

view_keydown(view, key, state)

Key down event

Parameters:

view – (TWidget *)
key – (int)
state – (::view_event_state_t)

view_click(view, ve)

Click event

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_dblclick(view, ve)

Double click event

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_curpos(view, *args)

Cursor position changed

Parameters:: view – (TWidget *)

view_close(view, *args)

View closed

Parameters:: view – (TWidget *)

view_switched(view, rt)

A view’s renderer has changed.

Parameters:

view – (TWidget *)
rt – (tcc_renderer_type_t)

view_mouse_over(view, ve)

The user moved the mouse over (or out of) a node or an edge. This is only relevant in a graph view.

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

view_loc_changed(view, now, was)

The location for the view has changed (can be either the place_t, the renderer_info_t, or both.)

Parameters:

view – (TWidget *)
now – (const lochist_entry_t *)
was – (const lochist_entry_t *)

view_mouse_moved(view, ve)

The mouse moved on the view

Parameters:

view – (TWidget *)
event – (const view_mouse_event_t *)

Refresh(): Refreshes the view. This causes the OnRefresh() to be called

GetCurrentRendererType()

SetCurrentRendererType(rtype)

Set the current view’s renderer.

Parameters:: rtype – The renderer type. Should be one of the idaapi.TCCRT_* values.

SetNodeInfo(node_index, node_info, flags)

Set the properties for the given node.

Example usage (set second nodes’s bg color to red):: inst = … p = idaapi.node_info_t() p.bg_color = 0x00ff0000 inst.SetNodeInfo(1, p, idaapi.NIF_BG_COLOR)

Parameters:

node_index – The node index.
node_info – An idaapi.node_info_t instance.
flags – An OR’ed value of NIF_* values.

SetNodesInfos(values)

Set the properties for the given nodes.

Example usage (set first three nodes’s bg color to purple):: inst = … p = idaapi.node_info_t() p.bg_color = 0x00ff00ff inst.SetNodesInfos({0 : p, 1 : p, 2 : p})

Parameters:: values – A dictionary of ‘int -> node_info_t’ objects.

GetNodeInfo(*args)

Get the properties for the given node.

Parameters:

ni – A node_info_t instance
node – The index of the node.

Returns:

success

DelNodesInfos(*nodes)

Delete the properties for the given node(s).

Parameters:: nodes – A list of node IDs

CreateGroups(groups_infos)

Send a request to modify the graph by creating a (set of) group(s), and perform an animation.

Each object in the ‘groups_infos’ list must be of the format: {

“nodes” : [<int>, <int>, <int>, …] # The list of nodes to group “text” : <string> # The synthetic text for that group

}

Parameters:: groups_infos – A list of objects that describe those groups.
Returns:: A [<int>, <int>, …] list of group nodes, or None (failure).

DeleteGroups(groups, new_current=-1)

Send a request to delete the specified groups in the graph, and perform an animation.

Parameters:

groups – A list of group node numbers.
new_current – A node to focus on after the groups have been deleted

Returns:

True on success, False otherwise.

SetGroupsVisibility(groups, expand, new_current=-1)

Send a request to expand/collapse the specified groups in the graph, and perform an animation.

Parameters:

groups – A list of group node numbers.
expand – True to expand the group, False otherwise.
new_current – A node to focus on after the groups have been expanded/collapsed.

Returns:

True on success, False otherwise.

GetWidget()

Return the TWidget underlying this view.

Returns:: The TWidget underlying this view, or None.

GetWidgetAsGraphViewer()

Return the graph_viewer_t underlying this view.

Returns:: The graph_viewer_t underlying this view, or None.

ida_kernwin.pyidag_bind(_self: PyObject *) → bool

ida_kernwin.pyidag_unbind(_self: PyObject *) → bool

class ida_kernwin.IDAViewWrapper(title)

Bases: CustomIDAMemo

Deprecated. Use View_Hooks instead.

Because the lifecycle of an IDAView is not trivial to track (e.g., a user might close, then re-open the same disassembly view), this wrapper doesn’t bring anything superior to the View_Hooks: quite the contrary, as the latter is much more generic (and better maps IDA’s internal model.)

Bind()

Unbind()

ida_kernwin.pyscv_init(py_link: PyObject *, title: str) → PyObject *

ida_kernwin.pyscv_refresh(py_this: PyObject *) → bool

ida_kernwin.pyscv_get_current_line(py_this: PyObject *, mouse: bool, notags: bool) → PyObject *

ida_kernwin.pyscv_is_focused(py_this: PyObject *) → bool

ida_kernwin.pyscv_count(py_this: PyObject *) → size_t

ida_kernwin.pyscv_show(py_this: PyObject *) → bool

ida_kernwin.pyscv_close(py_this: PyObject *) → None

ida_kernwin.pyscv_jumpto(py_this: PyObject *, ln: size_t, x: int, y: int) → bool

ida_kernwin.pyscv_get_line(py_this: PyObject *, nline: size_t) → PyObject *

ida_kernwin.pyscv_get_pos(py_this: PyObject *, mouse: bool) → PyObject *

ida_kernwin.pyscv_clear_lines(py_this: PyObject *) → PyObject *

ida_kernwin.pyscv_add_line(py_this: PyObject *, py_sl: PyObject *) → bool

ida_kernwin.pyscv_insert_line(py_this: PyObject *, nline: size_t, py_sl: PyObject *) → bool

ida_kernwin.pyscv_patch_line(py_this: PyObject *, nline: size_t, offs: size_t, value: int) → bool

ida_kernwin.pyscv_del_line(py_this: PyObject *, nline: size_t) → bool

ida_kernwin.pyscv_get_selection(py_this: PyObject *) → PyObject *

ida_kernwin.pyscv_get_current_word(py_this: PyObject *, mouse: bool) → PyObject *

ida_kernwin.pyscv_edit_line(py_this: PyObject *, nline: size_t, py_sl: PyObject *) → bool

ida_kernwin.pyscv_get_widget(py_this: PyObject *) → TWidget *

class ida_kernwin.simplecustviewer_t

Bases: object

The base class for implementing simple custom viewers

class UI_Hooks_Trampoline(v)

Bases: UI_Hooks

v

populating_widget_popup(form, popup_handle)

IDA is populating the context menu for a widget. This is your chance to attach_action_to_popup(). Have a look at ui_finish_populating_widget_popup, if you want to augment the context menu with your own actions after the menu has had a chance to be properly populated by the owning component or plugin (which typically does it on ui_populating_widget_popup.)

Parameters:

widget – (TWidget *)
popup_handle – (TPopupMenu *)
ctx – (const action_activation_ctx_t *)

Returns:

void

ui_hooks_trampoline

OnPopup(form, popup_handle): Context menu popup is about to be shown. Create items dynamically if you wish :returns: Boolean. True if you handled the event

Create(title)

Creates the custom view. This should be the first method called after instantiation

Parameters:: title – The title of the view
Returns:: Boolean whether it succeeds or fails. It may fail if a window with the same title is already open. In this case better close existing windows

Close(): Destroys the view. One has to call Create() afterwards. Show() can be called and it will call Create() internally. :returns: Boolean

Show(): Shows an already created view. It the view was closed, then it will call Create() for you :returns: Boolean

Refresh()

RefreshCurrent(): Refreshes the current line only

Count(): Returns the number of lines in the view

GetSelection(): Returns the selected range or None :returns: tuple(x1, y1, x2, y2), or None if no selection

ClearLines(): Clears all the lines

AddLine(line, fgcolor=None, bgcolor=None): Adds a colored line to the view :returns: Boolean

InsertLine(lineno, line, fgcolor=None, bgcolor=None): Inserts a line in the given position :returns: Boolean

EditLine(lineno, line, fgcolor=None, bgcolor=None): Edits an existing line. :returns: Boolean

PatchLine(lineno, offs, value): Patches an existing line character at the given offset. This is a low level function. You must know what you’re doing

DelLine(lineno): Deletes an existing line :returns: Boolean

GetLine(lineno): Returns a line :param lineno: The line number :returns: a tuple (colored_line, fgcolor, bgcolor), or None

GetCurrentWord(mouse=0): Returns the current word :param mouse: Use mouse position or cursor position :returns: None if failed or a String containing the current word at mouse or cursor

GetCurrentLine(mouse=0, notags=0): Returns the current line. :param mouse: Current line at mouse pos :param notags: If True then tag_remove() will be called before returning the line :returns: Returns the current line (colored or uncolored) or None on failure

GetPos(mouse=0): Returns the current cursor or mouse position. :param mouse: return mouse position :returns: Returns a tuple (lineno, x, y)

GetLineNo(mouse=0): Calls GetPos() and returns the current line number or -1 on failure

Jump(lineno, x=0, y=0)

IsFocused(): Returns True if the current view is the focused view

GetWidget()

Return the TWidget underlying this view.

Returns:: The TWidget underlying this view, or None.

ida_kernwin.plgform_new() → PyObject *

ida_kernwin.plgform_show(*args) → bool

ida_kernwin.plgform_close(py_link: PyObject *, options: int) → None

ida_kernwin.plgform_get_widget(py_link: PyObject *) → TWidget *

class ida_kernwin.PluginForm

Bases: object

PluginForm class.

This form can be used to host additional controls. Please check the PyQt example.

WOPN_MDI = 1

WOPN_TAB = 2

WOPN_RESTORE: if the widget was the only widget in a floating area the last time it was closed, it will be restored as floating, with the same position+size as before

WOPN_ONTOP = 8

WOPN_MENU = 16

WOPN_CENTERED = 32

WOPN_PERSIST: widget will remain available when starting or stopping debugger sessions

WOPN_DP_LEFT: Dock widget to the left of dest_ctrl.

WOPN_DP_TOP: Dock widget above dest_ctrl.

WOPN_DP_RIGHT: Dock widget to the right of dest_ctrl.

WOPN_DP_BOTTOM: Dock widget below dest_ctrl.

WOPN_DP_INSIDE: Create a new tab bar with both widget and dest_ctrl.

WOPN_DP_TAB: Place widget into a tab next to dest_ctrl, if dest_ctrl is in a tab bar (otherwise the same as WOPN_DP_INSIDE)

WOPN_DP_BEFORE: Place widget before dst_form in the tab bar instead of after; used with WOPN_DP_INSIDE and WOPN_DP_TAB

WOPN_DP_FLOATING: Make widget floating.

WOPN_DP_SZHINT: when floating or in a splitter (i.e., not tabbed), use the widget’s size hint to determine the best geometry (Qt only)

WOPN_DP_INSIDE_BEFORE

WOPN_DP_TAB_BEFORE

WOPN_CREATE_ONLY

Show(caption, options=0)

Creates the form if not was not created or brings to front if it was already created

Parameters:

caption – The form caption
options – One of PluginForm.WOPN_ constants

VALID_CAPSULE_NAME = b'$valid$'

static TWidgetToQtPythonWidget(tw, ctx=sys.modules['__main__']): Convert a TWidget* to a QWidget to be used by the Qt Python bindings

TWidgetToPyQtWidget

FormToPyQtWidget

static QtWidgetToTWidget(w, ctx=sys.modules['__main__'])

Convert a QWidget to a TWidget* to be used by IDA

Parameters:: ctx – Context. Reference to a module that already imported SIP and QtWidgets modules

static TWidgetToPySideWidget(tw, ctx=sys.modules['__main__'])

Use this method to convert a TWidget* to a QWidget to be used by PySide

Parameters:: ctx – Context. Reference to a module that already imported QtWidgets module

FormToPySideWidget

OnCreate(form)

This event is called when the plugin form is created. The programmer should populate the form when this event is triggered.

Returns:: None

OnClose(form)

Called when the plugin form is closed

Returns:: None

Close(options)

Closes the form.

Parameters:: options – Close options (WCLS_SAVE, WCLS_NO_CONTEXT, …)
Returns:: None

GetWidget()

Return the TWidget underlying this view.

Returns:: The TWidget underlying this view, or None.

WCLS_SAVE: save state in desktop config

WCLS_NO_CONTEXT: don’t change the current context (useful for toolbars)

WCLS_DONT_SAVE_SIZE: don’t save size of the window

WCLS_DELETE_LATER: assign the deletion of the widget to the UI loop ///<

WCLS_CLOSE_LATER

ida_kernwin.place_t_as_idaplace_t

ida_kernwin.place_t_as_simpleline_place_t

ida_kernwin.place_t_as_tiplace_t