kernwin.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 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;             
struct dbg_deref_options_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, 
  chtype_segment,                
  chtype_stkvar_xref_ea,         
  chtype_func_ea,                
};
 
 
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;
struct jvalue_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 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;
  ea_t ea;
};
 
//-------------------------------------------------------------------------
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_obsolete_get_last_widget,
 
  ui_obsolete_prompt_function_prototype,
 
  ui_parse_tagged_line_sections,
 
  ui_get_last_widget,     
 
  ui_obsolete_action_ctx_base_ctl,
 
  ui_obsolete_prompt_function_prototype_2,
 
  ui_open_ida_link,       
 
  ui_prompt_function_prototype,
 
  ui_about_to_exit,     
 
  ui_serve,             
  ui_stop_serving,      
 
 
  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;
typedef qvector<uint32> ordvec_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
struct hexplace_gen_t
{
  // data format to display
  enum data_kind_t
  {
    dk_float,
    dk_int,
    dk_addr_names,
    dk_addr_text,
    dk_addr_deref
  };
  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;
 
  virtual bool get_dbg_deref_options(dbg_deref_options_t &out) const
  {
    qnotused(out);
    return false;
  }
 
  static bool is_addr_kind(data_kind_t k)
  {
    return k == dk_addr_names || k == dk_addr_text || k == dk_addr_deref;
  }
  static bool can_show_text(data_kind_t k)
  {
    return k == dk_float || k == dk_int;
  }
  bool is_addr_kind() const
  {
    data_kind_t k = get_data_kind();
    return is_addr_kind(k);
  }
};
 
//-------------------------------------------------------------------------
// 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;
class segment_info_t;
class func_entry_info_t;
class fchunk_info_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);


 
typedef int idaapi til_tinfo_predicate_t(uint32 ord, const tinfo_t &type, void *ud);
 
//-------------------------------------------------------------------------
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;
 
//-------------------------------------------------------------------------
struct tagged_line_section_t;
#ifndef SWIG
idaman THREAD_SAFE ea_t ida_export tagged_line_section_t_get_addr(
        const tagged_line_section_t *sec,
        const qstring &line);
#endif // SWIG
 
//-------------------------------------------------------------------------
// 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;
  }

  ea_t get_addr(const qstring &line) const
  {
    return tagged_line_section_t_get_addr(this, line);
  }
 
};
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;
  }
 
  const tagged_line_section_t *next(
        const tagged_line_section_t &anchor,
        color_t tag) const
  {
    for ( const auto &one : *this )
      if ( one.byte_offsets.text_start > anchor.byte_offsets.text_start
        && 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
  // innermost_at(<any p>) --> r1 (because r2 and r3 are zero-length)
  const tagged_line_section_t *innermost_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;
  }
 
#ifndef NO_OBSOLETE_FUNCS
  DEPRECATED const tagged_line_section_t *nearest_at(
        cpidx_t x,
        color_t tag=0) const
  {
    return innermost_at(x, tag);
  }
#endif
 
  // 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
         || one.byte_offsets.text_start > nearest->byte_offsets.text_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;
};
 
