kernwin.hpp

Go to the documentation of this file.

 /*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2025 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */

 
#ifndef __KERNWIN_HPP
#define __KERNWIN_HPP
 
#ifndef SWIG
typedef uchar color_t;          
struct rangevec_t;              
class location_t;               
struct lochist_entry_t;         
struct strwinsetup_t;           
struct renderer_info_t;         
struct segm_move_infos_t;       
struct load_info_t;             
#endif // SWIG

enum mbox_kind_t
{
  mbox_internal,                
  mbox_info,
  mbox_warning,
  mbox_error,
  mbox_nomem,
  mbox_feedback,
  mbox_readerror,
  mbox_writeerror,
  mbox_filestruct,
  mbox_wait,
  mbox_hide,
  mbox_replace,
};
 

enum choose_type_t
{
  chtype_generic,                
  chtype_idasgn,                 
  chtype_entry,                  
  chtype_name,                   
  chtype_stkvar_xref,            
  chtype_xref,                   
  chtype_func,                   
  chtype_segm,                   
  chtype_strpath,                
  chtype_idatil,                 
  chtype_srcp,                   
  chtype_struct,                 
  chtype_enum,                   
  chtype_enum_by_value_and_size, 
};
 
 
enum beep_t             
{
  beep_default = 0
};
 
 
// Notify UI about various events. The kernel will call this function
// when something interesting for the UI happens.
// The UI should avoid calling the kernel from this callback.
 
class func_t;
class segment_t;
struct sreg_range_t;
class plugin_t;
struct plugmod_t;
struct procmod_t;
class minsn_t;
class idc_value_t;
class linput_t;
class snapshot_t;
class tinfo_t;
struct til_t;

enum tcc_renderer_type_t
{
  TCCRT_INVALID = 0,        
  TCCRT_FLAT,               
  TCCRT_GRAPH,              
  TCCRT_PROXIMITY           
};

enum tcc_place_type_t
{
  TCCPT_INVALID = 0,        
  TCCPT_PLACE,              
  TCCPT_SIMPLELINE_PLACE,   
  TCCPT_IDAPLACE,           
  TCCPT_TIPLACE,            
};

enum vme_button_t
{
  VME_UNKNOWN,              
  VME_LEFT_BUTTON,          
  VME_RIGHT_BUTTON,         
  VME_MID_BUTTON,           
};
 
//-------------------------------------------------------------------------
#define SETMENU_POSMASK       0x3
#define SETMENU_INS           0x0 
#define SETMENU_APP           0x1 
#define SETMENU_FIRST         0x2 
#define SETMENU_ENSURE_SEP    0x8 

#define CREATETB_ADV         0x1 
 
//-------------------------------------------------------------------------
#define HIF_IDENTIFIER   0x1  
#define HIF_REGISTER     0x2  
#define HIF_LOCKED       0x4  
#define HIF_NOCASE       0x8  
 
                         // bits 27-31 reserved
#define HIF_USE_SLOT     (1 << 27) 
#define HIF_SLOT_SHIFT   28        
#define HIF_GET_SLOT(flags) (((flags) >> HIF_SLOT_SHIFT) & 0x7) 
 
                         // convenience constants
                         // (not a macro HIF_SLOT(n) because SWIG won't pick it up for IDAPython)
#define HIF_SLOT_0       (HIF_USE_SLOT | (0 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_1       (HIF_USE_SLOT | (1 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_2       (HIF_USE_SLOT | (2 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_3       (HIF_USE_SLOT | (3 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_4       (HIF_USE_SLOT | (4 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_5       (HIF_USE_SLOT | (5 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_6       (HIF_USE_SLOT | (6 << HIF_SLOT_SHIFT)) 
#define HIF_SLOT_7       (HIF_USE_SLOT | (7 << HIF_SLOT_SHIFT)) 
 
#define REG_HINTS_MARKER SCOLOR_ON "\x7F"
#define REG_HINTS_MARKER_LEN 2
#define SRCDBG_HINTS_MARKER SCOLOR_ON "\x7E"
#define SRCDBG_HINTS_MARKER_LEN 2
 

#define CDVF_NOLINES        0x0001    
#define CDVF_LINEICONS      0x0002    
#define CDVF_STATUSBAR      0x0004    

#define IDCHK_OK        0       
#define IDCHK_ARG       -1      
#define IDCHK_KEY       -2      
#define IDCHK_MAX       -3      

#define WCLS_SAVE           0x1 
#define WCLS_NO_CONTEXT     0x2 
#define WCLS_DONT_SAVE_SIZE 0x4 
#define WCLS_DELETE_LATER   0x8 
#define WCLS_CLOSE_LATER WCLS_DELETE_LATER

#define DP_LEFT            0x0001 
#define DP_TOP             0x0002 
#define DP_RIGHT           0x0004 
#define DP_BOTTOM          0x0008 
#define DP_INSIDE          0x0010 
#define DP_TAB             0x0040 
#define DP_BEFORE          0x0020 
#define DP_FLOATING        0x0080 
#define DP_SZHINT          0x0100 

#define CDVF_NOLINES        0x0001    
#define CDVF_LINEICONS      0x0002    
#define CDVF_STATUSBAR      0x0004    

#define SVF_COPY_LINES  0x0000   
#define SVF_LINES_BYPTR 0x0001   

#define CVNF_LAZY (1 << 0) 
#define CVNF_JUMP (1 << 1) 
#define CVNF_ACT  (1 << 2) 
//
#define WOPN_RESTORE           0x00000004u 
#define WOPN_PERSIST           0x00000040u 
#define WOPN_CLOSED_BY_ESC     0x00000080u 
#define WOPN_NOT_CLOSED_BY_ESC 0x00000100u 
#define WOPN_DP_MASK           0x0FFF0000u
#define WOPN_DP_SHIFT          16
#define WOPN_DP_LEFT           (DP_LEFT << WOPN_DP_SHIFT)
#define WOPN_DP_TOP            (DP_TOP << WOPN_DP_SHIFT)
#define WOPN_DP_RIGHT          (DP_RIGHT << WOPN_DP_SHIFT)
#define WOPN_DP_BOTTOM         (DP_BOTTOM << WOPN_DP_SHIFT)
#define WOPN_DP_INSIDE         (DP_INSIDE << WOPN_DP_SHIFT)
#define WOPN_DP_TAB            (DP_TAB << WOPN_DP_SHIFT)
#define WOPN_DP_BEFORE         (DP_BEFORE << WOPN_DP_SHIFT)
#define WOPN_DP_FLOATING       (DP_FLOATING << WOPN_DP_SHIFT)
#define WOPN_DP_SZHINT         (DP_SZHINT << WOPN_DP_SHIFT)
#define WOPN_DP_INSIDE_BEFORE  (WOPN_DP_INSIDE | WOPN_DP_BEFORE)
#define WOPN_DP_TAB_BEFORE     (WOPN_DP_TAB | WOPN_DP_BEFORE)
#define WOPN_GET_DP(v)         (((v) & WOPN_DP_MASK) >> WOPN_DP_SHIFT)

#define RENADDR_IDA   0   
#define RENADDR_HR    1   

#define CVLF_USE_MOUSE  0x1 
 
#ifndef SWIG
union callui_t
{
  bool cnd;
  char i8;
  int i;
  short i16;
  int32 i32;
  uchar u8;
  ushort u16;
  uint32 u32;
  char *cptr;
  void *vptr;
  ssize_t ssize;
  func_t *fptr;
  segment_t *segptr;
  plugin_t *pluginptr;
  sreg_range_t *sraptr;
};
 
//-------------------------------------------------------------------------
enum execute_sync_availability_t
{
  esa_unknown = 0,
  esa_available,
  esa_unavailable,
  esa_release,
  esa_app_unavailable,
};
 
//-------------------------------------------------------------------------
enum execute_sync_ctl_t
{
  esctl_none = 0,
  esctl_cancel_request,
  esctl_cancel_thread_requests,
  esctl_set_availability,
};

/// (See convenience functions like get_screen_ea())
/// Events marked as 'cb:' are designed to be callbacks and should not
/// be used in callui(). The user may hook to ::HT_UI events to catch them
 
enum ui_notification_t
{
  ui_null = 0,
 
  ui_range,             
 
  ui_refresh_choosers,  
 
  ui_idcstart,          
 
  ui_idcstop,           
 
  ui_suspend,           
 
  ui_resume,            
 
  ui_broadcast,         
 
  ui_read_selection,    
 
  ui_read_range_selection,  
 
  ui_unmarksel,         
 
  ui_screenea,          
 
  ui_saving,            
 
  ui_saved,             
 
  ui_refreshmarked,     
 
  ui_refresh,           
 
  ui_choose,            
 
  ui_close_chooser,     
 
  ui_banner,            
 
  ui_setidle,           
 
  ui_database_closed,   
 
  ui_beep,              
 
  ui_is_msg_inited,     
 
  ui_msg,               
 
  ui_mbox,              
 
  ui_clr_cancelled,     
 
  ui_set_cancelled,     
 
  ui_test_cancelled,    
 
  ui_ask_buttons,       
 
  ui_ask_file,          
 
  ui_ask_form,          
 
  ui_ask_text,          
 
  ui_ask_str,           
 
  ui_ask_addr,          
 
  ui_ask_seg,           
 
  ui_ask_long,          
 
  ui_add_idckey,        
 
  ui_obsolete_del_idckey,
 
  ui_analyzer_options,  
 
  ui_load_file,         
 
  ui_run_dbg,           
 
  ui_get_cursor,        
 
  ui_get_curline,       
 
  ui_copywarn,          
 
  ui_noabort,           
 
  ui_lock_range_refresh,
 
  ui_unlock_range_refresh,
 
  ui_genfile_callback,  
 
  ui_open_url,          
 
  ui_hexdumpea,         
 
  ui_get_key_code,      
 
  ui_setup_plugins_menu,
 
  ui_get_kernel_version,
 
  ui_is_idaq,           
 
  ui_refresh_navband,   
 
  ui_debugger_menu_change, 
 
  ui_get_curplace,      
 
  ui_obsolete_display_widget,
  ui_close_widget,       
 
  ui_activate_widget,   
 
  ui_find_widget,       
 
  ui_get_current_widget,
 
  ui_widget_visible,    
 
  ui_widget_closing,    
 
  ui_widget_invisible,  
 
  ui_get_ea_hint,       
 
  ui_get_item_hint,     
 
  ui_refresh_custom_viewer,
 
  ui_destroy_custom_viewer,
 
  ui_jump_in_custom_viewer,
 
  ui_get_custom_viewer_curline,
 
  ui_get_current_viewer,
 
  ui_is_idaview,        
 
  ui_get_custom_viewer_hint,
 
  ui_set_custom_viewer_range,
 
  ui_database_inited,   
 
  ui_ready_to_run,      
 
  ui_set_custom_viewer_handler,
 
  ui_refresh_chooser,   
 
  ui_open_builtin,      
 
  ui_preprocess_action, 
 
  ui_postprocess_action,
 
  ui_set_custom_viewer_mode,
 
  ui_gen_disasm_text,   
 
  ui_gen_idanode_text,  
 
  ui_install_cli,       
 
  ui_execute_sync,      
 
  ui_execute_sync_ctl,  
 
  ui_get_chooser_obj,   
 
  ui_enable_chooser_item_attrs,
 
  ui_get_chooser_item_attrs,
 
  ui_set_dock_pos,      
 
  ui_get_opnum,         
 
  ui_install_custom_datatype_menu,
 
  ui_install_custom_optype_menu,
 
  ui_get_range_marker,  
 
  ui_lookup_key_code,   
 
  ui_load_custom_icon_file,
 
  ui_load_custom_icon,  
 
  ui_free_custom_icon,  
 
  ui_process_action,    
 
  ui_create_code_viewer,
 
  ui_addons,            
 
  ui_execute_ui_requests,
 
  ui_execute_ui_requests_list,
 
  ui_register_timer,    
 
  ui_unregister_timer,  
 
  ui_take_database_snapshot,
 
  ui_restore_database_snapshot,
 
  ui_set_code_viewer_line_handlers,
 
  ui_obsolete_refresh_custom_code_viewer,
 
  ui_create_source_viewer,
 
  ui_get_tab_size,      
 
  ui_repaint_qwidget,   
 
  ui_custom_viewer_set_userdata,
 
  ui_jumpto,            
 
  ui_open_form,         
 
  ui_unrecognized_config_directive,
 
  ui_get_output_cursor, 
 
  ui_get_output_curline,
 
  ui_get_output_selected_text,
 
  ui_get_renderer_type, 
 
  ui_set_renderer_type, 
 
  ui_get_viewer_user_data,
 
  ui_get_viewer_place_type,
 
  ui_ea_viewer_history_push_and_jump,
 
  ui_ea_viewer_history_info,
 
  ui_register_action,
 
  ui_unregister_action,
 
  ui_attach_action_to_menu,
 
  ui_detach_action_from_menu,
 
  ui_attach_action_to_popup,
 
  ui_detach_action_from_popup,
 
  ui_attach_dynamic_action_to_popup,
 
  ui_attach_action_to_toolbar,
 
  ui_detach_action_from_toolbar,
 
  ui_updating_actions,  
 
  ui_updated_actions,   
 
  ui_populating_widget_popup,
 
  ui_finish_populating_widget_popup,
 
  ui_update_action_attr,
 
  ui_get_action_attr,   
 
  ui_plugin_loaded,     
 
  ui_plugin_unloading,  
 
  ui_get_widget_type,  
 
  ui_current_widget_changed,
 
  ui_get_widget_title, 
 
  ui_obsolete_get_user_strlist_options,
 
  ui_create_custom_viewer,
 
  ui_custom_viewer_jump,
 
  ui_set_custom_viewer_handlers,
 
  ui_get_registered_actions,
 
  ui_create_toolbar,    
  ui_delete_toolbar,    
  ui_create_menu,       
  ui_delete_menu,       
  ui_obsolete_set_nav_colorizer,
  ui_get_chooser_data,  
  ui_obsolete_get_highlight, 
  ui_set_highlight,     
 
  ui_set_mappings,      
  ui_create_empty_widget,
 
  ui_msg_clear,         
  ui_msg_save,          
  ui_msg_get_lines,     
 
  ui_chooser_default_enter,
 
  ui_screen_ea_changed,
 
  ui_get_active_modal_widget,
 
  ui_navband_pixel,     
  ui_navband_ea,        
  ui_get_window_id,     
 
  ui_create_desktop_widget,
 
  ui_strchoose,         
 
 
  ui_set_nav_colorizer, 
  ui_display_widget,    
 
  ui_get_lines_rendering_info,
 
  ui_sync_sources,
 
  ui_get_widget_config,   
 
  ui_set_widget_config,   
 
  ui_obsolete_get_custom_viewer_location, // ui_get_custom_viewer_location_2
 
  ui_initing_database,    
 
  ui_destroying_procmod,  
 
  ui_destroying_plugmod,  
 
  ui_update_file_history, 
 
  ui_get_synced_group,
 
  ui_show_rename_dialog,  
 
  ui_desktop_applied,     
 
  ui_choose_bookmark,
 
  ui_get_custom_viewer_place_xcoord,
 
  ui_get_user_input_event,
 
  ui_get_highlight_2,     
 
  ui_get_custom_viewer_location_2,
 
  ui_get_chooser_rows,    
  ui_get_icon_id_by_name, 
  ui_open_builtin2,       
 
  ui_get_last_widget,     
 
  ui_prompt_function_prototype,
 
  ui_parse_tagged_line_sections,
  ui_last,              
 
  ui_dbg_begin = 1000, 
  ui_dbg_run_requests = ui_dbg_begin,
  ui_dbg_get_running_request,
  ui_dbg_get_running_notification,
  ui_dbg_clear_requests_queue,
  ui_dbg_get_process_state,
  ui_dbg_start_process,
  ui_dbg_request_start_process,
  ui_dbg_suspend_process,
  ui_dbg_request_suspend_process,
  ui_dbg_continue_process,
  ui_dbg_request_continue_process,
  ui_dbg_exit_process,
  ui_dbg_request_exit_process,
  ui_dbg_get_thread_qty,
  ui_dbg_getn_thread,
  ui_dbg_select_thread,
  ui_dbg_request_select_thread,
  ui_dbg_step_into,
  ui_dbg_request_step_into,
  ui_dbg_step_over,
  ui_dbg_request_step_over,
  ui_dbg_run_to,
  ui_dbg_request_run_to,
  ui_dbg_step_until_ret,
  ui_dbg_request_step_until_ret,
  ui_dbg_get_bpt_qty,
  ui_dbg_add_oldbpt,
  ui_dbg_request_add_oldbpt,
  ui_dbg_del_oldbpt,
  ui_dbg_request_del_oldbpt,
  ui_dbg_enable_oldbpt,
  ui_dbg_request_enable_oldbpt,
  ui_dbg_set_trace_size,
  ui_dbg_clear_trace,
  ui_dbg_request_clear_trace,
  ui_dbg_is_step_trace_enabled,
  ui_dbg_enable_step_trace,
  ui_dbg_request_enable_step_trace,
  ui_dbg_get_step_trace_options,
  ui_dbg_set_step_trace_options,
  ui_dbg_request_set_step_trace_options,
  ui_dbg_is_insn_trace_enabled,
  ui_dbg_enable_insn_trace,
  ui_dbg_request_enable_insn_trace,
  ui_dbg_get_insn_trace_options,
  ui_dbg_set_insn_trace_options,
  ui_dbg_request_set_insn_trace_options,
  ui_dbg_is_func_trace_enabled,
  ui_dbg_enable_func_trace,
  ui_dbg_request_enable_func_trace,
  ui_dbg_get_func_trace_options,
  ui_dbg_set_func_trace_options,
  ui_dbg_request_set_func_trace_options,
  ui_dbg_get_tev_qty,
  ui_dbg_get_tev_info,
  ui_dbg_get_call_tev_callee,
  ui_dbg_get_ret_tev_return,
  ui_dbg_get_bpt_tev_ea,
  ui_dbg_get_reg_value_type,
  ui_dbg_get_processes,
  ui_dbg_attach_process,
  ui_dbg_request_attach_process,
  ui_dbg_detach_process,
  ui_dbg_request_detach_process,
  ui_dbg_get_first_module,
  ui_dbg_get_next_module,
  ui_dbg_bring_to_front,
  ui_dbg_get_current_thread,
  ui_dbg_wait_for_next_event,
  ui_dbg_get_debug_event,
  ui_dbg_set_debugger_options,
  ui_dbg_set_remote_debugger,
  ui_dbg_load_debugger,
  ui_dbg_retrieve_exceptions,
  ui_dbg_store_exceptions,
  ui_dbg_define_exception,
  ui_dbg_suspend_thread,
  ui_dbg_request_suspend_thread,
  ui_dbg_resume_thread,
  ui_dbg_request_resume_thread,
  ui_dbg_get_process_options,
  ui_dbg_check_bpt,
  ui_dbg_set_process_state,
  ui_dbg_get_manual_regions,
  ui_dbg_set_manual_regions,
  ui_dbg_enable_manual_regions,
  ui_dbg_set_process_options,
  ui_dbg_is_busy,
  ui_dbg_hide_all_bpts,
  ui_dbg_edit_manual_regions,
  ui_dbg_get_sp_val,
  ui_dbg_get_ip_val,
  ui_dbg_get_reg_val,
  ui_dbg_set_reg_val,
  ui_dbg_request_set_reg_val,
  ui_dbg_get_insn_tev_reg_val,
  ui_dbg_get_insn_tev_reg_result,
  ui_dbg_register_provider,
  ui_dbg_unregister_provider,
  ui_dbg_handle_debug_event,
  ui_dbg_add_vmod,
  ui_dbg_del_vmod,
  ui_dbg_compare_bpt_locs,
  ui_obsolete_dbg_save_bpts,
  ui_dbg_set_bptloc_string,
  ui_dbg_get_bptloc_string,
  ui_dbg_internal_appcall,
  ui_dbg_internal_cleanup_appcall,
  ui_dbg_internal_get_sreg_base,
  ui_dbg_internal_ioctl,
  ui_dbg_read_memory,
  ui_dbg_write_memory,
  ui_dbg_read_registers,
  ui_dbg_write_register,
  ui_dbg_get_memory_info,
  ui_dbg_get_event_cond,
  ui_dbg_set_event_cond,
  ui_dbg_enable_bpt,
  ui_dbg_request_enable_bpt,
  ui_dbg_del_bpt,
  ui_dbg_request_del_bpt,
  ui_dbg_map_source_path,
  ui_dbg_map_source_file_path,
  ui_dbg_modify_source_paths,
  ui_dbg_is_bblk_trace_enabled,
  ui_dbg_enable_bblk_trace,
  ui_dbg_request_enable_bblk_trace,
  ui_dbg_get_bblk_trace_options,
  ui_dbg_set_bblk_trace_options,
  ui_dbg_request_set_bblk_trace_options,
  // trace management
  ui_dbg_load_trace_file,
  ui_dbg_save_trace_file,
  ui_dbg_is_valid_trace_file,
  ui_dbg_set_trace_file_desc,
  ui_dbg_get_trace_file_desc,
  ui_dbg_choose_trace_file,
  ui_dbg_diff_trace_file,
  ui_dbg_graph_trace,
  ui_dbg_get_tev_memory_info,
  ui_dbg_get_tev_event,
  ui_dbg_get_insn_tev_reg_mem,
  // breakpoint management (new codes were introduced in v6.3)
  ui_dbg_getn_bpt,
  ui_dbg_get_bpt,
  ui_dbg_find_bpt,
  ui_dbg_add_bpt,
  ui_dbg_request_add_bpt,
  ui_dbg_update_bpt,
  ui_dbg_for_all_bpts,
  ui_dbg_get_tev_ea,
  ui_dbg_get_tev_type,
  ui_dbg_get_tev_tid,
  ui_dbg_get_trace_base_address,
  // calluis for creating traces from scratch (added in 6.4)
  ui_dbg_set_trace_base_address,
  ui_dbg_add_tev,
  ui_dbg_add_insn_tev,
  ui_dbg_add_call_tev,
  ui_dbg_add_ret_tev,
  ui_dbg_add_bpt_tev,
  ui_dbg_add_debug_event,
  ui_dbg_add_thread,
  ui_dbg_del_thread,
  ui_dbg_add_many_tevs,
  ui_dbg_set_bpt_group,
  ui_dbg_set_highlight_trace_options,
  ui_dbg_set_trace_platform,
  ui_dbg_get_trace_platform,
  // added in 6.6
  ui_dbg_internal_get_elang,
  ui_dbg_internal_set_elang,
 
  // added in 6.7
  ui_dbg_load_dbg_dbginfo,
  ui_dbg_set_resume_mode,
  ui_dbg_request_set_resume_mode,
  ui_dbg_set_bptloc_group,
  ui_dbg_list_bptgrps,
  ui_dbg_rename_bptgrp,
  ui_dbg_del_bptgrp,
  ui_dbg_get_grp_bpts,
  ui_dbg_get_bpt_group,
  ui_dbg_change_bptlocs,
 
