cc-interface.hh

Go to the documentation of this file.

/* src/cc-interface.hh
 *
 * Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007 The University of York
 * Copyright 2007 by Paul Emsley
 * Copyright 2008, 2009, 2010, 2011, 2012 by The University of Oxford
 * Copyright 2015 by Medical Research Council
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc.,  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#ifndef CC_INTERFACE_HH
#define CC_INTERFACE_HH

#include <gtk/gtk.h>

#ifdef USE_GUILE
#include <libguile.h>
#endif // USE_GUILE

#ifdef USE_PYTHON
#include "Python.h"
#endif

#include "utils/coot-utils.hh"
#include "coot-utils/coot-coord-utils.hh"
#include "coot-utils/coot-density-stats.hh"

#include "ligand/dipole.hh"
#include "high-res/sequence-assignment.hh" // for residue_range_t

#include "coords/mmdb-extras.h"
#include "coords/mmdb-crystal.h"

#include "pli/flev-annotations.hh" // animated ligand interactions
#include "named-rotamer-score.hh"

#include "coords/phenix-geo.hh"

namespace coot {

   class alias_path_t {
   public:
      int index;
      std::string s;
      bool flag;
      alias_path_t(int index_in, const std::string &s_in, bool flag_in) : s(s_in) {
         index = index_in;
         flag = flag_in;
      }
   };

   //
   class pisa_interface_bond_info_t {
   public:
      pisa_interface_bond_info_t() {
         n_h_bonds = 0;
         n_salt_bridges = 0;
         n_cov_bonds = 0;
         n_ss_bonds = 0;
      }
      int n_h_bonds;
      int n_salt_bridges;
      int n_cov_bonds;
      int n_ss_bonds;
   };

#ifdef USE_GUILE
   pisa_interface_bond_info_t get_pisa_interface_bond_info_scm(SCM bonds_info_scm);
#endif
#ifdef USE_PYTHON
   pisa_interface_bond_info_t get_pisa_interface_bond_info_py(PyObject *bonds_info_py);
#endif

}

std::string git_commit();

std::vector<std::string> filtered_by_glob(const std::string &pre_directory,
                                          int data_type);
/*  Return 1 if search appears in list, 0 if not) */
short int
string_member(const std::string &search, const std::vector<std::string> &list);
bool compare_strings(const std::string &a, const std::string &b);


std::string pre_directory_file_selection(GtkWidget *sort_button);
void filelist_into_fileselection_clist(GtkWidget *fileselection, const std::vector<std::string> &v);

GtkWidget *wrapped_nothing_bad_dialog(const std::string &label);

std::pair<short int, float> float_from_entry(GtkWidget *entry);
std::pair<short int, int>   int_from_entry(GtkWidget *entry);

void
add_validation_mol_menu_item(int imol, const std::string &name, GtkWidget *menu, GtkSignalFunc callback);
void create_initial_validation_graph_submenu_generic(GtkWidget *window1,
                                                     const std::string &menu_name,
                                                     const std::string &sub_menu_name);

std::string probe_dots_short_contact_name_to_expanded_name(const std::string &short_name);

// To be used to (typically) get the menu item text label from chain
// option menus (rather than the ugly/broken casting of
// GtkPositionType data.  A wrapper to a static graphics_info_t
// function.
std::string menu_item_label(GtkWidget *menu_item);

// CaBLAM
std::vector<std::pair<coot::residue_spec_t, double> >
add_cablam_markup(int imol, const std::string &cablam_file_name);
#ifdef USE_GUILE
SCM add_cablam_markup_scm(int imol, const std::string &cablam_log_file_name);
#endif
#ifdef USE_PYTHON
PyObject *add_cablam_markup_py(int imol, const std::string &cablam_log_file_name);
#endif

/*  ---------------------------------------------------------------------- */
/*                       go to atom   :                                    */
/*  ---------------------------------------------------------------------- */

void set_rotation_centre(const clipper::Coord_orth &pos);

#ifdef USE_GUILE
//
// Pass the current values, return new values
SCM goto_next_atom_maybe_scm(const char *chain_id, int resno, const char *ins_code, const char *atom_name);
SCM goto_prev_atom_maybe_scm(const char *chain_id, int resno, const char *ins_code, const char *atom_name);
#endif

#ifdef USE_PYTHON

PyObject *goto_next_atom_maybe_py(const char *chain_id, int resno, const char *ins_code, const char *atom_name);
PyObject *goto_prev_atom_maybe_py(const char *chain_id, int resno, const char *ins_code, const char *atom_name);
#endif

int set_go_to_atom_from_spec(const coot::atom_spec_t &atom_spec);
int set_go_to_atom_from_res_spec(const coot::residue_spec_t &spec);
#ifdef USE_GUILE
int set_go_to_atom_from_res_spec_scm(SCM residue_spec);
int set_go_to_atom_from_atom_spec_scm(SCM residue_spec);
#endif
#ifdef USE_PYTHON
int set_go_to_atom_from_res_spec_py(PyObject *residue_spec);
int set_go_to_atom_from_atom_spec_py(PyObject *residue_spec);
#endif


// This is to make porting the active atom more easy for Bernhard.
// Return a class rather than a list, and rewrite the active-residue
// function use this atom-spec.  The first value of the pair indicates
// if an atom spec was found.
//
std::pair<bool, std::pair<int, coot::atom_spec_t> > active_atom_spec();
#ifdef USE_PYTHON
// return a tuple of (Py_Bool (number, atom_spec))
PyObject *active_atom_spec_py();
#endif // USE_PYTHON


/*  ---------------------------------------------------------------------- */
/*                       symmetry functions:                               */
/*  ---------------------------------------------------------------------- */
// get the symmetry operators strings for the given molecule
//
#ifdef USE_GUILE


SCM get_symmetry(int imol);
#endif // USE_GUILE

#ifdef USE_PYTHON
// return a python object as a list (or some other python container)
PyObject *get_symmetry_py(int imol);
#endif // USE_PYTHON

int clashes_with_symmetry(int imol, const char *chain_id, int res_no, const char *ins_code,
                          float clash_dist);

void add_molecular_symmetry(int imol,
                            double r_00, double r_01, double r_02,
                            double r_10, double r_11, double r_12,
                            double r_20, double r_21, double r_22,
                            double about_origin_x,
                            double about_origin_y,
                            double about_origin_z);

int add_molecular_symmetry_from_mtrix_from_file(int imol, const std::string &file_name);

int add_molecular_symmetry_from_mtrix_from_self_file(int imol);



/*  ---------------------------------------------------------------------- */
/*                       map functions:                                    */
/*  ---------------------------------------------------------------------- */