typedef uint128 builtin_widgets_mask_t;
inline builtin_widgets_mask_t builtin_widget_mask_from_id(int bwn) { TB_QASSERT(3446, bwn >= 0); return uint128(1) << bwn; }

 
idaman void ida_export mark_builtin_widgets(builtin_widgets_mask_t mask, bool dirty=true);

 
inline void mark_builtin_widget_by_id(int bwn, bool dirty=true)
{
  mark_builtin_widgets(builtin_widget_mask_from_id(bwn), dirty);
}

 
idaman void ida_export get_builtin_widgets_state(builtin_widgets_mask_t *out);


 
inline bool is_builtin_widget_dirty(int bwn)
{
  TB_QASSERT(3448, bwn <= 62); // attempt detecting ID-vs-mask confusion
  builtin_widgets_mask_t mask;
  get_builtin_widgets_state(&mask);
  return (mask & builtin_widget_mask_from_id(bwn)) != 0;
}
 
 
//-------------------------------------------------------------------------
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_TITREE                      10 
#define BWN_RESERVED_1                  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_RESERVED_2                  47 
#define BWN_RESERVED_3                  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_TREE               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 BWN_TEAMS_VAULT_FILES           63 // the 'Vault files' chooser
#define BWN_TEAMS_COMMITS               64 // the 'Commits' chooser
#define BWN_TEAMS_LOCAL_FILES           65 // the 'Local files' dirtree
#define BWN_TEAMS_WORKLISTS             66 // the 'Worklists' chooser
#define BWN_TEAMS_SITES                 67 // the 'Sites' chooser
#define BWN_TEAMS_USERS                 68 // the 'Users' chooser
#define BWN_TEAMS_FILE_HISTORY          69 // the file history chooser
#define BWN_TEAMS_COMMIT_FILES          70 // the commit files embedded chooser
#define BWN_TEAMS_EXT_ASSOCS            71 // the file extension associations embedded chooser
#define BWN_TEAMS_OPENED_FILES          72 // the opened files embedded chooser
#define BWN_TEAMS_VAULT_FILE_PICKER     73 // the opened files embedded chooser
#define BWN_DSC_INDEX                   74 
#define BWN_DSC_SYMBOLS                 75 
#define BWN_DSC_STRINGS                 76 
#define BWN_XREF_GRAPH                  77 
#define BWN_GIT_REPOS                   78 // the git 'Manage Repositories' chooser
#define BWN_XREF_GRAPH_MANAGER          79 
#define BWN_RECENT_SCRIPTS_TREE         80 
#define BWN_EXAMPLE_SCRIPTS_TREE        81 
#define BWN_SEARCH_SCRIPTS_TREE         82 
#define BWN_PATHFINDER                  83 
 
#define BWN_SNIPPETS_CSR BWN_SNIPPETS_TREE // bw-compat
 


