w_library.c

Go to the documentation of this file.

/* This file is part of the 'atomes' software
 
'atomes' is free software: you can redistribute it and/or modify it under the terms
of the GNU Affero General Public License as published by the Free Software Foundation,
either version 3 of the License, or (at your option) any later version.
 
'atomes' 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 Affero General Public License along with 'atomes'.
If not, see <https://www.gnu.org/licenses/>
 
Copyright (C) 2022-2026 by CNRS and University of Strasbourg */

 
/*
* This file: 'w_library.c'
*
* Contains:
*
 
 - The functions to create the molecular library
 - The functions to read the 'Simple chemical XML' files
 
*
* List of functions:
 
  int clean_xml_data (xmlDoc * doc, xmlTextReaderPtr reader);
  int sml_preview (const char * filetoread);
  int get_family (gchar * str);
  int get_sml_files ();
  int select_from_library (gboolean visible, project * this_proj, atom_search * asearch);
  int insert_this_project_from_lib (int id, gboolean visible, project * this_proj, atom_search * asearch);
 
  double get_z_from_periodic_table (gchar * lab);
 
  gchar * replace_markup (char * init, char * key, char * rep);
  gchar * substitute_string (gchar * init, gchar * o_motif, gchar * n_motif);
  gchar * check_xml_string (gchar * init);
  gchar * open_sml_file (const char * filetoread, int fam);
 
  void sort_files (int num_f);
  void fill_molecule_tree (GtkListStore * store);
  void fill_family_tree (GtkListStore * store);
  void insert_preview ();
  void prepare_preview (int active, int id, gboolean visible);
 
  G_MODULE_EXPORT void select_library_data (GtkTreeView * tree_view, GtkTreePath * path, GtkTreeViewColumn * column, gpointer data);
  G_MODULE_EXPORT void set_library_markup (GtkTreeViewColumn * col, GtkCellRenderer * renderer, GtkTreeModel * mod, GtkTreeIter * iter, gpointer data);
  G_MODULE_EXPORT void run_select_from_library (GtkDialog * lib, gint response_id, gpointer data);
 
  GtkWidget * library_tree (GtkListStore * store, int id, gchar * name);
 
*/
 
#include "global.h"
#include "bind.h"
#include "interface.h"
#include "project.h"
#include "glview.h"
#include "glwindow.h"
#include <libxml/xmlreader.h>
 