std::vector<int> auto_read_make_and_draw_maps(const char *filename);
std::vector<int> auto_read_make_and_draw_maps_from_mtz(const char *filename);
std::vector<int> auto_read_make_and_draw_maps_from_cns(const char *filename);


void add_map_colour_mol_menu_item(int imol, const std::string &name,
                                  GtkWidget *sub_menu, GtkSignalFunc callback);
/* Actually this function is generic and could be renamed so. */
void add_map_scroll_wheel_mol_menu_item(int imol,
                                        const std::string &name,
                                        GtkWidget *menu,
                                        GtkSignalFunc callback);

int sharpen_blur_map(int imol_map, float b_factor);

int sharpen_blur_map_with_resampling(int imol_map, float b_factor, float resample_factor);

#ifdef USE_GUILE
void multi_sharpen_blur_map_scm(int imol_map, SCM b_factors_list);
#endif

#ifdef USE_PYTHON
void multi_sharpen_blur_map_py(int imol_map, PyObject *b_factors_list);
#endif

#ifdef USE_PYTHON
PyObject *amplitude_vs_resolution_py(int mol_map);
#endif

#ifdef USE_GUILE
SCM amplitude_vs_resolution_scm(int mol_map);
#endif

int flip_hand(int imol_map);

#ifndef SWIG
int analyse_map_point_density_change(const std::vector<int> &map_number_list);
#endif

#ifdef USE_PYTHON
int analyse_map_point_density_change_py(PyObject *map_number_list);
#endif

void go_to_map_molecule_centre(int imol_map);

float b_factor_from_map(int imol_map);

#ifdef USE_GUILE
SCM map_colour_components(int imol);
#endif // GUILE

#ifdef USE_PYTHON
//
//
PyObject *map_colour_components_py(int imol);
#endif // PYTHON

int read_ccp4_map(const std::string &filename, int is_diff_map_flag);

int handle_read_ccp4_map(const std::string &filename, int is_diff_map_flag);

int handle_read_emdb_data(const std::string &dir_name);


#ifdef USE_GUILE

SCM multi_residue_torsion_fit_scm(int imol, SCM residues_specs_scm, int n_trials);
#endif // GUILE
void multi_residue_torsion_fit(int imol, const std::vector<coot::residue_spec_t> &specs, int n_trials);

#ifdef USE_PYTHON

PyObject *multi_residue_torsion_fit_py(int imol, PyObject *residues_specs_py, int n_trials);
#endif // PYTHON


/*  ------------------------------------------------------------------------ */
/*                         merge fragments                                   */
/*  ------------------------------------------------------------------------ */
//
//
int merge_fragments(int imol);


/*  ------------------------------------------------------------------------ */
/*                         refmac stuff                                      */
/*  ------------------------------------------------------------------------ */
//
//
void
execute_refmac_real(std::string pdb_in_filename,
                    std::string pdb_out_filename,
                    std::string mtz_in_filename,
                    std::string mtz_out_filename,
                    std::string cif_lib_filename, /* use "" for none */
                    std::string fobs_col_name,
                    std::string sigfobs_col_name,
                    std::string r_free_col_name,
                    short int have_sensible_free_r_flag,
                    short int make_molecules_flag,
                    std::string refmac_count_string,
                    int swap_map_colours_post_refmac_flag,
                    int imol_refmac_map,
                    int diff_map_flag,
                    int phase_combine_flag,
                    std::string phib_string,
                    std::string fom_string,
                    std::string ccp4i_project_dir);

std::string refmac_name(int imol);



/*  ------------------------------------------------------------------- */
/*                    file selection                                    */
/*  ------------------------------------------------------------------- */

namespace coot {
   class str_mtime {
   public:
      str_mtime(std::string file_in, time_t mtime_in) {
         mtime = mtime_in;
         file = file_in;
      }
      str_mtime() {}
      time_t mtime;
      std::string file;
   };

   class file_attribs_info_t {
   public:
      std::string directory_prefix;
      std::vector<str_mtime> file_mtimes;
   };
}


bool compare_mtimes(coot::str_mtime a, coot::str_mtime b);

std::vector<std::pair<std::string, std::string> > parse_ccp4i_defs(const std::string &filename);

std::string ccp4_project_directory(const std::string &ccp4_project_name);

/*  -------------------------------------------------------------------- */
/*                     history                                           */
/*  -------------------------------------------------------------------- */
#include "command-arg.hh"

void add_to_history(const std::vector<std::string> &ls);
void add_to_history_simple(const std::string &cmd);
void add_to_history_typed(const std::string &command,
                          const std::vector<coot::command_arg_t> &args);
std::string single_quote(const std::string &s);
std::string pythonize_command_name(const std::string &s);
std::string schemize_command_name(const std::string &s);
std::string languagize_command(const std::vector<std::string> &command_parts);

void add_to_database(const std::vector<std::string> &command_strings);


/*  ----------------------------------------------------------------------- */
/*                         Merge Molecules                                  */
/*  ----------------------------------------------------------------------- */
#include "merge-molecule-results-info-t.hh"
// return the status and vector of chain-ids of the new chain ids.
//
std::pair<int, std::vector<merge_molecule_results_info_t> > merge_molecules_by_vector(const std::vector<int> &add_molecules, int imol);

/*  ----------------------------------------------------------------------- */
/*                         Dictionaries                                     */
/*  ----------------------------------------------------------------------- */
std::vector<std::string> dictionary_entries();
void debug_dictionary();
// this can throw an exception
std::string SMILES_for_comp_id(const std::string &comp_id);
#ifdef USE_GUILE
SCM dictionaries_read();
SCM cif_file_for_comp_id_scm(const std::string &comp_id);
SCM dictionary_entries_scm();
SCM SMILES_for_comp_id_scm(const std::string &comp_id);
#endif // USE_GUILE


#ifdef USE_PYTHON
PyObject *dictionaries_read_py();
PyObject *cif_file_for_comp_id_py(const std::string &comp_id);
PyObject *dictionary_entries_py();
PyObject *SMILES_for_comp_id_py(const std::string &comp_id);
#endif // PYTHON


/*  ----------------------------------------------------------------------- */
/*                         Restraints                                       */
/*  ----------------------------------------------------------------------- */
#ifdef USE_GUILE
SCM monomer_restraints(const char *monomer_type);

SCM set_monomer_restraints(const char *monomer_type, SCM restraints);
#endif // USE_GUILE

#ifdef USE_PYTHON
PyObject *monomer_restraints_py(std::string monomer_type);
PyObject *monomer_restraints_for_molecule_py(std::string monomer_type, int imol);
PyObject *set_monomer_restraints_py(const char *monomer_type, PyObject *restraints);
#endif // USE_PYTHON