#define IWID_EXPORTS                    builtin_widget_mask_from_id(BWN_EXPORTS      )              
#define IWID_IMPORTS                    builtin_widget_mask_from_id(BWN_IMPORTS      )              
#define IWID_NAMES                      builtin_widget_mask_from_id(BWN_NAMES        )              
#define IWID_FUNCS                      builtin_widget_mask_from_id(BWN_FUNCS        )              
#define IWID_STRINGS                    builtin_widget_mask_from_id(BWN_STRINGS      )              
#define IWID_SEGS                       builtin_widget_mask_from_id(BWN_SEGS         )              
#define IWID_SEGREGS                    builtin_widget_mask_from_id(BWN_SEGREGS      )              
#define IWID_SELS                       builtin_widget_mask_from_id(BWN_SELS         )              
#define IWID_SIGNS                      builtin_widget_mask_from_id(BWN_SIGNS        )              
#define IWID_TILS                       builtin_widget_mask_from_id(BWN_TILS         )              
#define IWID_TITREE                     builtin_widget_mask_from_id(BWN_TITREE       )              
#define IWID_RESERVED_1                 builtin_widget_mask_from_id(BWN_RESERVED_1   )              
#define IWID_PROBS                      builtin_widget_mask_from_id(BWN_PROBS        )              
#define IWID_BPTS                       builtin_widget_mask_from_id(BWN_BPTS         )              
#define IWID_THREADS                    builtin_widget_mask_from_id(BWN_THREADS      )              
#define IWID_MODULES                    builtin_widget_mask_from_id(BWN_MODULES      )              
#define IWID_TRACE                      builtin_widget_mask_from_id(BWN_TRACE        )              
#define IWID_CALL_STACK                 builtin_widget_mask_from_id(BWN_CALL_STACK   )              
#define IWID_XREFS                      builtin_widget_mask_from_id(BWN_XREFS        )              
#define IWID_SEARCH                     builtin_widget_mask_from_id(BWN_SEARCH       )              
#define IWID_FRAME                      builtin_widget_mask_from_id(BWN_FRAME        )              
#define IWID_NAVBAND                    builtin_widget_mask_from_id(BWN_NAVBAND      )              
#define IWID_DISASM                     builtin_widget_mask_from_id(BWN_DISASM       )              
#define IWID_HEXVIEW                    builtin_widget_mask_from_id(BWN_HEXVIEW      )              
#define IWID_NOTEPAD                    builtin_widget_mask_from_id(BWN_NOTEPAD      )              
#define IWID_OUTPUT                     builtin_widget_mask_from_id(BWN_OUTPUT       )              
#define IWID_CLI                        builtin_widget_mask_from_id(BWN_CLI          )              
#define IWID_WATCH                      builtin_widget_mask_from_id(BWN_WATCH        )              
#define IWID_LOCALS                     builtin_widget_mask_from_id(BWN_LOCALS       )              
#define IWID_STKVIEW                    builtin_widget_mask_from_id(BWN_STKVIEW      )              
#define IWID_CHOOSER                    builtin_widget_mask_from_id(BWN_CHOOSER      )              
#define IWID_SHORTCUTCSR                builtin_widget_mask_from_id(BWN_SHORTCUTCSR  )              
#define IWID_SHORTCUTWIN                builtin_widget_mask_from_id(BWN_SHORTCUTWIN  )              
#define IWID_CPUREGS                    builtin_widget_mask_from_id(BWN_CPUREGS      )              
#define IWID_SO_STRUCTS                 builtin_widget_mask_from_id(BWN_SO_STRUCTS   )              
#define IWID_SO_OFFSETS                 builtin_widget_mask_from_id(BWN_SO_OFFSETS   )              
#define IWID_CMDPALCSR                  builtin_widget_mask_from_id(BWN_CMDPALCSR    )              
#define IWID_CMDPALWIN                  builtin_widget_mask_from_id(BWN_CMDPALWIN    )              
#define IWID_SNIPPETS                   builtin_widget_mask_from_id(BWN_SNIPPETS     )              
#define IWID_CUSTVIEW                   builtin_widget_mask_from_id(BWN_CUSTVIEW     )              
#define IWID_ADDRWATCH                  builtin_widget_mask_from_id(BWN_ADDRWATCH    )              
#define IWID_PSEUDOCODE                 builtin_widget_mask_from_id(BWN_PSEUDOCODE   )              
#define IWID_RESERVED_2                 builtin_widget_mask_from_id(BWN_RESERVED_2   )              
#define IWID_RESERVED_3                 builtin_widget_mask_from_id(BWN_RESERVED_3   )              
#define IWID_MDVIEWCSR                  builtin_widget_mask_from_id(BWN_MDVIEWCSR    )              
#define IWID_DISASM_ARROWS              builtin_widget_mask_from_id(BWN_DISASM_ARROWS)              
#define IWID_CV_LINE_INFOS              builtin_widget_mask_from_id(BWN_CV_LINE_INFOS)              
#define IWID_SRCPTHMAP_CSR              builtin_widget_mask_from_id(BWN_SRCPTHMAP_CSR)              
#define IWID_SRCPTHUND_CSR              builtin_widget_mask_from_id(BWN_SRCPTHUND_CSR)              
#define IWID_UNDOHIST                   builtin_widget_mask_from_id(BWN_UNDOHIST     )              
#define IWID_SNIPPETS_TREE              builtin_widget_mask_from_id(BWN_SNIPPETS_TREE)              
#define IWID_SCRIPTS_CSR                builtin_widget_mask_from_id(BWN_SCRIPTS_CSR  )              
#define IWID_BOOKMARKS                  builtin_widget_mask_from_id(BWN_BOOKMARKS    )              
#define IWID_TILIST                     builtin_widget_mask_from_id(BWN_TILIST       )              
#define IWID_TIL_VIEW                   builtin_widget_mask_from_id(BWN_TIL_VIEW     )              
#define IWID_TYPE_EDITOR                builtin_widget_mask_from_id(BWN_TYPE_EDITOR  )              
#define IWID_MICROCODE                  builtin_widget_mask_from_id(BWN_MICROCODE    )              
#define IWID_XREF_TREE                  builtin_widget_mask_from_id(BWN_XREF_TREE    )              
#define IWID_TEAMS_VAULT_FILES          builtin_widget_mask_from_id(BWN_TEAMS_VAULT_FILES)          
#define IWID_TEAMS_COMMITS              builtin_widget_mask_from_id(BWN_TEAMS_COMMITS)              
#define IWID_TEAMS_LOCAL_FILES          builtin_widget_mask_from_id(BWN_TEAMS_LOCAL_FILES)          
#define IWID_TEAMS_WORKLISTS            builtin_widget_mask_from_id(BWN_TEAMS_WORKLISTS)            
#define IWID_TEAMS_SITES                builtin_widget_mask_from_id(BWN_TEAMS_SITES)                
#define IWID_TEAMS_USERS                builtin_widget_mask_from_id(BWN_TEAMS_USERS)                
#define IWID_TEAMS_FILE_HISTORY         builtin_widget_mask_from_id(BWN_TEAMS_FILE_HISTORY)         
#define IWID_TEAMS_COMMIT_FILES         builtin_widget_mask_from_id(BWN_TEAMS_COMMIT_FILES)         
#define IWID_TEAMS_EXT_ASSOCS           builtin_widget_mask_from_id(BWN_TEAMS_EXT_ASSOCS)           
#define IWID_TEAMS_OPENED_FILES         builtin_widget_mask_from_id(BWN_TEAMS_OPENED_FILES)         
#define IWID_TEAMS_VAULT_FILE_PICKER    builtin_widget_mask_from_id(BWN_TEAMS_VAULT_FILE_PICKER)    
#define IWID_DSC_INDEX                  builtin_widget_mask_from_id(BWN_DSC_INDEX)                  
#define IWID_DSC_SYMBOLS                builtin_widget_mask_from_id(BWN_DSC_SYMBOLS)                
#define IWID_DSC_STRINGS                builtin_widget_mask_from_id(BWN_DSC_STRINGS)                
#define IWID_XREF_GRAPH                 builtin_widget_mask_from_id(BWN_XREF_GRAPH)                 
#define IWID_GIT_REPOS                  builtin_widget_mask_from_id(BWN_GIT_REPOS)                  
#define IWID_XREF_GRAPH_MANAGER         builtin_widget_mask_from_id(BWN_XREF_GRAPH_MANAGER)         
#define IWID_RECENT_SCRIPTS_TREE        builtin_widget_mask_from_id(BWN_RECENT_SCRIPTS_TREE)       
#define IWID_EXAMPLE_SCRIPTS_TREE       builtin_widget_mask_from_id(BWN_EXAMPLE_SCRIPTS_TREE)      
#define IWID_SEARCH_SCRIPTS_TREE        builtin_widget_mask_from_id(BWN_SEARCH_SCRIPTS_TREE)       
#define IWID_PATHFINDER                 builtin_widget_mask_from_id(BWN_PATHFINDER)               
#define IWID_ANY_SCRIPTS_PART (IWID_SNIPPETS                  \
                             | IWID_SNIPPETS_TREE             \
                             | IWID_RECENT_SCRIPTS_TREE       \
                             | IWID_EXAMPLE_SCRIPTS_TREE      \
                             | IWID_SEARCH_SCRIPTS_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_TEAMS_FILES_WIDGETS (IWID_TEAMS_WORKLISTS|IWID_TEAMS_VAULT_FILES|IWID_TEAMS_LOCAL_FILES|IWID_TEAMS_FILE_HISTORY)
 
 