  // added in 7.1
  ui_dbg_collect_stack_trace,
  ui_dbg_get_module_info,
 
  // source-level debugging
  ui_dbg_get_srcinfo_provider,
  ui_dbg_get_global_var,
  ui_dbg_get_local_var,
  ui_dbg_get_local_vars,
  ui_dbg_add_path_mapping,
  ui_dbg_get_current_source_file,
  ui_dbg_get_current_source_line,
 
  ui_dbg_srcdbg_step_into,
  ui_dbg_srcdbg_request_step_into,
  ui_dbg_srcdbg_step_over,
  ui_dbg_srcdbg_request_step_over,
  ui_dbg_srcdbg_step_until_ret,
  ui_dbg_srcdbg_request_step_until_ret,
 
  ui_dbg_getn_thread_name,
  ui_dbg_bin_search,
 
  ui_dbg_get_insn_tev_reg_val_i,
  ui_dbg_get_insn_tev_reg_result_i,
  ui_dbg_get_reg_val_i,
  ui_dbg_set_reg_val_i,
 
  ui_dbg_get_reg_info,
 
  ui_dbg_set_trace_dynamic_register_set,
  ui_dbg_get_trace_dynamic_register_set,
 
  // added in 7.7
  ui_dbg_enable_bptgrp,
 
  // added in 9.1
  ui_dbg_continue_backwards,
  ui_dbg_request_continue_backwards,
  ui_dbg_step_into_backwards,
  ui_dbg_request_step_into_backwards,
  ui_dbg_step_over_backwards,
  ui_dbg_request_step_over_backwards,
  ui_dbg_run_to_backwards,
  ui_dbg_request_run_to_backwards,
  ui_dbg_set_suspend_on_event,
 
  ui_dbg_end,
 
  // Debugging notifications
#ifdef _DEBUG
  debug_obsolete_assert_thread_waitready = ui_dbg_end
#endif
};
 
 
//--------------------------------------------------------------------------
 

 
idaman callui_t ida_export_data (idaapi*callui)(ui_notification_t what,...);
 

 
idaman int ida_export init_database(int argc, const char *const *argv, int *newfile);
 

 
idaman void ida_export term_database();
 

 
idaman NORETURN AS_PRINTF(1, 0) void ida_export verror(const char *format, va_list va);
 

 
idaman AS_PRINTF(3, 0) void ida_export vshow_hex(
        const void *dataptr,
        size_t len,
        const char *format,
        va_list va);
 

 
idaman AS_PRINTF(4, 0) void ida_export vshow_hex_file(
        linput_t *li,
        int64 pos,
        size_t count,
        const char *format,
        va_list va);
 
 
#endif // SWIG

 
inline ssize_t get_kernel_version(char *buf, size_t bufsize)
{
  return callui(ui_get_kernel_version, buf, bufsize).ssize;
}
 
// Return true if this is ida running as library
const int64 IDALIB_API_MAGIC = 0x001DA11B00000000LL;
inline bool is_ida_library(char *path = nullptr, size_t pathsize = 0, void** handle = nullptr)
{
  return callui(ui_broadcast, IDALIB_API_MAGIC, path, pathsize, handle).ssize > 0;
}
 
//--------------------------------------------------------------------------
//      K E R N E L   S E R V I C E S   F O R   U I
//--------------------------------------------------------------------------
//
// Generating text for the disassembly, enum, and structure windows.


class place_t
{
public:
  int lnnum;                      
  place_t()  {}                   
  place_t(int ln) : lnnum(ln) {}  
  DEFINE_MEMORY_ALLOCATION_FUNCS()
 
  
  /// This description is used on the status bar.
  /// \param vout     the output buffer
  /// \param ud       pointer to user-defined context data. Is supplied by ::linearray_t
  virtual void idaapi print(qstring *vout, void *ud) const = 0;

  /// Map the location to a number.
  /// This mapping is used to draw the vertical scrollbar.
  /// \param ud  pointer to user-defined context data. Is supplied by ::linearray_t
  virtual uval_t idaapi touval(void *ud) const                         = 0;

  virtual place_t *idaapi clone() const                                = 0;

  virtual void idaapi copyfrom(const place_t *from)                    = 0;

  virtual place_t *idaapi makeplace(void *ud, uval_t x, int lnnum) const= 0;

  virtual int idaapi compare(const place_t *t2) const                  = 0;

  virtual void idaapi adjust(void *ud)                                 = 0;

  virtual bool idaapi prev(void *ud)                                   = 0;

  virtual bool idaapi next(void *ud)                                   = 0;

  virtual bool idaapi beginning(void *ud) const                        = 0;

  virtual bool idaapi ending(void *ud) const                           = 0;

  virtual int idaapi generate(
        qstrvec_t *out,
        int *out_deflnnum,
        color_t *out_pfx_color,
        bgcolor_t *out_bgcolor,
        void *ud,
        int maxsize) const = 0;

  virtual void idaapi serialize(bytevec_t *out) const = 0;

  virtual bool idaapi deserialize(const uchar **pptr, const uchar *end) = 0;

  virtual int idaapi id() const = 0;

  virtual const char *idaapi name() const = 0;

  virtual ea_t idaapi toea() const { return BADADDR; }

  virtual bool idaapi rebase(const segm_move_infos_t & /*infos*/ ) { return true; }

  virtual place_t *idaapi enter(uint32 * /*out_flags*/) const { return nullptr; }

  virtual void idaapi leave(uint32 /*flags*/) const {}

  virtual int idaapi compare2(const place_t *t2, void * /*ud*/) const { return compare(t2); }

  virtual bool idaapi equals(const place_t *t2, void *ud) const
  {
    return compare2(t2, ud) == 0;
  }
};
 
#define DEFAULT_PLACE_LNNUM -1
#define MAX_PLACE_LNNUM INT_MAX

/// compare places and their lnnums
idaman int ida_export l_compare(const place_t *t1, const place_t *t2);
idaman int ida_export l_compare2(const place_t *t1, const place_t *t2, void *ud);
idaman bool ida_export l_equals(const place_t *t1, const place_t *t2, void *ud);
 
#ifndef SWIG
 
//--------------------------------------------------------------------------
#define define_place_exported_functions(classname)                                                      \
class classname;                                                                                        \
idaman void        ida_export classname ## __print(const classname *, qstring *, void*);                \
idaman uval_t      ida_export classname ## __touval(const classname *, void*);                           \
idaman place_t *   ida_export classname ## __clone(const classname *);                                  \
idaman void        ida_export classname ## __copyfrom(classname *, const place_t*);                      \
idaman place_t *   ida_export classname ## __makeplace(const classname *, void*, uval_t, int);             \
idaman int         ida_export classname ## __compare(const classname *, const place_t*);                 \
idaman int         ida_export classname ## __compare2(const classname *, const place_t*, void*);        \
idaman bool        ida_export classname ## __equals(const classname *, const place_t*, void*);          \
idaman void        ida_export classname ## __adjust(classname *, void*);                                 \
idaman bool        ida_export classname ## __prev(classname *, void*);                                   \
idaman bool        ida_export classname ## __next(classname *, void*);                                   \
idaman bool        ida_export classname ## __beginning(const classname *, void*);                        \
idaman bool        ida_export classname ## __ending(const classname *, void*);                           \
idaman int         ida_export classname ## __generate(                                                  \
        const classname *,                                                                              \
        qstrvec_t*,                                                                                     \
        int*,                                                                               \
        color_t*,                                                                                       \
        bgcolor_t*,                                                                                     \
        void*,                                                                                          \
        int);                                                                               \
idaman void        ida_export classname ## __serialize(const classname *, bytevec_t *out);              \
idaman bool        ida_export classname ## __deserialize(classname *, const uchar **, const uchar *);   \
idaman int         ida_export classname ## __id(const classname *);                                     \
idaman const char *ida_export classname ## __name(const classname *);                                   \
idaman ea_t        ida_export classname ## __toea(const classname *);                                   \
idaman place_t *   ida_export classname ## __enter(const classname *, uint32 *);                        \
idaman void        ida_export classname ## __leave(const classname *, uint32);                          \
idaman bool        ida_export classname ## __rebase(classname *, const segm_move_infos_t &);
 