element_data periodic_table_info[] = {
  {"X",  i18n("Unknown"), 0, 0},
  {"H",  i18n("Hydrogen"), 1, 1.008},
  {"He", i18n("Helium"), 2, 4.003},
  {"Li", i18n("Lithium"), 3, 6.94},
  {"Be", i18n("Beryllium"), 4, 9.012},
  {"B",  i18n("Boron"), 5, 10.81},
  {"C",  i18n("Carbon"), 6, 12.011},
  {"N",  i18n("Nitrogen"), 7, 14.007},
  {"O",  i18n("Oxygen"), 8, 15.999},
  {"F",  i18n("Fluorine"), 9, 18.998},
  {"Ne", i18n("Neon"), 10, 20.18},
  {"Na", i18n("Sodium"), 11, 22.99},
  {"Mg", i18n("Magnesium"), 12, 24.305},
  {"Al", i18n("Aluminium"), 13, 26.982},
  {"Si", i18n("Silicon"), 14, 28.085},
  {"P",  i18n("Phosphorus"), 15, 30.974},
  {"S",  i18n("Sulfur"), 16, 32.06},
  {"Cl", i18n("Chlorine"), 17, 35.45},
  {"Ar", i18n("Argon"), 18, 39.948},
  {"K",  i18n("Potassium"), 19, 39.098},
  {"Ca", i18n("Calcium"), 20, 40.078},
  {"Sc", i18n("Scandium"), 21, 44.956},
  {"Ti", i18n("Titanium"), 22, 47.867},
  {"V",  i18n("Vanadium"), 23, 50.942},
  {"Cr", i18n("Chromium"), 24, 51.996},
  {"Mn", i18n("Manganese"), 25, 54.938},
  {"Fe", i18n("Iron"), 26, 55.845},
  {"Co", i18n("Cobalt"), 27, 58.933},
  {"Ni", i18n("Nickel"), 28, 58.693},
  {"Cu", i18n("Copper"), 29, 63.546},
  {"Zn", i18n("Zinc"), 30, 65.38},
  {"Ga", i18n("Gallium"), 31, 69.723},
  {"Ge", i18n("Germanium"), 32, 72.63},
  {"As", i18n("Arsenic"), 33, 74.922},
  {"Se", i18n("Selenium"), 34, 78.971},
  {"Br", i18n("Bromine"), 35, 79.904},
  {"Kr", i18n("Krypton"), 36, 83.798},
  {"Rb", i18n("Rubidium"), 37, 85.468},
  {"Sr", i18n("Strontium"), 38, 87.62},
  {"Y",  i18n("Yttrium"), 39, 88.906},
  {"Zr", i18n("Zirconium"), 40, 91.224},
  {"Nb", i18n("Niobium"), 41, 92.906},
  {"Mo", i18n("Molybdenum"), 42, 95.95},
  {"Tc", i18n("Technetium"), 43, 98},
  {"Ru", i18n("Ruthenium"), 44, 101.07},
  {"Rh", i18n("Rhodium"), 45, 102.906},
  {"Pd", i18n("Palladium"), 46, 106.42},
  {"Ag", i18n("Silver"), 47, 107.868},
  {"Cd", i18n("Cadmium"), 48, 112.414},
  {"In", i18n("Indium"), 49, 114.818},
  {"Sn", i18n("Tin"), 50, 118.71},
  {"Sb", i18n("Antimony"), 51, 121.76},
  {"Te", i18n("Tellurium"), 52, 127.6},
  {"I",  i18n("Iodine"), 53, 126.904},
  {"Xe", i18n("Xenon"), 54, 131.293},
  {"Cs", i18n("Caesium"), 55, 132.905},
  {"Ba", i18n("Barium"), 56, 137.327},
  {"La", i18n("Lanthanum"), 57, 138.905},
  {"Ce", i18n("Cerium"), 58, 140.116},
  {"Pr", i18n("Praseodymium"), 59, 140.908},
  {"Nd", i18n("Neodymium"), 60, 144.242},
  {"Pm", i18n("Promethium"), 61, 145},
  {"Sm", i18n("Samarium"), 62, 150.36},
  {"Eu", i18n("Europium"), 63, 151.964},
  {"Gd", i18n("Gadolinium"), 64, 157.25},
  {"Tb", i18n("Terbium"), 65, 158.925},
  {"Dy", i18n("Dysprosium"), 66, 162.5},
  {"Ho", i18n("Holmium"), 67, 164.93},
  {"Er", i18n("Erbium"), 68, 167.259},
  {"Tm", i18n("Thulium"), 69, 168.934},
  {"Yb", i18n("Ytterbium"), 70, 173.045},
  {"Lu", i18n("Lutetium"), 71, 174.967},
  {"Hf", i18n("Hafnium"), 72, 178.49},
  {"Ta", i18n("Tantalum"), 73, 180.948},
  {"W",  i18n("Tungsten"), 74, 183.84},
  {"Re", i18n("Rhenium"), 75, 186.207},
  {"Os", i18n("Osmium"), 76, 190.23},
  {"Ir", i18n("Iridium"), 77, 192.217},
  {"Pt", i18n("Platinum"), 78, 195.084},
  {"Au", i18n("Gold"), 79, 196.967},
  {"Hg", i18n("Mercury"), 80, 200.592},
  {"Tl", i18n("Thallium"), 81, 204.38},
  {"Pb", i18n("Lead"), 82, 207.2},
  {"Bi", i18n("Bismuth"), 83, 208.98},
  {"Po", i18n("Polonium"), 84, 209},
  {"At", i18n("Astatine"), 85, 210},
  {"Rn", i18n("Radon"), 86, 222},
  {"Fr", i18n("Francium"), 87, 223},
  {"Ra", i18n("Radium"), 88, 226},
  {"Ac", i18n("Actinium"), 89, 227},
  {"Th", i18n("Thorium"), 90, 232.038},
  {"Pa", i18n("Protactinium"), 91, 231.036},
  {"U",  i18n("Uranium"), 92, 238.029},
  {"Np", i18n("Neptunium"), 93, 237},
  {"Pu", i18n("Plutonium"), 94, 244},
  {"Am", i18n("Americium"), 95, 243},
  {"Cm", i18n("Curium"), 96, 247},
  {"Bk", i18n("Berkelium"), 97, 247},
  {"Cf", i18n("Californium"), 98, 251},
  {"Es", i18n("Einsteinium"), 99, 252},
  {"Fm", i18n("Fermium"), 100, 257},
  {"Md", i18n("Mendelevium"), 101, 258},
  {"No", i18n("Nobelium"), 102, 258},
  {"Lr", i18n("Lawrencium"), 103, 262},
  {"Rf", i18n("Rutherfordium"), 104, 267},
  {"Db", i18n("Dubnium"), 105, 268},
  {"Sg", i18n("Seaborgium"), 106, 269},
  {"Bh", i18n("Bohrium"), 107, 270},
  {"Hs", i18n("Hassium"), 108, 277},
  {"Mt", i18n("Meitnerium"), 109, 278},
  {"Ds", i18n("Darmstadtium"), 110, 281},
  {"Rg", i18n("Roentgenium"), 111, 282},
  {"Cn", i18n("Copernicium"), 112, 285},
  {"Nh", i18n("Nihonium"), 113, 286},
  {"Fl", i18n("Flerovium"), 114, 289},
  {"Mc", i18n("Moscovium"), 115, 289},
  {"Lv", i18n("Livermorium"), 116, 293},
  {"Ts", i18n("Tennessine"), 117, 294},
  {"Og", i18n("Oganesson"), 118, 294},
  {"D",  i18n("Deuterium"), 1, 2.014000}};
 
insertion_menu mol[] = {
    { i18n("Atom"), NULL, -1, 0 },
    { NULL, "H", 1, 1 },
    { NULL, "B", 5, 1 },
    { NULL, "C", 6, 1 },
    { NULL, "N", 7, 1 },
    { NULL, "O", 8, 1 },
    { NULL, "F", 9, 1 },
    { NULL, "S", 16, 1 },
    { NULL, "Cl", 17, 1 },
    { NULL, i18n("Other ..."), -1, 1 },
    { i18n("Library"), NULL, -1, 0 },
    { NULL, "H<sub>2</sub>O", -1, 3 },
    { NULL, "CH<sub>4</sub>", -1, 5 },
    { NULL, i18n("Toluene"), -1, 15 },
    { NULL, "Cp", -1, 10 },
    { NULL, "C<sub>60</sub>", -1,  60},
    { NULL, i18n("Ni-Phthalocyanine"), -1, 57 },
    { NULL, i18n("More ..."), -1, -1 },
    { NULL, NULL, -1, 0 }};
 