/*  ----------------------------------------------------------------------- */
/*                      list nomenclature errors                            */
/*  ----------------------------------------------------------------------- */
std::vector<std::pair<std::string, coot::residue_spec_t> >
list_nomenclature_errors(int imol);

#ifdef USE_GUILE
SCM list_nomenclature_errors_scm(int imol);
#endif // USE_GUILE
#ifdef USE_PYTHON
PyObject *list_nomenclature_errors_py(int imol);
#endif // USE_PYTHON

void
show_fix_nomenclature_errors_gui(int imol,
                                 const std::vector<std::pair<std::string, coot::residue_spec_t> > &nomenclature_errors);

/*  ----------------------------------------------------------------------- */
/*                  dipole                                                  */
/*  ----------------------------------------------------------------------- */
// This is here because it uses a C++ class, coot::dipole
//
#ifdef USE_GUILE
SCM dipole_to_scm(std::pair<coot::dipole, int> dp);
#endif // USE_GUILE
#ifdef USE_PYTHON
PyObject *dipole_to_py(std::pair<coot::dipole, int> dp);
#endif // USE_PYTHON


#ifdef USE_PYTHON
PyObject *coot_has_guile();
#endif

bool coot_can_do_lidia_p();


/* commands to run python commands from guile and vice versa */
/* we ignore return values for now */
#ifdef USE_PYTHON
PyObject *run_scheme_command(const char *scheme_command);
#endif // USE_PYTHON
#ifdef USE_GUILE
SCM run_python_command(const char *python_command);
#endif // USE_GUILE

// This is not inside a #ifdef USE_PYTHON because we want to use it
// from the guile level and USE_PYTHON is not passed as an argument to
// swig when generating coot_wrap_guile.cc.
//
// [Consider removing safe_python_command_by_char_star() which is
// conditionally compiled].
int pyrun_simple_string(const char *python_command);

#ifdef USE_GUILE
// Return a list describing a residue like that returned by
// residues-matching-criteria (list return-val chain-id resno ins-code)
// This is a library function really.  There should be somewhere else to put it.
// It doesn't need expression at the scripting level.
// return a null list on problem
SCM residue_spec_to_scm(const coot::residue_spec_t &res);
#endif

#ifdef USE_PYTHON
// Return a list describing a residue like that returned by
// residues-matching-criteria [return_val, chain_id, resno, ins_code]
// This is a library function really.  There should be somewhere else to put it.
// It doesn't need expression at the scripting level.
// return a null list on problem
PyObject *residue_spec_to_py(const coot::residue_spec_t &res);
#endif

#ifdef USE_PYTHON
PyObject *residue_spec_make_triple_py(PyObject *residue_spec_py);
#endif // USE_PYTHON

#ifdef USE_GUILE
coot::residue_spec_t residue_spec_from_scm(SCM residue_in);
#endif

#ifdef USE_PYTHON
coot::residue_spec_t residue_spec_from_py(PyObject *residue_in);
#endif

// return a spec for the first residue with the given type.
// test the returned spec for unset_p().
//
coot::residue_spec_t get_residue_by_type(int imol, const std::string &residue_type);

std::vector<coot::residue_spec_t> get_residue_specs_in_mol(int imol, const std::string &residue_type);

#ifdef USE_PYTHON
// Always returns a list
PyObject *get_residue_specs_in_mol_py(int imol, const std::string &residue_type);
#endif

#ifdef USE_GUILE
// return a residue spec or scheme false
SCM get_residue_by_type_scm(int, const std::string &residue_type);
#endif
#ifdef USE_PYTHON
// return a residue spec or Python False.
PyObject *get_residue_by_type_py(int, const std::string &residue_type);
#endif


/*  ----------------------------------------------------------------------- */
/*               Atom info                                                  */
/*  ----------------------------------------------------------------------- */

#ifdef USE_GUILE
SCM atom_info_string_scm(int imol, const char *chain_id, int resno,
                         const char *ins_code, const char *atname,
                         const char *altconf);
SCM molecule_to_pdb_string_scm(int imol);
#endif // USE_GUILE

std::string resname_from_serial_number(int imol, const char *chain_id, int serial_num);

std::string residue_name(int imol, const std::string &chain_id, int resno, const std::string &ins_code);

//
int serial_number_from_residue_specs(int imol, const std::string &chain_id, int res_no, const std::string &ins_code);


#ifdef USE_GUILE
SCM residue_info(int imol, const char* chain_id, int resno, const char *ins_code);
SCM residue_name_scm(int imol, const char* chain_id, int resno, const char *ins_code);

SCM chain_fragments_scm(int imol, short int screen_output_also);

int add_molecule(SCM molecule_expression, const char *name);

int clear_and_update_molecule(int molecule_number, SCM molecule_expression);

SCM active_residue();

SCM closest_atom_simple_scm();

SCM closest_atom(int imol);

SCM closest_atom_raw_scm();

SCM residues_near_residue(int imol, SCM residue_in_scm, float radius);

SCM residues_near_residues_scm(int imol, SCM residues_in, float radius);

SCM residues_near_position_scm(int imol, SCM pos, float radius);

void label_closest_atoms_in_neighbour_residues_scm(int imol, SCM residue_spec_scm, float radius);

#endif        /* USE_GUILE */

void hydrogenate_region(float radius);

void add_hydrogens_from_file(int imol, std::string pdb_with_Hs_file_name);

/* Here the Python code for ATOM INFO */

#ifdef USE_PYTHON
PyObject *atom_info_string_py(int imol, const char *chain_id, int resno,
                              const char *ins_code, const char *atname,
                              const char *altconf);

PyObject *molecule_to_pdb_string_py(int imol);

//
PyObject *residue_info_py(int imol, const char* chain_id, int resno, const char *ins_code);
PyObject *residue_name_py(int imol, const char* chain_id, int resno, const char *ins_code);

// the expanded form of this is in c-interface.h
PyObject *residue_centre_from_spec_py(int imol,
                                      PyObject *spec_py);

PyObject *chain_fragments_py(int imol, short int screen_output_also);

#ifdef USE_PYTHON
void set_b_factor_residues_py(int imol, PyObject *residue_specs_b_value_tuple_list_py);
#endif

#ifdef USE_GUILE
void set_b_factor_residues_scm(int imol, SCM residue_specs_b_value_tuple_list_scm);
#endif



// And going the other way, given an python-expression, update
// molecule_number by the given molecule.  Clear what's currently
// there first though.
//
int clear_and_update_molecule_py(int molecule_number, PyObject *molecule_expression);
// return a molecule number, -1 on error
int add_molecule_py(PyObject *molecule_expression, const char *name);