#define define_place_virtual_functions(class)                         \
  virtual void idaapi print(qstring *buf, void *ud) const override    \
        {        class ## __print(this, buf, ud); }                   \
  virtual uval_t idaapi touval(void *ud) const override               \
        { return class ## __touval(this, ud); }                       \
  virtual place_t *idaapi clone() const override                      \
        { return class ## __clone(this); }                            \
  virtual void idaapi copyfrom(const place_t *from) override          \
        {        class ## __copyfrom(this, from); }                   \
  virtual place_t *idaapi makeplace(                                  \
        void *ud,                                                     \
        uval_t x,                                                     \
        int _lnnum) const override                                    \
        { return class ## __makeplace(this,ud,x,_lnnum); }            \
  virtual int idaapi compare(const place_t *t2) const override        \
        { return class ## __compare(this, t2); }                      \
  virtual void idaapi adjust(void *ud) override                       \
        {        class ## __adjust(this,ud); }                        \
  virtual bool idaapi prev(void *ud) override                         \
        { return class ## __prev(this,ud); }                          \
  virtual bool idaapi next(void *ud) override                         \
        { return class ## __next(this,ud); }                          \
  virtual bool idaapi beginning(void *ud) const override              \
        { return class ## __beginning(this,ud); }                     \
  virtual bool idaapi ending(void *ud) const override                 \
        { return class ## __ending(this,ud); }                        \
  virtual int idaapi generate(                                        \
        qstrvec_t *_out,                                              \
        int *_out_lnnum,                                              \
        color_t *_out_pfx_color,                                      \
        bgcolor_t *_out_bg_color,                                     \
        void *_ud,                                                    \
        int _max) const override                                      \
  {                                                                   \
    return class ## __generate(                                       \
            this, _out, _out_lnnum, _out_pfx_color,                   \
            _out_bg_color, _ud, _max);                                \
  }                                                                   \
  virtual void idaapi serialize(bytevec_t *out) const override        \
       { class ## __serialize(this, out); }                           \
  virtual bool idaapi deserialize(                                    \
        const uchar **pptr,                                           \
        const uchar *end) override                                    \
       { return class ## __deserialize(this, pptr, end); }            \
  virtual int idaapi id() const override                              \
       { return class ## __id(this); }                                \
  virtual const char * idaapi name() const override                   \
       { return class ## __name(this); }                              \
  virtual ea_t idaapi toea() const override                           \
       { return class ## __toea(this); }                              \
  virtual place_t *idaapi enter(uint32 *out_flags) const override     \
       { return class ## __enter(this, out_flags); }                  \
  virtual void idaapi leave(uint32 flags) const override              \
       { return class ## __leave(this, flags); }                      \
  virtual bool idaapi rebase(const segm_move_infos_t &infos) override \
       { return class ## __rebase(this, infos); }                     \
  virtual int idaapi compare2(const place_t *t2, void *ud) const override \
  { return class ## __compare2(this, t2, ud); }                       \
  virtual bool idaapi equals(const place_t *t2, void *ud) const override \
  { return class ## __equals(this, t2, ud); }
 
define_place_exported_functions(simpleline_place_t)
 
 
#endif // SWIG
 
//--------------------------------------------------------------------------


struct simpleline_t
{
  qstring line;                 
  color_t color = 1;            
  bgcolor_t bgcolor = DEFCOLOR; 
  simpleline_t() {}
  simpleline_t(color_t c, const char *str) : line(str), color(c) {}
  simpleline_t(const char *str) : line(str) {}
  simpleline_t(const qstring &str) : line(str) {}
  DEFINE_MEMORY_ALLOCATION_FUNCS()
};

typedef qvector<simpleline_t> strvec_t;

class simpleline_place_t : public place_t
{
public:
  uint32 n; 
  simpleline_place_t() { n = 0; lnnum = 0; }    
  simpleline_place_t(int _n) { n = _n; lnnum = 0; } 
  define_place_virtual_functions(simpleline_place_t);
};
 
//--------------------------------------------------------------------------
// user defined data for linearray_t: use ptr to result of calc_default_idaplace_flags()
#ifndef SWIG
define_place_exported_functions(idaplace_t)
#endif // SWIG
/// A location in a disassembly view
class idaplace_t : public place_t
{
public:
  ea_t ea; 
  idaplace_t() {} 
  idaplace_t(ea_t x, int ln) : place_t(ln), ea(x) {} 
  define_place_virtual_functions(idaplace_t);
};
 
//-------------------------------------------------------------------------
#ifndef SWIG
define_place_exported_functions(hexplace_t)
struct outctx_base_t;
struct hexplace_gen_t;
class hexview_t;
idaman void ida_export hexplace_t__out_one_item(
        const hexplace_t *_this,
        outctx_base_t &ctx,
        const hexplace_gen_t *hg,
        int itemno,
        color_t *color,
        color_t patch_or_edit);
idaman size_t ida_export hexplace_t__ea2str(
        char *buf,
        size_t bufsize,
        const hexplace_gen_t *hg,
        ea_t ea);
#endif // SWIG
 
#define HEXPLACE_COLOR_EDITED     COLOR_SYMBOL
#define HEXPLACE_COLOR_PATCHED    COLOR_VOIDOP
#define HEXPLACE_COLOR_SHOWSPACES COLOR_RESERVED1
 
// A helper, used as 'userdata' for generating lines in a hexplace_t
// None of the function pointers can be nullptr
struct hexplace_gen_t
{
  // data format to display
  enum data_kind_t
  {
    dk_float,
    dk_int,
    dk_addr_names,
    dk_addr_text,
  };
  enum int_format_t
  {
    if_hex,
    if_signed,
    if_unsigned,
  };
  // result of get_byte_value()
  enum byte_kind_t
  {
    BK_VALID,        // has a valid value
    BK_INVALIDADDR,  // address is invalid
    BK_NOVALUE,      // address is valid but contains no value
  };
 
  virtual bool is_editing() const = 0;
  virtual bool is_editing_text() const = 0;
  virtual bool is_curitem_changed() const = 0;
  virtual bool is_edited_byte(ea_t ea, uint64 *out_value=nullptr) const = 0;
  virtual byte_kind_t get_byte_value(
        ea_t ea,
        uint64 *out_value,
        bool *out_edited) const = 0;
  virtual void get_encoding(qstring *out) const = 0;
  virtual ea_t get_cur_item_ea() const = 0;
  virtual void get_cur_item_text(qstring *out) const = 0;
  virtual int get_alignment() const = 0;
  virtual int get_line_len(ea_t ea) const = 0;
  virtual int get_items_per_line() const = 0;
  virtual int get_bytes_per_item() const = 0;
  virtual int get_item_width(ea_t ea) const = 0;
  virtual data_kind_t get_data_kind() const = 0;
  virtual int_format_t get_int_format() const = 0;
  virtual bool has_central_separator() const = 0;
  virtual bool show_text() const = 0;
  virtual bool show_segaddr() const = 0;
  virtual int get_bitness() const = 0;
 
  bool is_addr_kind() const
  {
    data_kind_t k = get_data_kind();
    return k == dk_addr_names || k == dk_addr_text;
  }
};
 
//-------------------------------------------------------------------------
// class to represent lines in a hex dump window
// one line consists of hv->grid.items_per_line items
// each item is hv->grid.bytes_per_item bytes for 8-bit bytes or one "wide" byte
class hexplace_t : public idaplace_t
{
protected:
  ea_t sol; // EA at start-of-line
public:
  hexplace_t(ea_t _ea, int ln) : idaplace_t(_ea, ln), sol(_ea) {}
  define_place_virtual_functions(hexplace_t);
 
  void out_one_item(
        outctx_base_t &ctx,
        const hexplace_gen_t *hg,
        int itemno,
        color_t *color,
        color_t patch_or_edit) const
  {
    hexplace_t__out_one_item(this, ctx, hg, itemno, color, patch_or_edit);
  }
 
  // convert ea to text
  // use seg:off if segment base is not zero
  // otherwise print just the address
  static size_t ea2str(char *buf, size_t bufsize, const hexplace_gen_t *hg, ea_t ea)
  {
    return hexplace_t__ea2str(buf, bufsize, hg, ea);
  }
 
};
 
//--------------------------------------------------------------------------
#ifndef SWIG
define_place_exported_functions(tiplace_t)
#endif // SWIG
typedef uchar type_t;
typedef uval_t uval_t;
 
//-------------------------------------------------------------------------

typedef uint64 tif_cursor_t;
struct til_type_ref_t;
#define TIF_CURSOR_HEADER tif_cursor_t(-2)
#define TIF_CURSOR_FOOTER tif_cursor_t(-1)
 
inline bool is_tif_cursor_header(tif_cursor_t c) { return c == TIF_CURSOR_HEADER; }
inline bool is_tif_cursor_footer(tif_cursor_t c) { return c == TIF_CURSOR_FOOTER; }
inline bool is_tif_cursor_index(tif_cursor_t c) { return c != TIF_CURSOR_HEADER && c != TIF_CURSOR_FOOTER; }
 
//-------------------------------------------------------------------------
class tiplace_t : public place_t
{
public:
  uint32 ordinal = 0;
  tif_cursor_t cursor = TIF_CURSOR_HEADER;
 
  tiplace_t() {}
  tiplace_t(uint32 ord, tif_cursor_t c, int _lnnum) : ordinal(ord), cursor(c)
  {
    lnnum = _lnnum;
  }
  bool valid_ord() const { return ordinal != 0; }
  void reset() { ordinal = 0; cursor = TIF_CURSOR_HEADER; lnnum = 0; }
 
  bool is_header() const { return cursor == TIF_CURSOR_HEADER; }
  bool is_footer() const { return cursor == TIF_CURSOR_FOOTER; }
  bool is_index()  const { return cursor < TIF_CURSOR_HEADER; }
 
  void set_header() { cursor = TIF_CURSOR_HEADER; }
  void set_footer() { cursor = TIF_CURSOR_FOOTER; }
 
  define_place_virtual_functions(tiplace_t);

  virtual uint64 calc_udm_offset(const void *ud, ssize_t *p_udmidx=nullptr, int *p_bitoff=nullptr) const newapi;

  virtual void set_index_by_offset(void *ud, uint64 offset) newapi;

  virtual type_t get_kind(const void *ud) const newapi;

  virtual bool fill_type_ref(til_type_ref_t *out, const void *ud) const newapi;
};
 
//-------------------------------------------------------------------------
#define PCF_EA_CAPABLE          0x00000001 
#define PCF_MAKEPLACE_ALLOCATES 0x00000002 
 
//-------------------------------------------------------------------------
idaman int ida_export internal_register_place_class(
        const place_t *tmplate,
        int flags,
        const plugin_t *owner,
        int sdk_version);
 
 
//-------------------------------------------------------------------------
inline int register_place_class(
        const place_t *tmplate,
        int flags,
        const plugin_t *owner)
{
  return internal_register_place_class(tmplate, flags, owner, IDA_SDK_VERSION);
}
 
//-------------------------------------------------------------------------
/// Get information about a previously-registered place_t class.
/// See also register_place_class().
/// \param out_flags       output flags (can be nullptr)
/// \param out_sdk_version sdk version the place was created with (can be nullptr)
/// \param id              place class ID
/// \return the place_t template, or nullptr if not found
idaman const place_t *ida_export get_place_class(
        int *out_flags,
        int *out_sdk_version,
        int id);
 
//-------------------------------------------------------------------------
inline const place_t *get_place_class_template(int id)
{
  return get_place_class(nullptr, nullptr, id);
}
 
//-------------------------------------------------------------------------
inline bool is_place_class_ea_capable(int id)
{
  int flags;
  if ( get_place_class(&flags, nullptr, id) == nullptr )
    return false;
  return (flags & PCF_EA_CAPABLE) != 0;
}
 
//-------------------------------------------------------------------------
/// Get the place class ID for the place that has been registered as 'name'.
/// \param name the class name
/// \return the place class ID, or -1 if not found
idaman int ida_export get_place_class_id(const char *name);
 
#ifndef __UI__
  // A TWidget represents any user-facing widget present in IDA.
  // E.g., "IDA View-*", "Hex View-*", "Imports", "General registers", ...
  class TWidget;
#else
  #ifdef __QT__
    namespace QT
    {
      class QWidget;
    };
    typedef QT::QWidget TWidget;
  #else
    class TView;
    typedef TView TWidget;
  #endif
#endif
 
//-------------------------------------------------------------------------
class sync_source_t
{
  uchar storage[16];
 
  const TWidget **get_widget_ptr_storage() const
  {
    return (const TWidget **) &storage[sizeof(storage) - sizeof(TWidget *)];
  }
 
public:
  sync_source_t();
  sync_source_t(const TWidget *_view)
  {
    memset(storage, 0, sizeof(storage));
    *get_widget_ptr_storage() = _view;
    storage[0] = '\0';
  }
  sync_source_t(const char *_regname)
  {
    QASSERT(1716, _regname[0] != '\0');
    memset(storage, 0, sizeof(storage));
    ::qstrncpy((char *) storage, _regname, sizeof(storage));
  }
 
  bool operator==(const sync_source_t &_o) const
  {
    return memcmp(storage, _o.storage, sizeof(storage)) == 0;
  }
  bool operator!=(const sync_source_t &_o) const
  {
    return !((*this) == _o);
  }
 
  bool is_register() const { return storage[0] != '\0'; }
  bool is_widget() const { return !is_register(); }
  const TWidget *get_widget() const
  {
    QASSERT(1717, is_widget());
    return *get_widget_ptr_storage();
  }
  const char *get_register() const
  {
    QASSERT(1718, is_register());
    return (const char *) storage;
  }
};
DECLARE_TYPE_AS_MOVABLE(sync_source_t);
CASSERT(sizeof(sync_source_t) == 16);
typedef qvector<sync_source_t> sync_source_vec_t;
 
struct synced_group_t : public sync_source_vec_t
{
  bool has_widget(const TWidget *v) const { return has(sync_source_t((TWidget *) v)); }
  bool has_register(const char *r) const { return has(sync_source_t(r)); }
  bool has(const sync_source_t &ss) const { return find(ss) != end(); }
};
 
//-------------------------------------------------------------------------
/// with another place type, to be used with the view 'view'. Typically
/// used when views are synchronized.
/// The 'renderer_info_t' part of 'dst' will be pre-filled with
/// the current renderer_info_t of 'view', while the 'place_t' instance
/// will always be nullptr.
enum lecvt_code_t
{
  LECVT_CANCELED = -1,
  LECVT_ERROR = 0,
  LECVT_OK = 1,
};
 
#define LECVT_WITHIN_LISTING 0x1 // only perform conversion if the location is contained in the current listing (e.g., in the decompiler, don't decompile other functions)
typedef lecvt_code_t idaapi lochist_entry_cvt2_t(
        lochist_entry_t *dst,
        const lochist_entry_t &src,
        TWidget *view,
        uint32 flags);
 
//-------------------------------------------------------------------------

idaman void ida_export register_loc_converter2(
        const char *p1,
        const char *p2,
        lochist_entry_cvt2_t *cvt);
 
//-------------------------------------------------------------------------
idaman lochist_entry_cvt2_t *ida_export lookup_loc_converter2(
        const char *p1,
        const char *p2);
 
 
 
//----------------------------------------------------------------------
class twinpos_t
{
public:
  place_t *at; 
  int x;       
  twinpos_t(place_t *t=nullptr, int x0=0) { at=t; x=x0; }
  DEFINE_MEMORY_ALLOCATION_FUNCS()
};

/// A line in a text window
class twinline_t
{
public:
  place_t *at;             
  qstring line;            
  color_t prefix_color;    
  bgcolor_t bg_color;      
  bool is_default = false; 
  twinline_t(place_t *t=nullptr, color_t pc=1, bgcolor_t bc=DEFCOLOR)
    : at(t), prefix_color(pc), bg_color(bc) {}
  DEFINE_MEMORY_ALLOCATION_FUNCS()
};
DECLARE_TYPE_AS_MOVABLE(twinline_t);

typedef qvector<twinline_t> text_t;
 
#ifndef SWIG


#define DECLARE_LINEARRAY_HELPERS(decl) \
decl void  ida_export linearray_t_ctr(linearray_t *, void *ud); \
decl void  ida_export linearray_t_dtr(linearray_t *); \
decl int   ida_export linearray_t_set_place(linearray_t *, const place_t *new_at); \
decl void  ida_export linearray_t_copy_from(linearray_t *, const linearray_t *src); \
decl bool  ida_export linearray_t_beginning(const linearray_t *); \
decl bool  ida_export linearray_t_ending(const linearray_t *); \
decl const qstring *ida_export linearray_t_down(linearray_t *); \
decl const qstring *ida_export linearray_t_up(linearray_t *);
 
class linearray_t;
DECLARE_LINEARRAY_HELPERS(idaman)
#else
#  define DECLARE_LINEARRAY_HELPERS(decl)
#endif // SWIG

class linearray_t
{
  DECLARE_LINEARRAY_HELPERS(friend)
 
  qstrvec_t lines;       // lines corresponding to the current place_t
  place_t *at;
  void *ud;              // user defined data (UD)
                         // its meaning depends on the place_t used
  color_t prefix_color;  // prefix color
  bgcolor_t bg_color;    // background color
  qstring extra;         // the last line of the previous location after moving down
  int dlnnum;            // default line number (if unknown, -1)
  int max_lines;         // max number of lines to generate
 
  int getlines();
  void cleanup();
  int _set_place(const place_t *new_at);
  const qstring *_down();
  const qstring *_up();
  void  _copy_from(const linearray_t *src);
 
public:
 
  linearray_t(void *_ud) { linearray_t_ctr(this, _ud); }
  ~linearray_t()         { linearray_t_dtr(this); }
  DEFINE_MEMORY_ALLOCATION_FUNCS()
 
  
  int set_place(const place_t *new_at)   { return linearray_t_set_place(this, new_at); }

  void copy_from(const linearray_t *src) { linearray_t_copy_from(this, src); }

  place_t *get_place() const             { return at; }

  bgcolor_t get_bg_color() const         { return bg_color; }

  bgcolor_t get_pfx_color() const        { return prefix_color; }

  int get_dlnnum() const                 { return dlnnum; }

  int get_linecnt() const                { return int(lines.size()); }

  void *userdata() const                 { return ud; }

  void set_userdata(void *userd)         { ud = userd; }

  bool beginning() const                 { return linearray_t_beginning(this); }
 
  // Are we at the end?
  bool ending() const                    { return linearray_t_ending(this); }

  const qstring *down()                  { return linearray_t_down(this); }

  const qstring *up()                    { return linearray_t_up(this); }

  void set_max_lines(int n)              { max_lines = n; }
};
 
//-------------------------------------------------------------------------
typedef qvector<const twinline_t*> section_lines_refs_t;
typedef qvector<section_lines_refs_t> sections_lines_refs_t;
 
//-------------------------------------------------------------------------
struct lines_rendering_input_t
{
  int cb = sizeof(*this);
  sections_lines_refs_t sections_lines;       
  const synced_group_t *sync_group = nullptr; 
};
 
//-------------------------------------------------------------------------
//
#define CK_TRACE     80 
#define CK_TRACE_OVL 81 
#define CK_EXTRA1    82 
#define CK_EXTRA2    83 
#define CK_EXTRA3    84 
#define CK_EXTRA4    85 
#define CK_EXTRA5    86 
#define CK_EXTRA6    87 
#define CK_EXTRA7    88 
#define CK_EXTRA8    89 
#define CK_EXTRA9    90 
#define CK_EXTRA10   91 
#define CK_EXTRA11   92 
#define CK_EXTRA12   93 
#define CK_EXTRA13   94 
#define CK_EXTRA14   95 
#define CK_EXTRA15   96 
#define CK_EXTRA16   97 


#define LROEF_MASK      0x00FFFFFF
#define LROEF_FULL_LINE 0x00000000    
#define LROEF_CPS_RANGE 0x00000001    
 
struct line_rendering_output_entry_t
{
  const twinline_t *line;
  uint32 flags;           
 
  // 0x00000000: nothing
  // 0xAABBGGRR: where AA is 0: BBGGRR contains a key (CK_*) to a color property
  // 0xAABBGGRR: where AA is !0: 0xAABBGGRR is the background color, with alpha value, to be applied to that line
  //
  // The 'bg_color' specified here, will be applied on top of the background
  // color that was computed for 'line', which itself can be:
  //   - none (i.e., the default background color),
  //   - a possible value stored in the IDB (see 'set_item_color()'),
  //   - a value provided by processor_t::ev_get_bg_color
  // The value provided here should typically be partly transparent
  // so that it doesn't obstruct the computed background color
  // (the best, by far, is to stick to CK_* keys: their corresponding
  // colors typically have partial translucency, and each theme can
  // customize them.)
  bgcolor_t bg_color;
 
  int cpx;                
  int nchars;             
 
  line_rendering_output_entry_t(const twinline_t *_line, uint32 _flags=0, bgcolor_t _bg_color=0)
    : line(_line), flags(_flags), bg_color(_bg_color), cpx(-1), nchars(-1) {}
 
  line_rendering_output_entry_t(const twinline_t *_line, int _cpx, int _nchars, uint32 _flags, bgcolor_t _bg_color)
    : line(_line), flags(_flags|LROEF_CPS_RANGE), bg_color(_bg_color), cpx(_cpx), nchars(_nchars) {}
 
  bool is_bg_color_empty() const { return bg_color == 0; }
  bool is_bg_color_key() const { return (bg_color & 0xFF000000) == 0 && !is_bg_color_empty(); }
  bool is_bg_color_direct() const { return (bg_color & 0xFF000000) != 0; }
 
  bool operator==(const line_rendering_output_entry_t &r) const
  {
    bool ok = (flags & LROEF_MASK) == (r.flags & LROEF_MASK)
           && line == r.line
           && bg_color == r.bg_color;
    if ( ok && (flags & LROEF_CPS_RANGE) != 0 )
      ok = cpx == r.cpx && nchars == r.nchars;
    return ok;
  }
 
  bool operator!=(const line_rendering_output_entry_t &r) const
  { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(line_rendering_output_entry_t);
typedef qvector<line_rendering_output_entry_t*> line_rendering_output_entries_refs_t;
 
//-------------------------------------------------------------------------
struct lines_rendering_output_t
{
  line_rendering_output_entries_refs_t entries;
  uint32 flags = 0;
 
  ~lines_rendering_output_t()
  {
    clear();
  }
 
  void clear()
  {
    for ( size_t i = 0, n = entries.size(); i < n; ++i )
      delete entries[i];
  }
 
  bool operator==(const lines_rendering_output_t &r) const
  {
    if ( flags != r.flags )
      return false;
    const size_t n = entries.size();
    if ( n != r.entries.size() )
      return false;
    for ( size_t i = 0; i < n; ++i )
      if ( *entries[i] != *r.entries[i] )
        return false;
    return true;
  }
 
  bool operator!=(const lines_rendering_output_t &r) const
  { return !(*this == r); }
 
  void swap(lines_rendering_output_t &r)
  {
    qswap(flags, r.flags);
    entries.swap(r.entries);
  }
};
 
//-------------------------------------------------------------------------
// Represents a range in a line to be displayed in a listing (or graph).
// All coordinates are in codepoints (i.e., not UTF-8 bytes); color
// tags are ignored.
// In other words, coordinates are in "real, visible" glyphs.
typedef int cpidx_t; // codepoint index
typedef int cplen_t; // codepoint length
typedef qvector<cpidx_t> cpidxvec_t;
struct line_section_t
{
  cpidx_t start = -1;
  cplen_t length = -1;
 
 
  bool contains(cpidx_t x) const
  {
    return x >= start && x < start + length;
  }
 
  bool is_open() const { return length < 0; }
  bool is_closed() const { return !is_open(); }
  bool valid() const { return is_closed(); }
 
  bool operator==(const line_section_t &r) const { return start == r.start && length == r.length; }
  bool operator!=(const line_section_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(line_section_t);
typedef qvector<line_section_t> line_sections_t;
 
//-------------------------------------------------------------------------
// A tagged section in a line.
// Note: multiple sections with different tags can overlap.
// For example, the portion of text `[ebp+char_in_main]`:
// <on><opnd1><on><symbol>[<off><symbol><on><reg>ebp<off><reg><on><symbol>+<off><symbol><on><locname>char_in_main<off><locname><on><symbol>]<off><symbol><off><opnd1>
// ^________________________________________________________________________________________________________________________________________________________________^       // a `COLOR_OPND1` section
//           ^_________________________^                                                                                                                                    // a `COLOR_SYMBOL` section
//                                      ^____________________^                                                                                                              // a `COLOR_REG` section
// etc...
struct tagged_line_section_t : public line_section_t
{
  struct
  {
    int text_start = -1; // points right after <on><tag>
    int text_end = -1;   // points right before <off><tag>
  } byte_offsets;
  color_t tag = 0;
 
  tagged_line_section_t() {}
 
  bool operator==(const tagged_line_section_t &r) const
  {
    return this->line_section_t::operator==(r)
        && tag == r.tag
        && byte_offsets.text_start == r.byte_offsets.text_start
        && byte_offsets.text_end == r.byte_offsets.text_end;
  }
  bool operator!=(const tagged_line_section_t &r) const { return !(*this == r); }
 
  bool valid() const
  {
    return line_section_t::valid()
        && tag > 0
        && byte_offsets.text_start > -1
        && byte_offsets.text_end >= byte_offsets.text_start;
  }
 
  bool valid_in(const qstring &in) const
  {
    return valid()
        && byte_offsets.text_start <= in.length()
        && byte_offsets.text_end <= in.length();
  }
 
  bool substr(
        qstring *out,
        const qstring &in,
        const tagged_line_section_t *end = nullptr) const
  {
    bool ok = valid_in(in);
    if ( ok )
    {
      out->qclear();
      int e = byte_offsets.text_end;
      if ( end != nullptr && end->byte_offsets.text_start < e )
        e = end->byte_offsets.text_start;
      out->append(in.c_str() + byte_offsets.text_start,
                  e - byte_offsets.text_start);
    }
    return ok;
  }
 
};
DECLARE_TYPE_AS_MOVABLE(tagged_line_section_t);
typedef qvector<tagged_line_section_t> tagged_line_section_vec_t;
 
//-------------------------------------------------------------------------
// The list of tagged sections corresponding to a line of text in a listing
struct tagged_line_sections_t : public tagged_line_section_vec_t
{
  const tagged_line_section_t *first(color_t tag) const
  {
    for ( const auto &one : *this )
      if ( one.tag == tag )
        return &one;
    return nullptr;
  }
 
  void sections_at(
        tagged_line_sections_t *out,
        cpidx_t x,
        color_t tag=0) const
  {
    for ( const auto &one : *this )
      if ( one.contains(x) && (tag == 0 || one.tag == tag) )
        out->push_back(one);
  }
 
  // For example, '// XREF: __loff_t/r _IO_FILE/r'
  // <on><xref>// XREF: <on><addr:FF001BAC>__loff_t/r <on><addr:FF001BC9>_IO_FILE/r<off><dref>
  // ^___ r1 ________________________________________________________________________________^
  //                    ^ r2                          ^ r3
  // nearest_at(<any p>) --> r1 (because r2 and r3 are zero-length)
  const tagged_line_section_t *nearest_at(
        cpidx_t x,
        color_t tag=0) const
  {
    const tagged_line_section_t *nearest = nullptr;
    for ( const auto &one : *this )
    {
      if ( one.contains(x)
        && (tag == 0 || one.tag == tag)
        && (nearest == nullptr || one.start > nearest->start) )
      {
        nearest = &one;
      }
    }
    return nearest;
  }
 
  // For example, '// XREF: __loff_t/r _IO_FILE/r'
  // <on><xref>// XREF: <on><addr:FF001BAC>__loff_t/r <on><addr:FF001BC9>_IO_FILE/r<off><dref>
  // ^___ r1 ________________________________________________________________________________^
  //              ^ p1  ^ r2               ^ p2       ^ r3                  ^ p3
  // nearest_before(r1, p1, COLOR_ADDR) --> nullptr
  // nearest_before(r1, p2, COLOR_ADDR) --> r2 (zero-length)
  // nearest_before(r1, p3, COLOR_ADDR) --> r3 (zero-length)
  // nearest_after (r1, p1, COLOR_ADDR) --> r2 (zero-length)
  // nearest_after (r1, p2, COLOR_ADDR) --> r3 (zero-length)
  // nearest_after (r1, p3, COLOR_ADDR) --> nullptr
  const tagged_line_section_t *nearest_before(
        const tagged_line_section_t &range,
        cpidx_t start,
        color_t tag=0) const
  {
    const tagged_line_section_t *nearest = nullptr;
    for ( const auto &one : *this )
    {
      if ( range.contains(one.start)
        && one.start <= start
        && (tag == 0 || one.tag == tag)
        && (nearest == nullptr || one.start > nearest->start) )
      {
        nearest = &one;
      }
    }
    return nearest;
  }
  const tagged_line_section_t *nearest_after(
        const tagged_line_section_t &range,
        cpidx_t start,
        color_t tag=0) const
  {
    const tagged_line_section_t *nearest = nullptr;
    for ( const auto &one : *this )
    {
      if ( range.contains(one.start)
        && one.start > start
        && (tag == 0 || one.tag == tag)
        && (nearest == nullptr || one.start < nearest->start) )
      {
        nearest = &one;
      }
    }
    return nearest;
  }
};

struct listing_location_t
{
  int cb = sizeof(*this);
 
  const lochist_entry_t *loc = nullptr;
  const qstring *text = nullptr;
  const tagged_line_sections_t *tagged_sections = nullptr;
};
 
#ifndef SWIG
idaman uint64 ida_export get_dirty_infos();
#endif // SWIG
 


 
idaman void ida_export request_refresh(uint64 mask, bool cnd=true);
inline void clear_refresh_request(uint64 mask) { request_refresh(mask, false); }
 

 
idaman bool ida_export is_refresh_requested(uint64 mask);
 
 
//-------------------------------------------------------------------------
typedef int twidget_type_t; 

#define BWN_UNKNOWN       -1 
#define BWN_EXPORTS        0 
#define BWN_IMPORTS        1 
#define BWN_NAMES          2 
#define BWN_FUNCS          3 
#define BWN_STRINGS        4 
#define BWN_SEGS           5 
#define BWN_SEGREGS        6 
#define BWN_SELS           7 
#define BWN_SIGNS          8 
#define BWN_TILS           9 
#define BWN_TICSR         10 
#define BWN_CALLS         11 
#define BWN_PROBS         12 
#define BWN_BPTS          13 
#define BWN_THREADS       14 
#define BWN_MODULES       15 
#define BWN_TRACE         16 
#define BWN_CALL_STACK    17 
#define BWN_XREFS         18 
#define BWN_SEARCH        19 
#define BWN_FRAME         25 
#define BWN_NAVBAND       26 
#define BWN_DISASM        27 
#define BWN_HEXVIEW       28 
#define BWN_NOTEPAD       29 
#define BWN_OUTPUT        30 
#define BWN_CLI           31 
#define BWN_WATCH         32 
#define BWN_LOCALS        33 
#define BWN_STKVIEW       34 
#define BWN_CHOOSER       35 
#define BWN_SHORTCUTCSR   36 
#define BWN_SHORTCUTWIN   37 
#define BWN_CPUREGS       38 
#define BWN_SO_STRUCTS    39 
#define BWN_SO_OFFSETS    40 
#define BWN_CMDPALCSR     41 
#define BWN_CMDPALWIN     42 
#define BWN_SNIPPETS      43 
#define BWN_CUSTVIEW      44 
#define BWN_ADDRWATCH     45 
#define BWN_PSEUDOCODE    46 
#define BWN_CALLS_CALLERS 47 
#define BWN_CALLS_CALLEES 48 
#define BWN_MDVIEWCSR     49 
#define BWN_DISASM_ARROWS 50 
#define BWN_CV_LINE_INFOS 51 
#define BWN_SRCPTHMAP_CSR 52 
#define BWN_SRCPTHUND_CSR 53 
#define BWN_UNDOHIST      54 
#define BWN_SNIPPETS_CSR  55 
#define BWN_SCRIPTS_CSR   56 
#define BWN_BOOKMARKS     57 
#define BWN_TILIST        58 
#define BWN_TIL_VIEW      59 
#define BWN_TYPE_EDITOR   60 
#define BWN_MICROCODE     61 
#define BWN_XREF_TREE     62 


#define IWID_EXPORTS       (1ULL << BWN_EXPORTS      ) 
#define IWID_IMPORTS       (1ULL << BWN_IMPORTS      ) 
#define IWID_NAMES         (1ULL << BWN_NAMES        ) 
#define IWID_FUNCS         (1ULL << BWN_FUNCS        ) 
#define IWID_STRINGS       (1ULL << BWN_STRINGS      ) 
#define IWID_SEGS          (1ULL << BWN_SEGS         ) 
#define IWID_SEGREGS       (1ULL << BWN_SEGREGS      ) 
#define IWID_SELS          (1ULL << BWN_SELS         ) 
#define IWID_SIGNS         (1ULL << BWN_SIGNS        ) 
#define IWID_TILS          (1ULL << BWN_TILS         ) 
#define IWID_TICSR         (1ULL << BWN_TICSR        ) 
#define IWID_CALLS         (1ULL << BWN_CALLS        ) 
#define IWID_PROBS         (1ULL << BWN_PROBS        ) 
#define IWID_BPTS          (1ULL << BWN_BPTS         ) 
#define IWID_THREADS       (1ULL << BWN_THREADS      ) 
#define IWID_MODULES       (1ULL << BWN_MODULES      ) 
#define IWID_TRACE         (1ULL << BWN_TRACE        ) 
#define IWID_CALL_STACK    (1ULL << BWN_CALL_STACK   ) 
#define IWID_XREFS         (1ULL << BWN_XREFS        ) 
#define IWID_SEARCH        (1ULL << BWN_SEARCH       ) 
#define IWID_FRAME         (1ULL << BWN_FRAME        ) 
#define IWID_NAVBAND       (1ULL << BWN_NAVBAND      ) 
#define IWID_DISASM        (1ULL << BWN_DISASM       ) 
#define IWID_HEXVIEW       (1ULL << BWN_HEXVIEW      ) 
#define IWID_NOTEPAD       (1ULL << BWN_NOTEPAD      ) 
#define IWID_OUTPUT        (1ULL << BWN_OUTPUT       ) 
#define IWID_CLI           (1ULL << BWN_CLI          ) 
#define IWID_WATCH         (1ULL << BWN_WATCH        ) 
#define IWID_LOCALS        (1ULL << BWN_LOCALS       ) 
#define IWID_STKVIEW       (1ULL << BWN_STKVIEW      ) 
#define IWID_CHOOSER       (1ULL << BWN_CHOOSER      ) 
#define IWID_SHORTCUTCSR   (1ULL << BWN_SHORTCUTCSR  ) 
#define IWID_SHORTCUTWIN   (1ULL << BWN_SHORTCUTWIN  ) 
#define IWID_CPUREGS       (1ULL << BWN_CPUREGS      ) 
#define IWID_SO_STRUCTS    (1ULL << BWN_SO_STRUCTS   ) 
#define IWID_SO_OFFSETS    (1ULL << BWN_SO_OFFSETS   ) 
#define IWID_CMDPALCSR     (1ULL << BWN_CMDPALCSR    ) 
#define IWID_CMDPALWIN     (1ULL << BWN_CMDPALWIN    ) 
#define IWID_SNIPPETS      (1ULL << BWN_SNIPPETS     ) 
#define IWID_CUSTVIEW      (1ULL << BWN_CUSTVIEW     ) 
#define IWID_ADDRWATCH     (1ULL << BWN_ADDRWATCH    ) 
#define IWID_PSEUDOCODE    (1ULL << BWN_PSEUDOCODE   ) 
#define IWID_CALLS_CALLERS (1ULL << BWN_CALLS_CALLERS) 
#define IWID_CALLS_CALLEES (1ULL << BWN_CALLS_CALLEES) 
#define IWID_MDVIEWCSR     (1ULL << BWN_MDVIEWCSR    ) 
#define IWID_DISASM_ARROWS (1ULL << BWN_DISASM_ARROWS) 
#define IWID_CV_LINE_INFOS (1ULL << BWN_CV_LINE_INFOS) 
#define IWID_SRCPTHMAP_CSR (1ULL << BWN_SRCPTHMAP_CSR) 
#define IWID_SRCPTHUND_CSR (1ULL << BWN_SRCPTHUND_CSR) 
#define IWID_UNDOHIST      (1ULL << BWN_UNDOHIST     ) 
#define IWID_SNIPPETS_CSR  (1ULL << BWN_SNIPPETS_CSR ) 
#define IWID_SCRIPTS_CSR   (1ULL << BWN_SCRIPTS_CSR  ) 
#define IWID_BOOKMARKS     (1ULL << BWN_BOOKMARKS    ) 
#define IWID_TILIST        (1ULL << BWN_TILIST       ) 
#define IWID_TIL_VIEW      (1ULL << BWN_TIL_VIEW     ) 
#define IWID_TYPE_EDITOR   (1ULL << BWN_TYPE_EDITOR  ) 
#define IWID_XREF_TREE     (1ULL << BWN_XREF_TREE   ) 
 
#define IWID_ANY_LISTING   (IWID_DISASM|IWID_HEXVIEW|IWID_TILIST|IWID_FRAME|IWID_PSEUDOCODE|IWID_CUSTVIEW) 
#define IWID_EA_LISTING    (IWID_DISASM|IWID_HEXVIEW|IWID_PSEUDOCODE) 
#define IWID_ALL           0xFFFFFFFFFFFFFFFFULL       


 
inline bool is_chooser_widget(twidget_type_t t)
{
  return t == BWN_CHOOSER
      || (t >= BWN_EXPORTS && t <= BWN_SEARCH && t != BWN_CALLS)
      || t == BWN_SHORTCUTCSR
      || t == BWN_CMDPALCSR
      || t == BWN_CALLS_CALLERS
      || t == BWN_CALLS_CALLEES
      || t == BWN_MDVIEWCSR
      || t == BWN_SRCPTHMAP_CSR
      || t == BWN_SRCPTHUND_CSR
      || t == BWN_UNDOHIST
      || t == BWN_SNIPPETS_CSR
      || t == BWN_SCRIPTS_CSR
      || t == BWN_BOOKMARKS;
}
 
 
//---------------------------------------------------------------------------
//      D E B U G G I N G   F U N C T I O N S
//---------------------------------------------------------------------------

idaman uint32 ida_export_data debug;


#define IDA_DEBUG_DREFS         0x00000001      
#define IDA_DEBUG_OFFSET        0x00000002      
#define IDA_DEBUG_FLIRT         0x00000004      
#define IDA_DEBUG_IDP           0x00000008      
#define IDA_DEBUG_LDR           0x00000010      
#define IDA_DEBUG_PLUGIN        0x00000020      
#define IDA_DEBUG_IDS           0x00000040      
#define IDA_DEBUG_CONFIG        0x00000080      
#define IDA_DEBUG_CHECKMEM      0x00000100      
#define IDA_DEBUG_LICENSE       0x00000200      
#define IDA_DEBUG_DEMANGLE      0x00000400      
#define IDA_DEBUG_QUEUE         0x00000800      
#define IDA_DEBUG_ROLLBACK      0x00001000      
#define IDA_DEBUG_ALREADY       0x00002000      
#define IDA_DEBUG_TIL           0x00004000      
#define IDA_DEBUG_NOTIFY        0x00008000      
#define IDA_DEBUG_DEBUGGER      0x00010000      
#define IDA_DEBUG_APPCALL       0x00020000      
#define IDA_DEBUG_SRCDBG        0x00040000      
#define IDA_DEBUG_ACCESSIBILITY 0x00080000      
#define IDA_DEBUG_NETWORK       0x00100000      
#define IDA_DEBUG_INTERNET      IDA_DEBUG_NETWORK 
#define IDA_DEBUG_SIMPLEX       0x00200000      
#define IDA_DEBUG_DBGINFO       0x00400000      
#define IDA_DEBUG_LUMINA        0x00800000      
#define IDA_DEBUG_THEMES        0x01000000      
#define IDA_DEBUG_REGEX         0x02000000      
#define IDA_DEBUG_SUBPROC       0x04000000      
#define IDA_DEBUG_RANGECB       0x08000000      
#define IDA_DEBUG_ALWAYS        0xFFFFFFFF      
 
 
#ifndef SWIG

 
AS_PRINTF(1, 2) inline int ida_deb(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  int nbytes = callui(ui_msg, format, va).i;
  va_end(va);
  return nbytes;
}
 
#define deb(ida_debug_bits, ...)           \
  do                                       \
  {                                        \
    if ( (debug & (ida_debug_bits)) != 0 ) \
      ida_deb(__VA_ARGS__);                \
  } while ( false )

 
AS_PRINTF(3, 4) inline void show_hex(
        const void *dataptr,
        size_t len,
        const char *format,
        ...)
{
  va_list va;
  va_start(va,format);
  vshow_hex(dataptr, len, format, va);
  va_end(va);
}
 

 
AS_PRINTF(4, 5) inline void show_hex_file(
        linput_t *li,
        int64 pos,
        size_t count,
        const char *format,
        ...)
{
  va_list va;
  va_start(va,format);
  vshow_hex_file(li, pos, count, format, va);
  va_end(va);
}
#endif // SWIG
 
//-------------------------------------------------------------------------
//      U I   S E R V I C E  F U N C T I O N S
//-------------------------------------------------------------------------

enum action_state_t
{
  AST_ENABLE_ALWAYS,      
 
  AST_ENABLE_FOR_IDB,     
 
  AST_ENABLE_FOR_WIDGET,  
 
  AST_ENABLE,             
 
  AST_DISABLE_ALWAYS,     
  AST_DISABLE_FOR_IDB,    
  AST_DISABLE_FOR_WIDGET, 
  AST_DISABLE,            
};
 

 
inline bool is_action_enabled(action_state_t s)
{
  return s <= AST_ENABLE;
}
 
//-------------------------------------------------------------------------

#define CH_MODAL          0x00000001

#define CH_KEEP           0x00000002
#define CH_MULTI          0x00000004
#define CH_MULTI_EDIT     0x00000008
#define CH_NOBTNS         0x00000010
#define CH_ATTRS          0x00000020
#define CH_UNUSED         0x00000040
#define CH_FORCE_DEFAULT  0x00000080
#define CH_CAN_INS        0x00000100
#define CH_CAN_DEL        0x00000200
#define CH_CAN_EDIT       0x00000400
#define CH_CAN_REFRESH    0x00000800

#define CH_QFLT           0x00001000
#define CH_QFTYP_SHIFT       13
#define CH_QFTYP_DEFAULT     0  
#define CH_QFTYP_NORMAL      (1 << CH_QFTYP_SHIFT) 
#define CH_QFTYP_WHOLE_WORDS (2 << CH_QFTYP_SHIFT) 
#define CH_QFTYP_REGEX       (3 << CH_QFTYP_SHIFT) 
#define CH_QFTYP_FUZZY       (4 << CH_QFTYP_SHIFT) 
#define CH_QFTYP_MASK        (0x7 << CH_QFTYP_SHIFT)

#define CH_NO_STATUS_BAR  0x00010000

#define CH_RESTORE        0x00020000

#define CH_RENAME_IS_EDIT 0x00040000
 
#define CH_BUILTIN_SHIFT 19
#define CH_BUILTIN(id)   ((id+1) << CH_BUILTIN_SHIFT)
#define CH_BUILTIN_MASK  (0x3F << CH_BUILTIN_SHIFT)

#define CH_HAS_DIRTREE     0x02000000
 
#define CH_TM_NO_TREE      0x00000000 
#define CH_TM_FOLDERS_ONLY 0x04000000 
#define CH_TM_FULL_TREE    0x08000000 
#define CH_TM_SHIFT        26
#define CH_TM_MASK         (0x3 << CH_TM_SHIFT)

#define CH_HAS_DIFF        0x10000000

#define CH_NO_SORT         0x20000000

#define CH_NO_FILTER       0x40000000

#define CH_NON_PERSISTED_TREE 0x80000000


#define CH2_LAZY_LOADED 0x0001
#define CH2_HAS_INODE2INDEX 0x0002

#define CHCOL_PLAIN     0x00000000  
#define CHCOL_PATH      0x00010000  
#define CHCOL_HEX       0x00020000  
#define CHCOL_DEC       0x00030000  
#define CHCOL_EA        0x00040000  
#define CHCOL_FNAME     0x00050000  
#define CHCOL_FORMAT    0x00070000  
 
#define CHCOL_DEFHIDDEN 0x00100000  
#define CHCOL_DRAGHINT  0x00200000  
#define CHCOL_INODENAME 0x00400000  
 

#define CHITEM_BOLD          0x0001 
#define CHITEM_ITALIC        0x0002 
#define CHITEM_UNDER         0x0004 
#define CHITEM_STRIKE        0x0008 
#define CHITEM_GRAY          0x0010 

#define CHOOSER_NOMAINMENU  "NOMAINMENU\n"   
#define CHOOSER_NOSTATUSBAR "NOSTATUSBAR\n"  
 
class dirtree_t;

struct chooser_item_attrs_t
{
  int cb;               
  int flags;            
  bgcolor_t color;      
  chooser_item_attrs_t()
    : cb(sizeof(chooser_item_attrs_t)),
      flags(0),
      color(DEFCOLOR) {}
  void reset()      
  {
    cb    = sizeof(chooser_item_attrs_t);
    flags = 0;
    color = DEFCOLOR;
  }
  bool operator==(const chooser_item_attrs_t &other) const
  {
    return cb == other.cb
        && flags == other.flags
        && color == other.color;
  }
};
DECLARE_TYPE_AS_MOVABLE(chooser_item_attrs_t);


/// Row data returned by get_chooser_rows().
struct chooser_row_info_t
{
  qstrvec_t texts;            
  chooser_item_attrs_t attrs; 
  int icon = -1;              
 
  // needed by pywraps
  bool operator==(const chooser_row_info_t &other) const
  {
    return texts == other.texts
        && attrs == other.attrs
        && icon == other.icon;
  }
  bool operator!=(const chooser_row_info_t &other) const
  {
    return !(*this == other);
  }
};
DECLARE_TYPE_AS_MOVABLE(chooser_row_info_t);
typedef qvector<chooser_row_info_t> chooser_row_info_vec_t;


///@{
#define GCRF_HIGH_BIT  (0x8000000000000000ULL) // used to be:
                                               // (size_t(1) << (8 * sizeof(size_t) - 1))
                                               // but SWIG won't swallow the expression
#define GCRF_HEADER    (GCRF_HIGH_BIT | 0)  
#define GCRF_SELECTION (GCRF_HIGH_BIT | 1)  
#define GCRF_CURRENT   (GCRF_HIGH_BIT | 2)  
#define GCRF_ALL       (GCRF_HIGH_BIT | 3)  

struct action_ctx_base_t;
typedef action_ctx_base_t action_update_ctx_t;
struct chooser_stdact_desc_t
{
  int version = 1;      
  const char *label;    
  const char *tooltip;
  int icon;
 
  chooser_stdact_desc_t(
        const char *_label = nullptr,
        const char *_tooltip = nullptr,
        int _icon = -1)
    : label(_label), tooltip(_tooltip), icon(_icon) {}
  virtual ~chooser_stdact_desc_t() {}

  /// 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.
  virtual action_state_t idaapi ucb(action_update_ctx_t * /*ctx*/)
  {
    return AST_ENABLE_FOR_WIDGET;
  }
};

struct chooser_base_t
{
#ifdef SWIG
  %immutable;
#endif
protected:
  uint8 version = 3;  
  uint8 reserved = 0;
  uint16 flags2;      
  uint32 flags;       
 
public:
  // TODO reduce to 4 values
  // embedded chooser: width, height. Other values are ignored.
  // qt: y1 == -2 => minimal height (and centered)
  //     Other values are ignored.
  int x0 = -1;        
  int y0 = -1;
  int x1 = -1;
  int y1 = -1;
  int width = 0;      
  int height = 0;     
 
  const char *title;  
  int columns;        
  const int *widths;  
  const char *const *header;
  int icon = -1;      

  //  Context        | 1 | 2 | 3
  //  ---------------------------
  //  NO_SELECTION   | X | X | X
  //  EMPTY_CHOOSER  | X |   |
  //  ALREADY_EXISTS | X |   |
  static constexpr ssize_t NO_SELECTION   = -1; 
  static constexpr ssize_t EMPTY_CHOOSER  = -2; 
  static constexpr ssize_t ALREADY_EXISTS = -3; 
  static constexpr ssize_t NO_ATTR        = -4; 
 
  enum { POPUP_INS, POPUP_DEL, POPUP_EDIT, POPUP_REFRESH, NSTDPOPUPS };
  qstring popup_names[NSTDPOPUPS];
 
  int deflt_col = 0;  
 
  chooser_base_t(
          uint32 flags_ = 0,
          int columns_ = 0,
          const int *widths_ = nullptr,
          const char *const *header_ = nullptr,
          const char *title_ = nullptr,
          uint16 flags2_ = 0)
    : flags2(flags2_),
      flags(flags_),
      title(title_),
      columns(columns_),
      widths(widths_),
      header(header_) {}
  virtual ~chooser_base_t() {}
  DEFINE_MEMORY_ALLOCATION_FUNCS()
 
  // called when the corresponding widget is destroyed.
  //
  // In some rare cases where multiple chooser_base_t instance can
  // be backed by the same data (\sa get_obj_id), and a second instance
  // is created while the first is already displayed (therefore making
  // that second instance a duplicate), the second instance will be
  // destroyed through this method (and chooser_base_t::ALREADY_EXISTS
  // will be returned from choose().)
  void call_destructor()
  {
    if ( has_widget_lifecycle() )
      delete this;
  }

  virtual void *get_chooser_obj() { return this; }


  virtual const void *get_obj_id(size_t *len) const
  {
    // return the unique id
    *len = 0;
    return nullptr;
  }

  bool is_same(const chooser_base_t *other) const
  {
    size_t len1;
    const void *id1 = get_obj_id(&len1);
    size_t len2;
    const void *id2 = other->get_obj_id(&len2);
    return len1 == len2 && len1 != 0 && memcmp(id1, id2, len1) == 0;
  }

  /// is an operation allowed?
  bool can_ins() const     { return (flags & CH_CAN_INS    ) != 0; }
  bool can_del() const     { return (flags & CH_CAN_DEL    ) != 0; }
  bool can_edit() const    { return (flags & CH_CAN_EDIT   ) != 0; }
  bool can_refresh() const { return (flags & CH_CAN_REFRESH) != 0; }

  bool popup_allowed(int stdact_idx) const
  {
    switch ( stdact_idx )
    {
      case POPUP_INS:     return can_ins();
      case POPUP_DEL:     return can_del();
      case POPUP_EDIT:    return can_edit();
      case POPUP_REFRESH: return can_refresh();
      default:            return false;
    }
  }
  bool is_status_bar_hidden() const { return (flags & CH_NO_STATUS_BAR) != 0; }
  bool should_restore_geometry() const { return (flags & CH_RESTORE) != 0; }
  bool is_modal()         const { return (flags & CH_MODAL) != 0; }
  bool has_widget_lifecycle() const { return (flags & CH_KEEP) == 0; }
  bool is_multi()         const { return (flags & CH_MULTI) != 0; }
  bool ask_item_attrs()   const { return (flags & CH_ATTRS) != 0; }
  bool is_force_default() const { return (flags & CH_FORCE_DEFAULT) != 0; }
  uint get_builtin_number() const
  {
    return ((flags & CH_BUILTIN_MASK) >> CH_BUILTIN_SHIFT) - 1;
  }
  void set_ask_item_attrs(bool enable)
  {
    if ( enable )
      flags |= CH_ATTRS;
    else
      flags &= ~CH_ATTRS;
  }
  // check chooser version
  void check_version(uint32 ver) const { QASSERT(40217, version >= ver); }
  // should the quick filter be visible at startup?
  bool is_quick_filter_visible_initially() const { return (flags & CH_QFLT) != 0; }
  // what mode should the quick filter initially be put in?
  int get_quick_filter_initial_mode() const { return flags & CH_QFTYP_MASK; }
  // does the chooser have the ability to show a tree view?
  bool has_dirtree() const { return (flags & CH_HAS_DIRTREE) != 0; }
  // does the chooser have the ability to participate in a diff/merge workflow?
  bool has_diff_capability() const { return (flags & CH_HAS_DIFF) != 0; }
  // does chooser have sorting abilities?
  bool can_sort() const { return (flags & CH_NO_SORT) == 0; }
  // does chooser have filtering abilities?
  bool can_filter() const { return (flags & CH_NO_FILTER) == 0; }
  // should renaming trigger the 'edit' callback?
  bool should_rename_trigger_edit() const { return (flags & CH_RENAME_IS_EDIT) != 0; }
  // is the chooser dirtree persisted?
  bool is_dirtree_persisted() const { return (flags & CH_NON_PERSISTED_TREE) == 0; }
  // is the chooser lazy-loaded?
  bool is_lazy_loaded() const { return version >= 3 && (flags2 & CH2_LAZY_LOADED) != 0; }
  // chooser_implement inode2index
  bool has_inode_to_index() const { return version >= 3 && (flags2 & CH2_HAS_INODE2INDEX) != 0; }

  virtual bool idaapi init() { return true; }

  virtual size_t idaapi get_count() const = 0;

  virtual void idaapi get_row(
        qstrvec_t *out,
        int *out_icon,
        chooser_item_attrs_t *out_attrs,
        size_t n) const = 0;
 

  virtual ea_t idaapi get_ea(size_t /*n*/) const { return BADADDR; }

  enum cbres_t
  {
    NOTHING_CHANGED,
    ALL_CHANGED,
    SELECTION_CHANGED,
  };

  virtual void idaapi closed() {}
 
protected:
  // the default labels of the standard actions are different for the qt-
  // and txt-versions of the chooser
  void init_popup_names(const char *const default_popup_names[NSTDPOPUPS])
  {
    for ( int i = 0; i < NSTDPOPUPS; ++i )
      if ( popup_names[i].empty() )
        popup_names[i] = default_popup_names[i];
  }
#ifdef SWIG
  %mutable;
#endif
};
 
#ifndef SWIG

struct chooser_t : public chooser_base_t
{
  struct cbret_t
  {
    ssize_t idx;
    cbres_t changed;
    cbret_t() : idx(NO_SELECTION), changed(NOTHING_CHANGED) {}
    cbret_t(ssize_t idx_, cbres_t changed_ = ALL_CHANGED)
      : idx(idx_), changed(changed_) {}
  };
 
  chooser_t(uint32 flags_ = 0,
            int columns_ = 0,
            const int *widths_ = nullptr,
            const char *const *header_ = nullptr,
            const char *title_ = nullptr,
            uint16 flags2_ = 0)
    : chooser_base_t(
              (flags_ & ~CH_MULTI),
              columns_, widths_, header_,
              title_,
              flags2_) {}

  //lint -sem(chooser_t::choose,custodial(t))
  inline ssize_t choose(ssize_t deflt = 0);


  virtual ssize_t idaapi get_item_index(const void *item_data) const newapi
  {
    // no calculation when `item_data` already is an index
    return *(const ssize_t *)item_data;
  }

  typedef cbret_t (idaapi chooser_t::*cb_t)(size_t n);

  /// User asked to insert an element.
  virtual cbret_t idaapi ins(ssize_t /*n*/) newapi { return cbret_t(); }


  virtual cbret_t idaapi del(size_t /*n*/) newapi { return cbret_t(); }

  virtual cbret_t idaapi edit(size_t /*n*/) newapi { return cbret_t(); }

  virtual cbret_t idaapi enter(size_t n) newapi
  {
    cbres_t changed = cbres_t(callui(ui_chooser_default_enter, this, &n).i);
    return cbret_t(n, changed);
  }

  ///                  (as it may change during refresh)
  ///         changed  what is changed
  virtual cbret_t idaapi refresh(ssize_t n) newapi
  {
    return cbret_t(n, ALL_CHANGED);
  }

  virtual void idaapi select(ssize_t /*n*/) const newapi {}

  virtual dirtree_t *idaapi get_dirtree() newapi { return nullptr; }

  virtual inode_t idaapi index_to_inode(size_t /*n*/) const newapi { return inode_t(BADADDR); }

  virtual diffpos_t idaapi index_to_diffpos(size_t /*n*/) const newapi { return diffpos_t(-1); }

  virtual bool idaapi get_stdact_descs(
        chooser_stdact_desc_t * /*descs*/[NSTDPOPUPS]) newapi
  {
    return false;
  }

  /// given dirtree's link() or mkdir() methods to add the folder contents.
  /// \note The dirtree is chdir()-positioned to the directory being loaded,
  /// so relative paths (like simple filenames) may be useful.
  /// \param dt         dirtree used to fill the directory in
  /// \param dir_path   an absolute dirtree path to this directory
  /// \return success
  virtual bool idaapi do_lazy_load_dir(
        dirtree_t * /*dt*/,
        const qstring & /*dir_path*/) newapi
  {
    return false;
  }

  /// Implementing this function will result in increase overall performance
  /// especially for big choosers.
  /// \param inode inode of the item
  /// \return the index
  virtual size_t idaapi inode_to_index(inode_t /*inode*/) const newapi { return size_t(-1); }
 
protected:
  ssize_t new_sel_after_del(size_t n) const
  {
    size_t cnt = get_count();
    // assert: n < cnt
    return n + 1 < cnt
         ? n + 1
         : n - 1; // the last item deleted => no selection
  }
  ssize_t adjust_last_item(size_t n) const
  {
    size_t cnt = get_count();
    if ( cnt == 0 )
      return NO_SELECTION;
    // take in account deleting of the last item(s)
    return n < cnt ? n : cnt - 1;
  }
};

struct chooser_multi_t : public chooser_base_t
{
  chooser_multi_t(
          uint32 flags_ = 0,
          int columns_ = 0,
          const int *widths_ = nullptr,
          const char *const *header_ = nullptr,
          const char *title_ = nullptr,
          uint16 flags2_ = 0)
    : chooser_base_t(
              flags_ | CH_MULTI,
              columns_, widths_, header_,
              title_,
              flags2_) {}

  //lint -sem(chooser_multi_t::choose,custodial(t))
  inline ssize_t choose(const sizevec_t &deflt = sizevec_t());


  virtual void idaapi get_item_index(
        sizevec_t *sel,
        const void *item_data) const newapi
  {
    // no calculation when `item_data` already is a vector
    *sel = *(const sizevec_t *)item_data;
  }

  typedef cbres_t (idaapi chooser_multi_t::*cb_t)(sizevec_t *sel);

  virtual cbres_t idaapi ins(sizevec_t * /*sel*/) newapi
  {
    return NOTHING_CHANGED;
  }

  virtual cbres_t idaapi del(sizevec_t * /*sel*/) newapi
  {
    return NOTHING_CHANGED;
  }


  virtual cbres_t idaapi edit(sizevec_t * /*sel*/) newapi
  {
    return NOTHING_CHANGED;
  }


  virtual cbres_t idaapi enter(sizevec_t *sel) newapi
  {
    return cbres_t(callui(ui_chooser_default_enter, this, sel).i);
  }


  virtual cbres_t idaapi refresh(sizevec_t * /*sel*/) newapi
  {
    return ALL_CHANGED;
  }

  virtual void idaapi select(const sizevec_t &/*sel*/) const newapi {}

  virtual dirtree_t *idaapi get_dirtree() newapi { return nullptr; }

  virtual inode_t idaapi index_to_inode(size_t /*n*/) const newapi { return inode_t(BADADDR); }

  virtual diffpos_t idaapi index_to_diffpos(size_t /*n*/) const newapi { return diffpos_t(-1); }

  virtual bool idaapi get_stdact_descs(
        chooser_stdact_desc_t * /*descs*/[NSTDPOPUPS]) newapi
  {
    return false;
  }

  /// given dirtree's link() or mkdir() methods to add the folder contents.
  /// \note The dirtree is chdir()-positioned to the directory being loaded,
  /// so relative paths (like simple filenames) may be useful.
  /// \param dt         dirtree used to fill the directory in
  /// \param dir_path   an absolute dirtree path to this directory
  /// \return success
  virtual bool idaapi do_lazy_load_dir(
        dirtree_t * /*dt*/,
        const qstring & /*dir_path*/) newapi
  {
    return false;
  }

  /// Implementing this function will result in increase overall performance
  /// especially for big choosers.
  /// \param inode inode of the item
  /// \return the index
  virtual size_t idaapi inode_to_index(inode_t /*inode*/) const newapi { return size_t(-1); }
 
protected:
  // used in the del() callback to iterate
  static bool next_item_to_del(sizevec_t *sel);
  ssize_t new_sel_after_del(const sizevec_t &sel) const;
  void adjust_last_item(sizevec_t *sel, size_t n) const;
};
 

struct textctrl_info_t
{
  size_t  cb;                 
  qstring text;               
  uint16  flags;              

#define TXTF_AUTOINDENT  0x0001 
#define TXTF_ACCEPTTABS  0x0002 
#define TXTF_READONLY    0x0004 
#define TXTF_SELECTED    0x0008 
#define TXTF_MODIFIED    0x0010 
#define TXTF_FIXEDFONT   0x0020 
#define TXTF_LINENUMBERS 0x0040 
#define TXTF_HTML        0x0080 
  uint16  tabsize;            
  textctrl_info_t(): cb(sizeof(textctrl_info_t)), flags(0), tabsize(0) {} 
};

 


 
//lint -sem(choose,custodial(1))
ssize_t choose(chooser_base_t *ch, const void *def_item);
 
inline ssize_t chooser_t::choose(ssize_t deflt)
{
  // chooser uses the default implementation of the get_item_index()
  // callback
  return ::choose(this, &deflt);
}
 
inline ssize_t chooser_multi_t::choose(const sizevec_t &deflt)
{
  // chooser uses the default implementation of the get_item_index()
  // callback
  return ::choose(this, &deflt);
}

 
#endif // SWIG
 
//-------------------------------------------------------------------------
enum navaddr_type_t
{
  nat_lib = 0,
  nat_fun,
  nat_cod,
  nat_dat,
  nat_und,
  nat_ext,
  nat_err,
  nat_gap,
  nat_cur,
  nat_auto, // auto-analysis cursor color
  nat_lum,  // related to lumina
  nat_hlo,  // highlight outline
  nat_last
};


 
typedef uint32 idaapi nav_colorizer_t(ea_t ea, asize_t nbytes, void *ud);
 

 
inline void set_nav_colorizer(
        nav_colorizer_t **out_was_func,
        void **out_was_ud,
        nav_colorizer_t *func,
        void *ud)
{
  callui(ui_set_nav_colorizer, out_was_func, out_was_ud, func, ud);
}

/// Custom viewer & code viewer handler types
enum custom_viewer_handler_id_t
{
  CVH_USERDATA,
  CVH_KEYDOWN,               
  CVH_POPUP,                 
  CVH_DBLCLICK,              
  CVH_CURPOS,                
  CVH_CLOSE,                 
  CVH_CLICK,                 
  CVH_QT_AWARE,              
  CVH_HELP,                  
  CVH_MOUSEMOVE,             
 
  CDVH_USERDATA = 1000,      
  CDVH_SRCVIEW,              
  CDVH_LINES_CLICK,          
  CDVH_LINES_DBLCLICK,       
  CDVH_LINES_POPUP,          
  CDVH_LINES_DRAWICON,       
  CDVH_LINES_LINENUM,        
  CDVH_LINES_ICONMARGIN,     
  CDVH_LINES_RADIX,          
  CDVH_LINES_ALIGNMENT       
};
 
//-------------------------------------------------------------------------
#define VES_SHIFT        (1 << 0)
#define VES_ALT          (1 << 1)
#define VES_CTRL         (1 << 2)
#define VES_MOUSE_LEFT   (1 << 3)
#define VES_MOUSE_RIGHT  (1 << 4)
#define VES_MOUSE_MIDDLE (1 << 5)
#define VES_META         (1 << 7)
typedef int input_event_modifiers_t;
typedef input_event_modifiers_t view_event_state_t;
 
//-------------------------------------------------------------------------
enum msg_notification_t
{
  msg_activated,    
 
  msg_deactivated,  
 
  msg_click,        
 
  msg_dblclick,     
 
  msg_closed,       
 
  msg_keydown,      
};
 
//-------------------------------------------------------------------------
struct renderer_pos_info_t
{
  renderer_pos_info_t() : node(-1), cx(-1), cy(-1), sx(-1) {}
 
  int node; 

 
  short cx; 
            ///< When in graph mode: X coords of the character in 'node'.       \n
            ///< When in flat mode: X coords of the character in the line, w/o  \n
            ///< taking scrolling into consideration.
 
  short cy; 
 
  short sx; 
 
  bool operator == (const renderer_pos_info_t &r) const
    { return node == r.node && cx == r.cx && cy == r.cy && sx == r.sx; }
  bool operator != (const renderer_pos_info_t &r) const
    { return !(*this == r); }
};
 
//-------------------------------------------------------------------------
struct selection_item_t;
 
//-------------------------------------------------------------------------

/// (out of 'view_mouse_event_t' to make it easy for SWiG to wrap)
union view_mouse_event_location_t
{
  ea_t ea;                        
  const selection_item_t *item;   
};
 

struct view_mouse_event_t
{
  tcc_renderer_type_t rtype;        
 
  uint32 x;                         
  uint32 y;                         
 
  typedef view_mouse_event_location_t location_t;
  location_t location;              
 
  view_event_state_t state;         
 
  vme_button_t button;              
 
  renderer_pos_info_t renderer_pos; 
};
 
//-------------------------------------------------------------------------
enum view_notification_t
{
  view_activated,    
 
  view_deactivated,  
 
  view_keydown,      
                     ///< \param view   (TWidget *)
                     ///< \param key    (int)
                     ///< \param state  (::view_event_state_t)
 
  view_click,        
 
  view_dblclick,     
 
  view_curpos,       
 
  view_created,      
 
  view_close,        
 
  view_switched,     
 
  view_mouse_over,   
 
  view_loc_changed,  
 
  view_mouse_moved,  
};
 
#ifndef SWIG

 
typedef bool idaapi custom_viewer_keydown_t(TWidget *cv, int vk_key, int shift, void *ud);
 

 
typedef void idaapi custom_viewer_popup_t(TWidget *cv, void *ud);
 

 
typedef void idaapi custom_viewer_mouse_moved_t(TWidget *cv, int shift, view_mouse_event_t *e, void *ud);
 

 
typedef bool idaapi custom_viewer_click_t(TWidget *cv, int shift, void *ud);
 

 
typedef bool idaapi custom_viewer_dblclick_t(TWidget *cv, int shift, void *ud);
 

 
typedef void idaapi custom_viewer_curpos_t(TWidget *cv, void *ud);
 

 
typedef void idaapi custom_viewer_close_t(TWidget *cv, void *ud);
 
 
// obsolete
 
typedef int idaapi obsolete_custom_viewer_help_t(TWidget *cv, void *ud);
 

 
typedef bool idaapi custom_viewer_help_t(qstring *out, TWidget *cv, void *ud);
 

 
typedef void idaapi custom_viewer_adjust_place_t(TWidget *v, lochist_entry_t *loc, void *ud);
 

 
typedef int idaapi custom_viewer_get_place_xcoord_t(TWidget *v, const place_t *pline, const place_t *pitem, void *ud);
 
 
enum locchange_reason_t
{
  lcr_unknown,
  lcr_goto,
  lcr_user_switch, // user pressed <Space>
  lcr_auto_switch, // automatic switch
  lcr_jump,
  lcr_navigate,    // navigate back & forward
  lcr_scroll,      // user used scrollbars
  lcr_internal,    // misc. other reasons
};
 
#define LCMD_SYNC (1 << 0)
class locchange_md_t // location change metadata
{
protected:
  uchar cb;
  uchar r;
  uchar f;
  uchar reserved;
 
public:
  locchange_md_t(locchange_reason_t _reason, bool _sync)
    : cb(sizeof(*this)), r(uchar(_reason)), f(_sync ? LCMD_SYNC : 0), reserved(0) {}
  locchange_reason_t reason() const { return locchange_reason_t(r); }
  bool is_sync() const { return (f & LCMD_SYNC) != 0; }
};
CASSERT(sizeof(locchange_md_t) == sizeof(uint32));
DECLARE_TYPE_AS_MOVABLE(locchange_md_t);

///
/// This gives the view the possibility of declining the move.
/// Reasons for this can be:
///  - the location cannot be displayed,
///  - going there requires a long-running operation, that can be
///    canceled by the user (e.g., in case of the hexrays plugins:
///    during decompilation of the target function.)
///  - ...
///
/// This is called before the new location is committed to the view's history.
///
/// return
///    0 if the move is accepted
///    != 0 otherwise
 
typedef int idaapi custom_viewer_can_navigate_t(
        TWidget *v,
        const lochist_entry_t *now,
        const locchange_md_t &md,
        void *ud);
 

 
typedef void idaapi custom_viewer_location_changed_t(
        TWidget *v,
        const lochist_entry_t *was,
        const lochist_entry_t *now,
        const locchange_md_t &md,
        void *ud);
 
 
// Code viewer handlers for the lineinfo widget located to the left of the text.

 
typedef void idaapi code_viewer_lines_click_t(TWidget *c, const place_t *p, int pos, int shift, void *ud);
 

 
typedef int idaapi code_viewer_lines_icon_t(TWidget *cv, const place_t *p, int *pos, void *ud);
 

 
typedef bool idaapi code_viewer_lines_linenum_t(TWidget *cv, const place_t *p, uval_t *num, void *ud);
 
#endif // SWIG
 
//-------------------------------------------------------------------------
enum input_event_kind_t
{
  iek_unknown = 0,
  iek_shortcut,
  iek_key_press,
  iek_key_release,
  iek_mouse_button_press,
  iek_mouse_button_release,
  iek_mouse_wheel,
};
 
//-------------------------------------------------------------------------

 
struct input_event_t
{
  int cb;                            
  input_event_kind_t kind;           
  input_event_modifiers_t modifiers; 
  TWidget *target;                   
  void *source;                      
 
  struct input_event_shortcut_data_t
  {
    const char *action_name;         
  };
  struct input_event_keyboard_data_t
  {
    int key;                         
    char text[8];                    
  };
  struct input_event_mouse_data_t
  {
    int x;                           
    int y;                           
    vme_button_t button;             
  };
 
  union
  {
    input_event_shortcut_data_t shortcut;
    input_event_keyboard_data_t keyboard;
    input_event_mouse_data_t mouse;
  };
 
  input_event_t()
  {
    memset(this, 0, sizeof(*this));
    cb = sizeof(*this);
  }
};
 
//------------------------------------------------------------------------

/// Command line interpreter.
/// Provides functionality for the command line (located at the bottom of the main window).
/// Only GUI version of IDA supports CLIs.
struct cli_t
{
  size_t size;                  
  int32 flags;                  
#define CLIF_QT_AWARE    1      
  const char *sname;            
  const char *lname;            
  const char *hint;             

  bool (idaapi *execute_line)(const char *line);
  bool (idaapi *keydown)(
        qstring *line,
        int *p_x,
        int *p_sellen,
        int *p_vk_key,
        int shift);

  bool (idaapi *find_completions)(
          qstrvec_t *out_completions,
          qstrvec_t *out_hints,
          qstrvec_t *out_docs,
          int *out_match_start,
          int *out_match_end,
          const char *line,
          int x);
};
 
//---------------------------------------------------------------------------
#define MFF_FAST   0x0000       
 
#define MFF_READ   0x0001       
 
#define MFF_WRITE  0x0002       
 
#define MFF_NOWAIT 0x0004       
 

struct exec_request_t
{
  enum { MFF_MAGIC = 0x12345678 };

  bool valid() const
  {
    return (code & ~7) == MFF_MAGIC && (sem != nullptr || (code & MFF_NOWAIT) != 0);
  }
 
  ssize_t code = 0;   
  qsemaphore_t sem = nullptr;

  virtual ssize_t idaapi execute() = 0;

  virtual ~exec_request_t() { qsem_free(sem); sem = nullptr; code = 0; }
};
 
//---------------------------------------------------------------------------
class ui_request_t
{
public:

  virtual bool idaapi run() = 0;
  virtual ~ui_request_t() {}
};

class ui_requests_t : public qlist<ui_request_t *>
{
  DECLARE_UNCOPYABLE(ui_requests_t)
public:
  ui_requests_t() {}  
  ~ui_requests_t()    
  {
    for ( iterator p=begin(); p != end(); ++p )
      delete *p;
  }
};

typedef void idaapi ss_restore_cb_t(const char *errmsg, void *ud);

#define UIJMP_ACTIVATE        0x0001  
#define UIJMP_DONTPUSH        0x0002  

#define UIJMP_VIEWMASK        0x000C
#define UIJMP_ANYVIEW         0x0000  
#define UIJMP_IDAVIEW         0x0004  
#define UIJMP_IDAVIEW_NEW     0x0008  
 
class interactive_graph_t;
struct screen_graph_selection_t;
struct dirtree_selection_t;
 
//-------------------------------------------------------------------------
// Current selection
struct action_ctx_base_cur_sel_t
{
  twinpos_t from;      
  twinpos_t to;        
 
  action_ctx_base_cur_sel_t() { reset(); }
  void reset()
  {
    from.at = nullptr;
    from.x = -1;
    to.at = nullptr;
    to.x = -1;
  }
};
 
//-------------------------------------------------------------------------
struct action_ctx_base_t
{
  action_ctx_base_t()
  {
    reset();
  }

/// used by action_ctx_base_t::cur_flags
///@{
#define ACF_HAS_SELECTION               (1 << 0) 
#define ACF_XTRN_EA                     (1 << 1) 
#define ACF_HAS_FIELD_DIRTREE_SELECTION (1 << 2) 
#define ACF_HAS_SOURCE                  (1 << 3) 
#define ACF_HAS_TYPE_REF                (1 << 4) 


  void reset()
  {
    widget = nullptr;
    widget_type = BWN_UNKNOWN;
    widget_title.clear();
    chooser = nullptr;
    chooser_selection.clear();
    action = nullptr;
 
    //
    cur_flags = ACF_HAS_FIELD_DIRTREE_SELECTION | ACF_HAS_SOURCE | ACF_HAS_TYPE_REF;
    cur_ea = BADADDR;
    cur_value = BADADDR;
    cur_func = cur_fchunk = nullptr;
    cur_seg = nullptr;
    cur_sel.reset();
    regname = nullptr;
    focus = nullptr;
    graph = nullptr;
    graph_selection = nullptr;
    dirtree_selection = nullptr;
    type_ref = nullptr;
  }
  TWidget *widget;
  twidget_type_t widget_type;     
  qstring widget_title;           
  chooser_base_t *chooser;        
  sizevec_t chooser_selection;    
 
  const char *action;             
 
  uint32 cur_flags; 

  bool has_flag(uint32 flag) const { return (cur_flags & flag) == flag; }
 
  ea_t cur_ea;           
  uval_t cur_value;      
 
  func_t *cur_func;      
  func_t *cur_fchunk;    
 
  segment_t *cur_seg;    
 
  action_ctx_base_cur_sel_t cur_sel; 
 
  const char *regname;   
 
  TWidget *focus;        
 
  interactive_graph_t *graph; 
  screen_graph_selection_t *graph_selection; 
  const selection_item_t *hovered; 
 
  dirtree_selection_t *dirtree_selection; 
 
  til_type_ref_t *type_ref; 
};
 
//-------------------------------------------------------------------------
typedef action_ctx_base_t action_activation_ctx_t;
 
//-------------------------------------------------------------------------

typedef action_ctx_base_t action_update_ctx_t;
 
#define AHF_VERSION 1          
#define AHF_VERSION_MASK 0xFF  
 
//-------------------------------------------------------------------------
struct action_handler_t
{
  int flags;  

  action_handler_t(int _f = 0) : flags(_f) { flags |= AHF_VERSION; }

  /// It is called when the action is triggered, from a menu, from
  /// a popup menu, from the toolbar, or programmatically.
  /// \return non-zero: all IDA windows will be refreshed
  virtual int idaapi activate(action_activation_ctx_t *ctx) = 0;

  virtual action_state_t idaapi update(action_update_ctx_t *ctx) = 0;

  virtual ~action_handler_t() {}
 
  // Action handles may be allocated by a plugin and deleted by the kernel.
  // Therefore it is a good idea to unify the memory allocation methods.
  DEFINE_MEMORY_ALLOCATION_FUNCS();
};

struct action_desc_t
{
  int cb;                    
  const char *name;          
 
  const char *label;         
 
  action_handler_t *handler; 
 
  const void *owner;         
 
  const char *shortcut;      
  const char *tooltip;       
  int icon;                  

#define ADF_OWN_HANDLER   0x01  
#define ADF_NO_UNDO       0x02  
#define ADF_OT_MASK       0x0C  
#define ADF_OT_PLUGIN     0x00  
#define ADF_OT_PLUGMOD    0x04  
#define ADF_OT_PROCMOD    0x08  
#define ADF_GLOBAL        0x10  
#define ADF_NO_HIGHLIGHT  0x20  
#define ADF_CHECKABLE     0x40  
#define ADF_CHECKED       0x80  
  int flags;                 
};

#define ACTION_DESC_LITERAL_PLUGMOD(name, label, handler, plgmod, shortcut, tooltip, icon) \
  { sizeof(action_desc_t), name, label, handler, plgmod, shortcut, tooltip, icon, ADF_OT_PLUGMOD }

#define ACTION_DESC_LITERAL_PROCMOD(name, label, handler, prcmod, shortcut, tooltip, icon) \
  { sizeof(action_desc_t), name, label, handler, prcmod, shortcut, tooltip, icon, ADF_OT_PROCMOD }

#define ACTION_DESC_LITERAL_OWNER(name, label, handler, owner, shortcut, tooltip, icon, flags) \
  { sizeof(action_desc_t), name, label, handler, owner, shortcut, tooltip, icon, flags }

#define DYNACTION_DESC_LITERAL(label, handler, shortcut, tooltip, icon) \
  { sizeof(action_desc_t), nullptr, label, handler, nullptr, shortcut, tooltip, icon, ADF_OWN_HANDLER }

enum action_attr_t
{
  AA_NONE,        
  AA_LABEL,       
  AA_SHORTCUT,    
  AA_TOOLTIP,     
  AA_ICON,        
  AA_STATE,       
  AA_CHECKABLE,   
  AA_CHECKED,     
  AA_VISIBILITY,  
};
 
#ifndef SWIG
// Handlers to be used with create_custom_viewer()
class custom_viewer_handlers_t
{
  int cb;
public:
  inline constexpr custom_viewer_handlers_t(
          custom_viewer_keydown_t *_keyboard = nullptr,
          custom_viewer_popup_t *_popup = nullptr,
          custom_viewer_mouse_moved_t *_mouse_moved = nullptr,
          custom_viewer_click_t *_click = nullptr,
          custom_viewer_dblclick_t *_dblclick = nullptr,
          custom_viewer_curpos_t *_curpos = nullptr,
          custom_viewer_close_t *_close = nullptr,
          custom_viewer_help_t *_help = nullptr,
          custom_viewer_adjust_place_t *_adjust_place = nullptr,
          custom_viewer_get_place_xcoord_t *_get_place_xcoord = nullptr,
          custom_viewer_location_changed_t *_location_changed = nullptr,
          custom_viewer_can_navigate_t *_can_navigate = nullptr)
    : cb(sizeof(*this)),
      keyboard(_keyboard),
      popup(_popup),
      mouse_moved(_mouse_moved),
      click(_click),
      dblclick(_dblclick),
      curpos(_curpos),
      close(_close),
      obsolete_help(nullptr),
      adjust_place(_adjust_place),
      get_place_xcoord(_get_place_xcoord),
      location_changed(_location_changed),
      can_navigate(_can_navigate),
      help(_help)
  {}
  custom_viewer_keydown_t *keyboard;
  custom_viewer_popup_t *popup;
  custom_viewer_mouse_moved_t *mouse_moved;
  custom_viewer_click_t *click;
  custom_viewer_dblclick_t *dblclick;
  custom_viewer_curpos_t *curpos;
  custom_viewer_close_t *close;
  obsolete_custom_viewer_help_t *obsolete_help;
  custom_viewer_adjust_place_t *adjust_place;
  custom_viewer_get_place_xcoord_t *get_place_xcoord;
  custom_viewer_location_changed_t *location_changed;
  custom_viewer_can_navigate_t *can_navigate;
  custom_viewer_help_t *help;
 
  int size() const { return cb; }
};
#endif // SWIG
 
 
#ifndef __UI__         // Not for the UI
 
// Convenience functions offered by the user interface

 
THREAD_SAFE inline int execute_ui_requests(ui_requests_t *reqs)
{
  return callui(ui_execute_ui_requests_list, reqs).i;
}
 

/// \return a request id: a unique number that can be used to cancel the request
 
THREAD_SAFE inline int execute_ui_requests(ui_request_t *req, ...)
{
  va_list va;
  va_start(va, req);
  int req_id = callui(ui_execute_ui_requests, req, va).i;
  va_end(va);
  return req_id;
}
 

 
THREAD_SAFE inline bool cancel_exec_request(int req_id)
{
  return callui(ui_execute_sync_ctl, esctl_cancel_request, req_id).cnd;
}
 

 
THREAD_SAFE inline int cancel_thread_exec_requests(qthread_t tid)
{
  return callui(ui_execute_sync_ctl, esctl_cancel_thread_requests, tid).i;
}
 

/// 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.
///
/// \param tid thread id
/// \param availability the availability
/// \return the previous availability
 
THREAD_SAFE inline execute_sync_availability_t set_execute_sync_availability(
        qthread_t tid,
        execute_sync_availability_t availability)
{
  auto i = callui(ui_execute_sync_ctl, esctl_set_availability, tid, availability).i;
  return execute_sync_availability_t(i);
}
 

/// Get the group of widgets/registers
/// this view is synchronized with
/// \param w the widget
/// \return the group of widgets/registers, or nullptr
 
inline const synced_group_t *get_synced_group(const TWidget *w)
{
  return (synced_group_t *) callui(ui_get_synced_group, w).vptr;
}

/// \return success
 
inline bool jumpto(ea_t ea, int opnum=-1, int uijmp_flags=UIJMP_ACTIVATE)
{
  return callui(ui_jumpto, ea, opnum, uijmp_flags).cnd;
}
 

/// \retval 0    esc was pressed
 
inline bool banner(int wait)               { return callui(ui_banner, wait).cnd; }
 

 
THREAD_SAFE inline bool is_msg_inited() { return callui(ui_is_msg_inited).cnd; }
 

 
inline void refresh_idaview()          { callui(ui_refreshmarked); }
 

 
inline void refresh_idaview_anyway()   { callui(ui_refresh); }
 

 
inline void analyzer_options()         { callui(ui_analyzer_options); }
 

 
inline ea_t get_screen_ea()            { ea_t ea; callui(ui_screenea, &ea); return ea; }
 

 
inline int get_opnum()                 { return callui(ui_get_opnum).i; }
 

 
inline bool get_cursor(int *x, int *y)     { return callui(ui_get_cursor, x, y).cnd; }
 

 
inline bool get_output_cursor(int *x, int *y) { return callui(ui_get_output_cursor, x, y).cnd; }
 

 
inline const char *get_curline()       { return callui(ui_get_curline).cptr; }
 

 
inline void open_url(const char *url)      { callui(ui_open_url, url); }
 

 
inline ea_t get_hexdump_ea(int hexdump_num) { ea_t ea; callui(ui_hexdumpea, &ea, hexdump_num); return ea; }
 

 
inline ushort get_key_code(const char *keyname) { return callui(ui_get_key_code, keyname).i16; }
 

 
inline ushort lookup_key_code(int key, int shift, bool is_qt) { return callui(ui_lookup_key_code, key, shift, is_qt).i16; }
 

 
inline void refresh_navband(bool force)     { callui(ui_refresh_navband, force); }
 

 
inline bool refresh_chooser(const char *title) { return callui(ui_refresh_chooser, title).cnd; }
 

 
inline bool close_chooser(const char *title) { return callui(ui_close_chooser, title).cnd; }
 

 
inline void install_command_interpreter(const cli_t *cp) { callui(ui_install_cli, cp, true); }
 

 
inline void remove_command_interpreter(const cli_t *cp) { callui(ui_install_cli, cp, false); }
 

 
inline void gen_disasm_text(text_t &text, ea_t ea1, ea_t ea2, bool truncate_lines) { callui(ui_gen_disasm_text, &text, ea1, ea2, truncate_lines); }
 

 
THREAD_SAFE inline ssize_t execute_sync(exec_request_t &req, int reqf) { return callui(ui_execute_sync, &req, reqf).ssize; }
 

 
inline bool set_dock_pos(const char *src_ctrl, const char *dest_ctrl, int orient, int left = 0, int top = 0, int right = 0, int bottom = 0)
{
  return callui(ui_set_dock_pos, src_ctrl, dest_ctrl, orient, left, top, right, bottom).cnd;
}

 
inline int get_icon_id_by_name(const char *icon_name) { return callui(ui_get_icon_id_by_name, icon_name).i; }


 
inline int load_custom_icon(const char *file_name) { return callui(ui_load_custom_icon_file, file_name).i; }
 

 
inline int load_custom_icon(const void *ptr, unsigned int len, const char *format) { return callui(ui_load_custom_icon, ptr, len, format).i; }
 

 
inline void free_custom_icon(int icon_id) { callui(ui_free_custom_icon, icon_id); }
 

 
inline bool process_ui_action(const char *name, int flags=0, void *param=nullptr)
{
  return callui(ui_process_action, name, flags, param).cnd;
}
 

///                   - out: filename, id
/// \param err_msg  optional error msg buffer
/// \return success
 
inline bool take_database_snapshot(
        snapshot_t *ss,
        qstring *err_msg)
{
  return callui(ui_take_database_snapshot, ss, err_msg).cnd;
}
 

/// Note: This call is asynchronous. When it is completed, the callback will be triggered.
/// \param ss  snapshot instance (see build_snapshot_tree())
/// \param cb  A callback that will be triggered with a nullptr string.
///             on success and an actual error message on failure.
/// \param ud  user data passed to be passed to the callback
/// \return false if restoration could not be started (snapshot file was not found).  \n
///         If the returned value is True then check if the operation succeeded from the callback.
 
inline bool restore_database_snapshot(
        const snapshot_t *ss,
        ss_restore_cb_t *cb,
        void *ud)
{
  return callui(ui_restore_database_snapshot, ss, cb, ud).cnd;
}

typedef struct __qtimer_t {} *qtimer_t;
 


 
THREAD_SAFE inline qtimer_t register_timer(
        int interval_ms,
        int (idaapi *callback)(void *ud),
        void *ud)
{
  return (qtimer_t)(callui(ui_register_timer, interval_ms, callback, ud).vptr);
}
 

/// Unregister a timer (::ui_unregister_timer).
/// \param t handle to a registered timer
/// \return success
 
THREAD_SAFE inline bool unregister_timer(qtimer_t t)
{
  return callui(ui_unregister_timer, t).cnd;
}
 
//-------------------------------------------------------------------------

/// 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.
/// \param desc action to register
/// \return success
 
inline bool register_action(const action_desc_t &desc)
{
  return callui(ui_register_action, &desc).cnd;
}
 

 
inline bool unregister_action(const char *name)
{
  return callui(ui_unregister_action, name).cnd;
}
 

inline void get_registered_actions(qstrvec_t *out)
{
  callui(ui_get_registered_actions, out);
}
 

/// \param before if non-nullptr, the toolbar before which the new toolbar will be inserted
/// \param flags a combination of \ref CREATETB_, to determine toolbar position
/// \return success
inline bool create_toolbar(
        const char *name,
        const char *label,
        const char *before = nullptr,
        int flags = 0)
{
  return callui(ui_create_toolbar, name, label, before, flags).cnd;
}
 

inline bool delete_toolbar(const char *name)
{
  return callui(ui_delete_toolbar, name).cnd;
}
 

/// 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:
/// \code
///   // The new 'My menu' submenu will appear in the 'Comments' submenu
///   // before the 'Enter comment..." command
///   create_menu("(...)", "My menu", "Edit/Comments/Enter comment...");
/// \endcode
/// or
/// \code
///   // The new 'My menu' submenu will appear at the end of the
///   // 'Comments' submenu.
///   create_menu("(...)", "My menu", "Edit/Comments/");
/// \endcode
/// If the above fails, the new menu will be appended to the menubar.
/// \param name name of menu (must be unique)
/// \param label label of menu
/// \param menupath where should the menu be inserted
/// \return success
inline bool create_menu(
        const char *name,
        const char *label,
        const char *menupath=nullptr)
{
  return callui(ui_create_menu, name, label, menupath).cnd;
}
 

inline bool delete_menu(const char *name)
{
  return callui(ui_delete_menu, name).cnd;
}
 

/// If you want to modify the debugger menu, do it at the ui_debugger_menu_change
/// event (ida might destroy your menu item if you do it elsewhere).
/// \param menupath  path to the menu item after or before which the insertion will take place.  \n
///                    - 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
/// \param name      the action name
/// \param flags     a combination of \ref SETMENU_, to determine menu item position
/// \return success
 
inline bool attach_action_to_menu(
        const char *menupath,
        const char *name,
        int flags=0)
{
  return callui(ui_attach_action_to_menu, menupath, name, flags).cnd;
}
 

 
inline bool detach_action_from_menu(
        const char *menupath,
        const char *name)
{
  return callui(ui_detach_action_from_menu, menupath, name).cnd;
}
 

/// Attach an action to an existing toolbar (::ui_attach_action_to_toolbar).
/// \param toolbar_name  the name of the toolbar
/// \param name          the action name
/// \return success
 
inline bool attach_action_to_toolbar(
        const char *toolbar_name,
        const char *name)
{
  return callui(ui_attach_action_to_toolbar, toolbar_name, name).cnd;
}
 

/// Detach an action from the toolbar (::ui_detach_action_from_toolbar).
/// \param toolbar_name  the name of the toolbar
/// \param name          the action name
/// \return success
 
inline bool detach_action_from_toolbar(
        const char *toolbar_name,
        const char *name)
{
  return callui(ui_detach_action_from_toolbar, toolbar_name, name).cnd;
}
 

/// 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.
 
inline bool register_and_attach_to_menu(
        const char *menupath,
        const char *name,
        const char *label,
        const char *shortcut,
        int flags,
        action_handler_t *handler,
        void *owner,
        int action_desc_t_flags)
{
  action_desc_t desc = ACTION_DESC_LITERAL_OWNER(name, label, handler, owner, shortcut, nullptr, -1, action_desc_t_flags);
  if ( !register_action(desc) )
    return false;
  if ( !attach_action_to_menu(menupath, name, (flags & SETMENU_POSMASK)) )
  {
    unregister_action(name);
    return false;
  }
  return true;
}
 
//------------------------------------------------------------------------
// Get VCL global variables
class TPopupMenu;


 
inline void display_widget(TWidget *widget, uint32 options, const char *dest_ctrl=nullptr)
{
  callui(ui_display_widget, widget, options, dest_ctrl);
}
 

/// \param options  \ref WIDGET_CLOSE
 
inline void close_widget(TWidget *widget, int options)
{
  callui(ui_close_widget, widget, options);
}
 

/// \param take_focus  give focus to given widget
 
inline void activate_widget(TWidget *widget, bool take_focus)
{
  callui(ui_activate_widget, widget, take_focus);
}
 

/// \param caption  title of tab, or window title if widget is not tabbed
/// \return pointer to the TWidget, nullptr if none is found
 
inline TWidget *find_widget(const char *caption)
{
  return (TWidget *) callui(ui_find_widget, caption).vptr;
}
 

 
inline TWidget *get_current_widget()
{
  return (TWidget *) callui(ui_get_current_widget).vptr;
}
 

 
inline twidget_type_t get_widget_type(TWidget *widget)
{
  return twidget_type_t(callui(ui_get_widget_type, widget).i);
}
 

 
inline bool get_widget_title(qstring *buf, TWidget *widget)
{
  return callui(ui_get_widget_title, buf, widget).cnd;
}

/// \param maxplace  last location of the viewer
/// \param curplace  set current location
/// \param rinfo     renderer information (can be nullptr)
/// \param ud        user data for the viewer
/// \param cvhandlers    handlers for the viewer (can be nullptr)
/// \param cvhandlers_ud pointer to arbitrary user data; it will be passed to cvhandlers
/// \param parent    widget to hold viewer
/// \return pointer to resulting viewer
 
inline TWidget *create_custom_viewer(
        const char *title,
        const place_t *minplace,
        const place_t *maxplace,
        const place_t *curplace,
        const renderer_info_t *rinfo,
        void *ud,
        const custom_viewer_handlers_t *cvhandlers,
        void *cvhandlers_ud,
        TWidget *parent = nullptr)
{
  return (TWidget*) callui(
          ui_create_custom_viewer, title, minplace,
          maxplace, curplace, rinfo, ud, cvhandlers, cvhandlers_ud, parent).vptr;
}
 

 
inline bool custom_viewer_jump(
        TWidget *v,
        const lochist_entry_t &loc,
        uint32 flags=0)
{
  return callui(ui_custom_viewer_jump, v, &loc, flags).cnd;
}
 

 
inline bool ea_viewer_history_push_and_jump(TWidget *v, ea_t ea, int x, int y, int lnnum)
{
  return callui(ui_ea_viewer_history_push_and_jump, v, ea, x, y, lnnum).cnd;
}
 

/// \param[out] nfwd   number of available forward steps
/// \param v           ea viewer
/// \retval false  if the given ea viewer does not exist
/// \retval true   otherwise
 
inline bool get_ea_viewer_history_info(int *nback, int *nfwd, TWidget *v)
{
  return callui(ui_ea_viewer_history_info, nback, nfwd, v).cnd;
}
 

 
inline void refresh_custom_viewer(TWidget *custom_viewer)
{
  callui(ui_refresh_custom_viewer, custom_viewer);
}
 

 
inline void repaint_custom_viewer(TWidget *custom_viewer)
{
  callui(ui_repaint_qwidget, custom_viewer);
}
 

 
inline void destroy_custom_viewer(TWidget *custom_viewer)
{
  callui(ui_destroy_custom_viewer, custom_viewer);
}
 

/// \param place target position
/// \param x desired cursor position (column)
/// \param y desired cursor position (line)
/// \return success
 
inline bool jumpto(TWidget *custom_viewer, place_t *place, int x, int y)
{
  return callui(ui_jump_in_custom_viewer, custom_viewer, place, x, y).cnd;
}
 

/// See also the more complete get_custom_viewer_location()
///
/// \param custom_viewer  view
/// \param mouse          mouse position (otherwise cursor position)
/// \param[out] x         x coordinate
/// \param[out] y         y coordinate
 
inline place_t *get_custom_viewer_place(
        TWidget *custom_viewer,
        bool mouse,
        int *x,
        int *y)
{
  return (place_t *)callui(ui_get_curplace, custom_viewer, mouse, x, y).vptr;
}
 
inline bool get_custom_viewer_location(
        lochist_entry_t *out,
        TWidget *custom_viewer,
        bool mouse=false)
{
  return callui(ui_obsolete_get_custom_viewer_location, out, custom_viewer, mouse).cnd;
}
 
//-------------------------------------------------------------------------
inline bool get_custom_viewer_location(
        listing_location_t *out,
        TWidget *custom_viewer,
        uint32 flags=0)
{
  return callui(ui_get_custom_viewer_location_2, out, custom_viewer, flags).cnd;
}
 

 
inline bool is_idaq()
{
  return callui(ui_is_idaq).cnd;
}
 

/// \param widget        target widget
/// \param 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'.)
/// \param name          action name
/// \param popuppath     can be nullptr
/// \param flags         a combination of SETMENU_ flags (see \ref SETMENU_)
/// \return success
 
inline bool attach_action_to_popup(
        TWidget *widget,
        TPopupMenu *popup_handle,
        const char *name,
        const char *popuppath = nullptr,
        int flags=0)
{
  return callui(ui_attach_action_to_popup, widget, popup_handle, name, popuppath, flags).cnd;
}
 


 
inline bool detach_action_from_popup(TWidget *widget, const char *name)
{
  return callui(ui_detach_action_from_popup, widget, name).cnd;
}
 

/// will be 'delete'd when the action is unregistered.
/// \param unused        deprecated; should be nullptr
/// \param popup_handle  target popup
/// \param desc          created with #DYNACTION_DESC_LITERAL
/// \param popuppath     can be nullptr
/// \param flags         a combination of SETMENU_ constants (see \ref SETMENU_)
/// \param buf           a buffer, to retrieve the generated action name - can be nullptr
/// \return success
 
inline bool attach_dynamic_action_to_popup(
        TWidget *unused,
        TPopupMenu *popup_handle,
        const action_desc_t &desc,
        const char *popuppath = nullptr,
        int flags = 0,
        qstring *buf = nullptr)
{
  return callui(ui_attach_dynamic_action_to_popup, unused,
                popup_handle, &desc, popuppath, flags, buf).cnd;
}



 
inline bool update_action_label(const char *name, const char *label)
{
  return callui(ui_update_action_attr, name, AA_LABEL, label).cnd;
}
 

/// \param shortcut  new shortcut
/// \return success
 
inline bool update_action_shortcut(const char *name, const char *shortcut)
{
  return callui(ui_update_action_attr, name, AA_SHORTCUT, shortcut).cnd;
}
 

/// \param tooltip  new tooltip
/// \return success
 
inline bool update_action_tooltip(const char *name, const char *tooltip)
{
  return callui(ui_update_action_attr, name, AA_TOOLTIP, tooltip).cnd;
}
 

/// \param icon  new icon id
/// \return success
 
inline bool update_action_icon(const char *name, int icon)
{
  return callui(ui_update_action_attr, name, AA_ICON, &icon).cnd;
}
 

/// \param state  new state
/// \return success
 
inline bool update_action_state(const char *name, action_state_t state)
{
  return callui(ui_update_action_attr, name, AA_STATE, &state).cnd;
}
 

/// \param checkable  new checkability
/// \return success
 
inline bool update_action_checkable(const char *name, bool checkable)
{
  return callui(ui_update_action_attr, name, AA_CHECKABLE, &checkable).cnd;
}
 

/// \param checked  new checked state
/// \return success
 
inline bool update_action_checked(const char *name, bool checked)
{
  return callui(ui_update_action_attr, name, AA_CHECKED, &checked).cnd;
}
 

/// \param visible  new visibility
/// \return success
 
inline bool update_action_visibility(const char *name, bool visible)
{
  return callui(ui_update_action_attr, name, AA_VISIBILITY, &visible).cnd;
}


/// Convenience functions for ::ui_get_action_attr
//{


 
inline bool get_action_label(qstring *label, const char *name)
{
  return callui(ui_get_action_attr, name, AA_LABEL, label).cnd;
}
 

/// \param name           the action name
/// \return success
 
inline bool get_action_shortcut(qstring *shortcut, const char *name)
{
  return callui(ui_get_action_attr, name, AA_SHORTCUT, shortcut).cnd;
}
 

/// \param name          the action name
/// \return success
 
inline bool get_action_tooltip(qstring *tooltip, const char *name)
{
  return callui(ui_get_action_attr, name, AA_TOOLTIP, tooltip).cnd;
}
 

/// \param[out] icon  the icon id
/// \return success
 
inline bool get_action_icon(const char *name, int *icon)
{
  return callui(ui_get_action_attr, name, AA_ICON, icon).cnd;
}
 

/// \param[out] state  the action's state
/// \return success
 
inline bool get_action_state(const char *name, action_state_t *state)
{
  return callui(ui_get_action_attr, name, AA_STATE, state).cnd;
}
 

/// \param[out] checkable  the action's checkability
/// \return success
 
inline bool get_action_checkable(const char *name, bool *checkable)
{
  return callui(ui_get_action_attr, name, AA_CHECKABLE, checkable).cnd;
}
 

/// \param[out] checked  the action's checked state
/// \return success
 
inline bool get_action_checked(const char *name, bool *checked)
{
  return callui(ui_get_action_attr, name, AA_CHECKED, checked).cnd;
}
 

/// \param[out] visibility  the action's visibility
/// \return success
 
inline bool get_action_visibility(const char *name, bool *visibility)
{
  return callui(ui_get_action_attr, name, AA_VISIBILITY, visibility).cnd;
}


/// Convenience functions for ::ui_set_custom_viewer_handler
///@{


 
inline void set_custom_viewer_handlers(
        TWidget *custom_viewer,
        const custom_viewer_handlers_t *cvh,
        void *cvh_ud)
{
  callui(ui_set_custom_viewer_handlers, custom_viewer, cvh, cvh_ud);
}
 

 
inline void *set_custom_viewer_handler(
        TWidget *custom_viewer,
        custom_viewer_handler_id_t handler_id,
        void *handler_or_data)
{
  return callui(ui_set_custom_viewer_handler, custom_viewer, handler_id,
                handler_or_data).vptr;
}
 

 
inline bool set_custom_viewer_qt_aware(TWidget *custom_viewer)
{
  return callui(ui_set_custom_viewer_handler, custom_viewer, CVH_QT_AWARE).cnd;
}

 

/// 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()
///
/// \param custom_viewer  view
/// \param mouse          mouse position (otherwise cursor position)
/// \return pointer to contents of current line
 
inline const char *get_custom_viewer_curline(TWidget *custom_viewer, bool mouse)
{
  return callui(ui_get_custom_viewer_curline, custom_viewer, mouse).cptr;
}
 

/// \param pline a place corresponding to the line
/// \param pitem a place corresponding to the item
/// \retval -1 if 'pitem' is not included in the line
/// \retval -2 if 'pitem' points at the entire line
/// \retval >= 0 for the X coordinate within the pline, where pitem points
 
inline int get_custom_viewer_place_xcoord(
        TWidget *custom_viewer,
        const place_t *pline,
        const place_t *pitem)
{
  return callui(ui_get_custom_viewer_place_xcoord, custom_viewer, pline, pitem).i;
}
 


 
inline bool get_user_input_event(
        input_event_t *out)
{
  return callui(ui_get_user_input_event, out).cnd;
}

/// \param mouse    current for mouse pointer?
/// \return false if output contains no text
 
inline bool get_output_curline(qstring *buf, bool mouse)
{
  return callui(ui_get_output_curline, buf, mouse).cnd;
}
 

/// \return true if there is a selection
 
inline bool get_output_selected_text(qstring *buf)
{
  return callui(ui_get_output_selected_text, buf).cnd;
}
 

 
inline TWidget *get_current_viewer()
{
  return (TWidget *)callui(ui_get_current_viewer).vptr;
}
 

/// \return the viewer, if found
 
inline TWidget *get_last_widget(uint64 mask=uint64(-1))
{
  return (TWidget *)callui(ui_get_last_widget, mask).vptr;
}

/// Note: changes will not apply! It is the caller's job to apply the resulting out_tif.
/// Parameters:
/// \param[out] errbuf - (::qstring *) the output string for errors
/// \param[out] out_tif - (tinfo_t *) tif for created type
/// \param      pfn - (func_t *) editing function
/// \param      tif - (tinfo_t *) current function type
/// \param      name - (const char *) function name
/// \return     true if new type created successfully
 
inline bool prompt_function_prototype(qstring *errbuf, tinfo_t *out_tif, func_t *pfn, tinfo_t *tif, const char *name)
{
  return callui(ui_prompt_function_prototype, errbuf, out_tif, pfn, tif, name).cnd;
}

/// \param out sections storage
/// \param line input line
/// \return success
inline bool parse_tagged_line_sections(tagged_line_sections_t *out, const char *line)
{
  return callui(ui_parse_tagged_line_sections, out, line).cnd;
}
 
 

 
inline tcc_renderer_type_t get_view_renderer_type(TWidget *v)
{
  return tcc_renderer_type_t(callui(ui_get_renderer_type, v).i);
}
 

 
inline void set_view_renderer_type(TWidget *v, tcc_renderer_type_t rt)
{
  callui(ui_set_renderer_type, v, rt);
}
 

 
inline void set_custom_viewer_range(
        TWidget *custom_viewer,
        const place_t *minplace,
        const place_t *maxplace)
{
  callui(ui_set_custom_viewer_range, custom_viewer, minplace, maxplace);
}
 

 
inline TWidget *create_empty_widget(const char *title, int icon = -1)
{
  return (TWidget *) callui(ui_create_empty_widget, title, icon).vptr;
}
 

 
inline void msg_clear()
{
  callui(ui_msg_clear);
}
 

///             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.
/// \return success
 
inline bool msg_save(qstring &path)
{
  return callui(ui_msg_save, &path).cnd;
}
 

/// \param out Output storage
/// \param count The number of lines to retrieve. -1 means: all
 
inline void msg_get_lines(qstrvec_t *out, int count=-1)
{
  callui(ui_msg_get_lines, out, count);
}
 

/// this function will return nullptr even if it is currently shown.
/// \return TWidget * the active modal widget, or nullptr
 
inline TWidget *get_active_modal_widget()
{
  return (TWidget *) callui(ui_get_active_modal_widget).vptr;
}
 

 
inline int get_navband_pixel(bool *out_is_vertical, ea_t ea)
{
  return callui(ui_navband_pixel, out_is_vertical, ea).i;
}
 

 
inline ea_t get_navband_ea(int pixel)
{
  ea_t ea = BADADDR;
  callui(ui_navband_ea, &ea, pixel);
  return ea;
}
 

/// Get the system-specific window ID (GUI version only)
/// \param name name of the window (nullptr means the main IDA window)
/// \return the low-level window ID
 
inline void *get_window_id(const char *name=nullptr)
{
  return callui(ui_get_window_id, name).vptr;
}
 

 
inline bool is_idaview(TWidget *v)
{
  return callui(ui_is_idaview, v).cnd;
}
 

/// \param[out] p1  start of selection
/// \param[out] p2  end of selection
/// \retval false   no range is selected
/// \retval true    ok, start and end are filled
 
inline bool read_selection(TWidget *v, twinpos_t *p1, twinpos_t *p2)
{
  return callui(ui_read_selection, v, p1, p2).cnd;
}
 

/// \param v        view, nullptr means the last active window
///                 containing addresses
/// \param[out] ea1 start ea
/// \param[out] ea2 end ea
/// \retval 0 no range is selected \n
/// \retval 1 ok, start ea and end ea are filled
 
inline bool read_range_selection(TWidget *v, ea_t *ea1, ea_t *ea2)
{
  return callui(ui_read_range_selection, v, ea1, ea2).cnd;
}
 

 
inline void unmark_selection()         { callui(ui_unmarksel); }
 


 
inline TWidget *create_code_viewer(
        TWidget *custview,
        int flags = 0,
        TWidget *parent = nullptr)
{
  return (TWidget*)callui(ui_create_code_viewer, custview, flags, parent).vptr;
}
 

 
inline void *set_code_viewer_handler(
        TWidget *code_viewer,
        custom_viewer_handler_id_t handler_id,
        void *handler_or_data)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, handler_id,
                handler_or_data).vptr;
}
 

 
inline bool set_code_viewer_user_data(TWidget *code_viewer, void *ud)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, CDVH_USERDATA, ud).cnd;
}
 

 
inline void *get_viewer_user_data(TWidget *viewer)
{
  return callui(ui_get_viewer_user_data, viewer).vptr;
}
 

 
inline tcc_place_type_t get_viewer_place_type(TWidget *viewer)
{
  return tcc_place_type_t(callui(ui_get_viewer_place_type, viewer).i);
}
 

 
inline void set_code_viewer_line_handlers(
        TWidget *code_viewer,
        code_viewer_lines_click_t *click_handler,
        code_viewer_lines_click_t *popup_handler,
        code_viewer_lines_click_t *dblclick_handler,
        code_viewer_lines_icon_t *drawicon_handler,
        code_viewer_lines_linenum_t *linenum_handler)
{
  callui(ui_set_code_viewer_line_handlers, code_viewer, click_handler,
         popup_handler, dblclick_handler, drawicon_handler, linenum_handler);
}
 

 
inline bool set_code_viewer_lines_icon_margin(TWidget *code_viewer, int margin)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, CDVH_LINES_ICONMARGIN, margin).cnd;
}
 

 
inline bool set_code_viewer_lines_alignment(TWidget *code_viewer, int align)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, CDVH_LINES_ALIGNMENT, align).cnd;
}
 

 
inline bool set_code_viewer_lines_radix(TWidget *code_viewer, int radix)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, CDVH_LINES_RADIX, radix).cnd;
}
 

 
inline bool set_code_viewer_is_source(TWidget *code_viewer)
{
  return callui(ui_set_custom_viewer_handler, code_viewer, CDVH_SRCVIEW).cnd;
}
 

///                - if nullptr, the default size is returned.
 
inline int get_tab_size(const char *path)
{
  return callui(ui_get_tab_size, path).i;
}
 

 
THREAD_SAFE inline void clr_cancelled() { callui(ui_clr_cancelled); }
 

 
THREAD_SAFE inline void set_cancelled() { callui(ui_set_cancelled); }
 

 
THREAD_SAFE inline bool user_cancelled() { return callui(ui_test_cancelled).cnd; }
 

 
inline bool ui_load_new_file(
        qstring *temp_file,
        qstring *filename,
        linput_t **pli,
        ushort neflags,
        load_info_t **ploaders)
{
  return callui(ui_load_file, temp_file, filename, pli, neflags, ploaders).cnd;
}
 

 
inline bool ui_run_debugger(
        const char *dbgopts,
        const char *exename,
        int argc,
        const char *const *argv)
{
  return callui(ui_run_dbg, dbgopts, exename, argc, argv).cnd;
}
 

 
inline bool load_dbg_dbginfo(
        const char *path,
        linput_t *li=nullptr,
        ea_t base=BADADDR,
        bool verbose=false)
{
  return callui(ui_dbg_load_dbg_dbginfo, path, li, base, verbose).cnd;
}
 

 
inline int add_idc_hotkey(const char *hotkey, const char *idcfunc)
{
  return callui(ui_add_idckey, hotkey, idcfunc).i;
}
 

/// \param viewer    the viewer
/// \param out_flags storage for the flags (see \ref HIF_)
/// \param flags     input flags; optionally specify a highlight slot (0-7)
/// \return false if no identifier is highlighted
 
inline bool get_highlight(qstring *out_str, TWidget *viewer, uint32 *out_flags, uint32 flags=0)
{
  return callui(ui_get_highlight_2, out_str, viewer, out_flags, flags).cnd;
}
 

/// \param str      the text to match, or nullptr to remove current
/// \param flags    combination of HIF_... bits (see \ref HIF_)
/// \return false if an error occurred
 
inline bool set_highlight(TWidget *viewer, const char *str, int flags)
{
  return callui(ui_set_highlight, viewer, str, flags).cnd;
}
 
 
#ifndef SWIG
/// This pointer is initialized by setup_range_marker()
 
extern void (idaapi*range_marker)(ea_t ea, asize_t size);
 

 
inline void setup_range_marker()
{
  void *ptr = callui(ui_get_range_marker).vptr;
  if ( ptr != nullptr )
    range_marker = reinterpret_cast<void (idaapi*)(ea_t, asize_t)>(ptr);
}

 
inline void mark_range_for_refresh(ea_t ea, asize_t size)
{
  if ( range_marker != nullptr )
    range_marker(ea, size);
}
 

 
inline void mark_all_eaviews_for_refresh()
{
  if ( range_marker != nullptr )
    range_marker(0, BADADDR);
}

struct range_marker_suspender_t
{
  void (idaapi *backup)(ea_t ea, asize_t size);
  range_marker_suspender_t()
  {
    backup = range_marker;
    range_marker = nullptr;
  }
  ~range_marker_suspender_t()
  {
    range_marker = backup;
    mark_all_eaviews_for_refresh();
  }
};
#endif // SWIG
 




 
inline TWidget *open_exports_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_EXPORTS, ea).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_imports_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_IMPORTS, ea).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_names_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_NAMES, ea).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_funcs_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_FUNCS, ea).vptr;
}
 

/// \param selstart,selend   only display strings that occur within this range
/// \return pointer to resulting window
 
inline TWidget *open_strings_window(ea_t ea, ea_t selstart=BADADDR, ea_t selend=BADADDR)
{
  return (TWidget *) callui(ui_open_builtin, BWN_STRINGS, ea, selstart, selend).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_segments_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_SEGS, ea).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_segregs_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_SEGREGS, ea).vptr;
}
 

 
inline TWidget *open_selectors_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_SELS, 0).vptr;
}
 

 
inline TWidget *open_signatures_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_SIGNS, 0).vptr;
}
 

 
inline TWidget *open_tils_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_TILS, 0).vptr;
}
 

/// \param cursor  cursor to the type member
/// \return pointer to resulting window
 
inline TWidget *open_loctypes_window(int ordinal, const tif_cursor_t *cursor=nullptr)
{
  return (TWidget *) callui(ui_open_builtin2, BWN_TICSR, ordinal, cursor).vptr;
}

/// \return pointer to resulting window
 
inline TWidget *open_til_view_window(tinfo_t *tif, const tif_cursor_t *cursor=nullptr)
{
  return (TWidget *) callui(ui_open_builtin2, BWN_TIL_VIEW, tif, cursor).vptr;
}

 
inline TWidget *open_calls_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_CALLS, ea).vptr;
}

 
inline TWidget *open_problems_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_PROBS, ea).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_bpts_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_BPTS, ea).vptr;
}
 

 
inline TWidget *open_threads_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_THREADS, 0).vptr;
}
 

 
inline TWidget *open_modules_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_MODULES, 0).vptr;
}
 

 
inline TWidget *open_trace_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_TRACE, 0).vptr;
}
 

 
inline TWidget *open_stack_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_CALL_STACK, 0).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_xrefs_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_XREFS, ea).vptr;
}
 