#define FAMILY 26
gchar * family_list[FAMILY]={i18n("Misc"),
                             i18n("Alcohols"),
                             i18n("Aldehydes"),
                             i18n("Alkanes"),
                             i18n("Alkenes"),
                             i18n("Alkynes"),
                             i18n("Amides"),
                             i18n("Amines"),
                             i18n("Amino acids"),
                             i18n("Aromatics"),
                             i18n("Carboxylic acids"),
                             i18n("Cyclic alkanes"),
                             i18n("Cyclic alkenes"),
                             i18n("Ethers"),
                             i18n("Fatty acids"),
                             i18n("Fullerenes"),
                             i18n("Heterocyclics"),
                             i18n("Macrocycles"),
                             i18n("Ketones"),
                             i18n("Nitriles"),
                             i18n("Nucleobases"),
                             i18n("Steroids"),
                             i18n("Sugars (Linears)"),
                             i18n("Sugars (Cyclics)"),
                             i18n("Sulfoxides"),
                             i18n("Thiols")};
 
gchar * family_dir[FAMILY]={"Misc",
                            "Alcohols",
                            "Aldehydes",
                            "Alkanes",
                            "Alkenes",
                            "Alkynes",
                            "Amides",
                            "Amines",
                            "Amino_acids",
                            "Aromatics",
                            "Carboxylic_acids",
                            "Cyclic_alkanes",
                            "Cyclic_alkenes",
                            "Ethers",
                            "Fatty_acids",
                            "Fullerenes",
                            "Heterocyclics",
                            "Macrocycles",
                            "Ketones",
                            "Nitriles",
                            "Nucleobases",
                            "Steroids",
                            "Linear_sugars",
                            "Cyclic_sugars",
                            "Sulfoxides",
                            "Thiols"};
 
#ifdef GTK3
#ifndef G_OS_WIN32
extern void gtk_window_change_gdk_visual (GtkWidget * win);
#endif // G_OS_WIN32
#endif // GTK3
 
extern gboolean create_3d_model (int p, gboolean load);
extern G_MODULE_EXPORT void on_realize (GtkGLArea * area, gpointer data);
extern xmlNodePtr findnode (xmlNodePtr startnode, char * nname);
extern int action_atoms_from_project (project * this_proj, atom_search * asearch, gboolean visible);
extern void to_insert_in_project (int stat, int orig, project * this_proj, atom_search * asearch, gboolean visible);
extern void create_object_from_library (int p);
extern atom_search * remove_search;
GtkListStore * family_store;
GtkTreeIter first_family_iter;
GtkListStore * molecule_store;
GtkTreeIter first_mol_iter;
GtkTreeSelection * libselect[2];
int the_family;
gchar * the_molecule;
gchar ** sml_file_name;
gchar ** mol_name;
GtkWidget * lib_preview_box = NULL;
GtkWidget * lib_preview_plot = NULL;
project * lib_proj = NULL;
gchar * other_name[5];
int o_names;
int inserted_from_lib;

double get_z_from_periodic_table (gchar * lab)
{
  int i;
  for (i=0; i<120; i++)
  {
    if (g_strcmp0 (periodic_table_info[i].lab, lab) == 0) return periodic_table_info[i].Z;
  }
  return 0.0;
}

int clean_xml_data (xmlDoc * doc, xmlTextReaderPtr reader)
{
  xmlFreeDoc(doc);
  xmlFreeTextReader(reader);
  xmlCleanupParser();
  return 0;
}

gchar * replace_markup (char * init, char * key, char * rep)
{
  gchar * buffer = NULL;
  char * p = NULL;
  int inilen = strlen(init);
  int oldlen = strlen(key);
  int newlen = (rep) ? strlen(rep) : 0;
 
  // Is key in init
  p = strstr(init, key);
  if (! p) return g_strdup(init);
 
  buffer = g_malloc0 ((inilen+newlen-oldlen+1)*sizeof*buffer);
  buffer[0] = '\0';
 
  // Copy what is before the pattern
  strncat(buffer, init, p - init);
 
  // Replace
  if (rep) strcat(buffer, rep);
 
  // Add the rest of the key
  strcat(buffer, p+oldlen);
  return buffer;
}

gchar * substitute_string (gchar * init, gchar * o_motif, gchar * n_motif)
{
  gchar * str_a, * str_b;
  str_a = replace_markup (init, o_motif, n_motif);
  str_b = g_strdup_printf ("%s", init);
  while (g_strcmp0 (str_a, str_b))
  {
    g_free (str_b);
    str_b = g_strdup_printf ("%s", str_a);
    g_free (str_a);
    str_a = replace_markup (str_b, o_motif, n_motif);
  }
  g_free (str_b);
  return str_a;
}

gchar * check_xml_string (gchar * init)
{
  gchar * str = g_strdup_printf ("%s", substitute_string (init, "--i--", "<i>"));
  str = g_strdup_printf ("%s", substitute_string (str, "--I--", "</i>"));
  str = g_strdup_printf ("%s", substitute_string (str, "--b--", "<sup>"));
  str = g_strdup_printf ("%s", substitute_string (str, "--e--", "</sup>"));
  str = g_strdup_printf ("%s", substitute_string (str, "--c--", "<sub>"));
  str = g_strdup_printf ("%s", substitute_string (str, "--f--", "</sub>"));
 
  return str;
}