//
//
PyObject *active_residue_py();

PyObject *closest_atom_simple_py();

//
//
PyObject *closest_atom_py(int imol);

PyObject *closest_atom_raw_py();


// Return residue specs for residues that have atoms that are
// closer than radius Angstroems to any atom in the residue
// specified by residue_in.
//
PyObject *residues_near_residue_py(int imol, PyObject *residue_in, float radius);

// Return residue specs for residues that have atoms that are
// closer than radius Angstroems to any atom in the residues
// specified by residues_in.
//
PyObject *residues_near_residues_py(int imol, PyObject *residues_in, float radius);

PyObject *residues_near_position_py(int imol, PyObject *pos_in, float radius);

void label_closest_atoms_in_neighbour_residues_py(int imol, PyObject *residue_spec_py, float radius);

//
PyObject *get_bonds_representation(int imol);

//
PyObject *get_dictionary_radii();

//          the specified residue
PyObject *get_environment_distances_representation_py(int imol, PyObject *residue_spec_py);

//
PyObject *get_intermediate_atoms_bonds_representation();

#endif // USE_PYTHON

//
// 0 means off, 1 means on.
// Given the current wiring of the refinement, this is always 0, i.e. refine_residues()
// will return only after the atoms have finished moving.
int get_continue_updating_refinement_atoms_state();



// status bar atom info text here?!
std::string atom_info_as_text_for_statusbar(int atom_index, int imol);
std::string atom_info_as_text_for_statusbar(int atom_index, int imol,
                                            const std::pair<symm_trans_t, Cell_Translation> &sts);


/*  ----------------------------------------------------------------------- */
/*                  Refinement                                              */
/*  ----------------------------------------------------------------------- */


#ifdef USE_GUILE
SCM all_residues_with_serial_numbers_scm(int imol);
#endif
#ifdef USE_PYTHON
PyObject *all_residues_with_serial_numbers_py(int imol);
#endif


void regularize_residues(int imol, const std::vector<coot::residue_spec_t> &residues);

std::string mtz_file_name(int imol);

#ifdef USE_GUILE

SCM refine_zone_with_full_residue_spec_scm(int imol, const char *chain_id,
                                           int resno1,
                                           const char*inscode_1,
                                           int resno2,
                                           const char*inscode_2,
                                           const char *altconf);
#endif // USE_GUILE

#ifdef USE_PYTHON
PyObject *refine_zone_with_full_residue_spec_py(int imol, const char *chain_id,
                                           int resno1,
                                           const char*inscode_1,
                                           int resno2,
                                           const char*inscode_2,
                                           const char *altconf);
#endif // USE_PYTHON

void set_show_intermediate_atoms_rota_markup(short int state);
void set_show_intermediate_atoms_rama_markup(short int state);

void set_cryo_em_refinement(bool mode);
bool get_cryo_em_refinement();

#ifdef USE_GUILE
SCM accept_moving_atoms_scm();
#endif
#ifdef USE_PYTHON
PyObject *accept_moving_atoms_py();
#endif


#ifdef USE_PYTHON
void register_post_intermediate_atoms_moved_hook(PyObject *function_name);
#endif

void set_regenerate_bonds_needs_make_bonds_type_checked(bool state);
bool get_regenerate_bonds_needs_make_bonds_type_checked_state();



/*  ----------------------------------------------------------------------- */
/*                  rigid body fitting (multiple residue ranges)            */
/*  ----------------------------------------------------------------------- */

int rigid_body_fit_with_residue_ranges(int imol, const std::vector<coot::residue_range_t> &ranges);

// Model morphing (average the atom shift by using shifts of the
// atoms within shift_average_radius A of the central residue).
//
// return 0 on fail to move atoms and 1 on fitting happened.
//
int morph_fit_all(int imol, float transformation_averaging_radius);

int morph_fit_chain(int imol, std::string chain_id, float transformation_averaging_radius);
#ifdef USE_GUILE
int morph_fit_residues_scm(int imol, SCM residue_specs,       float transformation_averaging_radius);
#endif
#ifdef USE_PYTHON
int morph_fit_residues_py( int imol, PyObject *residue_specs, float transformation_averaging_radius);
#endif
int morph_fit_residues(int imol, const std::vector<coot::residue_spec_t> &residue_specs,
                       float transformation_averaging_radius);

int morph_fit_by_secondary_structure_elements(int imol, const std::string &chain_id);


/*  ----------------------------------------------------------------------- */
/*                  check water baddies                                     */
/*  ----------------------------------------------------------------------- */

std::vector<coot::atom_spec_t>
check_waters_baddies(int imol, float b_factor_lim, float map_sigma_lim, float min_dist, float max_dist, short int part_occ_contact_flag, short int zero_occ_flag, short int logical_operator_and_or_flag);

// blobs, returning position and volume
//
std::vector<std::pair<clipper::Coord_orth, double> >
find_blobs(int imol_model, int imol_map, float cut_off_density_level);

#ifdef USE_GUILE
SCM find_blobs_scm(int imol_model, int imol_map, float cut_off_density_level);
#endif
#ifdef USE_PYTHON
PyObject *find_blobs_py(int imol_model, int imol_map, float cut_off_density_level);
#endif

void b_factor_distribution_graph(int imol);

/*  ----------------------------------------------------------------------- */
/*                  water chain                                             */
/*  ----------------------------------------------------------------------- */


#ifdef USE_GUILE
SCM water_chain_from_shelx_ins_scm(int imol);
SCM water_chain_scm(int imol);
#endif

#ifdef USE_PYTHON
/* return the chain id of the water chain from a shelx molecule.  Raw interface.

Return False if no chain or bad imol*/
PyObject *water_chain_from_shelx_ins_py(int imol);
PyObject *water_chain_py(int imol);
#endif



/*  ----------------------------------------------------------------------- */
/*                  glyco tools                                             */
/*  ----------------------------------------------------------------------- */

void
print_glyco_tree(int imol, const std::string &chain_id, int resno, const std::string &ins_code);



/*  ----------------------------------------------------------------------- */
/*                  variance map                                            */
/*  ----------------------------------------------------------------------- */
int make_variance_map(std::vector<int> map_molecule_number_vec);
#ifdef USE_GUILE
int make_variance_map_scm(SCM map_molecule_number_list);
#endif
#ifdef USE_PYTHON
int make_variance_map_py(PyObject *map_molecule_number_list);
#endif

/*  ----------------------------------------------------------------------- */
/*                  spin search                                             */
/*  ----------------------------------------------------------------------- */