#define IWID_ALL           (uint128(0)-1)                                 
 
#define IWID_SNIPPETS_CSR IWID_SNIPPETS_TREE // bw-compat


 
inline bool is_chooser_widget(twidget_type_t t)
{
  return t == BWN_CHOOSER
      || (t >= BWN_EXPORTS && t <= BWN_SEARCH && t != BWN_FUNCS && t != BWN_TITREE && t != BWN_NAMES && t != BWN_IMPORTS && t != BWN_BPTS)
      || t == BWN_SHORTCUTCSR
      || t == BWN_CMDPALCSR
      || t == BWN_MDVIEWCSR
      || t == BWN_SRCPTHMAP_CSR
      || t == BWN_SRCPTHUND_CSR
      || t == BWN_UNDOHIST
      || t == BWN_GIT_REPOS;
}
 
inline bool is_teams_widget(twidget_type_t t)
{
  return t >= BWN_TEAMS_VAULT_FILES && t <= BWN_TEAMS_OPENED_FILES;
}
 
//---------------------------------------------------------------------------
//      D E B U G G I N G   F U N C T I O N S
//---------------------------------------------------------------------------

/// Controls debug messages - combination of \ref IDA_DEBUG_
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 OBSOLETE_CH_BUILTIN_SHIFT 19
#define OBSOLETE_CH_BUILTIN(id)   ((id+1) << OBSOLETE_CH_BUILTIN_SHIFT)
#define OBSOLETE_CH_BUILTIN_MASK  (0x3F << OBSOLETE_CH_BUILTIN_SHIFT)
 