int sml_preview (const char * filetoread)
{
  int i, j, k;
  xmlDoc * doc;
  xmlTextReaderPtr reader;
  xmlNodePtr racine, name_node, chem_node;
  xmlNodePtr n_node, at_node, sp_node, coord_node;
  xmlNodePtr spec_node, lab_node, lot_node, pbc_node;
  xmlAttrPtr xspec;
  xmlChar * content;
 
  if (lib_proj != NULL) close_project (lib_proj);
  init_project (TRUE);
  lib_proj = active_project;
 
  reader = xmlReaderForFile(filetoread, NULL, 0);
  doc = xmlParseFile(filetoread);
  racine = xmlDocGetRootElement(doc);
 
  name_node = findnode (racine -> children, "names");
  if (name_node == NULL) return clean_xml_data (doc, reader);
  n_node = findnode (name_node -> children, "library-name");
  if (n_node == NULL) return clean_xml_data (doc, reader);
  content = xmlNodeGetContent(n_node);
  lib_proj -> name = g_strdup_printf ("%s", content);
  xmlFree (content);
  lib_proj -> name = check_xml_string (lib_proj -> name);
  n_node = findnode (name_node -> children, "iupac-name");
  if (n_node == NULL) return clean_xml_data (doc, reader);
  o_names = 0;
  content = xmlNodeGetContent(n_node);
  other_name[0] = g_strdup_printf ("%s", content);
  xmlFree (content);
  o_names ++;
  n_node = findnode (name_node -> children, "other-names");
  if (n_node == NULL) return clean_xml_data (doc, reader);
  n_node = n_node -> children;
  for (name_node = n_node; name_node && o_names < 5; name_node = name_node->next)
  {
    if (name_node -> type == XML_ELEMENT_NODE)
    {
      content = xmlNodeGetContent(name_node);
      other_name[o_names] = g_strdup_printf ("%s", content);
      xmlFree (content);
      o_names ++;
    }
  }
  chem_node = findnode(racine -> children, "chemistry");
  if (chem_node == NULL) return clean_xml_data (doc, reader);
  at_node = findnode (chem_node -> children, "atoms");
  if (at_node == NULL) return clean_xml_data (doc, reader);
  content = xmlNodeGetContent(at_node);
  lib_proj -> natomes = (int)string_to_double ((gpointer)content);
  xmlFree (content);
 
  sp_node = findnode (chem_node -> children, "species");
  if (sp_node == NULL) return clean_xml_data (doc, reader);
  spec_node = sp_node -> properties -> children;
  if (spec_node == NULL) return clean_xml_data (doc, reader);
  content = xmlNodeGetContent(spec_node);
  lib_proj -> nspec = (int)string_to_double ((gpointer)content);
  xmlFree (content);
  if (lib_proj -> natomes < 1 || lib_proj -> nspec < 1) return clean_xml_data (doc, reader);
  alloc_proj_data (lib_proj, 1);
  lab_node = sp_node -> children;
  if (lab_node == NULL) return clean_xml_data (doc, reader);
  j = 0;
  for (i=0; i<lib_proj -> nspec; i++)
  {
    lab_node = findnode (lab_node, "label");
    if (lab_node == NULL) return clean_xml_data (doc, reader);
    content = xmlNodeGetContent(lab_node);
    lib_proj -> chemistry -> label[i] = g_strdup_printf ("%s", content);
    xmlFree (content);
    xspec = lab_node -> properties;
    if (xspec == NULL) return clean_xml_data (doc, reader);
    while (xspec)
    {
      lot_node = xspec -> children;
      if (lot_node == NULL) return clean_xml_data (doc, reader);
      if (g_strcmp0 ("num",(char *)xspec -> name) == 0)
      {
        content = xmlNodeGetContent(lot_node);
        lib_proj -> chemistry -> nsps[i] = (int)string_to_double ((gpointer)content);
        xmlFree (content);
        lib_proj -> chemistry -> chem_prop[CHEM_Z][i] = get_z_from_periodic_table (lib_proj -> chemistry -> label[i]);
        k = (int)lib_proj -> chemistry -> chem_prop[CHEM_Z][i];
        lib_proj -> chemistry -> chem_prop[CHEM_M][i] = periodic_table_info[k].M;
        lib_proj -> chemistry -> chem_prop[CHEM_R][i] = set_radius_ (& k, & j);
      }
      xspec = xspec -> next;
    }
    lab_node = lab_node -> next;
  }
  active_chem = lib_proj -> chemistry;
  initcutoffs (active_chem, lib_proj -> nspec);
  at_node = findnode (racine -> children, "coordinates");
  if (at_node == NULL) return clean_xml_data (doc, reader);
  coord_node = at_node -> children;
  if (coord_node == NULL) return clean_xml_data (doc, reader);
  for (i=0; i<lib_proj -> natomes; i++)
  {
    coord_node = findnode (coord_node, "atom");
    if (coord_node == NULL) return clean_xml_data (doc, reader);
    xspec = coord_node -> properties;
    if (xspec == NULL) return clean_xml_data (doc, reader);
    while (xspec)
    {
      lot_node = xspec -> children;
      if (lot_node == NULL) return clean_xml_data (doc, reader);
      content = xmlNodeGetContent(lot_node);
      if (g_strcmp0 ("x",(char *)xspec -> name) == 0)
      {
        lib_proj -> atoms[0][i].x = string_to_double ((gpointer)content);
      }
      else if (g_strcmp0 ("y",(char *)xspec -> name) == 0)
      {
        lib_proj -> atoms[0][i].y = string_to_double ((gpointer)content);
      }
      else if (g_strcmp0 ("z",(char *)xspec -> name) == 0)
      {
        lib_proj -> atoms[0][i].z = string_to_double ((gpointer)content);
      }
      else if (g_strcmp0 ("sp",(char *)xspec -> name) == 0)
      {
        lib_proj -> atoms[0][i].sp = (int)string_to_double ((gpointer)content);
        lib_proj -> atoms[0][i].show[0] = TRUE;
      }
      xmlFree (content);
      xspec = xspec -> next;
    }
    coord_node = coord_node -> next;
  }
  pbc_node = findnode (racine -> children, "lattice");
  if (pbc_node != NULL)
  {
 
  }
  xmlFreeDoc(doc);
  xmlFreeTextReader(reader);
  xmlCleanupParser();
  return 1;
}