void spin_search_by_atom_vectors(int imol_map, int imol, const std::string &chain_id, int resno, const std::string &ins_code, const std::pair<std::string, std::string> &direction_atoms_list, const std::vector<std::string> &moving_atoms_list);
#ifdef USE_GUILE
void spin_search(int imol_map, int imol, const char *chain_id, int resno, const char *ins_code, SCM direction_atoms_list, SCM moving_atoms_list);
void spin_N_scm(int imol, SCM residue_spec_scm, float angle);

SCM CG_spin_search_scm(int imol_model, int imol_map);
#endif

#ifdef USE_PYTHON
void spin_search_py(int imol_map, int imol, const char *chain_id, int resno, const char *ins_code, PyObject *direction_atoms_list, PyObject *moving_atoms_list);
void spin_N_py(int imol, PyObject *residue_spec, float angle);

PyObject *CG_spin_search_py(int imol_model, int imol_map);

#endif



/*  ----------------------------------------------------------------------- */
/*                  monomer lib                                             */
/*  ----------------------------------------------------------------------- */
std::vector<std::pair<std::string, std::string> > monomer_lib_3_letter_codes_matching(const std::string &search_string, short int allow_minimal_descriptions_flag);

void on_monomer_lib_search_results_button_press (GtkButton *button, gpointer user_data);
void on_monomer_lib_sbase_molecule_button_press (GtkButton *button, gpointer user_data);

/*  ----------------------------------------------------------------------- */
/*                  mutate                                                  */
/*  ----------------------------------------------------------------------- */
int mutate_internal(int ires, const char *chain_id,
                    int imol, std::string &target_res_type);
/* a function for multimutate to make a backup and set
   have_unsaved_changes_flag themselves */

/*  ----------------------------------------------------------------------- */
/*                  ligands                                                 */
/*  ----------------------------------------------------------------------- */
coot::graph_match_info_t
overlap_ligands_internal(int imol_ligand, int imol_ref, const char *chain_id_ref,
                         int resno_ref, bool apply_rtop_flag);


/*  ----------------------------------------------------------------------- */
/*                  conformers (part of ligand search)                      */
/*  ----------------------------------------------------------------------- */

#ifdef USE_GUILE


SCM ligand_search_make_conformers_scm();
#endif

#ifdef USE_PYTHON
PyObject *ligand_search_make_conformers_py();
#endif

std::vector<int> ligand_search_make_conformers_internal();


/*  ----------------------------------------------------------------------- */
//                  animated ligand interactions
/*  ----------------------------------------------------------------------- */
void add_animated_ligand_interaction(int imol, const coot::fle_ligand_bond_t &lb);


/*  ----------------------------------------------------------------------- */
/*                  Cootaneer                                               */
/*  ----------------------------------------------------------------------- */
int cootaneer_internal(int imol_map, int imol_model, const coot::atom_spec_t &atom_spec);

#ifdef USE_GUILE
int cootaneer(int imol_map, int imol_model, SCM atom_in_fragment_atom_spec);
#endif

#ifdef USE_PYTHON
int cootaneer_py(int imol_map, int imol_model, PyObject *atom_in_fragment_atom_spec);
#endif


/*  ----------------------------------------------------------------------- */
/*                  Sequence from Map                                       */
/*  ----------------------------------------------------------------------- */

std::string sequence_from_map(int imol, const std::string &chain_id,
                              int resno_start, int resno_end, int imol_map);

void apply_sequence_to_fragment(int imol, const std::string &chain_id, int resno_start, int resno_end,
                                int imol_map, const std::string &file_name_for_sequences);

void assign_sequence_to_active_fragment();


/*  ----------------------------------------------------------------------- */
/*                  Generic Objects                                         */
/*  ----------------------------------------------------------------------- */

// return a clean name and a flag to say that this was something that
// we were interested to make a graphics object from (rather than just
// header info)
std::pair<short int, std::string> is_interesting_dots_object_next_p(const std::vector<std::string> &vs);

/*  ----------------------------------------------------------------------- */
/*                  Generic Functions                                       */
/*  ----------------------------------------------------------------------- */
#ifdef USE_GUILE
SCM generic_string_vector_to_list_internal(const std::vector<std::string> &v);
SCM generic_int_vector_to_list_internal(const std::vector<int> &v);
std::vector<std::string> generic_list_to_string_vector_internal(SCM l);
SCM rtop_to_scm(const clipper::RTop_orth &rtop);
SCM inverse_rtop_scm(SCM rtop_scm);
// expects an expr of length 5, ie: (list chain-id res-no ins-cod atom-name alt-conf)
coot::atom_spec_t atom_spec_from_scm_expression(SCM expr);
SCM atom_spec_to_scm(const coot::atom_spec_t &spec);
#endif        /* USE_GUILE */

#ifdef USE_PYTHON
PyObject *generic_string_vector_to_list_internal_py(const std::vector<std::string>&v);
PyObject *generic_int_vector_to_list_internal_py(const std::vector<int> &v);
std::vector<std::string> generic_list_to_string_vector_internal_py(PyObject *l);
PyObject *rtop_to_python(const clipper::RTop_orth &rtop);
PyObject *inverse_rtop_py(PyObject *rtop_py);
coot::atom_spec_t atom_spec_from_python_expression(PyObject *expr);
PyObject *atom_spec_to_py(const coot::atom_spec_t &spec);
#endif // PYTHON

void set_display_control_button_state(int imol, const std::string &button_type, int state);

/*  ----------------------------------------------------------------------- */
/*                  Abstraction of New molecule by symmetry functions       */
/*  ----------------------------------------------------------------------- */

mmdb::Manager *new_molecule_by_symmetry_matrix_from_molecule(mmdb::Manager *mol,
                                                            double m11, double m12, double m13,
                                                            double m21, double m22, double m23,
                                                            double m31, double m32, double m33,
                                                            double tx, double ty, double tz,
                                                            int pre_shift_to_origin_na,
                                                            int pre_shift_to_origin_nb,
                                                            int pre_shift_to_origin_nc);


/*  ----------------------------------------------------------------------- */
/*                  LIBCURL/Download                                        */
/*  ----------------------------------------------------------------------- */

   void get_coords_for_accession_code(const std::string &code);