/// \param offset  offset where the cursor is placed
/// \return pointer to resulting window if 'pfn' is a valid function and the window was displayed,  \n
///                 nullptr otherwise
 
inline TWidget *open_frame_window(func_t *pfn, uval_t offset)
{
  return (TWidget *) callui(ui_open_builtin, BWN_FRAME, pfn, offset).vptr;
}
 

/// \param zoom  sets the navband zoom level
/// \return pointer to resulting window
 
inline TWidget *open_navband_window(ea_t ea, int zoom)
{
  return (TWidget *) callui(ui_open_builtin, BWN_NAVBAND, ea, zoom).vptr;
}
 

/// \param ranges        if != nullptr, then display a flow chart with the specified ranges
/// \return pointer to resulting window
 
inline TWidget *open_disasm_window(const char *window_title, const rangevec_t *ranges=nullptr)
{
  return (TWidget *) callui(ui_open_builtin, BWN_DISASM, window_title, BADADDR, ranges, 0).vptr;
}
 

/// \return pointer to resulting window
 
inline TWidget *open_hexdump_window(const char *window_title)
{
  return (TWidget *) callui(ui_open_builtin, BWN_HEXVIEW, window_title, BADADDR, 0).vptr;
}
 

 
inline TWidget *open_notepad_window()
{
  return (TWidget *) callui(ui_open_builtin, BWN_NOTEPAD, 0).vptr;
}
 