#define OBSOLETE_CH_HAS_DIRTREE     0x02000000 // Deprecated
#define OBSOLETE_CH_TM_NO_TREE      0x00000000 // Deprecated
#define OBSOLETE_CH_TM_FOLDERS_ONLY 0x04000000 // Deprecated
#define OBSOLETE_CH_TM_FULL_TREE    0x08000000 // Deprecated
#define OBSOLETE_CH_TM_SHIFT        26         // Deprecated
#define OBSOLETE_CH_TM_MASK         (0x3 << OBSOLETE_CH_TM_SHIFT) // Deprecated

#define CH_HAS_DIFF        0x10000000

#define CH_NO_SORT         0x20000000

#define CH_NO_FILTER       0x40000000
 
#define OBSOLETE_CH_NON_PERSISTED_TREE 0x80000000

#define OBSOLETE_CH2_LAZY_LOADED     0x0001 // Deprecated
#define OBSOLETE_CH2_HAS_INODE2INDEX 0x0002 // Deprecated

#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_SIZE      0x00060000  
#define CHCOL_TIMESTAMP 0x00070000  
#define CHCOL_FORMAT    0x000F0000  
 
#define CHCOL_DEFHIDDEN 0x00100000  
#define CHCOL_DRAGHINT  0x00200000  
#define OBSOLETE_CHCOL_INODENAME 0x00400000  // Deprecated
#define CHCOL_CHECKBOX  0x00800000  
 

#define CHITEM_BOLD          0x0001 
#define CHITEM_ITALIC        0x0002 
#define CHITEM_UNDER         0x0004 
#define CHITEM_STRIKE        0x0008 
#define CHITEM_GRAY          0x0010 
#define CHITEM_CHKST_MASK        0x0060 
#define   CHITEM_CHKST_UNCHECKED  0x0000 
#define   CHITEM_CHKST_PARTIAL    0x0020 
#define   CHITEM_CHKST_CHECKED    0x0040 

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

#define GCIF_SELECTION 0x1 
#define GCIF_CURRENT   0x2 

enum item_query_method_t
{
  iqm_bwn,
  iqm_ctx,
};
 
enum item_type_query_t
{
  itq_functions,
  itq_types,
};


/// actions", so there is some confusion in the naming.
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 = 5;  
                      // 4: extended storage for builtin id from 6 bits to 8
                      // 5: added checked() for CHCOL_CHECKBOX support
  uint8 reserved = 0;
  uint8 flags2;      
  int8 builtin_id;
  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,
          uint8 flags2_ = 0,
          twidget_type_t widget_type_ = BWN_UNKNOWN)
    : flags2(flags2_),
      builtin_id(widget_type_),
      flags(flags_),
      title(title_),
      columns(columns_),
      widths(widths_),
      header(header_)
      {
        auto old_builtin_id = ((flags & OBSOLETE_CH_BUILTIN_MASK) >> OBSOLETE_CH_BUILTIN_SHIFT) - 1;
 
        if ( old_builtin_id != BWN_UNKNOWN )
        {
          QASSERT(3449, builtin_id == BWN_UNKNOWN);
          builtin_id = old_builtin_id;
 
          flags &= ~OBSOLETE_CH_BUILTIN_MASK;
        }
 
        QASSERT(3450, static_cast<int32_t>(static_cast<int8_t>(widget_type_)) == widget_type_);
      }
  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; }
  twidget_type_t get_builtin_number() const
  {
    auto old_id = ((flags & OBSOLETE_CH_BUILTIN_MASK) >> OBSOLETE_CH_BUILTIN_SHIFT) - 1;
    if ( version < 4 )
      return old_id;
    QASSERT(3451, old_id == -1);
    return (signed char) builtin_id;
  }
  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 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 lazy-loaded?
  bool is_lazy_loaded() const { return version >= 3 && (flags2 & 0x0001) != 0; }
  // chooser_implement inode2index

  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,
            uint8 flags2_ = 0,
            twidget_type_t widget_type_ = BWN_UNKNOWN)
    : chooser_base_t(
              (flags_ & ~CH_MULTI),
              columns_, widths_, header_,
              title_,
              flags2_,
              widget_type_) {}

  //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(ssize_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); }


  virtual cbret_t idaapi checked(size_t /*n*/, int /*check_state*/) newapi
  {
    return cbret_t();
  }
 