gchar * open_sml_file (const char * filetoread, int fam)
{
  xmlDoc * doc;
  xmlTextReaderPtr reader;
  const xmlChar sml[8]="scl-xml";
  xmlChar * cdata;
  xmlNodePtr racine, node;
  /*
   * build an xmlReader for that file
   */
  reader = xmlReaderForFile(filetoread, NULL, 0);
  if (reader == NULL)
  {
    return NULL;
  }
  else
  {
    doc = xmlParseFile(filetoread);
    if (doc == NULL) return NULL;
    racine = xmlDocGetRootElement(doc);
    if (g_strcmp0 ((char *)(racine -> name), (char *)sml) != 0)
    {
      clean_xml_data (doc, reader);
      return NULL;
    }
    node = racine -> children;
    node = findnode(node, "class");
    cdata = xmlNodeGetContent(node);
    if (g_strcmp0 ((gchar *)cdata, family_list[fam]) != 0)
    {
      xmlFree (cdata);
      clean_xml_data (doc, reader);
      return NULL;
    }
    xmlFree (cdata);
    node = findnode (racine -> children, "names");
    if (node == NULL)
    {
      clean_xml_data (doc, reader);
      return NULL;
    }
    node = findnode (node -> children, "library-name");
    if (node == NULL)
    {
      clean_xml_data (doc, reader);
      return NULL;
    }
    cdata = xmlNodeGetContent(node);
    xmlFreeDoc(doc);
    xmlFreeTextReader(reader);
    xmlCleanupParser();
    return (gchar *)cdata;
  }
}

int get_family (gchar * str)
{
  int i;
  for (i=0; i<FAMILY; i++)
  {
    if (g_strcmp0 (str, _(family_list[i])) == 0) return i;
  }
  return -1;
}

void sort_files (int num_f)
{
  int i, j;
  gchar * str = NULL;
  for(i=0;i<num_f;i++)
  {
    for(j=i+1;j<num_f;j++)
    {
       if(g_strcmp0 (mol_name[i],mol_name[j])>0)
       {
         str = g_strdup_printf ("%s", mol_name[i]);
         mol_name[i] = g_strdup_printf ("%s", mol_name[j]);
         mol_name[j] = g_strdup_printf ("%s", str);
         str = g_strdup_printf ("%s", sml_file_name[i]);
         sml_file_name[i] = g_strdup_printf ("%s", sml_file_name[j]);
         sml_file_name[j] = g_strdup_printf ("%s", str);
       }
    }
  }
  for(i=0;i<num_f;i++)
  {
    mol_name[i] = check_xml_string(mol_name[i]);
  }
}