///          this can be an IDAView, or Enums view, etc.
/// \return pointer to resulting window
 
inline TWidget *open_bookmarks_window(TWidget *w)
{
  return (TWidget *) callui(ui_open_builtin, BWN_BOOKMARKS, w, 0).vptr;
}
 


/// [Un]synchronize sources
/// \param what
/// \param with
/// \param sync
/// \return success
inline bool sync_sources(
        const sync_source_t &what,
        const sync_source_t &with,
        bool sync)
{
  return callui(ui_sync_sources, &what, &with, sync).cnd;
}
 

 


 
inline char *choose_idasgn()
{
  return callui(ui_choose, chtype_idasgn).cptr;
}
 

/// \retval true   'buf' was filled with the name of the selected til
/// \retval false  otherwise
 
inline bool choose_til(qstring *buf)
{
  return callui(ui_choose, chtype_idatil, buf).cnd;
}
 

/// \return ea of selected entry point, #BADADDR if none selected
 
inline ea_t choose_entry(const char *title)
{
  ea_t ea;
  callui(ui_choose, chtype_entry, &ea, title);
  return ea;
}
 

/// Choose a name (::ui_choose, ::chtype_name).
/// \param title  chooser title
/// \return ea of selected name, #BADADDR if none selected
 
inline ea_t choose_name(const char *title)
{
  ea_t ea;
  callui(ui_choose, chtype_name, &ea, title);
  return ea;
}
 