protected:
  ssize_t new_sel_after_del(size_t n) const
  {
    size_t cnt = get_count();
    // assert: n < cnt
    return n + 1 < cnt
         ? ssize_t(n + 1)
         : ssize_t(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 ssize_t(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,
          uint8 flags2_ = 0,
          twidget_type_t widget_type_ = BWN_UNKNOWN)
    : chooser_base_t(
              flags_ | CH_MULTI,
              columns_, widths_, header_,
              title_,
              flags2_,
              widget_type_) {}

  //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); }


  virtual cbres_t idaapi checked(size_t /*n*/, int /*check_state*/) newapi
  {
    return NOTHING_CHANGED;
  }
 
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,      
  CDVH_LINES_FOLD_STATE,     
  CDVH_LINES_FOLD_TOGGLE,    
};
 
//-------------------------------------------------------------------------
#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);

enum place_collapsible_state_t
{
  pcs_none = 0,  
  pcs_expanded,  
  pcs_collapsed, 
};
 

/// Called by the UI for each visible line to draw the fold indicator.
/// \param cv  pointer to the code viewer (nullptr for custom data viewers)
/// \param p   the line position in the code viewer
/// \param ud  user data registered with the callbacks
/// \return the line's fold state
/// \note Must be paired with ::code_viewer_fold_toggle_t.
 
typedef place_collapsible_state_t idaapi code_viewer_fold_state_t(TWidget *cv, const place_t *p, void *ud);
 

 
typedef bool idaapi code_viewer_fold_toggle_t(TWidget *cv, const place_t *p, 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);
  }
};
 
//------------------------------------------------------------------------
struct cli_completion_t
{
  qstring text;
  qstring hint;
  qstring doc;
};
DECLARE_TYPE_AS_MOVABLE(cli_completion_t);
typedef qvector<cli_completion_t> cli_completion_vec_t;
 
//-------------------------------------------------------------------------
struct cli_completions_t
{
  size_t cb = sizeof(cli_completions_t);
  cli_completion_vec_t entries;
  int match_start = -1;
  int match_end = -1;
 
  size_t size() const { return entries.size(); }
  bool empty() const { return entries.empty(); }
 
  void clear()
  {
    entries.clear();
    match_start = -1;
    match_end = -1;
  };
 
  void swap(cli_completions_t &r)
  {
    entries.swap(r.entries);
    qswap(match_start, r.match_start);
    qswap(match_end, r.match_end);
  }
};


/// 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);

  bool (idaapi *find_completions_ex)(
          cli_completions_t *out,
          const char *line,
          int x,
          size_t max_results);
};
 
//---------------------------------------------------------------------------
#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;
    cur_seg_info = nullptr;
    cur_func_info = nullptr;
    cur_fchunk_info = 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; 
 
  segment_info_t *cur_seg_info;      
  func_entry_info_t *cur_func_info;  
  fchunk_info_t *cur_fchunk_info;    
};
 
//-------------------------------------------------------------------------
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,
          code_viewer_fold_state_t *_fold_state = nullptr,
          code_viewer_fold_toggle_t *_fold_toggle = 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),
      fold_state(_fold_state),
      fold_toggle(_fold_toggle)
  {}
  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;
  code_viewer_fold_state_t *fold_state;
  code_viewer_fold_toggle_t *fold_toggle;
 
  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).
/// GUI-only: in headless builds (idalib/idat) this always returns false
/// \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;
}
 

/// whenever something is queued for the main thread
/// (execute_sync requests from worker threads), dispatches the
/// queued work, then sleeps again. Returns when stop_serving() is called
/// In GUI mode this is a no-op because Qt's own event loop
/// already serves this role. Must be called from the main thread.
 
inline void serve()
{
  callui(ui_serve);
}
 

/// in GUI mode.
 
THREAD_SAFE inline void stop_serving()
{
  callui(ui_stop_serving);
}
 
//-------------------------------------------------------------------------

/// 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(builtin_widgets_mask_t mask=IWID_ALL)
{
  return (TWidget *)callui(ui_get_last_widget, low(mask), high(mask)).vptr;
}