#ifdef USE_LIBCURL
// return 0 on success.
int coot_get_url(const char *url, const char *file_name);
int coot_get_url_and_activate_curl_hook(const char *url, const char *file_name, short int do_hook_flag);
#ifdef USE_GUILE
// this handles URLs that are strings, not binaries.
SCM coot_get_url_as_string(const char *url);
// for the callback of the update binary progress bar.  How much done
// is the file that I am downloading?
SCM curl_progress_info(const char *file_name);
#endif /* USE_GUILE */
#ifdef USE_PYTHON
// this handles URLs that are strings, not binaries.
PyObject *coot_get_url_as_string_py(const char *url);
// for the callback of the update binary progress bar.  How much done
// is the file that I am downloading? Not absolutely required for python
PyObject *curl_progress_info_py(const char *file_name);
#endif /* USE_PYTHON */
// internal use
size_t write_coot_curl_data(void *buffer, size_t size, size_t nmemb, void *userp);
// internal use
size_t write_coot_curl_data_to_file(void *buffer, size_t size, size_t nmemb, void *userp);
// internal use (strings, not binaries).
std::string coot_get_url_as_string_internal(const char *url);
void *wrapped_curl_easy_perform(void *data);
void stop_curl_download(const char *file_name); // stop curling the to file_name;

std::string get_drug_mdl_via_wikipedia_and_drugbank(std::string drugname);

#endif /* USE_LIBCURL */


/*  ----------------------------------------------------------------------- */
/*                  Functions for FLEV layout callbacks                     */
/*  ----------------------------------------------------------------------- */
// orient the graphics somehow so that the interaction between
// central_residue and neighbour_residue is perpendicular to screen z.
void orient_view(int imol,
                 const coot::residue_spec_t &central_residue_spec, // ligand typically
                 const coot::residue_spec_t &neighbour_residue_spec);


/*  \brief return a list of chiral centre ids as determined from topological
    equivalence analysis based on the bond info (and element names). */
std::vector<std::string>
topological_equivalence_chiral_centres(const std::string &residue_type);




/*  ----------------------------------------------------------------------- */
/*                  Pisa internal                                           */
/*  ----------------------------------------------------------------------- */
clipper::Coord_orth
make_complementary_dotted_surfaces(int imol_1, int imol_2,
                                   std::vector<coot::residue_spec_t> &r1,
                                   std::vector<coot::residue_spec_t> &r2);
#ifdef USE_GUILE
std::vector<coot::residue_spec_t>
residue_records_list_scm_to_residue_specs(SCM mol_1_residue_records,
                                          const std::string &chain_id);
SCM symbol_value_from_record(SCM record_1, const std::string &symbol);
#endif
#ifdef USE_PYTHON
std::vector<coot::residue_spec_t>
residue_records_list_py_to_residue_specs(PyObject *mol_1_residue_records,
                                         const std::string &chain_id);
//PyObject *symbol_value_from_record(PyObject *record_1, const std::string &symbol);
#endif

void
add_generic_object_bond(int imol1, int imol2,
                        const coot::atom_spec_t &atom_spec_1,
                        const coot::atom_spec_t &atom_spec_2,
                        int generic_object_number,
                        const std::string &colour);

void
pisa_interfaces_display_only(int imol_1, int imol_2, clipper::Coord_orth centre_pt);
std::string untangle_mmdb_chain_id_string(const std::string &mmdb_chain_id_in);


/*  ----------------------------------------------------------------------- */
/*               Return Rotamer score (don't touch the model)               */
/*  ----------------------------------------------------------------------- */


std::vector<coot::named_rotamer_score> score_rotamers(int imol,
                                                      const char *chain_id,
                                                      int res_no,
                                                      const char *ins_code,
                                                      const char *alt_conf,
                                                      int imol_map,
                                                      int clash_flag,
                                                      float lowest_probability);

#ifdef USE_GUILE
//
// The density fit score is for side-chain atoms.
// return a list (possibly empty).
//
SCM score_rotamers_scm(int imol,
                       const char *chain_id,
                       int res_no,
                       const char *ins_code,
                       const char *alt_conf,
                       int imol_map,
                       int clash_flag,
                       float lowest_probability);
#endif

#ifdef USE_PYTHON
// return a list (possibly empty)
PyObject *score_rotamers_py(int imol,
                            const char *chain_id,
                            int res_no,
                            const char *ins_code,
                            const char *alt_conf,
                            int imol_map,
                            int clash_flag,
                            float lowest_probability);
#endif


/*  ----------------------------------------------------------------------- */
/*               Use Cowtan's protein_db to discover loops                  */
/*  ----------------------------------------------------------------------- */
/* \{ */
// return in the first pair, the imol of the new molecule generated
// from an atom selection of the imol_coords for the residue selection
// of the loop and the molecule number of the consolidated solutions
// (displayed in purple).  and the second of the outer pair, there is
// vector of molecule indices for each of the candidate loops.
//
// return -1 in the first of the pair on failure
//
std::pair<std::pair<int, int> , std::vector<int> >
protein_db_loops(int imol_coords,
                 const std::vector<coot::residue_spec_t> &residue_specs,
                 int imol_map, int nfrags, bool preserve_residue_names);
// so that we can create a "original loop" molecule from the atom
// specs picked (i.e. the atom selection string should extend over the
// range from the smallest residue number to the largest (in the same
// chain)).
std::string
protein_db_loop_specs_to_atom_selection_string(const std::vector<coot::residue_spec_t> &specs);
#ifdef USE_GUILE
SCM protein_db_loops_scm(int imol_coords, SCM residues_specs, int imol_map, int nfrags, bool preserve_residue_names);
#endif
#ifdef USE_PYTHON
PyObject *protein_db_loops_py(int imol_coords, PyObject *residues_specs, int imol_map, int nfrags, bool preserve_residue_names);
#endif
/* \} */


/* ------------------------------------------------------------------------- */
/*                      HOLE                                                 */
/* ------------------------------------------------------------------------- */
void hole(int imol,
          float start_x, float start_y, float start_z,
          float   end_x, float   end_y, float   end_z,
          float colour_map_multiplier, float colour_map_offset,
          int n_runs, bool show_probe_radius_graph_flag,
          std::string export_surface_dots_file_name);


// GUI stuff
void probe_radius_graph_close_callback( GtkWidget *button,
                                         GtkWidget *dialog);
void show_hole_probe_radius_graph(const std::vector<std::pair<clipper::Coord_orth, double> > &hole_path, double path_length);
void show_hole_probe_radius_graph_basic(const std::vector<std::pair<clipper::Coord_orth, double> > &hole_path, double path_length);
void show_hole_probe_radius_graph_goocanvas(const std::vector<std::pair<clipper::Coord_orth, double> > &hole_path, double path_length);


/* ------------------------------------------------------------------------- */
/*                      LINKs                                                */
/* ------------------------------------------------------------------------- */

void
make_link(int imol, coot::atom_spec_t &spec_1, coot::atom_spec_t &spec_2,
          const std::string &link_name, float length);