/// Choose an xref to a stack variable (::ui_choose, ::chtype_name).
/// \param pfn         function
/// \param srkvar_tid  frame variable TID
/// \return ea of the selected xref, BADADDR if none selected
 
inline ea_t choose_stkvar_xref(func_t *pfn, tid_t srkvar_tid)
{
  ea_t ea;
  callui(ui_choose, chtype_stkvar_xref, &ea, pfn, srkvar_tid);
  return ea;
}
 

/// Choose an xref to an address (::ui_choose, ::chtype_xref).
/// \param to  referenced address
/// \return ea of selected xref, BADADDR if none selected
 
inline ea_t choose_xref(ea_t to)
{
  ea_t ea;
  callui(ui_choose, chtype_xref, &ea, to);
  return ea;
}
 

/// Choose an enum (::ui_choose, ::chtype_enum).
/// \param[out] out    the selected enum type
/// \param title       chooser title
/// \param default_ord ordinal of enum to select by default
/// \retval true       the selected type is in OUT
/// \retval false      nothing was selected
 
inline bool choose_enum(tinfo_t *out, const char *title, uint32 default_ord)
{
  return callui(ui_choose, chtype_enum, out, title, default_ord).cnd;
}
 

/// ask if the user would like to import a standard enum.
/// \param[out] out     the selected enum type
/// \param title        chooser title
/// \param default_ord  ordinal of enum to select by default
/// \param value        value to search for
/// \param nbytes       size of value
/// \param[out] serial  serial number of imported enum member, if one was found
/// \retval true        the selected type is in OUT
/// \retval false       nothing was selected
 