/// Note: changes will not apply! It is the caller's job to apply the resulting out_tif and out_name.
/// \param[out] errbuf   (::qstring *) the output string for errors
/// \param[out] out_tif  (tinfo_t *) tif for created type
/// \param[out] out_name (::qstring *) new name of type
/// \param      func_ea  (::ea_t) function start address
/// \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, qstring *out_name, ea_t func_ea, tinfo_t *tif, const char *name)
{
  return callui(ui_prompt_function_prototype, errbuf, out_tif, out_name, func_ea, tif, name).cnd;
}
 

/// \param[out] errbuf - (::qstring *) the output string for errors
/// \param[out] out_tif - (tinfo_t *) tif for created type
/// \param[out] out_name - (::qstring *) new name of 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
 
DEPRECATED inline bool prompt_function_prototype_ex(qstring *errbuf, tinfo_t *out_tif, qstring *out_name, func_t *pfn, tinfo_t *tif, const char *name)
{
  return callui(ui_obsolete_prompt_function_prototype_2, errbuf, out_tif, out_name, 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_TITREE, 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_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 'func_ea' is a valid function and the window was displayed,  \n
///                 nullptr otherwise
 
inline TWidget *open_frame_window_ea(ea_t func_ea, uval_t offset)
{
  return (TWidget *) callui(ui_open_builtin2, BWN_FRAME, func_ea, offset).vptr;
}
 

/// \param pfn     function to analyze
/// \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
 
DEPRECATED 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;
}


/// \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_stkvar_xref_ea).
/// \param func_ea     function start address
/// \param stkvar_tid  frame variable TID
/// \return ea of the selected xref, BADADDR if none selected
 
inline ea_t choose_stkvar_xref_ea(ea_t func_ea, tid_t stkvar_tid)
{
  ea_t ea;
  callui(ui_choose, chtype_stkvar_xref_ea, &ea, func_ea, stkvar_tid);
  return ea;
}
 

/// \deprecated Use choose_stkvar_xref_ea() for safer access.
/// Choose an xref to a stack variable (::ui_choose, ::chtype_stkvar_xref).
/// \param pfn         function
/// \param srkvar_tid  frame variable TID
/// \return ea of the selected xref, BADADDR if none selected
 
DEPRECATED 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 ea_t choose_func_ea(const char *title, ea_t default_ea)
{
  return callui(ui_choose, chtype_func_ea, title, default_ea).ea;
}
 

/// \param title       chooser title
/// \param default_ea  ea of function to select by default
/// \return pointer to function that was selected, nullptr if none selected
 
inline func_t *choose_func(const char *title, ea_t default_ea)
{
  return callui(ui_choose, chtype_func, title, default_ea).fptr;
}
 

/// \param title       chooser title
/// \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 default_ea  ea of segment to select by default
/// \return pointer to segment that was selected, nullptr if none selected
 
inline ea_t choose_segment(const char *title, ea_t default_ea)
{
  return callui(ui_choose, chtype_segment, title, default_ea).ea;
}
 

/// \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 attempts to find the chooser 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);
  ssize_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;
}

 
inline bool open_ida_link(const char *uri) { return callui(ui_open_ida_link, uri).cnd; }
 
#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 multiline 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 hide the No button (e.g., when only Yes/Cancel semantics are wanted),
  the following keyword can be used:
 
  HIDENO
 
  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-2026 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;
}
DEPRECATED inline TWidget *open_calls_window(ea_t ea)
{
  return (TWidget *) callui(ui_open_builtin, BWN_RESERVED_1, ea).vptr;
}
DEPRECATED inline bool prompt_function_prototype(qstring *errbuf, tinfo_t *out_tif, func_t *pfn, tinfo_t *tif, const char *name)
{
  return callui(ui_obsolete_prompt_function_prototype, errbuf, out_tif, pfn, tif, name).cnd;
}
idaman DEPRECATED void ida_export ida_checkmem(const char *file, int line);
 
idaman DEPRECATED void ida_export request_refresh(uint64 mask, bool cnd=true);
idaman DEPRECATED bool ida_export is_refresh_requested(uint64 mask);
#  ifndef SWIG
idaman DEPRECATED uint64 ida_export get_dirty_infos();
#  endif // SWIG
 
#endif
 
#endif // __KERNWIN_HPP