#ifdef USE_GUILE
void make_link_scm(int imol, SCM spec_1, SCM spec_2, const std::string&link_name, float length);
// return a list of the links in the given molecule.
// will return an empty list for non-valid (i.e. non-model) molecules
//
SCM link_info_scm(int imol);
#endif
#ifdef USE_PYTHON
void make_link_py(int imol, PyObject *spec_1, PyObject *spec_2, const std::string&link_name, float length);
// return a list of the links in the given molecule.
// will return an empty list for non-valid (i.e. non-model) molecules
//
PyObject *link_info_py(int imol);
#endif


/* ------------------------------------------------------------------------- */
/*                      Drag and drop                                        */
/* ------------------------------------------------------------------------- */

// \{
int handle_drag_and_drop_string(const std::string &uri);
// \}


/* ------------------------------------------------------------------------- */
/*                      Map Contours                                         */
/* ------------------------------------------------------------------------- */

#ifdef USE_PYTHON
// \{
PyObject *map_contours(int imol, float contour_level);
// \}
#endif // USE_PYTHON

void set_radial_map_colouring_centre(int imol, float x, float y, float z);

void set_radial_map_colouring_min_radius(int imol, float r);

void set_radial_map_colouring_max_radius(int imol, float r);

void set_radial_map_colouring_invert(int imol, int invert_state);

void set_radial_map_colouring_saturation(int imol, float saturation);



/* ------------------------------------------------------------------------- */
/*                      correlation maps                                     */
/* ------------------------------------------------------------------------- */



//         functions, let's set it here (default is 1.5A)
//
void set_map_correlation_atom_radius(float r);

// Don't count the grid points of residues_specs that are in grid
// points of (potentially overlapping) neighbour_residue_spec.
//
#ifdef USE_GUILE
// 0: all-atoms
// 1: main-chain atoms if is standard amino-acid, else all atoms
// 2: side-chain atoms if is standard amino-acid, else all atoms
// 3: side-chain atoms-excluding CB if is standard amino-acid, else all atoms
// 4: main-chain atoms if is standard amino-acid, else nothing
// 5: side-chain atoms if is standard amino-acid, else nothing
// 10: atom radius is dependent atom atom B-factor
SCM map_to_model_correlation_scm(int imol,
                                 SCM residue_specs,
                                 SCM neighb_residue_specs,
                                 unsigned short int atom_mask_mode,
                                 int imol_map);
SCM map_to_model_correlation_stats_scm(int imol,
                                       SCM residue_specs,
                                       SCM neighb_residue_specs,
                                       unsigned short int atom_mask_mode,
                                       int imol_map);
#endif

#ifdef USE_PYTHON
PyObject *map_to_model_correlation_py(int imol,
                                      PyObject *residue_specs,
                                      PyObject *neighb_residue_specs,
                                      unsigned short int atom_mask_mode,
                                      int imol_map);
PyObject *map_to_model_correlation_stats_py(int imol,
                                      PyObject *residue_specs,
                                      PyObject *neighb_residue_specs,
                                      unsigned short int atom_mask_mode,
                                      int imol_map);

PyObject *
map_to_model_correlation_stats_per_residue_range_py(int imol,
                                                    const std::string &chain_id,
                                                    int imol_map,
                                                    unsigned int n_residue_per_residue_range,
                                                    short int exclude_NOC_flag);

#endif

// 0: all-atoms
// 1: main-chain atoms if is standard amino-acid, else all atoms
// 2: side-chain atoms if is standard amino-acid, else all atoms
// 3: side-chain atoms-excluding CB if is standard amino-acid, else all atoms
// 4: main-chain atoms if is standard amino-acid, else nothing
// 5: side-chain atoms if is standard amino-acid, else nothing
// 10: atom radius is dependent atom atom B-factor
float
map_to_model_correlation(int imol,
                         const std::vector<coot::residue_spec_t> &residue_specs,
                         const std::vector<coot::residue_spec_t> &neigh_residue_specs,
                         unsigned short int atom_mask_mode,
                         int imol_map);

// 0: all-atoms
// 1: main-chain atoms if is standard amino-acid, else all atoms
// 2: side-chain atoms if is standard amino-acid, else all atoms
// 3: side-chain atoms-excluding CB if is standard amino-acid, else all atoms
// 4: main-chain atoms if is standard amino-acid, else nothing
// 5: side-chain atoms if is standard amino-acid, else nothing
//
coot::util::density_correlation_stats_info_t
map_to_model_correlation_stats(int imol,
                               const std::vector<coot::residue_spec_t> &residue_specs,
                               const std::vector<coot::residue_spec_t> &neigh_residue_specs,
                               unsigned short int atom_mask_mode,
                               int imol_map);
#ifndef SWIG

// 0: all-atoms
// 1: main-chain atoms if is standard amino-acid, else all atoms
// 2: side-chain atoms if is standard amino-acid, else all atoms
// 3: side-chain atoms-excluding CB if is standard amino-acid, else all atoms
// 4: main-chain atoms if is standard amino-acid, else nothing
// 5: side-chain atoms if is standard amino-acid, else nothing
//
std::vector<std::pair<coot::residue_spec_t,float> >
map_to_model_correlation_per_residue(int imol, const std::vector<coot::residue_spec_t> &specs,
                                     unsigned short int atom_mask_mode,
                                     int imol_map);

std::map<coot::residue_spec_t, coot::util::density_stats_info_t>
map_to_model_correlation_stats_per_residue(int imol,
                                           const std::vector<coot::residue_spec_t> &residue_specs,
                                           unsigned short int atom_mask_mode,
                                           float atom_radius_for_masking,
                                           int imol_map);

std::pair<std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t>,
          std::map<coot::residue_spec_t, coot::util::density_correlation_stats_info_t> >
map_to_model_correlation_stats_per_residue_range(int imol, const std::string &chain_id, int imol_map,
                                                 unsigned int n_residue_per_residue_range,
                                                 short int exclude_NOC_flag);

#endif // not for swigging.

#ifdef USE_GUILE
SCM
map_to_model_correlation_per_residue_scm(int imol, SCM residue_specs,
                                         unsigned short int atom_mask_mode,
                                         int imol_map);

SCM
map_to_model_correlation_stats_per_residue_scm(int imol,
                                               SCM residue_specs_scm,
                                               unsigned short int atom_mask_mode,
                                               float atom_radius_for_masking,
                                               int imol_map);

SCM map_to_model_correlation_stats_per_residue_range_scm(int imol, const std::string &chain_id, int imol_map,
                                                         unsigned int n_residue_per_residue_range,
                                                         short int exclude_NOC_flag);