int get_sml_files ()
{
  int val = 0;
  gchar * str, * fsml;
  gchar * libdir;
#ifdef G_OS_WIN32
   libdir  = g_strdup_printf ("%s\\molecules\\%s", PACKAGE_LIB_DIR, family_dir[the_family]);
   gchar * libwin32 = g_strdup_printf ("%s\\molecules\\%s\\*.sml", PACKAGE_LIB_DIR, family_dir[the_family]);
   WIN32_FIND_DATA ffd;
   HANDLE hFind = FindFirstFile (libwin32, & ffd);
   if (hFind != INVALID_HANDLE_VALUE)
   {
     if (ffd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
     {
       str = g_strdup_printf ("%s\\%s", libdir, (char *)ffd.cFileName);
       if (open_sml_file(str, the_family) != NULL) val ++;
       g_free (str);
     }
     while (FindNextFile(hFind, &ffd) != 0)
     {
       if (ffd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
       {
         str = g_strdup_printf ("%s\\%s", libdir, (char *)ffd.cFileName);
         if (open_sml_file(str, the_family) != NULL) val ++;
         g_free (str);
       }
     }
     FindClose(hFind);
   }
#else
   libdir = g_strdup_printf ("%s/molecules/%s", PACKAGE_LIB_DIR, family_dir[the_family]);
   DIR * d;
   struct dirent * dir;
   d = opendir(libdir);
   if (d)
   {
     while ((dir = readdir(d)) != NULL)
     {
       if (dir -> d_type == DT_REG)
       {
         str = g_strdup_printf ("%s/%s", libdir, dir -> d_name);
         if (open_sml_file(str, the_family) != NULL) val ++;
         g_free (str);
       }
     }
     closedir(d);
   }
#endif
  if (val > 0)
  {
    sml_file_name = g_malloc0(val*sizeof*sml_file_name);
    mol_name = g_malloc0(val*sizeof*mol_name);
    val = 0;
#ifdef G_OS_WIN32
    hFind = FindFirstFile (libwin32, & ffd);
    if (hFind != INVALID_HANDLE_VALUE)
    {
      if (ffd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
      {
        str = g_strdup_printf ("%s\\%s", libdir, (char *)ffd.cFileName);
        fsml = open_sml_file(str, the_family);
        if (fsml != NULL)
        {
          sml_file_name[val] = g_strdup_printf ("%s", str);
          mol_name[val] = g_strdup_printf ("%s", fsml);
          val ++;
          g_free (fsml);
        }
        g_free (str);
      }
      while (FindNextFile(hFind, &ffd) != 0)
      {
        if (ffd.dwFileAttributes != FILE_ATTRIBUTE_DIRECTORY)
        {
          str = g_strdup_printf ("%s\\%s", libdir, (char *)ffd.cFileName);
          fsml = open_sml_file(str, the_family);
          if (fsml != NULL)
          {
            sml_file_name[val] = g_strdup_printf ("%s", str);
            mol_name[val] = g_strdup_printf ("%s", fsml);
            val ++;
            g_free (fsml);
          }
          g_free (str);
        }
      }
      FindClose(hFind);
    }
#else
    d = opendir (libdir);
    if (d)
    {
      while ((dir = readdir(d)) != NULL)
      {
        if (dir -> d_type == DT_REG)
        {
          str = g_strdup_printf ("%s/%s", libdir, dir -> d_name);
          fsml = open_sml_file(str, the_family);
          if (fsml != NULL)
          {
            sml_file_name[val] = g_strdup_printf ("%s", str);
            mol_name[val] = g_strdup_printf ("%s", fsml);
            val ++;
            g_free (fsml);
          }
          g_free (str);
        }
      }
      closedir(d);
    }
#endif
    sort_files (val);
  }
  return val;
}

void fill_molecule_tree (GtkListStore * store)
{
  GtkTreeIter mol_level;
  int i;
  for (i=0; i<get_sml_files (); i++)
  {
    if (i == 0)
    {
      gtk_list_store_append (store, & first_mol_iter);
      gtk_list_store_set (store, & first_mol_iter, 0, -(i+1), 1, mol_name[i], -1);
    }
    else
    {
      gtk_list_store_append (store, & mol_level);
      gtk_list_store_set (store, & mol_level, 0, -(i+1), 1, mol_name[i], -1);
    }
  }
}

void fill_family_tree (GtkListStore * store)
{
  GtkTreeIter family_level;
  int i;
  for (i=0; i<FAMILY; i++)
  {
    if (i == 0)
    {
      gtk_list_store_append (store, & first_family_iter);
      gtk_list_store_set (store, & first_family_iter, 0, i, 1, _(family_list[i]), -1);
    }
    else
    {
      gtk_list_store_append (store, & family_level);
      gtk_list_store_set (store, & family_level, 0, i, 1, _(family_list[i]), -1);
    }
  }
}

void insert_preview ()
{
  gchar * str;
  lib_preview_plot = gtk_fixed_new ();
  add_box_child_start (GTK_ORIENTATION_HORIZONTAL, lib_preview_box, lib_preview_plot, FALSE, FALSE, 0);
  GtkWidget * grid = gtk_grid_new ();
  gtk_fixed_put (GTK_FIXED(lib_preview_plot), grid, 0, 10);
  gtk_widget_set_size_request (grid, -1, 200);
  gtk_grid_set_row_homogeneous (GTK_GRID (grid), TRUE);
  gtk_grid_set_column_homogeneous (GTK_GRID (grid), TRUE);
  gtk_grid_set_row_spacing (GTK_GRID (grid), 1);
  gtk_grid_set_column_spacing (GTK_GRID (grid), 1);
 
  gtk_grid_attach (GTK_GRID (grid), lib_proj -> modelgl -> plot, 0, 0, 4, 4);
  gtk_grid_attach (GTK_GRID (grid), markup_label(_("<i>Formula:</i>"), 100, -1, 0.0, 0.5), 5, 1, 3, 1);
  int i;
  for (i=0; i<lib_proj -> nspec; i++)
  {
    if (i > 0)
    {
      str = g_strdup_printf ("%s <b>%s", str, lib_proj -> chemistry -> label[i]);
    }
    else
    {
      str = g_strdup_printf ("<b>%s", lib_proj -> chemistry -> label[i]);
    }
    if (lib_proj -> chemistry -> nsps[i] > 1)
    {
      str = g_strdup_printf ("%s<sub>%d</sub>", str, lib_proj -> chemistry -> nsps[i]);
    }
    str = g_strdup_printf ("%s</b>", str);
  }
  gtk_grid_attach (GTK_GRID (grid), markup_label(str, 100, -1, 0.0, 0.5), 8, 1, 3, 1);
  gtk_grid_attach (GTK_GRID (grid),markup_label(_("<i>Molecular mass:</i>"), 100, -1, 0.0, 0.5), 5, 2, 3, 1);
  g_free (str);
  double mass = 0.0;
  for (i=0; i<lib_proj -> nspec; i++)
  {
    mass += (lib_proj -> chemistry -> nsps[i]*lib_proj -> chemistry -> chem_prop[CHEM_M][i]);
  }
  str = g_strdup_printf ("<b>%.3f g/mol</b>", mass);
  gtk_grid_attach (GTK_GRID (grid), markup_label(str, 100, -1, 0.0, 0.5), 8, 2, 3, 1);
  g_free (str);
 
  gtk_grid_attach (GTK_GRID (grid), markup_label(_("<i>IUPAC name:</i>"), 100, -1, 0.0, 0.5), 0, 5, 3, 1);
  str = g_strdup_printf ("<b>%s</b>", check_xml_string(other_name[0]));
  gtk_grid_attach (GTK_GRID (grid), markup_label(str, 100, 30, 0.0, 0.5), 3, 5, 11, 1);
 
  if (o_names > 1)
  {
    GtkWidget * hbox = create_hbox (0);
    gtk_fixed_put (GTK_FIXED(lib_preview_plot), hbox, 0, 230);
    GtkWidget * vbox = create_vbox (BSEP);
    add_box_child_start (GTK_ORIENTATION_HORIZONTAL, hbox, vbox, FALSE, FALSE, 0);
    add_box_child_start (GTK_ORIENTATION_VERTICAL, vbox, markup_label(_("<i>Other name(s):</i>"), 100, 30, 0.0, 0.5), FALSE, FALSE, 0);
    for (i=1; i<o_names; i++)
    {
      if (i > 1)
      {
        str = g_strdup_printf ("%s\n<b>%s</b>", str, check_xml_string(other_name[i]));
      }
      else
      {
        str = g_strdup_printf ("<b>%s</b>", check_xml_string(other_name[i]));
      }
    }
    vbox = create_vbox (BSEP);
    add_box_child_start (GTK_ORIENTATION_HORIZONTAL, hbox, vbox, FALSE, FALSE, 15);
    add_box_child_start (GTK_ORIENTATION_VERTICAL, vbox, markup_label(str, 100, 30+20*(o_names-2), 0.0, 0.5), FALSE, FALSE, 0);
    g_free (str);
  }
  show_the_widgets (lib_preview_box);
}

void prepare_preview (int active, int id, gboolean visible)
{
  if (sml_file_name != NULL)
  {
    if (sml_preview (sml_file_name[id]))
    {
      lib_preview_plot = destroy_this_widget (lib_preview_plot);
      lib_proj -> run = TRUE;
      active_project_changed (lib_proj -> id);
      create_3d_model (lib_proj -> id, FALSE);
      if (visible)
      {
        insert_preview ();
      }
      else
      {
        on_realize (NULL, lib_proj -> modelgl);
      }
      bonds_update = 0;
      active_glwin = lib_proj -> modelgl;
      active_glwin -> init = FALSE;
      active_image = active_glwin -> anim -> last -> img;
      lib_proj  -> runc[0] = TRUE;
      init_atomes_analysis (lib_proj, TRUE);
      on_calc_bonds_released (NULL, NULL);
      lib_proj -> modelgl -> anim -> last -> img -> quality = 30;
      lib_proj -> modelgl -> anim -> last -> img -> rep = ORTHOGRAPHIC;
      lib_proj -> modelgl -> anim -> last -> img -> xyz -> axis = NONE;
      lib_proj -> modelgl -> anim -> last -> img -> abc -> box = NONE;
      if (visible)
      {
        gtk_widget_set_size_request (lib_proj -> modelgl -> plot, 150, 150);
        update (lib_proj -> modelgl);
      }
      active_project_changed (active);
    }
  }
}

G_MODULE_EXPORT void select_library_data (GtkTreeView * tree_view, GtkTreePath * path, GtkTreeViewColumn * column, gpointer data)
{
  GtkTreeIter row;
  GtkTreeModel * model = gtk_tree_view_get_model(tree_view);
  if (gtk_tree_model_get_iter (model, & row, path))
  {
    GValue val = {0, };
    GValue vbl = {0, };
    gtk_tree_model_get_value (model, & row, 0, & val);
    gtk_tree_model_get_value (model, & row, 1, & vbl);
    int i = (int)g_value_get_int (& val);
    if (i > -1)
    {
      the_family = i;
      gtk_list_store_clear (molecule_store);
      fill_molecule_tree (molecule_store);
      gtk_tree_selection_select_iter (libselect[1], & first_mol_iter);
      prepare_preview (activep, 0, TRUE);
    }
    else
    {
      the_molecule = g_strdup_printf ("%s", (char *)g_value_get_string (& vbl));
      prepare_preview (activep, -i-1, TRUE);
    }
  }
}

G_MODULE_EXPORT void set_library_markup (GtkTreeViewColumn * col, GtkCellRenderer * renderer, GtkTreeModel * mod, GtkTreeIter * iter, gpointer data)
{
  set_renderer_markup (mod, iter, renderer, 1);
}

GtkWidget * library_tree (GtkListStore * store, int id, gchar * name)
{
  GtkWidget * scrol = create_scroll (NULL, 150, 300, GTK_SHADOW_ETCHED_IN);
  GtkTreeViewColumn * datacol;
  GtkCellRenderer * datacel;
  GtkWidget * dataview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
  datacel = gtk_cell_renderer_text_new ();
  datacol = gtk_tree_view_column_new_with_attributes (name, datacel, "text", 1, NULL);
  gtk_tree_view_column_set_cell_data_func (datacol, datacel, set_library_markup, NULL, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(dataview), datacol);
  gtk_tree_view_column_set_alignment (datacol, 0.5);
  gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW(dataview), TRUE);
  g_signal_connect (G_OBJECT(dataview), "row-activated", G_CALLBACK(select_library_data), NULL);
  g_object_unref (store);
  libselect[id] = gtk_tree_view_get_selection (GTK_TREE_VIEW(dataview));
  gtk_tree_selection_set_mode (libselect[id], GTK_SELECTION_SINGLE);
  add_container_child (CONTAINER_SCR, scrol, dataview);
  return scrol;
}
 
gboolean lib_res;
gboolean lib_visible;

G_MODULE_EXPORT void run_select_from_library (GtkDialog * lib, gint response_id, gpointer data)
{
  gboolean done = FALSE;
  atom_search * asearch = (atom_search *)data;
  project * this_proj = get_project_by_id (asearch -> proj);
  GtkWidget * vbox;
  switch (response_id)
  {
    case GTK_RESPONSE_APPLY:
      vbox = dialog_get_content_area ((GtkWidget *)lib);
      widget_set_sensitive (vbox, FALSE);
      if (this_proj -> modelgl) this_proj -> modelgl -> other_status = 2;
      create_object_from_library (lib_proj -> id);
      active_project_changed (activep);
      if (asearch -> action == INSERT)
      {
        to_insert_in_project (FROM_LIBRARY, -1, this_proj, asearch, lib_visible);
        if (! lib_visible)
        {
          gboolean vis;
          if (this_proj -> modelgl)
          {
            vis = (this_proj -> modelgl -> atom_win) ? this_proj -> modelgl -> atom_win -> visible : FALSE;
          }
          else
          {
            vis = FALSE;
          }
          inserted_from_lib += action_atoms_from_project (this_proj, asearch, vis);
        }
        if (this_proj -> modelgl) this_proj -> modelgl -> nth_copy ++;
      }
      lib_res = FROM_LIBRARY;
      widget_set_sensitive (vbox, TRUE);
      if (asearch -> action == REPLACE) done = TRUE;
      break;
    default:
      if (this_proj -> modelgl)
      {
        if (this_proj -> modelgl -> mode == EDITION) asearch -> todo[0] = 0;
      }
      lib_res = 0;
      done = TRUE;
      break;
  }
  if (done) destroy_this_dialog (lib);
}

int select_from_library (gboolean visible, project * this_proj, atom_search * asearch)
{
  int active = activep;
  int nats = this_proj -> natomes;
  lib_visible = visible;
  GtkWidget * lib = dialogmodal (_("Library"), GTK_WINDOW((this_proj -> modelgl) ? this_proj -> modelgl -> win : MainWindow));
#ifdef GTK3
#ifdef GTKGLAREA
#ifndef OSX
#ifndef G_OS_WIN32
  if (! atomes_visual) gtk_window_change_gdk_visual (lib);
#endif // G_OS_WIN32
#endif // OSX
#endif // GTKGLAREA
#endif // GTK3
  gtk_dialog_add_button (GTK_DIALOG(lib), (asearch -> action == REPLACE) ? _("Replace") : _("Insert"), GTK_RESPONSE_APPLY);
  GtkWidget * vbox = dialog_get_content_area (lib);
  GtkWidget * hbox = create_hbox (5);
  add_box_child_start (GTK_ORIENTATION_VERTICAL, vbox, hbox, FALSE, FALSE, 0);
  sml_file_name = mol_name = NULL;
  family_store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
  fill_family_tree (family_store);
  add_box_child_start (GTK_ORIENTATION_HORIZONTAL, hbox, library_tree (family_store, 0, _("Family")), FALSE, FALSE, 0);
  molecule_store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
  add_box_child_start (GTK_ORIENTATION_HORIZONTAL, hbox, library_tree (molecule_store, 1, _("Molecule")), FALSE, FALSE, 0);
  lib_preview_box = create_hbox(0);
  add_box_child_start (GTK_ORIENTATION_HORIZONTAL, hbox, lib_preview_box, FALSE, FALSE, 10);
  lib_preview_plot = NULL;
  the_family = 0;
  gtk_tree_selection_select_iter (libselect[0], & first_family_iter);
  gtk_list_store_clear (molecule_store);
  fill_molecule_tree (molecule_store);
  gtk_tree_selection_select_iter (libselect[1], & first_mol_iter);
  show_the_widgets (lib);
  prepare_preview (active, 0, TRUE);
  if (this_proj -> modelgl) this_proj -> modelgl -> nth_copy = 0;
  inserted_from_lib = 0;
  run_this_gtk_dialog (lib, G_CALLBACK(run_select_from_library), asearch);
  active_project_changed (active);
  if (! nats && active_project -> natomes)
  {
    int i;
    if (active_image -> style == SPACEFILL)
    {
      i = OGL_STYLES + active_image -> filled_type;
      set_this_style (active_glwin, WIREFRAME);
    }
    else
    {
      i = active_image -> style;
      set_this_style (active_glwin, OGL_STYLES);
    }
    set_this_style (active_glwin, i);
  }
  if (sml_file_name != NULL) g_free (sml_file_name);
  if (mol_name != NULL) g_free (mol_name);
  if (lib_proj != NULL) close_project (lib_proj);
  lib_proj = NULL;
  lib_preview_plot = NULL;
  return lib_res;
}

int insert_this_project_from_lib (int id, gboolean visible, project * this_proj, atom_search * asearch)
{
  sml_file_name = mol_name = NULL;
  int family[6] = {0, 3, 9, 9, 15, 17};
  int molec[6] = {0, 8, 36, 21, 11, 0};
  int active = activep;
  int nats = this_proj -> natomes;
  the_family = family[id];
  if (get_sml_files ())
  {
    prepare_preview (active, molec[id], FALSE);
    if (this_proj -> modelgl) this_proj -> modelgl -> other_status = 2;
    create_object_from_library (lib_proj -> id);
    if (asearch -> action == INSERT)
    {
      to_insert_in_project (FROM_LIBRARY, -1, this_proj, asearch, visible);
    }
  }
  active_project_changed (active);
  if (! nats && active_project -> natomes)
  {
    int i;
    if (active_image -> style == SPACEFILL)
    {
      i = OGL_STYLES + active_image -> filled_type;
      set_this_style (active_glwin, WIREFRAME);
    }
    else
    {
      i = active_image -> style;
      set_this_style (active_glwin, OGL_STYLES);
    }
    set_this_style (active_glwin, i);
  }
  if (sml_file_name != NULL) g_free (sml_file_name);
  if (mol_name != NULL) g_free (mol_name);
  if (lib_proj != NULL) close_project (lib_proj);
  lib_proj = NULL;
  return FROM_LIBRARY;
}