inline bool choose_enum_by_value(
        tinfo_t *out,
        const char *title,
        uint32 default_ord,
        uint64 value,
        int nbytes,
        uchar *serial)
{
  return callui(ui_choose, chtype_enum_by_value_and_size, out, default_ord, title, value, nbytes, serial).cnd;
}

 
inline func_t *choose_func(const char *title, ea_t default_ea)
{
  return callui(ui_choose, chtype_func, title, default_ea).fptr;
}
 

/// \param default_ea  ea of segment to select by default
/// \return pointer to segment that was selected, nullptr if none selected
 
inline segment_t *choose_segm(const char *title, ea_t default_ea)
{
  return callui(ui_choose, chtype_segm, title, default_ea).segptr;
}
 

/// \param[in]  title  chooser title
/// \retval true   the selected type is in OUT
/// \retval false  nothing was selected
 
inline bool choose_struct(tinfo_t *out, const char *title)
{
  return callui(ui_choose, chtype_struct, out, title).cnd;
}
 

/// \return pointer to segment register range of selected change point, nullptr if none selected
 
inline sreg_range_t *choose_srcp(const char *title)
{
  return callui(ui_choose, chtype_srcp, title).sraptr;
}

 
#ifndef SWIG

 
inline int choose_struc_path(
        const char *title,
        tid_t strid,
        uval_t offset,
        adiff_t delta,
        bool appzero,
        tid_t *path)
{
  return callui(ui_choose, chtype_strpath, title, strid,
                                            offset, delta, appzero, path).i;
}
 
 
 

 
//lint -sem(choose,custodial(1))
inline ssize_t choose(chooser_base_t *ch, const void *def_item)
{
  return callui(ui_choose, chtype_generic, ch, def_item).ssize;
}
 
#endif // SWIG
 

/// 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.
///
/// \note This is object is chooser-specific.
/// \return the object that was used to create the chooser
 
inline void *get_chooser_obj(const char *chooser_caption)
{
  return callui(ui_get_chooser_obj, chooser_caption).vptr;
}

/// See also get_chooser_rows().
 
inline bool get_chooser_data(
        qstrvec_t *out,
        const char *chooser_caption,
        int n)
{
  return callui(ui_get_chooser_data, out, chooser_caption, n).cnd;
}

/// Get the chooser contents corresponding to the rows indicated by "what".
/// \param out A vector of chooser_row_info_t, one entry per returned row.
/// \param chooser_caption The caption that identifies the desired chooser.
/// \param what Either one of the GCRF_ flags, or a row index.
/// \return Success.
 
inline bool get_chooser_rows(
        chooser_row_info_vec_t *out,
        const char *chooser_caption,
        size_t what)
{
  return callui(ui_get_chooser_rows, out, chooser_caption, what).cnd;
}
 


 
inline bool idaapi enable_chooser_item_attrs(const char *chooser_caption, bool enable)
{
  return callui(ui_enable_chooser_item_attrs, chooser_caption, enable).cnd;
}
 

 
THREAD_SAFE AS_PRINTF(1, 0) inline void show_wait_box_v(const char *format, va_list va)
{
  callui(ui_mbox, mbox_wait, format, va);
}
 

THREAD_SAFE AS_PRINTF(1, 2) inline void show_wait_box(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  show_wait_box_v(format, va);
  va_end(va);
}
 

 
THREAD_SAFE inline void hide_wait_box()
{
  // stupid watcom requires va_list should not be nullptr
  callui(ui_mbox, mbox_hide, nullptr, &callui);
}
 

 
THREAD_SAFE AS_PRINTF(1, 2) inline void replace_wait_box(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  callui(ui_mbox, mbox_replace, format, va);
  va_end(va);
}
 

 
inline void beep(beep_t beep_type=beep_default)
{
  callui(ui_beep, beep_type);
}
 

 
inline bool display_copyright_warning()
{
  return callui(ui_copywarn).cnd;
}
 
#endif  // __UI__ END OF UI SERVICE FUNCTIONS
 

/// Show a message box asking to send the input file to support@hex-rays.com.
/// \param format  the reason why the input file is bad
 
THREAD_SAFE AS_PRINTF(1, 2) inline void ask_for_feedback(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  callui(ui_mbox, mbox_feedback, format, va);
  va_end(va);
}
 

 
AS_PRINTF(2, 3) inline bool ask_addr(ea_t *addr, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool ok = callui(ui_ask_addr, addr, format, va).cnd;
  va_end(va);
  return ok;
}
 

 
AS_PRINTF(2, 3) inline bool ask_seg(sel_t *sel, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool ok = callui(ui_ask_seg, sel, format, va).cnd;
  va_end(va);
  return ok;
}
 

 
AS_PRINTF(2, 3) inline bool ask_long(sval_t *value, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool ok = callui(ui_ask_long, value, format, va).cnd;
  va_end(va);
  return ok;
}
 
 
//---------------------------------------------------------------------------
//      E R R O R / W A R N I N G / I N F O   D I A L O G   B O X E S
//---------------------------------------------------------------------------

 
idaman bool ida_export_data batch;
 

 
idaman int ida_export_data errorexit;
 

 
THREAD_SAFE AS_PRINTF(1, 2) NORETURN inline void error(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  verror(format, va);
  // NOTREACHED
}
 

 
THREAD_SAFE AS_PRINTF(1, 0) inline ssize_t vwarning(const char *format, va_list va)
{
  return callui(ui_mbox, mbox_warning, format, va).ssize;
}
 
THREAD_SAFE AS_PRINTF(1, 2) inline ssize_t warning(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  ssize_t rc = vwarning(format, va);
  va_end(va);
  return rc;
}
 

 
THREAD_SAFE AS_PRINTF(1, 0) inline ssize_t vinfo(const char *format, va_list va)
{
  return callui(ui_mbox, mbox_info, format, va).ssize;
}
 
THREAD_SAFE AS_PRINTF(1, 2) inline ssize_t info(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  size_t rc = vinfo(format, va);
  va_end(va);
  return rc;
}
 

 
THREAD_SAFE AS_PRINTF(1, 0) NORETURN inline void vnomem(const char *format, va_list va)
{
  callui(ui_mbox, mbox_nomem, format, va);
  // NOTREACHED
  abort(); // to suppress compiler warning or error
}
 
THREAD_SAFE AS_PRINTF(1, 2) NORETURN inline void nomem(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  vnomem(format, va);
  // NOTREACHED
}
 

 
THREAD_SAFE AS_PRINTF(1, 0) inline int vmsg(const char *format, va_list va)
{
  return callui(ui_msg, format, va).i;
}
 
THREAD_SAFE AS_PRINTF(1, 2) inline int msg(const char *format, ...)
{
  va_list va;
  va_start(va, format);
  int nbytes = vmsg(format, va);
  va_end(va);
  return nbytes;
}
 
#ifndef SWIG

//----------------------------------------------------------------------
//      F O R M S  -  C O M P L E X   D I A L O G   B O X E S
//----------------------------------------------------------------------

 
inline int vask_form(const char *format, va_list va)
{
  return callui(ui_ask_form, format, va).i;
}

/// \param form  dialog box as a string. see \ref FORM_C
/// \retval 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.
/// \retval 1    ok, all input fields are filled and validated.
/// \retval -1   the form has the 'No' button and the user cancelled the dialog
 
inline int ask_form(const char *form, ...)
{
  va_list va;
  va_start(va, form);
  int code = vask_form(form, va);
  va_end(va);
  return code;
}
 

 
inline TWidget *vopen_form(const char *format, uint32 flags, va_list va)
{
  return (TWidget *)callui(ui_open_form, format, flags, va).vptr;
}
 

/// - by pressing the small 'x' in the window title
/// - by calling form_actions_t::close() from the form callback
///   (\ref form_actions_t)
///
/// \note pressing the 'Yes/No/Cancel' buttons does not close the modeless
///       form, except if the form callback explicitly calls close().
/// \param form      dialog box as a string. see \ref FORM_C
/// \param flags     \ref WIDGET_OPEN
/// \return handle to the form or nullptr.
///         the handle can be used with TWidget functions: close_widget()/activate_widget()/etc
 
inline TWidget *open_form(const char *form, uint32 flags, ...)
{
  va_list va;
  va_start(va, flags);
  TWidget *widget = vopen_form(form, flags, va);
  va_end(va);
  return widget;
}

 

struct form_actions_t
{

  virtual bool idaapi _get_field_value(int field_id, void *buf) = 0;

  virtual bool idaapi _set_field_value(int field_id, const void *buf) = 0;

  virtual bool idaapi enable_field(int field_id, bool enable) = 0;

  virtual bool idaapi show_field(int field_id, bool display) = 0;

  virtual bool idaapi move_field(int field_id, int x, int y, int w, int h) = 0;

  virtual int idaapi get_focused_field() = 0;

  virtual bool idaapi set_focused_field(int field_id) = 0;

  virtual void idaapi refresh_field(int field_id) = 0;

  virtual void idaapi close(int close_normally) = 0;

  virtual void *idaapi get_ud() = 0;

  virtual bool idaapi _get_str_field_value(int field_id, char *buf, const size_t bufsize) = 0;

#define DEF_SET_METHOD(NAME, TYPE)                                   \
  bool idaapi set_ ## NAME ## _value(int field_id, const TYPE *val)  \
  {                                                                  \
    return _set_field_value(field_id, val);                          \
  }
#define DEF_FIELD_METHOD(NAME, TYPE)                                 \
  bool idaapi get_ ## NAME ## _value(int field_id, TYPE *val)        \
  {                                                                  \
    return _get_field_value(field_id, val);                          \
  }                                                                  \
  DEF_SET_METHOD(NAME, TYPE)
#define DEF_STR_FIELD_METHOD(NAME            )                       \
  bool idaapi get_ ## NAME ## _value(int field_id, char *buf, const size_t bufsize) \
  {                                                                  \
    return _get_str_field_value(field_id, buf, bufsize);             \
  }                                                                  \
  DEF_SET_METHOD(NAME, char)
 