// 0: all-atoms
// 1: main-chain atoms if is standard amino-acid, else all atoms
// 2: side-chain atoms if is standard amino-acid, else all atoms
// 3: side-chain atoms-excluding CB if is standard amino-acid, else all atoms
// 4: main-chain atoms if is standard amino-acid, else nothing
// 5: side-chain atoms if is standard amino-acid, else nothing
//
SCM qq_plot_map_and_model_scm(int imol,
                              SCM residue_specs_scm,
                              SCM neigh_residue_specs_scm,
                              unsigned short int atom_mask_mode,
                              int imol_map);
#endif

#ifdef USE_PYTHON
PyObject *map_to_model_correlation_per_residue_py(int imol, PyObject *residue_specs,
                                                  unsigned short int atom_mask_mode,
                                                  int imol_map);
PyObject *qq_plot_map_and_model_py(int imol,
                              PyObject *residue_specs_py,
                              PyObject *neigh_residue_specs_py,
                              unsigned short int atom_mask_mode,
                              int imol_map);
#endif

#ifdef __cplusplus
#ifdef USE_GUILE
float density_score_residue_scm(int imol, SCM residue_spec, int imol_map);
#endif
#ifdef USE_PYTHON
float density_score_residue_py(int imol, PyObject *residue_spec, int imol_map);
#endif
#endif

float density_score_residue(int imol, const char *chain_id, int res_no, const char *ins_code, int imol_map);


#ifdef USE_GUILE

SCM map_mean_scm(int imol);
SCM map_sigma_scm(int imol);
SCM map_statistics_scm(int imol);
#endif
#ifdef USE_PYTHON

PyObject *map_mean_py(int imol);
PyObject *map_sigma_py(int imol);
PyObject *map_statistics_py(int imol);
#endif /*USE_PYTHON */



/*  ----------------------------------------------------------------------- */
/*                  sequence (assignment)                                   */
/*  ----------------------------------------------------------------------- */
/* section Get Sequence  */
/* \{ */
std::string get_sequence_as_fasta_for_chain(int imol, const std::string &chain_id);

void write_sequence(int imol, const std::string &file_name);

/* \} */


/* ------------------------------------------------------------------------- */
/*                      interesting positions list                           */
/* ------------------------------------------------------------------------- */
#ifdef USE_GUILE
void register_interesting_positions_list_scm(SCM pos_list);
#endif // USE_GUILE
#ifdef USE_PYTHON
void register_interesting_positions_list_py(PyObject *pos_list);
#endif // USE_PYTHON

/* ------------------------------------------------------------------------- */
/*                      all-molecule atom overlaps                           */
/* ------------------------------------------------------------------------- */
#ifdef USE_PYTHON
PyObject *molecule_atom_overlaps_py(int imol);
#endif // USE_PYTHON
#ifdef USE_GUILE
SCM molecule_atom_overlaps_scm(int imol);
#endif // USE_GUILE

/* ------------------------------------------------------------------------- */
/*                      prodrg import function                               */
/* ------------------------------------------------------------------------- */
//
//
void prodrg_import_function(std::string file_name, std::string comp_id);



/* ------------------------------------------------------------------------- */
/*                       SBase import function                               */
/* ------------------------------------------------------------------------- */
//
//
void sbase_import_function(std::string comp_id);

/* ------------------------------------------------------------------------- */
/*                       Alignment functions (now C++)                       */
/* ------------------------------------------------------------------------- */

std::pair<int, std::string>
align_to_closest_chain(std::string target_seq, float match_fraction);

#ifdef __cplusplus/* protection from use in callbacks.c, else compilation probs */
#ifdef USE_PYTHON
PyObject *align_to_closest_chain_py(std::string target_seq, float match_fraction);
#endif /* USE_PYTHON */
#ifdef USE_GUILE
SCM align_to_closest_chain_scm(std::string target_seq, float match_fraction);
#endif /* USE_GUILE */
#endif /* c++ */


#ifdef __cplusplus/* protection from use in callbacks.c, else compilation probs */
#ifdef USE_GUILE
SCM spherical_density_overlap(SCM i_scm, SCM j_scm);
#endif // USE_GUILE
#endif // __cplusplus

void resolve_clashing_sidechains_by_deletion(int imol);

void resolve_clashing_sidechains_by_rebuilding(int imol);

/*  ----------------------------------------------------------------------- */
/*                  GUIL Utility Functions                                  */
/*  ----------------------------------------------------------------------- */
void simple_text_dialog(const std::string &dialog_title, const std::string &text,
                        int geom_x, int geom_y);


/*  ----------------------------------------------------------------------- */
/*                  Phenix Functions                                        */
/*  ----------------------------------------------------------------------- */
void graphics_to_phenix_geo_representation(int imol, int mode,
                                           const coot::phenix_geo_bonds &g);
void graphics_to_phenix_geo_representation(int imol, int mode,
                                           const std::string &geo_file_name);

/*  ----------------------------------------------------------------------- */
/*                  Client/Server                                        */
/*  ----------------------------------------------------------------------- */
#ifdef USE_PYTHON
void set_python_draw_function(const std::string &command_string);
#endif // USE_PYTHON


/*  ----------------------------------------------------------------------- */
/*                  Pathology Plots                                         */
/*  ----------------------------------------------------------------------- */
#ifdef USE_PYTHON
PyObject *pathology_data(const std::string &mtz_file_name,
                         const std::string &fp_col,
                         const std::string &sigfp_col);
#endif // USE_PYTHON

/*  ----------------------------------------------------------------------- */
/*                  Utility Functions                                       */
/*  ----------------------------------------------------------------------- */

// These functions are for storing the molecule number and (some other
// number) as an int and used with GPOINTER_TO_INT and GINT_TO_POINTER.
int encode_ints(int i1, int i2);
std::pair<int, int> decode_ints(int i);

void store_keyed_user_name(std::string key, std::string user_name, std::string passwd);

#ifdef USE_GUILE
std::vector<coot::residue_spec_t> scm_to_residue_specs(SCM s);
// and that backwards is scm_residue() above.
int key_sym_code_scm(SCM s_scm);
#endif // USE_GUILE
#ifdef USE_PYTHON
std::vector<coot::residue_spec_t> py_to_residue_specs(PyObject *s);
int key_sym_code_py(PyObject *po);
#endif // USE_PYTHON
#ifdef USE_GUILE
#ifdef USE_PYTHON
PyObject *scm_to_py(SCM s);
SCM py_to_scm(PyObject *o);
#endif // USE_GUILE
#endif // USE_PYTHON

#ifdef USE_GUILE
clipper::Spacegroup scm_symop_strings_to_space_group(SCM symop_string_list);
#endif

#ifdef USE_PYTHON
clipper::Spacegroup py_symop_strings_to_space_group(PyObject *symop_string_list);
#endif

#endif // CC_INTERFACE_HH