  // get/set value of radio button (r, R)
  DEF_FIELD_METHOD(radiobutton, ushort)
  // get/set value of radio button group
  DEF_FIELD_METHOD(rbgroup, ushort)
  // get/set value of check box (c, C)
  DEF_FIELD_METHOD(checkbox, ushort)
  // get/set value of check box group
  DEF_FIELD_METHOD(cbgroup, ushort)
  // get/set value of color control (K)
  DEF_FIELD_METHOD(color, bgcolor_t)
  // get/set embedded chooser selected items (E)
  DEF_FIELD_METHOD(chooser, sizevec_t)
  // get/set value of editable combo box (b when field 'width' >0)
  DEF_FIELD_METHOD(combobox, qstring)
  // get/set selected item of read-only combo box (b when field 'width' ==0)
  DEF_FIELD_METHOD(combobox, int)
  // get/set value of multiline text input control (t)
  DEF_FIELD_METHOD(text, textctrl_info_t)
  // get/set text of buttons
  DEF_FIELD_METHOD(button, qstring)
  // get/set value of dynamic label (%)
  DEF_STR_FIELD_METHOD(label)
  // get/set string value (X, F, f)
  DEF_STR_FIELD_METHOD(string)
  // get/set path value (F, f)
  DEF_STR_FIELD_METHOD(path)
  // get/set string value (q, I, y, p)
  DEF_FIELD_METHOD(string, qstring)
  // get/set identifier value (I)
  DEF_FIELD_METHOD(ident, qstring)
  // get/set value of segment (S)
  DEF_FIELD_METHOD(segment, sel_t)
  // get/set signed value (n, D, O, Y, H)
  DEF_FIELD_METHOD(signed, sval_t)
  // get/set unsigned value (N, M)
  DEF_FIELD_METHOD(unsigned, uval_t)
  // get/set value of default base (usually hex) number (l)
  DEF_FIELD_METHOD(int64, int64)
  // get/set value of default base (usually hex) number (L)
  DEF_FIELD_METHOD(uint64, uint64)
  // get/set address value ($)
  DEF_FIELD_METHOD(ea, ea_t)
  // get/set tabbed widget current tab
  DEF_FIELD_METHOD(current_tab, int)
 
#undef DEF_FIELD_METHOD
#undef DEF_SET_METHOD
#undef DEF_STR_FIELD_METHOD
 
  enum dlgbtn_t
  {
    dbt_yes,
    dbt_cancel,
    dbt_no
  };
 
  // Enable or disable a standard dialog button (Yes, Cancel, None)
  virtual bool enable_dialog_button(dlgbtn_t btn, bool enabled) = 0;
 
  // Get state of a standard button
  virtual bool is_dialog_button_enabled(dlgbtn_t btn) = 0;
 
  // Update the list of available options for a combobox (b)
  //
  // Note: the contents of the `qstrvec_t` that was passed to ask_form/open_form will be modified
  virtual void swap_combobox_choices(int fid, qstrvec_t &items) = 0;

  virtual bool idaapi set_field_label(int fid, const qstring &text) = 0;
 
  // Update tab attribute
  enum tab_attr_t
  {
    ta_unknown = 0,
    ta_visible,
    ta_enabled,
  };
  virtual bool idaapi set_tab_attribute(int fid, int tab, tab_attr_t attr, const void *in) = 0;
  virtual bool idaapi get_tab_attribute(void *out, int fid, int tab, tab_attr_t attr) = 0;
  inline bool set_tab_visible(int fid, int tab, bool visible)
  {
    return set_tab_attribute(fid, tab, ta_visible, &visible);
  }
  inline bool is_tab_visible(bool *out, int fid, int tab)
  {
    return get_tab_attribute(out, fid, tab, ta_visible);
  }
  inline bool set_tab_enabled(int fid, int tab, bool enabled)
  {
    return set_tab_attribute(fid, tab, ta_enabled, &enabled);
  }
  inline bool is_tab_enabled(bool *out, int fid, int tab)
  {
    return get_tab_attribute(out, fid, tab, ta_enabled);
  }
};
 


/// The callback will be also called before displaying the form and as soon
/// as the user presses the 'Yes/No/Cancel' buttons or closes the window.
/// The callback will be called for both modal and modeless window.
/// \param field_id  id of the modified field or a special field id \ref CB_
/// \param fa helper class with useful virtual functions
/// \retval 0        continue editing
/// \retval >0       form will be closed
/// \note the return value is used by IDA only for modal forms, and only for
///       the following special field ids: CB_CLOSE, CB_YES, CB_NO, CB_CANCEL
///       (for modeless forms CB_CLOSE is also used).
 
typedef int idaapi formchgcb_t(int field_id, form_actions_t &fa);
 

 
typedef int idaapi buttoncb_t(int button_code, form_actions_t &fa);
 
 
#endif // SWIG
 
//---------------------------------------------------------------------------
//      Y E S / N O   D I A L O G   B O X
//---------------------------------------------------------------------------

#define ASKBTN_YES     1  
#define ASKBTN_NO      0  
#define ASKBTN_CANCEL -1  
#define ASKBTN_BTN1    1  
#define ASKBTN_BTN2    0  
#define ASKBTN_BTN3   -1  
 
 
THREAD_SAFE AS_PRINTF(5, 0) inline int vask_buttons(
        const char *Yes,
        const char *No,
        const char *Cancel,
        int deflt,
        const char *format,
        va_list va)
{
  return callui(ui_ask_buttons, Yes, No, Cancel, deflt, format, va).i;
}
 
 
AS_PRINTF(2, 0) inline int vask_yn(int deflt, const char *format, va_list va)
{
  return vask_buttons(nullptr, nullptr, nullptr, deflt, format, va);
}
 

 
AS_PRINTF(2, 3) inline int ask_yn(int deflt, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  int code = vask_yn(deflt, format, va);
  va_end(va);
  return code;
}
 

 
AS_PRINTF(5, 6) inline int ask_buttons(
        const char *Yes,
        const char *No,
        const char *Cancel,
        int deflt,
        const char *format,
        ...)
{
  va_list va;
  va_start(va, format);
  int code = vask_buttons(Yes, No, Cancel, deflt, format, va);
  va_end(va);
  return code;
}
 
//------------------------------------------------------------------------
/* Format of dialog box (actually they are mutliline strings
                         delimited by newline characters)
 
  The very first line of dialog box can specify a dialog box
  title if the following line appears:
 
  TITLE title string
 
 
  Then, the next line may contain an icon to display
  in the GUI version (ignored by the text version):
 
  ICON NONE          (no icon)
       INFO          (information icon)
       QUESTION      (question icon)
       WARNING       (warning icon)
       ERROR         (error icon)
 
 
  Then, the next line may contain a 'Don't display this message again'
  checkbox. If this checkbox is selected and the user didn't select cancel,
  the button he selected is saved and automatically returned.
 
  AUTOHIDE NONE      (no checkbox)
           DATABASE  (return value is saved to database)
           REGISTRY  (return value is saved to Windows registry or idareg.cfg
                      if non-Windows version)
           SESSION   (return value is saved for the current IDA session)
  It is possible to append "*" to the AUTOHIDE keywords to have this checkbox
  initially checked. For example: "AUTOHIDE REGISTRY*"
 
  To hide the cancel button the following keyword can be used:
 
  HIDECANCEL
 
  To enable rich text (i.e., HTML) in the Qt version of IDA,
  the following keyword can be used:
 
  RICHTEXT
 
  Please note that the user still can cancel the dialog box by pressing Esc
  or clicking on the 'close window' button.
 
  Finally, if the dialog box is kept in IDA.HLP, the following may appear
  to add a Help button (this defines help context for the whole dialog box):
 
  @hlpMessageName[]
 
 
  Each keyword should be alone on a line.
 
  Next, a format string must be specified.
  To center message lines in the text version, start them with '\3' character
  (currently ignored in the GUI version).
*/
 
//---------------------------------------------------------------------------
//      A S K   S T R I N G   O F   T E X T
//---------------------------------------------------------------------------

 
AS_PRINTF(3, 0) inline bool vask_str(
        qstring *str,
        int hist,
        const char *format,
        va_list va)
{
  return callui(ui_ask_str, str, hist, format, va).cnd;
}
 
AS_PRINTF(3, 4) inline bool ask_str(qstring *str, int hist, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool result = vask_str(str, hist, format, va);
  va_end(va);
  return result;
}

#define HIST_SEG    1           
#define HIST_CMT    2           
#define HIST_SRCH   3           
#define HIST_IDENT  4           
#define HIST_FILE   5           
#define HIST_TYPE   6           
#define HIST_CMD    7           
#define HIST_DIR    8           
#define HIST_IDENT2 9           
 

 
AS_PRINTF(2, 3) inline bool ask_ident(qstring *str, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool result = vask_str(str, HIST_IDENT, format, va);
  va_end(va);
  return result;
}

 
AS_PRINTF(2, 3) inline bool ask_ident2(qstring *str, const char *format, ...)
{
  va_list va;
  va_start(va, format);
  bool result = vask_str(str, HIST_IDENT2, format, va);
  va_end(va);
  return result;
}
 
 

 
AS_PRINTF(4, 0) inline bool vask_text(
        qstring *answer,
        size_t max_size,
        const char *defval,
        const char *format,
        va_list va)
{
  return callui(ui_ask_text, answer, max_size, defval, format, va).cnd;
}
 
AS_PRINTF(4, 5) inline bool ask_text(
        qstring *answer,
        size_t max_size,
        const char *defval,
        const char *format,
        ...)
{
  va_list va;
  va_start(va, format);
  bool result = vask_text(answer, max_size, defval, format, va);
  va_end(va);
  return result;
}
 
 
//---------------------------------------------------------------------------
//      A S K   A D D R E S S E S ,   N A M E S ,   N U M B E R S ,   E T C .
//---------------------------------------------------------------------------

 
AS_PRINTF(3, 0) inline char *vask_file(
        bool for_saving,
        const char *defval,
        const char *format,
        va_list va)
{
  return callui(ui_ask_file, for_saving, defval, format, va).cptr;
}
 
 
AS_PRINTF(3, 4) inline char *ask_file(
        bool for_saving,
        const char *defval,
        const char *format,
        ...)
{
  va_list va;
  va_start(va, format);
  char *answer = vask_file(for_saving, defval, format, va);
  va_end(va);
  return answer;
}
 
 
//---------------------------------------------------------------------------
//      A D D - O N S
//---------------------------------------------------------------------------

struct addon_info_t
{
  size_t cb;                //< size of this structure
  const char *id;           //< product code, e.g. "com.hexrays.hexx86w". Must be unique
  const char *name;         //< descriptive name, e.g. "Hex-Rays x86 Decompiler (Windows)"
  const char *producer;     //< e.g. "Hex-Rays SA"
  const char *version;      //< version string, e.g. 1.5.110408
  const char *url;          //< URL of the product http://www.hex-rays.com/decompiler.shtml
  const char *freeform;     //< any string, e.g. "Copyright (c) 2007-2025 Hex-Rays"
  const void *custom_data;  //< custom data (license ID etc). Can be nullptr. Not displayed in UI.
  size_t custom_size;

  addon_info_t()
    : cb(sizeof(addon_info_t)),
      id(nullptr),
      name(nullptr),
      producer(nullptr),
      version(nullptr),
      url(nullptr),
      freeform(nullptr),
      custom_data(nullptr),
      custom_size(0)
  {}
};
 
#ifndef __UI__




 
inline int register_addon(const addon_info_t *info)
{
  return callui(ui_addons, 0, info).i;
}
 

 
inline int addon_count()
{
  return callui(ui_addons, 1).i;
}
 

/// NB: all pointers are invalidated by next call to register_addon or get_addon_info
/// \return false if not found
 
inline bool get_addon_info(const char *id, addon_info_t *info)
{
  return callui(ui_addons, 2, id, info).cnd;
}
 

/// NB: all pointers are invalidated by next call to register_addon or get_addon_info
/// \return false if index is out of range
 
inline bool get_addon_info_idx(int index, addon_info_t *info)
{
  return callui(ui_addons, 3, index, info).cnd;
}

 
#endif
 
//---------------------------------------------------------------------------
//      S T R I N G   F U N C T I O N S
//---------------------------------------------------------------------------


 
idaman THREAD_SAFE char *ida_export add_spaces(char *str, size_t bufsize, ssize_t len);
 

 
idaman THREAD_SAFE char *ida_export trim(char *str);
 

 
idaman THREAD_SAFE const char *ida_export skip_spaces(const char *ptr);
inline char *skip_spaces(char *ptr) 
  { return CONST_CAST(char*)(skip_spaces((const char *)ptr)); }

struct strarray_t
{
  int code;
  const char *text;
};
 

/// Passed as 'flags' parameter to qcleanline()
///@{
#define CLNL_RTRIM      (1 << 0) 
#define CLNL_LTRIM      (1 << 1) 
#define CLNL_FINDCMT    (1 << 2) 
 
#define CLNL_TRIM       (CLNL_RTRIM|CLNL_LTRIM)

 
idaman THREAD_SAFE ssize_t ida_export qcleanline(
        qstring *buf,
        char cmt_char='\0',
        uint32 flags=CLNL_TRIM|CLNL_FINDCMT);
 

 
idaman THREAD_SAFE const char *ida_export strarray(const strarray_t *array, size_t array_size, int code);
 

 
idaman size_t ida_export ea2str(char *buf, size_t bufsize, ea_t ea);
 
//---------------------------------------------------------------------------
//      C O N V E R S I O N S
//---------------------------------------------------------------------------

inline bool ea2str(qstring *out, ea_t ea)
{
  char tmp[MAXSTR];
  if ( ea2str(tmp, sizeof(tmp), ea) <= 0 )
    return false;
  *out = tmp;
  return true;
}
 


 
idaman bool ida_export str2ea(ea_t *out, const char *str, ea_t screen_ea=BADADDR);
 

 
idaman bool ida_export str2ea_ex(ea_t *out, const char *str, ea_t screen_ea=BADADDR, int flags=0);

#define S2EAOPT_NOCALC 0x00000001 

 
idaman bool ida_export atoea(ea_t *out, const char *str);
 
#ifndef SWIG

 
idaman size_t ida_export stoa(qstring *out, ea_t from, sel_t seg);

 
idaman int ida_export atos(sel_t *seg, const char *str);
 
 
#define MAX_NUMBUF (128+8) 
 

 
idaman size_t ida_export b2a_width(int nbytes, int radix);
 

 
idaman size_t ida_export b2a32(char *buf, size_t bufsize, uint32 x, int nbytes, int radix);
 

 
idaman size_t ida_export b2a64(char *buf, size_t bufsize, uint64 x, int nbytes, int radix);
 
 

 
idaman size_t ida_export btoa_width(int nbytes, flags64_t flag, int n);
 

 
idaman size_t ida_export btoa32(char *buf, size_t bufsize, uint32 x, int radix=0);
 

 
idaman size_t ida_export btoa64(char *buf, size_t bufsize, uint64 x, int radix=0);
 

 
idaman size_t ida_export btoa128(char *buf, size_t bufsize, uint128 x, int radix=0);
 
#ifdef __EA64__
#define b2a b2a64
#define btoa btoa64
#define atob atob64
#else
#define b2a b2a32    
#define btoa btoa32  
#define atob atob32  
#endif
 

 
idaman size_t ida_export numop2str(
        char *buf,
        size_t bufsize,
        ea_t ea,
        int n,
        uint64 x,
        int nbytes,
        int radix=0);
 

 
idaman bool ida_export atob32(uint32 *x, const char *str);
 

 
idaman bool ida_export atob64(uint64 *x, const char *str); // returns 1-ok
 

 
idaman size_t ida_export pretty_print_size(char *buf, size_t bufsize, uint64 value);

 
idaman bool ida_export parse_pretty_size(uint64 *out, const char *in);
 

 
idaman void ida_export append_disp(qstring *buf, adiff_t disp, bool tag=true);
 

 
idaman THREAD_SAFE int ida_export r50_to_asc(char *p, const ushort *r, int k);
 

 
int THREAD_SAFE asc_to_r50(ushort *r, const char *p, int k);
 

 
//----------------------------------------------------------------------------
#define IS_BUTTONCB_T(v)         (std::is_same<decltype(v), buttoncb_t>::value)
#define IS_FORMCHGCB_T(v)        (std::is_same<decltype(v), formchgcb_t>::value)
#define IS_TEXTCTRL_INFO_T(v)    (std::is_base_of<textctrl_info_t, std::remove_reference<decltype(v)>::type>::value)
#define IS_CHOOSER_BASE_T(v)     (std::is_base_of<chooser_base_t, std::remove_reference<decltype(v)>::type>::value)

 
#endif // SWIG
 
//----------------------------------------------------------------------------
#define IK_CANCEL              0x03
#define IK_BACK                0x08
#define IK_TAB                 0x09
#define IK_CLEAR               0x0C
#define IK_RETURN              0x0D
#define IK_SHIFT               0x10
#define IK_CONTROL             0x11
#define IK_MENU                0x12
#define IK_PAUSE               0x13
#define IK_CAPITAL             0x14
#define IK_KANA                0x15
#define IK_ESCAPE              0x1B
#define IK_MODECHANGE          0x1F
#define IK_SPACE               0x20
#define IK_PRIOR               0x21
#define IK_NEXT                0x22
#define IK_END                 0x23
#define IK_HOME                0x24
#define IK_LEFT                0x25
#define IK_UP                  0x26
#define IK_RIGHT               0x27
#define IK_DOWN                0x28
#define IK_SELECT              0x29
#define IK_PRINT               0x2A
#define IK_EXECUTE             0x2B
#define IK_SNAPSHOT            0x2C
#define IK_INSERT              0x2D
#define IK_DELETE              0x2E
#define IK_HELP                0x2F
#define IK_LWIN                0x5B
#define IK_RWIN                0x5C
#define IK_APPS                0x5D
#define IK_SLEEP               0x5F
#define IK_NUMPAD0             0x60
#define IK_NUMPAD1             0x61
#define IK_NUMPAD2             0x62
#define IK_NUMPAD3             0x63
#define IK_NUMPAD4             0x64
#define IK_NUMPAD5             0x65
#define IK_NUMPAD6             0x66
#define IK_NUMPAD7             0x67
#define IK_NUMPAD8             0x68
#define IK_NUMPAD9             0x69
#define IK_MULTIPLY            0x6A
#define IK_ADD                 0x6B
#define IK_SEPARATOR           0x6C
#define IK_SUBTRACT            0x6D
#define IK_DECIMAL             0x6E
#define IK_DIVIDE              0x6F
#define IK_F1                  0x70
#define IK_F2                  0x71
#define IK_F3                  0x72
#define IK_F4                  0x73
#define IK_F5                  0x74
#define IK_F6                  0x75
#define IK_F7                  0x76
#define IK_F8                  0x77
#define IK_F9                  0x78
#define IK_F10                 0x79
#define IK_F11                 0x7A
#define IK_F12                 0x7B
#define IK_F13                 0x7C
#define IK_F14                 0x7D
#define IK_F15                 0x7E
#define IK_F16                 0x7F
#define IK_F17                 0x80
#define IK_F18                 0x81
#define IK_F19                 0x82
#define IK_F20                 0x83
#define IK_F21                 0x84
#define IK_F22                 0x85
#define IK_F23                 0x86
#define IK_F24                 0x87
#define IK_NUMLOCK             0x90
#define IK_SCROLL              0x91
#define IK_OEM_FJ_MASSHOU      0x93
#define IK_OEM_FJ_TOUROKU      0x94
#define IK_LSHIFT              0xA0
#define IK_RSHIFT              0xA1
#define IK_LCONTROL            0xA2
#define IK_RCONTROL            0xA3
#define IK_LMENU               0xA4
#define IK_RMENU               0xA5
#define IK_BROWSER_BACK        0xA6
#define IK_BROWSER_FORWARD     0xA7
#define IK_BROWSER_REFRESH     0xA8
#define IK_BROWSER_STOP        0xA9
#define IK_BROWSER_SEARCH      0xAA
#define IK_BROWSER_FAVORITES   0xAB
#define IK_BROWSER_HOME        0xAC
#define IK_VOLUME_MUTE         0xAD
#define IK_VOLUME_DOWN         0xAE
#define IK_VOLUME_UP           0xAF
#define IK_MEDIA_NEXT_TRACK    0xB0
#define IK_MEDIA_PREV_TRACK    0xB1
#define IK_MEDIA_STOP          0xB2
#define IK_MEDIA_PLAY_PAUSE    0xB3
#define IK_LAUNCH_MAIL         0xB4
#define IK_LAUNCH_MEDIA_SELECT 0xB5
#define IK_LAUNCH_APP1         0xB6
#define IK_LAUNCH_APP2         0xB7
#define IK_OEM_1               0xBA
#define IK_OEM_PLUS            0xBB
#define IK_OEM_COMMA           0xBC
#define IK_OEM_MINUS           0xBD
#define IK_OEM_PERIOD          0xBE
#define IK_OEM_2               0xBF
#define IK_OEM_3               0xC0
#define IK_OEM_4               0xDB
#define IK_OEM_5               0xDC
#define IK_OEM_6               0xDD
#define IK_OEM_7               0xDE
#define IK_OEM_102             0xE2
#define IK_PLAY                0xFA
#define IK_ZOOM                0xFB
#define IK_OEM_CLEAR           0xFE

enum cb_id
{
  CB_INIT = -1,
  CB_YES  = -2,       // the user pressed 'Yes' button
  CB_CLOSE = -3,      // the form is closed by the window manager
                      // (usually by pressing the small 'x' at the title)
  CB_INVISIBLE = -4,  // corresponds to ui_widget_invisible
  CB_DESTROYING = -5, // the actual widget tree is being destroyed
  CB_NO = -6,         // the user pressed 'No' button
  CB_CANCEL = -7,     // the user pressed 'Cancel' button or Esc
};
 
#ifndef SWIG
//-------------------------------------------------------------------------
inline void place_t__serialize(const place_t *_this, bytevec_t *out)
{
  out->pack_dd(_this->lnnum);
}
 
//-------------------------------------------------------------------------
inline bool place_t__deserialize(place_t *_this, const uchar **pptr, const uchar *end)
{
  if ( *pptr >= end )
    return false;
  _this->lnnum = unpack_dd(pptr, end);
  return true;
}
#endif
 
#ifndef NO_OBSOLETE_FUNCS
#define ACTION_DESC_LITERAL(name, label, handler, shortcut, tooltip, icon)\
  { sizeof(action_desc_t), name, label, handler, &PLUGIN, shortcut, tooltip, icon, ADF_OT_PLUGIN }
 
DEPRECATED inline void get_user_strlist_options(strwinsetup_t *out)
{
  callui(ui_obsolete_get_user_strlist_options, out);
}
DEPRECATED inline bool del_idc_hotkey(const char *hotkey)
{
  return callui(ui_obsolete_del_idckey, hotkey).cnd;
}
idaman DEPRECATED void ida_export ida_checkmem(const char *file, int line);
#endif
 
#endif // __KERNWIN_HPP