Setting.c

/* 
A* -------------------------------------------------------------------
B* This file contains source code for the PyMOL computer program
C* copyright 1998-2000 by Warren Lyford Delano of DeLano Scientific. 
D* -------------------------------------------------------------------
E* It is unlawful to modify or remove this copyright notice.
F* -------------------------------------------------------------------
G* Please see the accompanying LICENSE file for further information. 
H* -------------------------------------------------------------------
I* Additional authors of this source file include:
-* 
-* 
-*
Z* -------------------------------------------------------------------
*/

#include"os_proprietary.h"

#include"os_predef.h"
#include"os_std.h"

#include"Base.h"
#include"OOMac.h"
#include"MemoryDebug.h"
#include"Ortho.h"
#include"Setting.h"
#include"Scene.h"
#include"ButMode.h"
#include"Executive.h"
#include"Editor.h"
#include"P.h"
#include"Util.h"
#include"main.h"
#include"PConv.h"
#include"Wizard.h"
#include"Seq.h"
#include"PyMOLOptions.h"
#include"OVContext.h"

static void *SettingPtr(CSetting * I, int index, ov_size size);

static CSetting *SettingCopyAll(PyMOLGlobals * G, CSetting * src, CSetting * dst)
{
  if(!dst) {
    dst = Calloc(CSetting, 1);
    if(dst) {
      SettingInit(G, dst);
    }
  }
  if(dst && src) {

    /* simply overwriting existing data (if any) ... in the future we
       may need to release references etc. before doing this */

    unsigned int size = VLAGetSize(src->info);
    VLACheck(dst->info, SettingRec, size);
    UtilCopyMem(dst->info, src->info, sizeof(SettingRec) * size);
    VLACheck(dst->data, char, src->size);
    dst->size = src->size;
    UtilCopyMem(dst->data, src->data, src->size);
  }
  return dst;
}

void SettingStoreDefault(PyMOLGlobals * G)
{
  G->Default = SettingCopyAll(G, G->Setting, G->Default);
}

void SettingPurgeDefault(PyMOLGlobals * G)
{
  if(G->Default) {
    SettingPurge(G->Default);
    FreeP(G->Default);
    G->Default = NULL;
  }
}

void SettingUniqueDetachChain(PyMOLGlobals * G, int unique_id)
{
  register CSettingUnique *I = G->SettingUnique;
  OVreturn_word result;
  if(OVreturn_IS_OK(result = OVOneToOne_GetForward(I->id2offset, unique_id))) {
    int offset = result.word;
    int next;

    OVOneToOne_DelForward(I->id2offset, unique_id);

    {
      SettingUniqueEntry *entry;
      while(offset) {
        entry = I->entry + offset;
        next = entry->next;
        entry->next = I->next_free;
        I->next_free = offset;
        offset = next;
      }
    }
  } else {
    /* uncaught error */
  }
}

static void SettingUniqueExpand(PyMOLGlobals * G)
{
  register CSettingUnique *I = G->SettingUnique;

  if(!I->next_free) {
    int new_n_alloc = (I->n_alloc * 3) / 2;
    int a;
    VLACheck(I->entry, SettingUniqueEntry, new_n_alloc);
    for(a = I->n_alloc; a < new_n_alloc; a++) {
      I->entry[a].next = I->next_free;
      I->next_free = a;
    }
    I->n_alloc = new_n_alloc;
  }
}

int SettingUniqueCheck(PyMOLGlobals * G, int unique_id, int setting_id)
{
  register CSettingUnique *I = G->SettingUnique;
  OVreturn_word result;
  if(OVreturn_IS_OK(result = OVOneToOne_GetForward(I->id2offset, unique_id))) {
    int offset = result.word;
    SettingUniqueEntry *entry;

    while(offset) {
      entry = I->entry + offset;
      if(entry->setting_id == setting_id) {
        return 1;
      }
      offset = entry->next;
    }
  }
  return 0;
}

static int SettingUniqueGetTypedValue(PyMOLGlobals * G, int unique_id, int setting_id,
                                      int setting_type, void *value)
{
  register CSettingUnique *I = G->SettingUnique;
  OVreturn_word result;
  if(OVreturn_IS_OK(result = OVOneToOne_GetForward(I->id2offset, unique_id))) {
    int offset = result.word;
    SettingUniqueEntry *entry;
    while(offset) {
      entry = I->entry + offset;
      if(entry->setting_id == setting_id) {
        if(entry->type == setting_type) {
          *(int *) value = entry->value.int_;
        } else
          switch (setting_type) {
          case cSetting_int:
          case cSetting_color:
          case cSetting_boolean:
            switch (entry->type) {
            case cSetting_float:
              *(int *) value = (int) (*(float *) &entry->value.float_);
              break;
            default:
              *(int *) value = entry->value.int_;
              break;
            }
            break;
          case cSetting_float:
            *(float *) value = (float) (*(int *) &entry->value.int_);
            break;
          }
        return 1;
      }
      offset = entry->next;
    }
  }
  return 0;
}

int SettingUniqueGet_b(PyMOLGlobals * G, int unique_id, int setting_id, int *value)
{
  return SettingUniqueGetTypedValue(G, unique_id, setting_id, cSetting_boolean, value);
}

int SettingUniqueGet_i(PyMOLGlobals * G, int unique_id, int setting_id, int *value)
{
  return SettingUniqueGetTypedValue(G, unique_id, setting_id, cSetting_int, value);
}

int SettingUniqueGet_f(PyMOLGlobals * G, int unique_id, int setting_id, float *value)
{
  return SettingUniqueGetTypedValue(G, unique_id, setting_id, cSetting_float, value);
}

int SettingUniqueGet_color(PyMOLGlobals * G, int unique_id, int setting_id, int *value)
{
  return SettingUniqueGetTypedValue(G, unique_id, setting_id, cSetting_color, value);
}

void SettingUniqueSetTypedValue(PyMOLGlobals * G, int unique_id, int setting_id,
                                int setting_type, void *value)

/* set value to NULL in order to delete setting */
{
  register CSettingUnique *I = G->SettingUnique;
  OVreturn_word result;

  if(OVreturn_IS_OK((result = OVOneToOne_GetForward(I->id2offset, unique_id)))) {       /* setting list exists for atom */
    int offset = result.word;
    int prev = 0;
    int found = false;
    while(offset) {
      SettingUniqueEntry *entry = I->entry + offset;
      if(entry->setting_id == setting_id) {
        found = true;           /* this setting is already defined */
        if(value) {             /* if redefining value */
          entry->value.int_ = *(int *) value;
          entry->type = setting_type;
        } else {                /* or NULL value means delete this setting */
          if(!prev) {           /* if first entry in list */
            OVOneToOne_DelForward(I->id2offset, unique_id);
            if(entry->next) {   /* set new list start */
              OVOneToOne_Set(I->id2offset, unique_id, entry->next);
            }
          } else {              /* otherwise excise from middle or end */
            I->entry[prev].next = entry->next;
          }
          entry->next = I->next_free;
          I->next_free = offset;
        }
        break;
      }
      prev = offset;
      offset = entry->next;
    }
    if((!found) && value) {     /* setting not found in existing list, so append new value */
      if(!I->next_free)
        SettingUniqueExpand(G);
      if(I->next_free) {
        offset = I->next_free;
        {
          SettingUniqueEntry *entry = I->entry + offset;
          I->next_free = entry->next;
          entry->next = 0;

          if(prev) {            /* append onto existing list */
            I->entry[prev].next = offset;
            entry->type = setting_type;
            entry->value.int_ = *(int *) value;
            entry->setting_id = setting_id;
          } else if(OVreturn_IS_OK(OVOneToOne_Set(I->id2offset, unique_id, offset))) {
            /* create new list */
            entry->type = setting_type;
            entry->value.int_ = *(int *) value;
            entry->setting_id = setting_id;
          }
        }
      }
    }
  } else if(value && (result.status == OVstatus_NOT_FOUND)) {   /* new setting list for atom */
    if(!I->next_free)
      SettingUniqueExpand(G);
    if(I->next_free) {
      int offset = I->next_free;
      SettingUniqueEntry *entry = I->entry + offset;

      if(OVreturn_IS_OK(OVOneToOne_Set(I->id2offset, unique_id, offset))) {
        I->next_free = entry->next;
        entry->type = setting_type;
        entry->value.int_ = *(int *) value;
        entry->setting_id = setting_id;
        entry->next = 0;
      }
    }
  } else {
    /* unhandled error */
  }
}

void SettingUniqueSet_i(PyMOLGlobals * G, int unique_id, int setting_id, int value)
{
  SettingUniqueSetTypedValue(G, unique_id, setting_id, cSetting_int, &value);
}

void SettingUniqueSet_f(PyMOLGlobals * G, int unique_id, int setting_id, float value)
{
  SettingUniqueSetTypedValue(G, unique_id, setting_id, cSetting_float, &value);
}

void SettingUniqueSet_b(PyMOLGlobals * G, int unique_id, int setting_id, int value)
{
  SettingUniqueSetTypedValue(G, unique_id, setting_id, cSetting_boolean, &value);
}

void SettingUniqueSet_color(PyMOLGlobals * G, int unique_id, int setting_id, int value)
{
  SettingUniqueSetTypedValue(G, unique_id, setting_id, cSetting_color, &value);
}

void SettingUniqueResetAll(PyMOLGlobals * G)
{
  register CSettingUnique *I = G->SettingUnique;

  OVOneToOne_Reset(I->id2offset);
  {
    int a;
    I->n_alloc = 10;
    VLAFreeP(I->entry);
    I->entry = VLACalloc(SettingUniqueEntry, I->n_alloc);
    /* note: intentially skip index 0  */
    for(a = 2; a < 10; a++) {
      I->entry[a].next = a - 1;
    }
    I->next_free = I->n_alloc - 1;
  }
}

int SettingUniqueCopyAll(PyMOLGlobals * G, int src_unique_id, int dst_unique_id)
{
  int ok = true;
  register CSettingUnique *I = G->SettingUnique;
  OVreturn_word dst_result;

  if(OVreturn_IS_OK((dst_result = OVOneToOne_GetForward(I->id2offset, dst_unique_id)))) {       /* setting list exists for atom */

    /* note, this code path not yet tested...doesn't occur */

    OVreturn_word src_result;
    if(OVreturn_IS_OK(src_result = OVOneToOne_GetForward(I->id2offset, src_unique_id))) {
      int src_offset = src_result.word;
      SettingUniqueEntry *src_entry;
      while(src_offset) {
        src_entry = I->entry + src_offset;

        {
          int setting_id = src_entry->setting_id;
          int setting_type = src_entry->type;
          int setting_value = src_entry->value.int_;
          int dst_offset = dst_result.word;
          int prev = 0;
          int found = false;
          while(dst_offset) {
            SettingUniqueEntry *dst_entry = I->entry + dst_offset;
            if(dst_entry->setting_id == setting_id) {
              found = true;     /* this setting is already defined */
              dst_entry->value.int_ = setting_value;
              dst_entry->type = setting_type;
              break;
            }
            prev = dst_offset;
            dst_offset = dst_entry->next;
          }
          if(!found) {          /* setting not found in existing list, so append new value */
            if(!I->next_free)
              SettingUniqueExpand(G);
            if(I->next_free) {
              dst_offset = I->next_free;
              {
                SettingUniqueEntry *dst_entry = I->entry + dst_offset;
                I->next_free = dst_entry->next;
                dst_entry->next = 0;
                if(prev) {      /* append onto existing list */
                  I->entry[prev].next = dst_offset;
                  dst_entry->type = setting_type;
                  dst_entry->value.int_ = setting_value;
                  dst_entry->setting_id = setting_id;
                } else
                  if(OVreturn_IS_OK
                     (OVOneToOne_Set(I->id2offset, dst_unique_id, dst_offset))) {
                  /* create new list */
                  dst_entry->type = setting_type;
                  dst_entry->value.int_ = setting_value;
                  dst_entry->setting_id = setting_id;
                }
              }
            }
          }
        }
        src_offset = I->entry[src_offset].next; /* src_entry invalid, since I->entry may have changed */
      }
    }
  } else if(dst_result.status == OVstatus_NOT_FOUND) {  /* new setting list for atom */
    OVreturn_word src_result;
    if(OVreturn_IS_OK(src_result = OVOneToOne_GetForward(I->id2offset, src_unique_id))) {
      int src_offset = src_result.word;
      int prev = 0;
      SettingUniqueEntry *src_entry;
      while(ok && src_offset) {
        if(!I->next_free)
          SettingUniqueExpand(G);
        {
          src_entry = I->entry + src_offset;
          {
            int setting_id = src_entry->setting_id;
            int setting_type = src_entry->type;
            int setting_value = src_entry->value.int_;
            if(I->next_free) {
              int dst_offset = I->next_free;
              SettingUniqueEntry *dst_entry = I->entry + dst_offset;
              I->next_free = dst_entry->next;

              if(!prev) {
                if(!OVreturn_IS_OK
                   (OVOneToOne_Set(I->id2offset, dst_unique_id, dst_offset))) {
                  ok = false;
                }
              } else {
                I->entry[prev].next = dst_offset;
              }

              if(ok) {
                dst_entry->type = setting_type;
                dst_entry->value.int_ = setting_value;
                dst_entry->setting_id = setting_id;
                dst_entry->next = 0;
              }
              prev = dst_offset;
            }
          }
        }
        src_offset = I->entry[src_offset].next; /* src_entry invalid, since I->entry may have changed */
      }
    }
  } else {
    ok = false;
    /* unhandled error */
  }

  return ok;
}

static void SettingUniqueInit(PyMOLGlobals * G)
{
  register CSettingUnique *I = G->SettingUnique;

  if((I = (G->SettingUnique = Calloc(CSettingUnique, 1)))) {
    I->id2offset = OVOneToOne_New(G->Context->heap);
    {
      int a;
      I->n_alloc = 10;
      I->entry = VLACalloc(SettingUniqueEntry, I->n_alloc);
      /* note: intentially skip index 0  */
      for(a = 2; a < 10; a++) {
        I->entry[a].next = a - 1;       /* 1-based linked list with 0 as sentinel */
      }
      I->next_free = I->n_alloc - 1;
    }
  }
}

static void SettingUniqueFree(PyMOLGlobals * G)
{
  register CSettingUnique *I = G->SettingUnique;
  VLAFreeP(I->entry);
  OVOneToOne_Del(I->id2offset);
  if(I->old2new)
    OVOneToOne_Del(I->old2new);
  FreeP(I);
}

int SettingUniqueConvertOldSessionID(PyMOLGlobals * G, int old_unique_id)
{
  register CSettingUnique *I = G->SettingUnique;
  int unique_id = old_unique_id;
  if(I->old2new) {
    OVreturn_word ret;
    if(OVreturn_IS_OK(ret = OVOneToOne_GetForward(I->old2new, old_unique_id))) {
      unique_id = ret.word;
    }
  }
  return unique_id;
}

int SettingUniqueFromPyList(PyMOLGlobals * G, PyObject * list, int partial_restore)
{
#ifdef _PYMOL_NOPY
  return 0;
#else
  int ok = true;
  register CSettingUnique *I = G->SettingUnique;
  if(!partial_restore) {
    SettingUniqueResetAll(G);
    if(I->old2new) {
      OVOneToOne_Del(I->old2new);
      I->old2new = NULL;
    }
  } else {
    if(!I->old2new) {
      I->old2new = OVOneToOne_New(G->Context->heap);
    } else {
      OVOneToOne_Reset(I->old2new);
    }
  }
  if(list)
    if(PyList_Check(list)) {
      ov_size n_id = PyList_Size(list);
      ov_size a;
      for(a = 0; a < n_id; a++) {
        PyObject *id_list = PyList_GetItem(list, a);
        int unique_id;
        if(ok)
          ok = PyList_Check(id_list);
        if(ok)
          ok = (PyList_Size(id_list) > 1);
        if(ok)
          ok = PConvPyIntToInt(PyList_GetItem(id_list, 0), &unique_id);
        if(ok && partial_restore) {
          if(AtomInfoIsUniqueIDActive(G, unique_id)) {
            /* if this ID is already active, then we need a substitute */
            int old_unique_id = unique_id;
            unique_id = AtomInfoGetNewUniqueID(G);
            OVOneToOne_Set(I->old2new, old_unique_id, unique_id);
          }
        }
        if(ok) {
          ov_size n_set = 0;

          PyObject *setting_list = PyList_GetItem(id_list, 1);
          if(ok)
            ok = PyList_Check(setting_list);
          if(ok)
            n_set = PyList_Size(setting_list);
          if(ok) {
            ov_size b;
            for(b = 0; b < n_set; b++) {
              PyObject *entry_list = PyList_GetItem(setting_list, b);
              if(ok)
                ok = PyList_Check(entry_list);
              if(ok)
                ok = (PyList_Size(entry_list) > 2);
              if(ok) {
                int setting_id;
                int setting_type;
                union {
                  int int_;
                  float float_;
                } value_store;
                if(ok)
                  ok = PConvPyIntToInt(PyList_GetItem(entry_list, 0), &setting_id);
                if(ok)
                  ok = PConvPyIntToInt(PyList_GetItem(entry_list, 1), &setting_type);
                if(ok)
                  switch (setting_type) {

                  case cSetting_int:
                  case cSetting_color:
                  case cSetting_boolean:
                    ok = PConvPyIntToInt(PyList_GetItem(entry_list, 2),
                                         &value_store.int_);
                    break;
                  case cSetting_float:
                    ok = PConvPyFloatToFloat(PyList_GetItem(entry_list, 2),
                                             &value_store.float_);
                    break;
                  }
                if(ok) {
                  SettingUniqueSetTypedValue(G, unique_id, setting_id,
                                             setting_type, &value_store.int_);
                }
              }
            }
          }
        }
      }
    }
  return ok;
#endif
}

PyObject *SettingUniqueAsPyList(PyMOLGlobals * G)
{
#ifdef _PYMOL_NOPY
  return NULL;
#else
  PyObject *result = NULL;
  register CSettingUnique *I = G->SettingUnique;
  {
    ov_word hidden = 0;
    OVreturn_word ret;
    int n_entry = 0;
    while(1) {
      ret = OVOneToOne_IterateForward(I->id2offset, &hidden);
      if(ret.status != OVstatus_YES)
        break;
      n_entry++;
    }
    result = PyList_New(n_entry);
    if(result) {
      hidden = 0;
      n_entry = 0;
      while(1) {
        PyObject *setting_list = NULL;
        int save_offset, unique_id;
        ret = OVOneToOne_IterateForward(I->id2offset, &hidden);

        if(ret.status != OVstatus_YES)
          break;
        unique_id = ret.word;
        if(OVreturn_IS_OK(ret = OVOneToOne_GetForward(I->id2offset, unique_id))) {
          int offset = ret.word;
          int n_set = 0;

          /* count number of settings for this unique_id */

          SettingUniqueEntry *entry;
          save_offset = offset;
          while(offset) {
            entry = I->entry + offset;
            n_set++;
            offset = entry->next;
          }

          /* create and insert list for each setting */

          setting_list = PyList_New(n_set);
          n_set = 0;
          offset = save_offset;
          while(offset) {
            PyObject *setting_entry = PyList_New(3);
            entry = I->entry + offset;
            PyList_SetItem(setting_entry, 0, PyInt_FromLong(entry->setting_id));
            PyList_SetItem(setting_entry, 1, PyInt_FromLong(entry->type));
            switch (entry->type) {
            case cSetting_int:
            case cSetting_color:
            case cSetting_boolean:
              PyList_SetItem(setting_entry, 2, PyInt_FromLong(entry->value.int_));
              break;
            case cSetting_float:
              PyList_SetItem(setting_entry, 2,
                             PyFloat_FromDouble(*(float *) &entry->value.float_));
              break;
            }
            PyList_SetItem(setting_list, n_set, setting_entry);
            n_set++;
            offset = entry->next;
          }
        }

        /* add this unique_id set into the overall list */

        {
          PyObject *unique_list = PyList_New(2);
          PyList_SetItem(unique_list, 0, PyInt_FromLong(unique_id));
          PyList_SetItem(unique_list, 1, setting_list);
          PyList_SetItem(result, n_entry, unique_list);
        }
        n_entry++;
      }
    }
  }
  return (PConvAutoNone(result));
#endif
}

int SettingSetSmart_i(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index,
                      int value)
{
  int dummy;
  if(set1 && SettingGetIfDefined_i(G, set1, index, &dummy)) {
    return SettingSet_i(set1, index, value);
  }
  if(set2 && SettingGetIfDefined_i(G, set2, index, &dummy)) {
    return SettingSet_i(set2, index, value);
  }
  return SettingSetGlobal_i(G, index, value);
}

int SettingSetGlobalsFromPyList(PyMOLGlobals * G, PyObject * list)
{
#ifdef _PYMOL_NOPY
  return 0;
#else
  int ok = true;

  int session_migration = SettingGetGlobal_b(G, cSetting_session_migration);
  int session_version_check = SettingGetGlobal_b(G, cSetting_session_version_check);
  int full_screen = SettingGetGlobal_b(G, cSetting_full_screen);
  int internal_gui = SettingGetGlobal_b(G, cSetting_internal_gui);
  int internal_feedback = SettingGetGlobal_b(G, cSetting_internal_feedback);

  int stereo = SettingGetGlobal_b(G, cSetting_stereo);
  int text = SettingGetGlobal_b(G, cSetting_text);
  int texture_fonts = SettingGetGlobal_b(G, cSetting_texture_fonts);
  int use_display_lists = SettingGetGlobal_b(G, cSetting_use_display_lists);
  int max_threads = SettingGetGlobal_i(G, cSetting_max_threads);
  int nvidia_bugs = SettingGetGlobal_b(G, cSetting_nvidia_bugs);
  int ati_bugs = SettingGetGlobal_b(G, cSetting_ati_bugs);
  int stereo_mode = SettingGetGlobal_i(G, cSetting_stereo_mode);
  int stereo_double_pump_mono = SettingGetGlobal_b(G, cSetting_stereo_double_pump_mono);
  int show_progress = SettingGetGlobal_b(G, cSetting_show_progress);
  int defer_updates = SettingGetGlobal_b(G, cSetting_defer_updates);
  int suspend_updates = SettingGetGlobal_b(G, cSetting_suspend_updates);
  int cache_max = SettingGetGlobal_i(G, cSetting_cache_max);
  int logging = SettingGetGlobal_i(G, cSetting_logging);
  float no_idle = SettingGetGlobal_f(G, cSetting_no_idle);
  float slow_idle = SettingGetGlobal_f(G, cSetting_fast_idle);
  float fast_idle = SettingGetGlobal_f(G, cSetting_slow_idle);
  int mouse_grid = SettingGetGlobal_b(G, cSetting_mouse_grid);
  int mouse_z_scale = SettingGetGlobal_i(G,cSetting_mouse_scale);
  register CSetting *I = G->Setting;
  if(list)
    if(PyList_Check(list))
      ok = SettingFromPyList(I, list);

  SettingSet_i(I, cSetting_security, G->Security);      /* always override Security setting with global variable */
  SettingSet_b(I, cSetting_session_migration, session_migration);       /* preserve current migration info */
  SettingSet_b(I, cSetting_session_version_check, session_version_check);

  /* restore the following settings  */

  SettingSetGlobal_f(G, cSetting_no_idle, no_idle);
  SettingSetGlobal_f(G, cSetting_fast_idle, fast_idle);
  SettingSetGlobal_f(G, cSetting_slow_idle, slow_idle);

  SettingSet_b(I, cSetting_stereo, stereo);
  SettingSet_b(I, cSetting_text, text);
  SettingSet_b(I, cSetting_texture_fonts, texture_fonts);
  SettingSet_b(I, cSetting_use_display_lists, use_display_lists);
  SettingSet_i(I, cSetting_max_threads, max_threads);
  SettingSet_i(I, cSetting_nvidia_bugs, nvidia_bugs);
  SettingSet_i(I, cSetting_ati_bugs, ati_bugs);
  SettingSet_i(I, cSetting_cache_max, cache_max);
  SettingSet_i(I, cSetting_logging, logging);

  SettingSet_i(I, cSetting_stereo_mode, stereo_mode);
  SettingSet_b(I, cSetting_stereo_double_pump_mono, stereo_double_pump_mono);
  SettingSet_b(I, cSetting_full_screen, full_screen);
  SettingSet_b(I, cSetting_show_progress, show_progress);
  SettingSet_b(I, cSetting_defer_updates, defer_updates);
  SettingSet_b(I, cSetting_suspend_updates, suspend_updates);
  SettingSet_b(I, cSetting_session_changed, 0);

  SettingSet_b(I, cSetting_mouse_grid, mouse_grid);
  SettingSet_i(I, cSetting_mouse_z_scale, mouse_z_scale);
  if(G->Option->presentation) {
    SettingSet_b(I, cSetting_full_screen, full_screen);
    SettingSet_b(I, cSetting_presentation, 1);
    SettingSet_b(I, cSetting_internal_gui, internal_gui);
    SettingSet_b(I, cSetting_internal_feedback, internal_feedback);
  }
  if(G->Option->no_quit) {
    SettingSet_b(I, cSetting_presentation_auto_quit, 0);
  }

#ifdef _PYMOL_ACTIVEX
  SettingSet_i(I, cSetting_max_threads, 1);
  SettingSet_b(I, cSetting_async_builds, 0);
#endif
  return (ok);
#endif
}

PyObject *SettingGetGlobalsAsPyList(PyMOLGlobals * G)
{
#ifdef _PYMOL_NOPY
  return NULL;
#else
  PyObject *result = NULL;
  register CSetting *I = G->Setting;
  result = SettingAsPyList(I);
  return (PConvAutoNone(result));
#endif
}

#ifndef _PYMOL_NOPY
static PyObject *get_list(CSetting * I, int index)
{
  PyObject *result = NULL;
  int setting_type = I->info[index].type;
  switch (setting_type) {

  case cSetting_boolean:
  case cSetting_int:
  case cSetting_color:
    result = PyList_New(3);
    PyList_SetItem(result, 0, PyInt_FromLong(index));
    PyList_SetItem(result, 1, PyInt_FromLong(setting_type));
    PyList_SetItem(result, 2,
                   PyInt_FromLong(*((int *) (I->data + I->info[index].offset))));
    break;
  case cSetting_float:
    result = PyList_New(3);
    PyList_SetItem(result, 0, PyInt_FromLong(index));
    PyList_SetItem(result, 1, PyInt_FromLong(setting_type));
    PyList_SetItem(result, 2,
                   PyFloat_FromDouble(*((float *) (I->data + I->info[index].offset))));
    break;
  case cSetting_float3:
    result = PyList_New(3);
    PyList_SetItem(result, 0, PyInt_FromLong(index));
    PyList_SetItem(result, 1, PyInt_FromLong(setting_type));
    PyList_SetItem(result, 2,
                   PConvFloatArrayToPyList(((float *) (I->data + I->info[index].offset)),
                                           3));
    break;
  case cSetting_string:
    result = PyList_New(3);
    PyList_SetItem(result, 0, PyInt_FromLong(index));
    PyList_SetItem(result, 1, PyInt_FromLong(setting_type));
    PyList_SetItem(result, 2,
                   PyString_FromString(((char *) (I->data + I->info[index].offset))));
    break;
  default:
    result = Py_None;
    break;
  }
  return (PConvAutoNone(result));
}
#endif

PyObject *SettingAsPyList(CSetting * I)
{
#ifdef _PYMOL_NOPY
  return NULL;
#else

  PyObject *result = NULL;
  int cnt = 0;
  int a;

  if(I) {
    for(a = 0; a < cSetting_INIT; a++) {
      if(I->info[a].defined)
        cnt++;
    }
    result = PyList_New(cnt);
    cnt = 0;
    for(a = 0; a < cSetting_INIT; a++) {
      if(I->info[a].defined) {
        PyList_SetItem(result, cnt, get_list(I, a));
        cnt++;
      }
    }
  }
  return (PConvAutoNone(result));
#endif
}


/*========================================================================*/
#ifndef _PYMOL_NOPY
static int set_list(CSetting * I, PyObject * list)
{
  int ok = true;
  int index;
  int setting_type;
  char *str;
  if(list != Py_None) {
    if(ok)
      ok = (list != NULL);
    if(ok)
      ok = PyList_Check(list);
    if(ok)
      ok = PConvPyIntToInt(PyList_GetItem(list, 0), &index);
    if(ok)
      ok = PConvPyIntToInt(PyList_GetItem(list, 1), &setting_type);
    if(ok && (index < cSetting_INIT)) { /* ignore unknown settings */
      switch (index) {
        /* don't restore the folllowing settings,
           which are inherently system-dependent */
      case cSetting_stereo_double_pump_mono:
      case cSetting_max_threads:
      case cSetting_session_migration:
        break;
      default:
        if(ok)
          switch (setting_type) {
          case cSetting_boolean:
          case cSetting_int:
            ok = PConvPyIntToInt(PyList_GetItem(list, 2),
                                 (int *) SettingPtr(I, index, sizeof(int)));
            break;
          case cSetting_color:
            {
              int color = 0;
              ok = PConvPyIntToInt(PyList_GetItem(list, 2), &color);
              if(ok)
                color = ColorConvertOldSessionIndex(I->G, color);
              *((int *) SettingPtr(I, index, sizeof(int))) = color;
            }
            break;
          case cSetting_float:
            ok = PConvPyFloatToFloat(PyList_GetItem(list, 2),
                                     (float *) SettingPtr(I, index, sizeof(float)));
            break;
          case cSetting_float3:
            ok = PConvPyListToFloatArrayInPlaceAutoZero(PyList_GetItem(list, 2),
                                                        (float *) SettingPtr(I, index,
                                                                             3 *
                                                                             sizeof
                                                                             (float)), 3);
            break;
          case cSetting_string:
            ok = PConvPyStrToStrPtr(PyList_GetItem(list, 2), &str);
            if(ok) {
              strcpy(((char *) SettingPtr(I, index, strlen(str) + 1)), str);
            }
            break;
          }
      }
      if(ok)
        I->info[index].type = setting_type;
    }
  }
  return (ok);
}
#endif

/*========================================================================*/
CSetting *SettingNewFromPyList(PyMOLGlobals * G, PyObject * list)
{
#ifdef _PYMOL_NOPY
  return NULL;
#else

  int ok = true;
  ov_size size;
  ov_size a;
  CSetting *I = NULL;
  if(ok)
    ok = (list != NULL);
  if(ok)
    ok = PyList_Check(list);
  if(ok) {
    I = SettingNew(G);
    size = PyList_Size(list);
    for(a = 0; a < size; a++) {
      if(ok)
        ok = set_list(I, PyList_GetItem(list, a));
    }
  }
  return (I);
#endif
}


/*========================================================================*/
int SettingFromPyList(CSetting * I, PyObject * list)
{
#ifdef _PYMOL_NOPY
  return 0;
#else

  int ok = true;
  ov_size size;
  ov_size a;
  if(ok)
    ok = (I != NULL);
  if(ok)
    ok = PyList_Check(list);
  if(ok) {
    size = PyList_Size(list);
    for(a = 0; a < size; a++) {
      if(!set_list(I, PyList_GetItem(list, a)))
        ok = false;
    }
  }
  return (ok);
#endif
}


/*========================================================================*/
#ifndef _PYMOL_NOPY
PyObject *SettingGetUpdateList(PyMOLGlobals * G, CSetting * I)
{                               /* assumes blocked interpreter */

  int a;
  int n;
  PyObject *result;

  if(!I)
    I = G->Setting;             /* fall back on global settings */

  n = VLAGetSize(I->info);
  result = PyList_New(0);
  for(a = 0; a < n; a++) {
    if(I->info[a].changed) {
      I->info[a].changed = false;
      PyList_Append(result, PyInt_FromLong(a));
    }
  }
  return (result);

}
#endif


/*========================================================================*/
void SettingCheckHandle(PyMOLGlobals * G, CSetting ** handle)
{
  if(!*handle)
    *handle = SettingNew(G);
}


/*========================================================================*/
int SettingGetTextValue(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index,
                        char *buffer)

/* not range checked */
{
  int type;
  int ok = true;
  float *ptr;
  type = SettingGetType(G, index);
  switch (type) {
  case cSetting_boolean:
    if(SettingGet_b(G, set1, set2, index))
      sprintf(buffer, "on");
    else
      sprintf(buffer, "off");
    break;
  case cSetting_int:
    sprintf(buffer, "%d", SettingGet_i(G, set1, set2, index));
    break;
  case cSetting_float:
    sprintf(buffer, "%1.5f", SettingGet_f(G, set1, set2, index));
    break;
  case cSetting_float3:
    ptr = SettingGet_3fv(G, set1, set2, index);
    sprintf(buffer, "[ %1.5f, %1.5f, %1.5f ]", ptr[0], ptr[1], ptr[2]);
    break;
  case cSetting_color:
    {
      int color = SettingGet_color(G, set1, set2, index);
      if(color < 0) {
        switch (color) {
        case cColorAtomic:
          strcpy(buffer, "atomic");
          break;
        case cColorObject:
          strcpy(buffer, "object");
          break;
        case cColorFront:
          strcpy(buffer, "front");
          break;
        case cColorBack:
          strcpy(buffer, "back");
          break;
        default:
          if(color > cColorExtCutoff) {
            strcpy(buffer, "default");
          } else {
            char *st = ColorGetName(G, color);
            if(st)
              strcpy(buffer, st);
            else
              strcpy(buffer, "invalid");
          }
          break;
        }
      } else {
        /* assuming valid color */
        strcpy(buffer, ColorGetName(G, color));
      }
    }
    break;
  case cSetting_string:
    strcpy(buffer, SettingGet_s(G, set1, set2, index));
    break;
  default:
    ok = false;
    break;
  }
  return (ok);
}


/*========================================================================*/
#ifndef _PYMOL_NOPY
int SettingSetFromTuple(PyMOLGlobals * G, CSetting * I, int index, PyObject * tuple)

/* must have interpret locked to make this call */
{
  PyObject *value;
  int type;
  int ok = true;
  if(!I)
    I = G->Setting;             /* fall back on global settings */

  /* this data structure has been pre-checked at the python level... */

  type = PyInt_AsLong(PyTuple_GetItem(tuple, 0));
  value = PyTuple_GetItem(tuple, 1);
  switch (type) {
  case cSetting_boolean:
    SettingSet_b(I, index, PyInt_AsLong(PyTuple_GetItem(value, 0)));
    break;
  case cSetting_int:
    SettingSet_i(I, index, PyInt_AsLong(PyTuple_GetItem(value, 0)));
    break;
  case cSetting_float:
    SettingSet_f(I, index, (float) PyFloat_AsDouble(PyTuple_GetItem(value, 0)));
    break;
  case cSetting_float3:
    SettingSet_3f(I, index,
                  (float) PyFloat_AsDouble(PyTuple_GetItem(value, 0)),
                  (float) PyFloat_AsDouble(PyTuple_GetItem(value, 1)),
                  (float) PyFloat_AsDouble(PyTuple_GetItem(value, 2)));
    break;
  case cSetting_color:
    SettingSet_color(I, index, PyString_AsString(PyTuple_GetItem(value, 0)));
    break;
  case cSetting_string:
    SettingSet_s(I, index, PyString_AsString(PyTuple_GetItem(value, 0)));
    break;
  default:
    ok = false;
    break;
  }
  return (ok);
}
#endif

/*========================================================================*/
int SettingStringToTypedValue(PyMOLGlobals * G, int index, char *st, int *type,
                              int *value)
{
  int ok = true;

  /* this data structure has been pre-checked at the python level... */

  *type = SettingGetType(G, index);

  switch (*type) {
  case cSetting_boolean:
    if((!*st) || (*st == '0') || (*st == 'F') || WordMatchExact(G, st, "on", true)
       || WordMatchExact(G, st, "false", true))
      *value = 0;
    else
      *value = 1;
    break;
  case cSetting_int:
    if(sscanf(st, "%d", value) != 1)
      ok = false;
    break;
  case cSetting_float:
    if(sscanf(st, "%f", (float *) value) != 1)
      ok = false;
    break;
  case cSetting_color:
    {
      int color_index = ColorGetIndex(G, st);
      if((color_index < 0) && (color_index > cColorExtCutoff))
        color_index = 0;
      *(value) = color_index;
    }
    break;
  default:
    ok = false;
    break;
  }
  return (ok);
}

int SettingSetFromString(PyMOLGlobals * G, CSetting * I, int index, char *st)
{
  int type;
  int ok = true;
  if(!I)
    I = G->Setting;             /* fall back on global settings */

  /* this data structure has been pre-checked at the python level... */

  type = SettingGetType(G, index);

  switch (type) {
  case cSetting_boolean:
    if((!*st) || (*st == '0') || (*st == 'F') || WordMatchExact(G, st, "on", true)
       || WordMatchExact(G, st, "false", true))
      SettingSet_b(I, index, 0);
    else
      SettingSet_b(I, index, 1);
    break;
  case cSetting_int:
    {
      int tmp;
      if(sscanf(st, "%d", &tmp) == 1)
        SettingSet_i(I, index, tmp);
      else
        ok = false;
    }
    break;
  case cSetting_float:
    {
      float tmp;
      if(sscanf(st, "%f", &tmp) == 1)
        SettingSet_f(I, index, tmp);
      else
        ok = false;
    }
    break;
  case cSetting_float3:
    {
      float tmp1, tmp2, tmp3;
      if(sscanf(st, "%f%f%f", &tmp1, &tmp2, &tmp3) == 3)
        SettingSet_3f(I, index, tmp1, tmp2, tmp3);
      else
        ok = false;
    }
    break;
  case cSetting_color:
    SettingSet_color(I, index, st);
    break;
  case cSetting_string:
    SettingSet_s(I, index, st);
    break;
  default:
    ok = false;
    break;
  }
  return (ok);
}


/*========================================================================*/
#ifndef _PYMOL_NOPY
PyObject *SettingGetTuple(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{                               /* assumes blocked python interpeter */
  PyObject *result = NULL;
  float *ptr;
  int type = SettingGetType(G, index);

  switch (type) {
  case cSetting_boolean:
    result = Py_BuildValue("(i(i))", type, SettingGet_b(G, set1, set2, index));
    break;
  case cSetting_int:
    result = Py_BuildValue("(i(i))", type, SettingGet_i(G, set1, set2, index));
    break;
  case cSetting_float:
    result = Py_BuildValue("(i(f))", type, SettingGet_f(G, set1, set2, index));
    break;
  case cSetting_float3:
    ptr = SettingGet_3fv(G, set1, set2, index);
    result = Py_BuildValue("(i(fff))", type, ptr[0], ptr[1], ptr[2]);
    break;
  case cSetting_color:
    result = Py_BuildValue("(i(i))", type, SettingGet_color(G, set1, set2, index));
    break;
  case cSetting_string:
    result = Py_BuildValue("(i(s))", type, SettingGet_s(G, set1, set2, index));
    break;
  default:
    result = PConvAutoNone(Py_None);
    break;
  }
  return result;
}
#endif

/*========================================================================*/
#ifndef _PYMOL_NOPY
PyObject *SettingGetDefinedTuple(PyMOLGlobals * G, CSetting * set1, int index)
{                               /* Assumes blocked Python interpreter */
  PyObject *result = NULL;
  int defined = true;
  int type = SettingGetType(G, index);
  int int1;
  float float1, *vect1 = NULL;
  char *str1;
  switch (type) {
  case cSetting_boolean:
    defined = SettingGetIfDefined_b(G, set1, index, &int1);
    if(defined)
      result = Py_BuildValue("(i(i))", type, int1);
    break;
  case cSetting_int:
    defined = SettingGetIfDefined_i(G, set1, index, &int1);
    if(defined)
      result = Py_BuildValue("(i(i))", type, int1);
    break;
  case cSetting_float:
    defined = SettingGetIfDefined_f(G, set1, index, &float1);
    if(defined)
      result = Py_BuildValue("(i(f))", type, float1);
    break;
  case cSetting_float3:
    defined = SettingGetIfDefined_3fv(G, set1, index, &vect1);
    result = Py_BuildValue("(i(fff))", type, vect1[0], vect1[1], vect1[2]);
    break;
  case cSetting_color:
    defined = SettingGetIfDefined_color(G, set1, index, &int1);
    if(defined)
      result = Py_BuildValue("(i(i))", type, int1);
    break;
  case cSetting_string:
    defined = SettingGetIfDefined_s(G, set1, index, &str1);
    if(defined)
      result = Py_BuildValue("(i(s))", type, str1);
    break;
  default:
    break;
  }
  if(!defined) {
    result = Py_BuildValue("(i)", 0);
  }
  if(!result) {
    result = PConvAutoNone(Py_None);
  }
  return result;
}
#endif


/*========================================================================*/
CSetting *SettingNew(PyMOLGlobals * G)
{
  OOAlloc(G, CSetting);
  SettingInit(G, I);
  return (I);
}


/*========================================================================*/
void SettingPurge(CSetting * I)
{
  if(I) {
    VLAFreeP(I->data);
    VLAFreeP(I->info);
    I->size = 0;
  }
}


/*========================================================================*/
void SettingFreeP(CSetting * I)
{
  if(I)
    SettingPurge(I);
  OOFreeP(I);
}


/*========================================================================*/
void SettingInit(PyMOLGlobals * G, CSetting * I)
{
  I->G = G;
  I->size = sizeof(int);        /* insures offset is never zero, except when undef */
  I->data = VLAlloc(char, 10);
  I->info = VLAMalloc(cSetting_INIT, sizeof(SettingRec), 5, 1); /* auto-zero */
}


/*========================================================================*/
void SettingClear(CSetting * I, int index)
{
  if(I)
    I->info[index].defined = false;
}


/*========================================================================*/
static void *SettingPtr(CSetting * I, int index, ov_size size)
{
  /* note that this routine essentially leaks RAM in terms of not
     recovering space used for previous settings of smaller size */

  VLACheck(I->info, SettingRec, index);
  {
    SettingRec *sr = I->info + index;
    if(size < sizeof(int))
      size = sizeof(int);       /* make sure we're word aligned */
    while(size & (sizeof(int) - 1))
      size++;

    if((!sr->offset) || (sr->max_size < size)) {
      sr->offset = I->size;
      I->size += size;
      sr->max_size = size;
      VLACheck(I->data, char, I->size);
    }
    sr->defined = true;
    sr->changed = true;
    return (I->data + sr->offset);
  }
}


/*========================================================================*/
int SettingUnset(CSetting * I, int index)
{
  if(I) {
    SettingRec *sr = I->info + index;
    sr->defined = false;
    sr->changed = true;
  }
  return true;
}


/*========================================================================*/
int SettingGetType(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (I->info[index].type);
}


/*========================================================================*/
static int get_i(CSetting * I, int index)
{
  PyMOLGlobals *G = I->G;
  int result;
  switch (I->info[index].type) {
  case cSetting_boolean:
  case cSetting_int:
  case cSetting_color:
    result = (*((int *) (I->data + I->info[index].offset)));
    break;
  case cSetting_float:
    result = (int) (*((float *) (I->data + I->info[index].offset)));
    break;
  default:
    PRINTFB(G, FB_Setting, FB_Errors)
      "Setting-Error: type read mismatch (int) %d\n", index ENDFB(G);
    result = 0;
    break;
  }
  return (result);
}


/*========================================================================*/
static int get_b(CSetting * I, int index)
{
  int result;
  PyMOLGlobals *G = I->G;
  switch (I->info[index].type) {
  case cSetting_boolean:
  case cSetting_int:
  case cSetting_color:
    result = (*((int *) (I->data + I->info[index].offset)));
    break;
  case cSetting_float:
    result = (int) (*((float *) (I->data + I->info[index].offset)));
    break;
  default:
    PRINTFB(G, FB_Setting, FB_Errors)
      "Setting-Error: type read mismatch (boolean) %d\n", index ENDFB(G);
    result = 0;
  }
  return (result);
}


/*========================================================================*/
static int get_color(CSetting * I, int index)
{
  int result;
  PyMOLGlobals *G = I->G;
  switch (I->info[index].type) {
  case cSetting_boolean:
  case cSetting_int:
  case cSetting_color:
    result = (*((int *) (I->data + I->info[index].offset)));
    break;
  case cSetting_float:
    result = (int) (*((float *) (I->data + I->info[index].offset)));
    break;
  default:
    PRINTFB(G, FB_Setting, FB_Errors)
      "Setting-Error: type read mismatch (color) %d\n", index ENDFB(G);
    result = 0;
  }
  return (result);
}


/*========================================================================*/
static float get_f(CSetting * I, int index)
{
  float result;
  PyMOLGlobals *G = I->G;
  switch (I->info[index].type) {
  case cSetting_boolean:
  case cSetting_int:
  case cSetting_color:
    result = (float) (*((int *) (I->data + I->info[index].offset)));
    break;
  case cSetting_float:
    result = (*((float *) (I->data + I->info[index].offset)));
    break;
  default:
    PRINTFB(G, FB_Setting, FB_Errors)
      "Setting-Error: type read mismatch (float) %d\n", index ENDFB(G);
    result = 0.0F;
  }
  return (result);
}


/*========================================================================*/
static char *get_s(CSetting * I, int index)
{
  char *result;
  PyMOLGlobals *G = I->G;
  switch (I->info[index].type) {
  case cSetting_string:
    result = ((char *) (I->data + I->info[index].offset));
    break;
  default:
    PRINTFB(G, FB_Setting, FB_Errors)
      "Setting-Error: type read mismatch (string) %d\n", index ENDFB(G);
    result = NULL;
  }
  return (result);
}


/*========================================================================*/
int SettingSet_b(CSetting * I, int index, int value)
{
  int ok = true;
  if(I) {
    VLACheck(I->info, SettingRec, index);
    {
      int setting_type = I->info[index].type;
      PyMOLGlobals *G = I->G;
      switch (setting_type) {
      case cSetting_blank:
      case cSetting_boolean:
      case cSetting_int:
      case cSetting_color:
      *((int *) SettingPtr(I, index, sizeof(int))) = value;
      if(setting_type == cSetting_blank)
        I->info[index].type = cSetting_boolean;
      break;
      case cSetting_float:
      *((float *) SettingPtr(I, index, sizeof(float))) = (float) value;
      break;
      default:
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: type set mismatch (boolean) %d\n", index ENDFB(G);
      ok = false;
      }
    }
  } else {
    ok = false;
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_i(CSetting * I, int index, int value)
{
  int ok = true;
  if(I) {
    PyMOLGlobals *G = I->G;
    VLACheck(I->info, SettingRec, index);
    {
      int setting_type = I->info[index].type;
      switch (setting_type) {
      case cSetting_blank:
      case cSetting_boolean:
      case cSetting_int:
      case cSetting_color:
      *((int *) SettingPtr(I, index, sizeof(int))) = value;
      if(setting_type == cSetting_blank)
        I->info[index].type = cSetting_int;
      break;
      case cSetting_float:
      *((float *) SettingPtr(I, index, sizeof(float))) = (float) value;
      break;
      default:
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: type set mismatch (integer)\n" ENDFB(G);
      ok = false;
      }
    }
  } else {
    ok = false;
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_color(CSetting * I, int index, char *value)
{
  int ok = true;
  int color_index;
  if(I) {
    PyMOLGlobals *G = I->G;
    color_index = ColorGetIndex(G, value);
    if((color_index == -1) && (strcmp(value, "-1") &&
                               strcmp(value, "-2") &&
                               strcmp(value, "-3") &&
                               strcmp(value, "-4") &&
                               strcmp(value, "-5") && strcmp(value, "default"))) {
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: unknown color '%s'\n", value ENDFB(G);
      ok = false;

    } else {
      VLACheck(I->info, SettingRec, index);
      {
      int setting_type = I->info[index].type;
      switch (setting_type) {
      case cSetting_blank:
      case cSetting_boolean:
      case cSetting_int:
      case cSetting_color:
        *((int *) SettingPtr(I, index, sizeof(int))) = color_index;
        if(setting_type == cSetting_blank)
          I->info[index].type = cSetting_color;
        break;
      case cSetting_float:
        *((float *) SettingPtr(I, index, sizeof(float))) = (float) color_index;
        break;
      default:
        PRINTFB(G, FB_Setting, FB_Errors)
          "Setting-Error: type set mismatch (color)\n" ENDFB(G);
        ok = false;
      }
      }
    }
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_f(CSetting * I, int index, float value)
{
  int ok = true;
  if(I) {
    PyMOLGlobals *G = I->G;
    VLACheck(I->info, SettingRec, index);
    {
      int setting_type = I->info[index].type;
      switch (setting_type) {
      case cSetting_boolean:
      case cSetting_int:
      case cSetting_color:
      *((int *) SettingPtr(I, index, sizeof(int))) = (int) value;
      break;
      case cSetting_blank:
      case cSetting_float:
      *((float *) SettingPtr(I, index, sizeof(float))) = value;
      if(setting_type == cSetting_blank)
        I->info[index].type = cSetting_float;
      break;
      default:
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: type set mismatch (float)\n" ENDFB(G);
      ok = false;
      }
    }
  } else {
    ok = false;
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_s(CSetting * I, int index, char *value)
{
  int ok = true;
  if(I) {
    PyMOLGlobals *G = I->G;
    VLACheck(I->info, SettingRec, index);
    {
      int setting_type = I->info[index].type;
      switch (setting_type) {
      case cSetting_blank:
      case cSetting_string:
      strcpy(((char *) SettingPtr(I, index, strlen(value) + 1)), value);
      if(setting_type == cSetting_blank)
        I->info[index].type = cSetting_string;
      break;
      default:
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: type set mismatch (string)\n" ENDFB(G);
      ok = false;
      }
      if(setting_type == cSetting_blank)
      I->info[index].type = cSetting_string;
    }
  } else {
    ok = false;
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_3f(CSetting * I, int index, float value1, float value2, float value3)
{
  int ok = false;
  float *ptr;
  if(I) {
    PyMOLGlobals *G = I->G;
    VLACheck(I->info, SettingRec, index);
    {
      int setting_type = I->info[index].type;
      switch (setting_type) {
      case cSetting_blank:
      case cSetting_float3:
      ptr = (float *) SettingPtr(I, index, sizeof(float) * 3);
      ptr[0] = value1;
      ptr[1] = value2;
      ptr[2] = value3;
      if(setting_type == cSetting_blank)
        I->info[index].type = cSetting_float3;
      break;
      default:
      PRINTFB(G, FB_Setting, FB_Errors)
        "Setting-Error: type set mismatch (float3)\n" ENDFB(G);
      ok = false;
      }
    }
  } else {
    ok = false;
  }
  return (ok);
}


/*========================================================================*/
int SettingSet_3fv(CSetting * I, int index, float *vector)
{
  float *ptr;
  ptr = (float *) SettingPtr(I, index, sizeof(float) * 3);
  copy3f(vector, ptr);
  I->info[index].type = cSetting_float3;
  return (true);
}


/*========================================================================*/
int SettingGetGlobal_b(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (get_b(I, index));
}


/*========================================================================*/
int SettingGetGlobal_i(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (get_i(I, index));
}


/*========================================================================*/
float SettingGetGlobal_f(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (get_f(I, index));
}


/*========================================================================*/
char *SettingGetGlobal_s(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (get_s(I, index));
}

int SettingGetGlobal_color(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (get_color(I, index));
}


/*========================================================================*/
void SettingGetGlobal_3f(PyMOLGlobals * G, int index, float *value)
{
  register CSetting *I = G->Setting;
  float *ptr;
  ptr = (float *) (I->data + I->info[index].offset);
  copy3f(ptr, value);
}


/*========================================================================*/
float *SettingGetGlobal_3fv(PyMOLGlobals * G, int index)
{
  register CSetting *I = G->Setting;
  return (float *) (I->data + I->info[index].offset);
}


/*========================================================================*/
int SettingGet_b(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (get_b(set1, index));
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (get_b(set2, index));
    }
  }
  return (SettingGetGlobal_i(G, index));
}


/*========================================================================*/
int SettingGetIfDefined_b(PyMOLGlobals * G, CSetting * set1, int index, int *value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      *value = get_b(set1, index);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGetIfDefined_i(PyMOLGlobals * G, CSetting * set1, int index, int *value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      *value = get_i(set1, index);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGetIfDefined_color(PyMOLGlobals * G, CSetting * set1, int index, int *value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      *value = get_color(set1, index);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGetIfDefined_f(PyMOLGlobals * G, CSetting * set1, int index, float *value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      *value = get_f(set1, index);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGetIfDefined_3fv(PyMOLGlobals * G, CSetting * set1, int index, float **value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      (*value) = (float *) (set1->data + set1->info[index].offset);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGetIfDefined_s(PyMOLGlobals * G, CSetting * set1, int index, char **value)
{
  int result = false;
  if(set1) {
    if(set1->info[index].defined) {
      *value = get_s(set1, index);
      result = true;
    }
  }
  return (result);
}


/*========================================================================*/
int SettingGet_i(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (get_i(set1, index));
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (get_i(set2, index));
    }
  }
  return (SettingGetGlobal_i(G, index));
}


/*========================================================================*/
int SettingGet_color(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (get_color(set1, index));
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (get_color(set2, index));
    }
  }
  return (SettingGetGlobal_i(G, index));
}


/*========================================================================*/
float SettingGet_f(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (get_f(set1, index));
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (get_f(set2, index));
    }
  }
  return (SettingGetGlobal_f(G, index));
}


/*========================================================================*/
char *SettingGet_s(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (get_s(set1, index));
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (get_s(set2, index));
    }
  }
  return (SettingGetGlobal_s(G, index));
}


/*========================================================================*/
void SettingGet_3f(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index,
                   float *value)
{
  float *ptr;
  if(set1) {
    if(set1->info[index].defined) {
      ptr = (float *) (set1->data + set1->info[index].offset);
      copy3f(ptr, value);
      return;
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      ptr = (float *) (set2->data + set2->info[index].offset);
      copy3f(ptr, value);
      return;
    }
  }
  SettingGetGlobal_3f(G, index, value);
}


/*========================================================================*/
float *SettingGet_3fv(PyMOLGlobals * G, CSetting * set1, CSetting * set2, int index)
{
  if(set1) {
    if(set1->info[index].defined) {
      return (float *) (set1->data + set1->info[index].offset);
    }
  }
  if(set2) {
    if(set2->info[index].defined) {
      return (float *) (set2->data + set2->info[index].offset);
    }
  }
  return (SettingGetGlobal_3fv(G, index));
}


/*========================================================================*/

/*========================================================================*/
int SettingGetIndex(PyMOLGlobals * G, char *name)
{                               /* can be called from any thread state */
#ifdef _PYMOL_NOPY
  /* we're going to need a C-based dictionary and settings name list for this situation */
  return 0;
#else
  PyObject *tmp;
  int unblock;
  int index = -1;

  unblock = PAutoBlock(G);
  if(P_setting) {
    tmp = PyObject_CallMethod(P_setting, "_get_index", "s", name);
    if(tmp) {
      if(PyInt_Check(tmp))
        index = PyInt_AsLong(tmp);
      Py_DECREF(tmp);
    }
  }
  PAutoUnblock(G, unblock);

  return (index);
#endif
}


/*========================================================================*/
int SettingGetName(PyMOLGlobals * G, int index, SettingName name)
{                               /* can be called from any thread state */
#ifdef _PYMOL_NOPY
  /* we're going to need a C-based dictionary and settings name list for this situation */
  name[0] = 0;
  return 0;
#else
  PyObject *tmp;
  int unblock;
  name[0] = 0;
  unblock = PAutoBlock(G);
  if(P_setting) {
    tmp = PyObject_CallMethod(P_setting, "_get_name", "i", index);
    if(tmp) {
      if(PyString_Check(tmp))
        UtilNCopy(name, PyString_AsString(tmp), sizeof(SettingName));
      Py_DECREF(tmp);
    }
  }
  PAutoUnblock(G, unblock);
  return (name[0] != 0);
#endif
}


/*========================================================================*/
void SettingGenerateSideEffects(PyMOLGlobals * G, int index, char *sele, int state)
{
  char all[] = "all";
  char *inv_sele;
  if(!sele) {
    inv_sele = all;
  } else if(sele[0] == 0) {
    inv_sele = all;
  } else {
    inv_sele = sele;
  }
  switch (index) {
  case cSetting_stereo:
    SceneUpdateStereo(G);
    break;
  case cSetting_pickable:
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvAll);
    SceneChanged(G);
    break;
  case cSetting_grid_mode:
  case cSetting_grid_slot:
    ExecutiveInvalidateGroups(G, false);
    SceneChanged(G);
    break;
  case cSetting_grid_max:
    SceneChanged(G);
    break;
  case cSetting_defer_builds_mode:
    ExecutiveRebuildAll(G);
    break;
  case cSetting_seq_view:
  case cSetting_seq_view_label_spacing:
  case cSetting_seq_view_label_mode:
  case cSetting_seq_view_label_start:
  case cSetting_seq_view_format:
  case cSetting_seq_view_color:
  case cSetting_seq_view_unaligned_mode:
    SeqChanged(G);
    break;
  case cSetting_seq_view_fill_color:
  case cSetting_seq_view_fill_char:
  case cSetting_seq_view_label_color:
    OrthoDirty(G);
    break;
  case cSetting_show_frame_rate:
    OrthoDirty(G);
    break;
  case cSetting_group_full_member_names:
  case cSetting_group_arrow_prefix:
    OrthoDirty(G);
    break;
  case cSetting_static_singletons:
    SeqChanged(G);
    break;
  case cSetting_seq_view_location:
  case cSetting_seq_view_overlay:
    PParse(G, "cmd.viewport(-1,-1)");
    break;
  case cSetting_stereo_mode:
    SceneUpdateStereoMode(G);
    break;
  case cSetting_dot_lighting:
  case cSetting_mesh_lighting:
  case cSetting_light:
  case cSetting_light2:
  case cSetting_light3:
  case cSetting_light_count:
  case cSetting_fog:
  case cSetting_field_of_view:
  case cSetting_fog_start:
  case cSetting_two_sided_lighting:
  case cSetting_transparency_mode:
  case cSetting_transparency_global_sort:
  case cSetting_dot_normals:
  case cSetting_mesh_normals:
  case cSetting_use_shaders:
    SceneInvalidate(G);
    break;
  case cSetting_stereo_shift:
  case cSetting_stereo_angle:
  case cSetting_stereo_dynamic_strength:
  case cSetting_texture_fonts:
    SceneInvalidate(G);
    break;
  case cSetting_scene_buttons:
  case cSetting_scene_buttons_mode:
    SceneInvalidate(G);
    break;
  case cSetting_dash_round_ends:
  case cSetting_dash_color:
  case cSetting_angle_color:
  case cSetting_dihedral_color:
    SceneInvalidate(G);
    break;
  case cSetting_mouse_selection_mode:
    OrthoDirty(G);
    break;
  case cSetting_internal_gui_control_size:
    WizardRefresh(G);
    OrthoDirty(G);
    break;
  case cSetting_hide_underscore_names:
    ExecutiveInvalidateGroups(G, false);
    OrthoDirty(G);
    break;
  case cSetting_gradient_spacing:
  case cSetting_gradient_max_length:
  case cSetting_gradient_min_length:
  case cSetting_gradient_normal_min_dot:
  case cSetting_gradient_step_size:
  case cSetting_gradient_min_slope:
  case cSetting_gradient_symmetry:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_min_mesh_spacing:
  case cSetting_mesh_grid_max:
  case cSetting_mesh_cutoff:
  case cSetting_mesh_carve_state:
  case cSetting_mesh_carve_cutoff:
  case cSetting_mesh_carve_selection:
  case cSetting_mesh_clear_state:
  case cSetting_mesh_clear_cutoff:
  case cSetting_mesh_clear_selection:
  case cSetting_mesh_mode:
  case cSetting_mesh_type:
  case cSetting_mesh_solvent:
  case cSetting_mesh_quality:
  case cSetting_mesh_skip:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_valence:
  case cSetting_valence_mode:
  case cSetting_valence_size:
  case cSetting_half_bonds:
  case cSetting_stick_transparency:
  case cSetting_line_stick_helper:
  case cSetting_hide_long_bonds:
  case cSetting_line_use_shader:
    ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_slice_height_scale:
  case cSetting_slice_height_map:
  case cSetting_slice_grid:
  case cSetting_slice_dynamic_grid:
  case cSetting_slice_dynamic_grid_resolution:
    ExecutiveInvalidateRep(G, inv_sele, cRepSlice, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_label_font_id:
  case cSetting_label_size:
    SceneChanged(G);
    break;
  case cSetting_retain_order:
  case cSetting_pdb_hetatm_sort:
  case cSetting_pdb_insertions_go_first:
    ExecutiveSort(G, inv_sele);
    break;
  case cSetting_roving_lines:
  case cSetting_roving_sticks:
  case cSetting_roving_spheres:
  case cSetting_roving_labels:
  case cSetting_roving_selection:
  case cSetting_roving_ribbon:
  case cSetting_roving_cartoon:
  case cSetting_roving_polar_contacts:
  case cSetting_roving_polar_cutoff:
  case cSetting_roving_nonbonded:
  case cSetting_roving_nb_spheres:
  case cSetting_roving_map1_level:
  case cSetting_roving_map2_level:
  case cSetting_roving_map3_level:
  case cSetting_roving_map1_name:
  case cSetting_roving_map2_name:
  case cSetting_roving_map3_name:
  case cSetting_roving_isosurface:
  case cSetting_roving_isomesh:
    SceneRovingChanged(G);
    break;
  case cSetting_roving_byres:
  case cSetting_roving_detail:
    SceneRovingDirty(G);
    break;
  case cSetting_dash_length:
  case cSetting_dash_gap:
  case cSetting_dash_radius:
  case cSetting_dash_width:
  case cSetting_angle_size:
  case cSetting_label_digits:
  case cSetting_label_distance_digits:
  case cSetting_label_angle_digits:
  case cSetting_label_dihedral_digits:
  case cSetting_angle_label_position:
  case cSetting_dihedral_size:
  case cSetting_dihedral_label_position:
    ExecutiveRebuildAllObjectDist(G);
    SceneChanged(G);
    break;
  case cSetting_button_mode:
    EditorMouseInvalid(G);
    OrthoDirty(G);
    break;
  case cSetting_stick_radius:
  case cSetting_stick_h_scale:
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep);       /* base width */
    SceneChanged(G);
    break;
  case cSetting_stick_ball:
  case cSetting_stick_nub:
  case cSetting_stick_ball_ratio:
  case cSetting_stick_ball_color:
  case cSetting_stick_fixed_radius:
  case cSetting_stick_valence_scale:
  case cSetting_stick_quality:
  case cSetting_stick_overlap:
  case cSetting_stick_color:
  case cSetting_stick_use_shader:
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_clamp_colors:
  case cSetting_ramp_blend_nearby_colors:
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_label_color:
  case cSetting_label_outline_color:
  case cSetting_label_position:
    ExecutiveRebuildAllObjectDist(G);
    ExecutiveInvalidateRep(G, inv_sele, cRepLabel, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_cartoon_color:
    ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_ribbon_color:
  case cSetting_ribbon_nucleic_acid_mode:
    ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_all_states:
    SceneChanged(G);
    break;
  case cSetting_sel_counter:
    break;
  case cSetting_line_width:    /* auto-disable smooth lines if line width > 1 */
    /*    SettingSet(G,cSetting_line_smooth,0);  NO LONGER */
  case cSetting_line_color:
  case cSetting_line_radius:
    ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepNonbonded, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_scene_current_name:
    SceneRestartFrameTimer(G);
    break;
  case cSetting_mesh_width:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_ellipsoid_probability:
  case cSetting_ellipsoid_scale:
  case cSetting_ellipsoid_color:
  case cSetting_ellipsoid_transparency:
    ExecutiveInvalidateRep(G, inv_sele, cRepEllipsoid, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_ellipsoid_quality:
  case cSetting_cgo_ellipsoid_quality:
    ExecutiveInvalidateRep(G, inv_sele, cRepCGO, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepEllipsoid, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_mesh_color:
  case cSetting_mesh_negative_color:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_ray_color_ramps:
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;

  case cSetting_cull_spheres:
  case cSetting_sphere_scale:
  case cSetting_sphere_transparency:
  case cSetting_sphere_solvent:
  case cSetting_sphere_mode:
  case cSetting_sphere_point_max_size:
  case cSetting_sphere_point_size:
  case cSetting_sphere_use_shader:
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_sphere_quality:
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepNonbondedSphere, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_nonbonded_size:
  case cSetting_nonbonded_transparency:
    ExecutiveInvalidateRep(G, inv_sele, cRepNonbonded, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepNonbondedSphere, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_mesh_radius:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_surface_negative_color:
  case cSetting_surface_color:
  case cSetting_transparency:
  case cSetting_surface_ramp_above_mode:
    ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_dot_color:
    ExecutiveInvalidateRep(G, inv_sele, cRepDot, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_sphere_color:
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvColor);
    SceneChanged(G);
    break;

  case cSetting_surface_quality:
  case cSetting_surface_mode:
  case cSetting_surface_normal:
  case cSetting_surface_type:
  case cSetting_surface_carve_state:
  case cSetting_surface_carve_cutoff:
  case cSetting_surface_carve_selection:
  case cSetting_surface_carve_normal_cutoff:
  case cSetting_surface_clear_state:
  case cSetting_surface_clear_cutoff:
  case cSetting_surface_clear_selection:
  case cSetting_surface_trim_cutoff:
  case cSetting_surface_trim_factor:
  case cSetting_surface_circumscribe:
  case cSetting_surface_solvent:
  case cSetting_surface_proximity:
  case cSetting_surface_cavity_mode:   
  case cSetting_surface_cavity_radius:
  case cSetting_surface_cavity_cutoff:   
  case cSetting_surface_use_shader:
  case cSetting_cavity_cull:
    ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_surface_negative_visible:
    ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvAll);
    SceneChanged(G);
    break;
  case cSetting_mesh_negative_visible:
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvAll);
    SceneChanged(G);
    break;
  case cSetting_solvent_radius:
    ExecutiveInvalidateRep(G, inv_sele, cRepSurface, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepMesh, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepDot, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_trace_atoms_mode:
    ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_ribbon_smooth:
  case cSetting_ribbon_power:
  case cSetting_ribbon_power_b:
  case cSetting_ribbon_sampling:
  case cSetting_ribbon_radius:
  case cSetting_ribbon_width:
  case cSetting_ribbon_throw:
  case cSetting_ribbon_trace_atoms:
  case cSetting_ribbon_transparency:
    ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_draw_mode:
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep);
    break;
  case cSetting_cartoon_side_chain_helper:
    ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_ribbon_side_chain_helper:
    ExecutiveInvalidateRep(G, inv_sele, cRepRibbon, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepLine, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepCyl, cRepInvRep);
    ExecutiveInvalidateRep(G, inv_sele, cRepSphere, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_cartoon_transparency:
  case cSetting_cartoon_ring_transparency:
  case cSetting_cartoon_trace_atoms:
  case cSetting_cartoon_refine:
  case cSetting_cartoon_nucleic_acid_mode:
  case cSetting_cartoon_nucleic_acid_color:
  case cSetting_cartoon_ring_mode:
  case cSetting_cartoon_ring_finder:
  case cSetting_cartoon_ring_width:
  case cSetting_cartoon_ring_color:
  case cSetting_cartoon_ladder_mode:
  case cSetting_cartoon_ladder_radius:
  case cSetting_cartoon_ladder_color:
  case cSetting_cartoon_sampling:
  case cSetting_cartoon_loop_quality:
  case cSetting_ray_trace_mode:        /* affects loop quality */
  case cSetting_cartoon_loop_radius:
  case cSetting_cartoon_loop_cap:
  case cSetting_cartoon_tube_quality:
  case cSetting_cartoon_tube_radius:
  case cSetting_cartoon_tube_cap:
  case cSetting_cartoon_putty_quality:
  case cSetting_cartoon_putty_radius:
  case cSetting_cartoon_putty_range:
  case cSetting_cartoon_putty_scale_min:
  case cSetting_cartoon_putty_scale_max:
  case cSetting_cartoon_putty_scale_power:
  case cSetting_cartoon_putty_transform:
  case cSetting_cartoon_power:
  case cSetting_cartoon_power_b:
  case cSetting_cartoon_ring_radius:
  case cSetting_cartoon_rect_length:
  case cSetting_cartoon_rect_width:
  case cSetting_cartoon_oval_length:
  case cSetting_cartoon_oval_width:
  case cSetting_cartoon_oval_quality:
  case cSetting_cartoon_round_helices:
  case cSetting_cartoon_flat_sheets:
  case cSetting_cartoon_refine_normals:
  case cSetting_cartoon_smooth_loops:
  case cSetting_cartoon_dumbbell_width:
  case cSetting_cartoon_dumbbell_length:
  case cSetting_cartoon_dumbbell_radius:
  case cSetting_cartoon_fancy_helices:
  case cSetting_cartoon_fancy_sheets:
  case cSetting_cartoon_cylindrical_helices:
  case cSetting_cartoon_refine_tips:
  case cSetting_cartoon_helix_radius:
  case cSetting_cartoon_throw:
  case cSetting_cartoon_debug:
  case cSetting_cartoon_highlight_color:
  case cSetting_cartoon_discrete_colors:
  case cSetting_cartoon_smooth_first:
  case cSetting_cartoon_smooth_last:
  case cSetting_cartoon_smooth_cycles:
  case cSetting_cartoon_flat_cycles:
  case cSetting_cartoon_use_shader:
    ExecutiveInvalidateRep(G, inv_sele, cRepCartoon, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_dot_width:
  case cSetting_dot_radius:
  case cSetting_dot_density:
  case cSetting_dot_mode:
  case cSetting_dot_solvent:
  case cSetting_dot_hydrogens:
  case cSetting_trim_dots:
    ExecutiveInvalidateRep(G, inv_sele, cRepDot, cRepInvRep);
    SceneChanged(G);
    break;
  case cSetting_bg_gradient:
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_bg_rgb_top:
    {
      /* clamp this value */
      float vv[3], *v = SettingGetfv(G, cSetting_bg_rgb_top);
      if((v[0] > 1.0F) || (v[1] > 1.0F) || (v[2] > 1.0F)) {
        vv[0] = v[0] / 255.0F;
        vv[1] = v[1] / 255.0F;
        vv[2] = v[2] / 255.0F;
        SettingSet_3fv(G->Setting, cSetting_bg_rgb_top, vv);
      }
      ColorUpdateFront(G, v);
    }
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_bg_rgb_bottom:
    {
      /* clamp this value */
      float vv[3], *v = SettingGetfv(G, cSetting_bg_rgb_bottom);
      if((v[0] > 1.0F) || (v[1] > 1.0F) || (v[2] > 1.0F)) {
        vv[0] = v[0] / 255.0F;
        vv[1] = v[1] / 255.0F;
        vv[2] = v[2] / 255.0F;
        SettingSet_3fv(G->Setting, cSetting_bg_rgb_bottom, vv);
      }
      ColorUpdateFront(G, v);
    }
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_bg_rgb:
    {
      /* clamp this value */
      float vv[3], *v = SettingGetfv(G, cSetting_bg_rgb);
      if((v[0] > 1.0F) || (v[1] > 1.0F) || (v[2] > 1.0F)) {
        vv[0] = v[0] / 255.0F;
        vv[1] = v[1] / 255.0F;
        vv[2] = v[2] / 255.0F;
        SettingSet_3fv(G->Setting, cSetting_bg_rgb, vv);
      }
      ColorUpdateFront(G, v);
    }
    ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_line_smooth:
  case cSetting_ortho:
  case cSetting_reflect:
  case cSetting_direct:
  case cSetting_ambient:
  case cSetting_gl_ambient:    /* deprecated */
  case cSetting_specular:
  case cSetting_specular_intensity:
  case cSetting_cgo_line_width:
  case cSetting_selection_width:
  case cSetting_selection_width_scale:
  case cSetting_selection_width_max:
    SceneInvalidate(G);
    break;
  case cSetting_depth_cue:
    SceneInvalidate(G);
    break;
  case cSetting_sculpting:
    OrthoDirty(G);
    break;
  case cSetting_auto_overlay:
    OrthoRemoveAutoOverlay(G); /* always start clean */
    break;
  case cSetting_overlay:
  case cSetting_overlay_lines:
  case cSetting_text:
    OrthoDirty(G);
    break;
  case cSetting_internal_gui_mode:
  case cSetting_internal_gui_width:
  case cSetting_internal_gui:
  case cSetting_internal_feedback:
  case cSetting_mouse_grid:
  case cSetting_movie_panel_row_height:
  case cSetting_movie_panel:
    OrthoCommandIn(G, "viewport");
    break;
  case cSetting_suspend_updates:
    if(!SettingGet(G, cSetting_suspend_updates)) {
      SceneChanged(G);          /* force big update upon resumption */
      OrthoDirty(G);
    }
    break;
  case cSetting_security:
    G->Security = (int) SettingGet(G, cSetting_security);
    break;
  case cSetting_state:
  case cSetting_frame:
    SceneChanged(G);
    break;
  case cSetting_dynamic_width:
  case cSetting_dynamic_width_factor:
  case cSetting_dynamic_width_min:
  case cSetting_dynamic_width_max:
    SceneChanged(G);
    break;
  case cSetting_rock:
  case cSetting_sweep_mode:
  case cSetting_sweep_phase:
  case cSetting_sweep_angle:
  case cSetting_sweep_speed:
    SceneRestartSweepTimer(G);
    break;
  case cSetting_motion_power:
  case cSetting_motion_bias:
  case cSetting_motion_simple:
  case cSetting_motion_linear:
  case cSetting_motion_hand:
  case cSetting_movie_loop:
    if(SettingGetGlobal_b(G, cSetting_movie_auto_interpolate)) {
      ExecutiveMotionReinterpolate(G);
    }
    break;
  case cSetting_volume_bit_depth:
    ExecutiveInvalidateRep(G, inv_sele, cRepVolume, cRepInvColor);
    SceneInvalidate(G);
    break;
  case cSetting_volume_data_range:
    ExecutiveInvalidateRep(G, inv_sele, cRepVolume, cRepInvAll);
    SceneInvalidate(G);
    break;
  case cSetting_volume_layers:
    ExecutiveInvalidateRep(G, inv_sele, cRepVolume, cRepInvAll);
    SceneInvalidate(G);
    break;
  case cSetting_atom_type_format:
    {
      char *setting;
      char *lsetting;
      int i;
      setting = SettingGetGlobal_s(G, cSetting_atom_type_format);
      lsetting = mmalloc(strlen(setting)+1);
      for (i=0; i<=strlen(setting); i++){
      lsetting[i] = tolower(setting[i]);
      }
      if (strcmp(lsetting, "mol2") && 
        strcmp(lsetting, "sybyl") && 
        strcmp(lsetting, "macromodel") &&
        strcmp(lsetting, "mmd")){
      printf("lsetting='%s'\n", lsetting);
      PRINTFB(G, FB_Setting, FB_Warnings)
        "Setting-Warning: atom_type_format needs to be either mol2/sybyl or macromodel/mmd setting back to default mol2\n"
        ENDFB(G);
      SettingSet_s(G->Setting, cSetting_atom_type_format, "mol2");      
      } else if (strcmp(setting, lsetting)){
      SettingSet_s(G->Setting, cSetting_atom_type_format, lsetting);
      }
      mfree(lsetting);
      ExecutiveInvalidateRep(G, inv_sele, cRepAll, cRepInvAll);
    }
    break;
  default:
    break;
  }
}


/*========================================================================*/
int SettingSetfv(PyMOLGlobals * G, int index, float *v)
{
  /* Warren, are these side effects still relevant? */

  register CSetting *I = G->Setting;
  int ok = true;
  switch (index) {
  case cSetting_dot_mode:
    SettingSet_f(I, index, v[0]);
    /*I->Setting[index].Value[0]=v[0]; */
    break;
  case cSetting_bg_rgb:
    {
      float vv[3];

      if((v[0] > 1.0F) || (v[1] > 1.0F) || (v[2] > 1.0F)) {
        vv[0] = v[0] / 255.0F;
        vv[1] = v[1] / 255.0F;
        vv[2] = v[2] / 255.0F;
        SettingSet_3fv(I, index, vv);
      } else {
        SettingSet_3fv(I, index, v);
      }
      ColorUpdateFront(G, v);
    }
    ExecutiveInvalidateRep(G, "all", cRepAll, cRepInvColor);
    SceneChanged(G);
    break;
  case cSetting_light:
    SettingSet_3fv(I, index, v);
    SceneInvalidate(G);
    break;
  case cSetting_valence:
    ExecutiveInvalidateRep(G, "all", cRepLine, cRepInvRep);
    SettingSet_f(I, index, v[0]);
    SceneChanged(G);
    break;
  case cSetting_dash_length:
  case cSetting_dash_gap:
    ExecutiveInvalidateRep(G, "all", cRepDash, cRepInvRep);
    SettingSet_f(I, index, v[0]);
    SceneChanged(G);
    break;
  case cSetting_button_mode:
    SettingSet_f(I, index, v[0]);
    OrthoDirty(G);
    break;
  case cSetting_stick_radius:
  case cSetting_stick_quality:
  case cSetting_stick_overlap:
    ExecutiveInvalidateRep(G, "all", cRepCyl, cRepInvRep);
    SettingSet_f(I, index, v[0]);
    /*I->Setting[index].Value[0]=v[0];   */
    SceneChanged(G);
    break;
  case cSetting_label_color:
    ExecutiveInvalidateRep(G, "all", cRepLabel, cRepInvRep);
    SettingSet_f(I, index, v[0]);
    /* I->Setting[index].Value[0]=v[0]; */
    SceneChanged(G);
    break;
  case cSetting_all_states:
    SettingSet_f(I, index, v[0]);
    /* I->Setting[index].Value[0]=v[0];  */
    SceneChanged(G);
    break;
  case cSetting_dot_density:
    SettingSet_f(I, index, v[0]);
    /*I->Setting[index].Value[0]=v[0]; */
    break;
  case cSetting_sel_counter:
    SettingSet_f(I, index, v[0]);
    /*I->Setting[index].Value[0]=v[0]; */
    break;
  case cSetting_ortho:
  case cSetting_gl_ambient:
    SceneInvalidate(G);
    break;
  case cSetting_overlay:
  case cSetting_text:
    OrthoDirty(G);
  default:
    ok = SettingSet_f(I, index, v[0]);
    /*I->Setting[index].Value[0]=v[0]; */
    break;
  }
  return (ok);
}


/*========================================================================*/
int SettingSetGlobal_b(PyMOLGlobals * G, int index, int value)
{
  return (SettingSet_b(G->Setting, index, value));
}


/*========================================================================*/
int SettingSetGlobal_i(PyMOLGlobals * G, int index, int value)
{
  return (SettingSet_i(G->Setting, index, value));
}


/*========================================================================*/
int SettingSetGlobal_f(PyMOLGlobals * G, int index, float value)
{
  return (SettingSet_f(G->Setting, index, value));
}


/*========================================================================*/
int SettingSetGlobal_3f(PyMOLGlobals * G, int index, float value1, float value2,
                        float value3)
{
  return (SettingSet_3f(G->Setting, index, value1, value2, value3));
}


/*========================================================================*/
int SettingSet(PyMOLGlobals * G, int index, float v)
{
  return (SettingSetfv(G, index, &v));
}


/*========================================================================*/
int SettingSetNamed(PyMOLGlobals * G, char *name, char *value)
{
  int ok = true;
  int index = SettingGetIndex(G, name);
  float v, vv[3];
  SettingName realName;
  char buffer[1024] = "";
  if(index >= 0) {
    SettingGetName(G, index, realName);
    switch (index) {
    case cSetting_dot_mode:
      if(strcmp(value, "molecular") == 0) {
        v = 0.0;
        SettingSetfv(G, index, &v);
        sprintf(buffer, " Setting: %s set to %s\n", realName, value);
      } else if(strcmp(value, "solvent_accessible") == 0) {
        v = 1.0;
        SettingSetfv(G, index, &v);
        sprintf(buffer, " Setting: %s set to %s\n", realName, value);
      } else if(sscanf(value, "%f", &v) == 1) {
        SettingSetfv(G, index, &v);
        sprintf(buffer, " Setting: %s set to %s\n", realName, value);
      }
      break;
    case cSetting_bg_rgb:
    case cSetting_light:
      if(sscanf(value, "%f%f%f", vv, vv + 1, vv + 2) == 3) {
        SettingSetfv(G, index, vv);
        sprintf(buffer, " Setting: %s set to %5.3f %8.3f %8.3f\n", realName,
                *vv, *(vv + 1), *(vv + 2));
      }
      break;
    case cSetting_dot_density:
      sscanf(value, "%f", &v);
      SettingSetfv(G, index, &v);
      sprintf(buffer, " Setting: %s set to %d\n", realName, (int) v);
      break;
    case cSetting_text:
    case cSetting_overlay:
    case cSetting_sel_counter:
    case cSetting_dist_counter:
      sscanf(value, "%f", &v);
      SettingSetfv(G, index, &v);
      break;
    case cSetting_line_width:  /* auto-disable smooth lines if line width > 1 */
    case cSetting_mesh_width:
      sscanf(value, "%f", &v);
      SettingSetfv(G, index, &v);
      sprintf(buffer, " Setting: %s set to %5.3f\n", realName, v);
      SceneInvalidate(G);
      break;
    default:
      sscanf(value, "%f", &v);
      SettingSetfv(G, index, &v);
      sprintf(buffer, " Setting: %s set to %5.3f\n", realName, v);
      break;
    }
  } else {
    PRINTFB(G, FB_Setting, FB_Warnings)
      " Error: Non-Existent Settin\n" ENDFB(G);
    ok = false;
  }
  if(buffer[0]) {
    PRINTFB(G, FB_Setting, FB_Actions)
      "%s", buffer ENDFB(G);
  }
  return (ok);
}


/*========================================================================*/
float SettingGetNamed(PyMOLGlobals * G, char *name)
{
  return (SettingGet(G, SettingGetIndex(G, name)));
}


/*========================================================================*/
float SettingGet(PyMOLGlobals * G, int index)
{
  return (SettingGetGlobal_f(G, index));
}


/*========================================================================*/
float *SettingGetfv(PyMOLGlobals * G, int index)
{
  return (SettingGetGlobal_3fv(G, index));
}


/*========================================================================*/
void SettingFreeGlobal(PyMOLGlobals * G)
{
  register CSetting *I = G->Setting;
  SettingUniqueFree(G);
  SettingPurge(I);
  if(G->Default) {
    SettingPurge(G->Default);
    FreeP(G->Default);
  }
  FreeP(G->Setting);
}


/*========================================================================*/
void SettingInitGlobal(PyMOLGlobals * G, int alloc, int reset_gui, int use_default)
{
  register CSetting *I = G->Setting;

  /* use function pointers to prevent the compiler from inlining every
     call in this block (a waste of RAM and time) */

  int (*set_f) (CSetting * I, int index, float valueI) = SettingSet_f;
  int (*set_i) (CSetting * I, int index, int value) = SettingSet_i;
  int (*set_3f) (CSetting * I, int index, float value1, float value2, float value3) =
    SettingSet_3f;
  int (*set_b) (CSetting * I, int index, int value) = SettingSet_b;
  int (*set_color) (CSetting * I, int index, char *value) = SettingSet_color;
  int (*set_s) (CSetting * I, int index, char *value) = SettingSet_s;

  if(alloc || !I) {
    I = (G->Setting = Calloc(CSetting, 1));
    SettingUniqueInit(G);
    SettingInit(G, I);
  }

  if(G->Default && use_default) {

    SettingCopyAll(G, G->Default, G->Setting);

  } else {

    set_f(I, cSetting_bonding_vdw_cutoff, 0.2F);

    set_f(I, cSetting_min_mesh_spacing, 0.6F);

    set_i(I, cSetting_dot_density, 2);

    set_i(I, cSetting_dot_mode, 0);

    set_f(I, cSetting_solvent_radius, 1.4F);

    set_i(I, cSetting_sel_counter, 0);

    set_3f(I, cSetting_bg_rgb, 0.0F, 0.0F, 0.0F);

    set_f(I, cSetting_ambient, 0.14F);

    set_f(I, cSetting_direct, 0.45F);

    set_f(I, cSetting_reflect, 0.45F);

    set_3f(I, cSetting_light, -0.4F, -0.4F, -1.0F);

    set_i(I, cSetting_antialias, 1);

    set_i(I, cSetting_cavity_cull, 10);

    set_f(I, cSetting_gl_ambient, 0.12F);       /* no longer effective */

    set_b(I, cSetting_single_image, 0);

    set_f(I, cSetting_movie_delay, 30.0F);

    set_f(I, cSetting_ribbon_power, 2.0F);

    set_f(I, cSetting_ribbon_power_b, 0.5F);

    set_i(I, cSetting_ribbon_sampling, 1);

    set_f(I, cSetting_ribbon_radius, 0.0F);

    set_f(I, cSetting_stick_radius, 0.25F);

    set_i(I, cSetting_hash_max, 100);

    set_b(I, cSetting_ortho, 0);

    set_f(I, cSetting_power, 1.0F);

    set_f(I, cSetting_spec_reflect, -1.0F);

    set_f(I, cSetting_spec_power, -1.0F);

    set_f(I, cSetting_sweep_angle, 20.0F);

    set_f(I, cSetting_sweep_speed, 0.75F);

    set_b(I, cSetting_dot_hydrogens, 1);

    set_f(I, cSetting_dot_radius, 0.0F);

    set_b(I, cSetting_ray_trace_frames, 0);

    set_b(I, cSetting_cache_frames, 0);

    set_b(I, cSetting_trim_dots, 1);

    set_i(I, cSetting_cull_spheres, 0);

    set_f(I, cSetting_test1, 3.0F);

    set_f(I, cSetting_test2, -0.5F);

    set_f(I, cSetting_surface_best, 0.25F);

    set_f(I, cSetting_surface_normal, 0.5F);

    set_i(I, cSetting_surface_quality, 0);

    set_b(I, cSetting_surface_proximity, 1);

    set_f(I, cSetting_stereo_angle, 2.1F);

    set_f(I, cSetting_stereo_shift, 2.0F);

    set_b(I, cSetting_line_smooth, 1);

    set_f(I, cSetting_line_width, 1.49F);       /* under 1.5F to retain SGI antialiasing */

    set_b(I, cSetting_half_bonds, 0);

    set_i(I, cSetting_stick_quality, 8);

    set_f(I, cSetting_stick_overlap, 0.2F);

    set_f(I, cSetting_stick_nub, 0.7F);

    set_b(I, cSetting_all_states, 0);

    set_b(I, cSetting_pickable, 1);

    set_i(I, cSetting_sphere_quality, 1);

    set_b(I, cSetting_auto_show_lines, G->Option->sphere_mode < 0);

    set_f(I, cSetting_fast_idle, 10000.0F);     /* 1/100th of a sec. */

    set_f(I, cSetting_no_idle, 2000.0F);        /* 1/500th of a sec. */

    set_f(I, cSetting_slow_idle, 40000.0F);     /* 1/25th of a sec. */

    set_f(I, cSetting_idle_delay, 1.5F);

    set_f(I, cSetting_rock_delay, 30.0F);

    set_i(I, cSetting_dist_counter, 0);

    set_f(I, cSetting_dash_length, 0.15F);

    set_f(I, cSetting_dash_gap, 0.45F);

    set_i(I, cSetting_auto_zoom, G->Option->zoom_mode);

    set_i(I, cSetting_overlay, 0);

    set_b(I, cSetting_text, 0);

    set_i(I, cSetting_button_mode, 0);

    set_b(I, cSetting_valence, 0);

    set_f(I, cSetting_nonbonded_size, 0.25F);

    set_color(I, cSetting_label_color, "-6");

    set_f(I, cSetting_ray_trace_fog, -1.0F);

    set_f(I, cSetting_spheroid_scale, 1.0F);

    set_f(I, cSetting_ray_trace_fog_start, -1.0F);

    set_f(I, cSetting_spheroid_smooth, 1.1F);

    set_f(I, cSetting_spheroid_fill, 1.30F);

    set_b(I, cSetting_auto_show_nonbonded, G->Option->sphere_mode < 0);

    set_f(I, cSetting_mesh_radius, 0.000F);

#ifdef WIN32
    /* BEGIN PROPRIETARY CODE SEGMENT (see disclaimer in "os_proprietary.h") */
    set_b(I, cSetting_cache_display, 0);
    /* END PROPRIETARY CODE SEGMENT */
#else
    set_b(I, cSetting_cache_display, 1);
#endif

    set_b(I, cSetting_normal_workaround, 0);

    set_b(I, cSetting_backface_cull, 0); 

    set_f(I, cSetting_gamma, 1.0F);

    set_f(I, cSetting_dot_width, 2.0F);

    set_b(I, cSetting_auto_show_selections, 1);

    set_b(I, cSetting_auto_hide_selections, 1);

    set_f(I, cSetting_selection_width, 3.0F);

    set_f(I, cSetting_selection_overlay, 1.0F);

    set_b(I, cSetting_static_singletons, 1);

    set_i(I, cSetting_max_triangles, 1000000);  /* no longer used */

    set_b(I, cSetting_depth_cue, 1);

    set_f(I, cSetting_specular, 1.0F);

    set_f(I, cSetting_shininess, 55.0F);

    set_f(I, cSetting_fog, 1.0F);

    set_b(I, cSetting_isomesh_auto_state, 0);   /* no longer necessary? */

    set_f(I, cSetting_mesh_width, 1.0F);

    set_i(I, cSetting_cartoon_sampling, 7);

    set_f(I, cSetting_cartoon_loop_radius, 0.2F);

    set_f(I, cSetting_cartoon_loop_quality, 6.0F);

    set_f(I, cSetting_cartoon_power, 2.0F);

    set_f(I, cSetting_cartoon_power_b, 0.52F);

    set_f(I, cSetting_cartoon_rect_length, 1.40F);

    set_f(I, cSetting_cartoon_rect_width, 0.4F);

    if(reset_gui) {
      set_i(I, cSetting_internal_gui_width, cOrthoRightSceneMargin);

      set_b(I, cSetting_internal_gui, 1);
    }

    set_f(I, cSetting_cartoon_oval_length, 1.35F);

    set_f(I, cSetting_cartoon_oval_width, 0.25F);

    set_f(I, cSetting_cartoon_oval_quality, 10.0F);

    set_f(I, cSetting_cartoon_tube_radius, 0.5F);

    set_f(I, cSetting_cartoon_tube_quality, 9.0F);

    set_i(I, cSetting_cartoon_debug, 0);

    set_f(I, cSetting_ribbon_width, 3.0F);

    set_f(I, cSetting_dash_width, 2.5F);

    set_f(I, cSetting_dash_radius, 0.00F);

    set_f(I, cSetting_cgo_ray_width_scale, -0.15F);

    set_f(I, cSetting_line_radius, 0.0F);

    set_b(I, cSetting_cartoon_round_helices, 1);

    set_i(I, cSetting_cartoon_refine_normals, -1);

    set_b(I, cSetting_cartoon_flat_sheets, 1);

    set_b(I, cSetting_cartoon_smooth_loops, 0);

    set_f(I, cSetting_cartoon_dumbbell_length, 1.60F);

    set_f(I, cSetting_cartoon_dumbbell_width, 0.17F);

    set_f(I, cSetting_cartoon_dumbbell_radius, 0.16F);

    set_b(I, cSetting_cartoon_fancy_helices, 0);

    set_b(I, cSetting_cartoon_fancy_sheets, 1);

    set_b(I, cSetting_ignore_pdb_segi, 0);

    set_f(I, cSetting_ribbon_throw, 1.35F);

    set_f(I, cSetting_cartoon_throw, 1.35F);

    set_i(I, cSetting_cartoon_refine, 5);

    set_i(I, cSetting_cartoon_refine_tips, 10);

    set_b(I, cSetting_cartoon_discrete_colors, 0);

    set_b(I, cSetting_normalize_ccp4_maps, 1);

    set_f(I, cSetting_surface_poor, 0.85F);

    set_i(I, cSetting_internal_feedback, G->Option->internal_feedback);

    set_f(I, cSetting_cgo_line_width, 1.00F);

    set_f(I, cSetting_cgo_line_radius, -0.05F);

    set_i(I, cSetting_logging, 0);      /* 0 = off, 1 = regular (PML), 2 = python (PYM) */

    set_b(I, cSetting_robust_logs, 0);

    set_b(I, cSetting_log_box_selections, 1);

    set_b(I, cSetting_log_conformations, 1);

    set_f(I, cSetting_valence_size, 0.060F);

    set_f(I, cSetting_surface_miserable, 2.0F);

    set_i(I, cSetting_ray_opaque_background, -1);

    set_f(I, cSetting_transparency, 0.0F);

    set_i(I, cSetting_ray_texture, 0);

    set_3f(I, cSetting_ray_texture_settings, 0.1F, 5.0F, 1.0F);

    set_b(I, cSetting_suspend_updates, 0);

    set_b(I, cSetting_full_screen, 0);

    set_i(I, cSetting_surface_mode, 0); /* by flag is the default */

    set_color(I, cSetting_surface_color, "-1"); /* use atom colors by default */

    set_i(I, cSetting_mesh_mode, 0);    /* by flag is the default */

    set_color(I, cSetting_mesh_color, "-1");    /* use atom colors by default */

    set_b(I, cSetting_auto_indicate_flags, 0);

    set_i(I, cSetting_surface_debug, 0);

    set_f(I, cSetting_ray_improve_shadows, 0.1F);

    set_b(I, cSetting_smooth_color_triangle, 0);

    set_i(I, cSetting_ray_default_renderer, 0);

    set_f(I, cSetting_field_of_view, 20.0F);

    set_f(I, cSetting_reflect_power, 1.0F);

    set_b(I, cSetting_preserve_chempy_ids, 0);

    set_f(I, cSetting_sphere_scale, 1.0F);

    set_i(I, cSetting_two_sided_lighting, -1);

    set_f(I, cSetting_secondary_structure, 2.0F);       /* unused? */

    set_b(I, cSetting_auto_remove_hydrogens, 0);

    set_b(I, cSetting_raise_exceptions, 1);

    set_b(I, cSetting_stop_on_exceptions, 0);

    set_b(I, cSetting_sculpting, 0);

    set_b(I, cSetting_auto_sculpt, 0);

    set_f(I, cSetting_sculpt_vdw_scale, 0.97F);

    set_f(I, cSetting_sculpt_vdw_scale14, 0.90F);       /* 0.915 */

    set_f(I, cSetting_sculpt_vdw_weight, 1.0F);

    set_f(I, cSetting_sculpt_vdw_weight14, 0.2F);       /* 0.33 */

    set_f(I, cSetting_sculpt_bond_weight, 2.25F);

    set_f(I, cSetting_sculpt_angl_weight, 1.0F);

    set_f(I, cSetting_sculpt_pyra_weight, 1.0F);

    set_f(I, cSetting_sculpt_plan_weight, 1.0F);

    set_i(I, cSetting_sculpting_cycles, 10);

    set_f(I, cSetting_sphere_transparency, 0.0F);

    set_color(I, cSetting_sphere_color, "-1");  /* use atom colors by default */

    set_i(I, cSetting_sculpt_field_mask, 0x1FF);        /* all terms */

    set_f(I, cSetting_sculpt_hb_overlap, 1.0F);

    set_f(I, cSetting_sculpt_hb_overlap_base, 0.35F);

    set_b(I, cSetting_legacy_vdw_radii, 0);

    set_b(I, cSetting_sculpt_memory, 1);

    set_i(I, cSetting_connect_mode, 0);

    set_b(I, cSetting_cartoon_cylindrical_helices, 0);

    set_f(I, cSetting_cartoon_helix_radius, 2.25F);

    set_f(I, cSetting_connect_cutoff, 0.35F);

    set_b(I, cSetting_save_pdb_ss, 0);

    set_f(I, cSetting_sculpt_line_weight, 1.0F);

    set_i(I, cSetting_fit_iterations, 1000);

    set_f(I, cSetting_fit_tolerance, 0.0000001F);

    set_s(I, cSetting_batch_prefix, "tmp_pymol");

    if(!G->Option->stereo_mode) {
      if(G->StereoCapable || G->Option->blue_line) {
        set_i(I, cSetting_stereo_mode, 1);      /* quadbuffer if we can */
      } else {
        set_i(I, cSetting_stereo_mode, 2);      /* otherwise crosseye by default */
      }
    } else {
      set_i(I, cSetting_stereo_mode, G->Option->stereo_mode);
    }

    set_i(I, cSetting_cgo_sphere_quality, 1);

    set_b(I, cSetting_pdb_literal_names, 0);

    set_b(I, cSetting_wrap_output, 0);

    set_f(I, cSetting_fog_start, 0.45F);

    set_i(I, cSetting_frame, 1);

    set_i(I, cSetting_state, 1);

    set_b(I, cSetting_ray_shadows, 1);

    set_i(I, cSetting_ribbon_trace_atoms, 0);

    set_i(I, cSetting_security, 1);

    set_f(I, cSetting_stick_transparency, 0.0F);

    set_b(I, cSetting_ray_transparency_shadows, 1);

    set_i(I, cSetting_session_version_check, 0);

    set_f(I, cSetting_ray_transparency_specular, 0.6F);

    set_b(I, cSetting_stereo_double_pump_mono, 0);

    set_b(I, cSetting_sphere_solvent, 0);

    set_i(I, cSetting_mesh_quality, 2);

    set_i(I, cSetting_mesh_solvent, 0);

    set_b(I, cSetting_dot_solvent, 0);

    set_f(I, cSetting_ray_shadow_fudge, 0.001F);

    set_f(I, cSetting_ray_triangle_fudge, 0.0000001F);

    set_i(I, cSetting_debug_pick, 0);

    set_color(I, cSetting_dot_color, "-1");     /* use atom colors by default */

    set_f(I, cSetting_mouse_limit, 100.0F);

    set_f(I, cSetting_mouse_scale, 1.3F);

    set_i(I, cSetting_transparency_mode, 2);

    set_b(I, cSetting_clamp_colors, 1);

    set_f(I, cSetting_pymol_space_max_red, 0.90F);

    set_f(I, cSetting_pymol_space_max_green, 0.75F);

    set_f(I, cSetting_pymol_space_max_blue, 0.90F);

    set_f(I, cSetting_pymol_space_min_factor, 0.15F);

    set_b(I, cSetting_roving_origin, 1);

    set_f(I, cSetting_roving_sticks, 6.0F);

    set_f(I, cSetting_roving_lines, 10.0F);

    set_f(I, cSetting_roving_spheres, 0.0F);

    set_f(I, cSetting_roving_labels, 0.0F);

    set_f(I, cSetting_roving_delay, 0.2F);

    set_s(I, cSetting_roving_selection, "all");

    set_b(I, cSetting_roving_byres, 1);

    set_f(I, cSetting_roving_ribbon, -7.0F);

    set_f(I, cSetting_roving_cartoon, 0.0F);

    set_f(I, cSetting_roving_polar_contacts, 7.0F);

    set_f(I, cSetting_roving_polar_cutoff, 3.31F);

    set_f(I, cSetting_roving_nonbonded, 0.0F);

    set_i(I, cSetting_float_labels, 0);

    set_b(I, cSetting_roving_detail, 0);

    set_f(I, cSetting_roving_nb_spheres, 8.0F);

    set_color(I, cSetting_ribbon_color, "-1");  /* use atom colors by default */

    set_color(I, cSetting_cartoon_color, "-1"); /* use atom colors by default */

    set_i(I, cSetting_ribbon_smooth, 0);

    set_b(I, cSetting_auto_color, 1);

    set_i(I, cSetting_auto_color_next, 0);

    set_color(I, cSetting_ray_interior_color, "-1");    /* object color */

    set_color(I, cSetting_cartoon_highlight_color, "-1");       /* no color */

    /* In order to get electrostatic potentials in kT from the Coulomb equation... 

       PyMOL charges: Q, in e
       PyMOL distances: r, in Angstrom
       Coulomb Constant: K = 8.987552e9 ((J*m)/(C^2))
       Angstrom Convertor: 1 A = 1e-10 m
       Coulomb Convertor: 1 e = 1.60217733e-19 C
       Angstrom Convertor: 1 A = 10e-10 m
       Dielectric Constant: D (unitless)

       ePot = (KQ)/(Dr) = 

       8.987552e9 J*m     1.6021773e-19 C   1.6021773e-19 C      1 A        Q  
       ---------------- * --------------- * --------------- * ---------- * --- =
       C^2              1 e               1 e            1e-10 m     Dr

       2.3070795237e-18 J*A      Q
       = ---------------------- * ---
       e^2               Dr

       Boltzmann Constant: k = 1.380658e-23 (J/K)
       Temperature: 300 Kelvin

       kT = 1.380658e-23 * 300 = 4.141974e-21 J

       2.3070795237e-18 J*A         1 kT             Q
       ePot = --------------------- * ------------------ * ---
       e^2              4.141974e-21 J       Dr

       557.00000 kT*A    Q
       ePot = -------------- * --- which will give kT/e units when applied
       e^2           Dr
     */

    set_f(I, cSetting_coulomb_units_factor, 557.00000F);

    set_f(I, cSetting_coulomb_dielectric, 2.0F);

    set_b(I, cSetting_ray_interior_shadows, 0);

    set_i(I, cSetting_ray_interior_texture, -1);

    set_s(I, cSetting_roving_map1_name, "");

    set_s(I, cSetting_roving_map2_name, "");

    set_s(I, cSetting_roving_map3_name, "");

    set_f(I, cSetting_roving_map1_level, 1.0F);

    set_f(I, cSetting_roving_map2_level, 2.0F);

    set_f(I, cSetting_roving_map3_level, 3.0F);

    set_f(I, cSetting_roving_isomesh, 8.0F);

    set_f(I, cSetting_roving_isosurface, 0.0F);

    set_f(I, cSetting_scenes_changed, 1.0F);

    set_f(I, cSetting_gaussian_b_adjust, 0.0F);

    set_b(I, cSetting_pdb_standard_order, 1);

    set_i(I, cSetting_cartoon_smooth_first, 1);
    set_i(I, cSetting_cartoon_smooth_last, 1);
    set_i(I, cSetting_cartoon_smooth_cycles, 2);
    set_i(I, cSetting_cartoon_flat_cycles, 4);

#ifdef WIN32
#ifdef _PYMOL_ACTIVEX
    set_i(I, cSetting_max_threads, 1);
#else
    /* BEGIN PROPRIETARY CODE SEGMENT (see disclaimer in "os_proprietary.h") */
    {
      SYSTEM_INFO SysInfo;
      GetSystemInfo(&SysInfo);
      {
        DWORD count = SysInfo.dwNumberOfProcessors;
        if(count > 1) {
          set_i(I, cSetting_max_threads, count);
        } else {
          set_i(I, cSetting_max_threads, 1);
        }
      }
    }
    /* END PROPRIETARY CODE SEGMENT */
#endif
#else
    set_i(I, cSetting_max_threads, 1);
#endif

    set_i(I, cSetting_show_progress, 1);

    set_i(I, cSetting_use_display_lists, 0);    /* don't make this default
                                                   until we have a way of
                                                   reusing display list 
                                                   identifiers */

    set_i(I, cSetting_cache_memory, 0); /* doesn't seem to do any good :( */

    set_b(I, cSetting_simplify_display_lists, 0);

    set_i(I, cSetting_retain_order, 0);

    set_i(I, cSetting_pdb_hetatm_sort, 0);

    set_i(I, cSetting_pdb_use_ter_records, 1);

    set_i(I, cSetting_cartoon_trace_atoms, 0);

    set_i(I, cSetting_ray_oversample_cutoff, 120);

    /* note that this setting is ad-hoc and calibrated such that a
       gaussian_resolution of 2.0 returns maps with the straight atomic
       scattering factors (unblurred).  At resolution of 4.0, they are
       blurred 2X, 8.0:4X, and so forth.... */
    set_f(I, cSetting_gaussian_resolution, 2.0F);

    set_f(I, cSetting_gaussian_b_floor, 0.0F);

    set_i(I, cSetting_sculpt_nb_interval, 17);

    set_f(I, cSetting_sculpt_tors_weight, 0.05F);

    set_f(I, cSetting_sculpt_tors_tolerance, 0.05F);

    set_b(I, cSetting_stick_ball, false);

    set_f(I, cSetting_stick_ball_ratio, 1.0F);

    set_b(I, cSetting_stick_fixed_radius, false);

    set_f(I, cSetting_cartoon_transparency, 0.0F);

    set_b(I, cSetting_dash_round_ends, 1);

    set_f(I, cSetting_h_bond_max_angle, 63.0F);

    set_f(I, cSetting_h_bond_cutoff_center, 3.6F);

    set_f(I, cSetting_h_bond_cutoff_edge, 3.2F);

    set_f(I, cSetting_h_bond_power_a, 1.6F);

    set_f(I, cSetting_h_bond_power_b, 5.0F);

    set_f(I, cSetting_h_bond_cone, 180.0F);

    set_f(I, cSetting_ss_helix_psi_target, -48.0F);
    set_f(I, cSetting_ss_helix_psi_include, 55.0F);     /* 30 */
    set_f(I, cSetting_ss_helix_psi_exclude, 85.0F);

    set_f(I, cSetting_ss_helix_phi_target, -57.0F);
    set_f(I, cSetting_ss_helix_phi_include, 55.0F);
    set_f(I, cSetting_ss_helix_phi_exclude, 85.0F);

    set_f(I, cSetting_ss_strand_psi_target, 124.0F);
    set_f(I, cSetting_ss_strand_psi_include, 40.0F);
    set_f(I, cSetting_ss_strand_psi_exclude, 90.0F);    /* 80 */

    set_f(I, cSetting_ss_strand_phi_target, -129.0F);
    set_f(I, cSetting_ss_strand_phi_include, 40.0F);
    set_f(I, cSetting_ss_strand_phi_exclude, 100.0F);

    set_b(I, cSetting_movie_loop, 1);

    set_b(I, cSetting_pdb_retain_ids, 0);

    set_b(I, cSetting_pdb_no_end_record, 0);

    set_f(I, cSetting_cgo_dot_width, 2.0F);
    set_f(I, cSetting_cgo_dot_radius, -1.0F);
    set_b(I, cSetting_defer_updates, 0);
    set_b(I, cSetting_normalize_o_maps, 1);
    set_b(I, cSetting_swap_dsn6_bytes, 1);
    set_b(I, cSetting_pdb_insertions_go_first, 0);
    set_b(I, cSetting_roving_origin_z, 1);
    set_f(I, cSetting_roving_origin_z_cushion, 3.0F);
    set_f(I, cSetting_specular_intensity, 0.5F);
    set_i(I, cSetting_overlay_lines, 5);
    set_f(I, cSetting_ray_transparency_spec_cut, 0.9F);
    set_b(I, cSetting_internal_prompt, 1);
    set_b(I, cSetting_normalize_grd_maps, 0);

    set_b(I, cSetting_ray_blend_colors, 0);
    set_f(I, cSetting_ray_blend_red, 0.17F);
    set_f(I, cSetting_ray_blend_green, 0.25F);
    set_f(I, cSetting_ray_blend_blue, 0.14F);
    set_f(I, cSetting_png_screen_gamma, 2.4F);
    set_f(I, cSetting_png_file_gamma, 1.0F);
    set_b(I, cSetting_editor_label_fragments, 0);
    set_i(I, cSetting_internal_gui_control_size, 18);
    set_b(I, cSetting_auto_dss, 1);
    set_i(I, cSetting_transparency_picking_mode, 2);    /* auto */
    set_b(I, cSetting_virtual_trackball, 1);
    set_i(I, cSetting_transparency_picking_mode, 2);    /* auto */
    set_i(I, cSetting_pdb_reformat_names_mode, 0);      /*
                                                           0 = no reformatting, 
                                                           1 = pdb compliant,
                                                           2 = amber compliant,
                                                           3 = pdb I/O, but iupac inside
                                                         */
    set_f(I, cSetting_ray_pixel_scale, 1.30F);
#ifdef _PYMOL_FREETYPE
    set_i(I, cSetting_label_font_id, 5);
#else
    set_i(I, cSetting_label_font_id, 0);
#endif
    set_b(I, cSetting_pdb_conect_all, 0);
    set_s(I, cSetting_button_mode_name, "");
    set_i(I, cSetting_surface_type, 0);
    set_b(I, cSetting_dot_normals, 1);
    set_b(I, cSetting_session_migration, 1);
    set_b(I, cSetting_mesh_normals, 1);
    set_i(I, cSetting_mesh_type, 0);    /* 0 = lines, 1 = points, 2 = solid, 3 = gradient */

    set_b(I, cSetting_dot_lighting, 1);
    set_b(I, cSetting_mesh_lighting, 0);
    set_b(I, cSetting_surface_solvent, 0);
    set_i(I, cSetting_triangle_max_passes, 5);
    set_f(I, cSetting_ray_interior_reflect, 0.4F);
    set_i(I, cSetting_internal_gui_mode, 0);
    set_s(I, cSetting_surface_carve_selection, "");
    set_i(I, cSetting_surface_carve_state, 0);
    set_f(I, cSetting_surface_carve_cutoff, 0.0F);
    set_s(I, cSetting_surface_clear_selection, "");
    set_i(I, cSetting_surface_clear_state, 0);
    set_f(I, cSetting_surface_clear_cutoff, 0.0F);
    set_f(I, cSetting_surface_trim_cutoff, 0.2F);
    set_f(I, cSetting_surface_trim_factor, 2.0F);
    set_i(I, cSetting_ray_max_passes, 25);
    set_b(I, cSetting_active_selections, true);
    set_f(I, cSetting_ray_transparency_contrast, 1.0F);
    set_b(I, cSetting_seq_view, 0);
    set_i(I, cSetting_mouse_selection_mode, 1);
    set_i(I, cSetting_seq_view_label_spacing, 5);
    set_i(I, cSetting_seq_view_label_start, 1);
    set_i(I, cSetting_seq_view_format, 0);
    set_i(I, cSetting_seq_view_location, 0);
    set_b(I, cSetting_seq_view_overlay, 0);
    set_b(I, cSetting_auto_classify_atoms, 1);
    set_i(I, cSetting_cartoon_nucleic_acid_mode, 4);
    set_color(I, cSetting_seq_view_color, "-1");
    set_i(I, cSetting_seq_view_label_mode, 2);
    set_i(I, cSetting_surface_ramp_above_mode, 0);
    set_b(I, cSetting_stereo, 0);
    set_i(I, cSetting_wizard_prompt_mode, 1);
    set_f(I, cSetting_coulomb_cutoff, 10.0F);
    set_b(I, cSetting_slice_track_camera, 0);
    set_f(I, cSetting_slice_height_scale, 1.0F);
    set_b(I, cSetting_slice_height_map, 0);
    set_f(I, cSetting_slice_grid, 0.3F);
    set_b(I, cSetting_slice_dynamic_grid, 0);
    set_f(I, cSetting_slice_dynamic_grid_resolution, 3.0F);
    set_b(I, cSetting_pdb_insure_orthogonal, 1);
    set_f(I, cSetting_ray_direct_shade, 0.0F);  /* only meaningful with one light source */
    set_color(I, cSetting_stick_color, "-1");
    set_f(I, cSetting_cartoon_putty_radius, 0.40F);
    set_f(I, cSetting_cartoon_putty_quality, 11.0F);
    set_f(I, cSetting_cartoon_putty_scale_min, 0.6F);
    set_f(I, cSetting_cartoon_putty_scale_max, 4.0F);
    set_f(I, cSetting_cartoon_putty_scale_power, 1.5F);
    set_f(I, cSetting_cartoon_putty_range, 2.0F);
    set_b(I, cSetting_cartoon_side_chain_helper, 0);
    set_b(I, cSetting_surface_optimize_subsets, 1);
    set_i(I, cSetting_multiplex, -1);
    if(G->Option->multisample > 1)
      set_b(I, cSetting_texture_fonts, 1);
    else
      set_b(I, cSetting_texture_fonts, 0);
    set_b(I, cSetting_pqr_workarounds, 1);
    set_b(I, cSetting_animation, 1);
    set_f(I, cSetting_animation_duration, 0.75F);
    set_i(I, cSetting_scene_animation, -1);
    set_b(I, cSetting_line_stick_helper, 1);
    set_i(I, cSetting_ray_orthoscopic, -1);
    set_i(I, cSetting_ribbon_side_chain_helper, 0);
    set_f(I, cSetting_selection_width_max, 10.0F);
    set_f(I, cSetting_selection_width_scale, 2.0F);
    set_s(I, cSetting_scene_current_name, "");
    set_b(I, cSetting_presentation, G->Option->presentation);
    set_i(I, cSetting_presentation_mode, 1);
    set_b(I, cSetting_pdb_truncate_residue_name, false);
    set_b(I, cSetting_scene_loop, 0);
    set_i(I, cSetting_sweep_mode, 0);
    set_f(I, cSetting_sweep_phase, 0.0F);
    set_b(I, cSetting_scene_restart_movie_delay, 1);
    set_b(I, cSetting_mouse_restart_movie_delay, 0);
    set_f(I, cSetting_angle_size, 0.6666F);
    set_f(I, cSetting_angle_label_position, 0.5);
    set_f(I, cSetting_dihedral_size, 0.6666F);
    set_f(I, cSetting_dihedral_label_position, 1.2F);
    set_i(I, cSetting_defer_builds_mode, G->Option->defer_builds_mode);
    set_b(I, cSetting_seq_view_discrete_by_state, 1);
    set_f(I, cSetting_scene_animation_duration, 2.25F);
    set_s(I, cSetting_wildcard, "*");
    set_s(I, cSetting_atom_name_wildcard, "");
    set_b(I, cSetting_ignore_case, 1);
    set_b(I, cSetting_presentation_auto_quit, !G->Option->no_quit);
    set_b(I, cSetting_editor_auto_dihedral, 1);
    set_b(I, cSetting_presentation_auto_start, 1);
    set_b(I, cSetting_validate_object_names, 1);
    set_b(I, cSetting_unused_boolean_def_true, 1);
    set_b(I, cSetting_auto_show_spheres, G->Option->sphere_mode >= 0);
    set_i(I, cSetting_sphere_mode, G->Option->sphere_mode);
    set_f(I, cSetting_sphere_point_max_size, 18.0);
    set_f(I, cSetting_sphere_point_size, 1.0);
    set_b(I, cSetting_pdb_honor_model_number, false);
    set_b(I, cSetting_rank_assisted_sorts, true);
    set_i(I, cSetting_ribbon_nucleic_acid_mode, 0);
    set_i(I, cSetting_cartoon_ring_mode, 0);
    set_f(I, cSetting_cartoon_ring_width, 0.125F);
    set_color(I, cSetting_cartoon_ring_color, "-1");
    set_i(I, cSetting_cartoon_ring_finder, 1);
    set_i(I, cSetting_cartoon_tube_cap, 2);
    set_i(I, cSetting_cartoon_loop_cap, 1);
    set_i(I, cSetting_nvidia_bugs, 0);
    set_f(I, cSetting_image_dots_per_inch, 0.0F);
    /* default is to leave it unspecified in PNG file */
    set_b(I, cSetting_opaque_background, 1);
    set_b(I, cSetting_draw_frames, 0);
    set_b(I, cSetting_show_alpha_checker, 1);
    set_i(I, cSetting_matrix_mode, -1); /* -1: automatic behavior based on implied intent
                                            0: coordinates (pre-1.0 legacy default mode)
                                            1: per-object matrices (TTTs: version 1.0 default mode?)
                                            2: per-state matrices (partially implemented)
                                            3: per-group matrices (may come in the future) */
    set_b(I, cSetting_editor_auto_origin, 1);
    set_s(I, cSetting_session_file, "");
    set_f(I, cSetting_cgo_transparency, 0.0F);
    set_b(I, cSetting_legacy_mouse_zoom, 0);
    set_b(I, cSetting_auto_number_selections, 0);
    set_i(I, cSetting_sculpt_vdw_vis_mode, 0);
    set_f(I, cSetting_sculpt_vdw_vis_min, -0.1F);
    set_f(I, cSetting_sculpt_vdw_vis_mid, 0.1F);
    set_f(I, cSetting_sculpt_vdw_vis_max, 0.3F);
    set_i(I, cSetting_cartoon_ladder_mode, 1);
    set_f(I, cSetting_cartoon_ladder_radius, 0.25F);
    set_color(I, cSetting_cartoon_ladder_color, "-1");
    set_color(I, cSetting_cartoon_nucleic_acid_color, "-1");
    set_f(I, cSetting_cartoon_ring_transparency, -1.0F);
    set_f(I, cSetting_label_size, 14.0F);
    set_f(I, cSetting_spec_direct, 0.0F);
    set_i(I, cSetting_light_count, 2);
    set_3f(I, cSetting_light2, -0.55F, -0.7F, 0.15F);
    set_3f(I, cSetting_light3, 0.3F, -0.6F, -0.2F);
    set_b(I, cSetting_hide_underscore_names, 1);
    set_b(I, cSetting_selection_round_points, 0);
    set_i(I, cSetting_distance_exclusion, 5);
    set_i(I, cSetting_h_bond_exclusion, 3);
    set_i(I, cSetting_label_shadow_mode, 0);
    set_3f(I, cSetting_light4, -1.2F, 0.3F, -0.2F);
    set_3f(I, cSetting_light5, 0.3F, 0.6F, -0.75F);
    set_3f(I, cSetting_light6, -0.3F, 0.5F, 0.0F);
    set_3f(I, cSetting_light7, 0.9F, -0.1F, -0.15F);
    set_color(I, cSetting_label_outline_color, "-1");
    set_i(I, cSetting_ray_trace_mode, 0);
    set_f(I, cSetting_ray_trace_gain, 0.12F);
    set_b(I, cSetting_selection_visible_only, 0);
    set_3f(I, cSetting_label_position, 0.0F, 0.0F, 1.75F);
    set_f(I, cSetting_ray_trace_depth_factor, 0.1F);
    set_f(I, cSetting_ray_trace_slope_factor, 0.6F);
    set_f(I, cSetting_ray_trace_disco_factor, 0.05F);
    set_f(I, cSetting_ray_shadow_decay_factor, 0.0F);
    set_i(I, cSetting_ray_interior_mode, 0);
    set_f(I, cSetting_ray_legacy_lighting, 0.0F);
    set_b(I, cSetting_sculpt_auto_center, 0);
    set_i(I, cSetting_pdb_discrete_chains, -1);
    set_i(I, cSetting_pdb_unbond_cations, 1);
    set_f(I, cSetting_sculpt_tri_scale, 1.025F);        /* allow for some play here... */
    set_f(I, cSetting_sculpt_tri_weight, 1.0F);
    set_i(I, cSetting_sculpt_tri_min, 2);
    set_i(I, cSetting_sculpt_tri_max, 18);
    set_i(I, cSetting_sculpt_tri_mode, 0);
    set_s(I, cSetting_pdb_echo_tags, "HEADER, TITLE, COMPND");
    set_b(I, cSetting_connect_bonded, 0);
    set_f(I, cSetting_spec_direct_power, 55.0F);
    set_3f(I, cSetting_light8, 1.3F, 2.0F, 0.8F);
    set_3f(I, cSetting_light9, -1.7F, -0.5F, 1.2F);
    set_f(I, cSetting_ray_shadow_decay_range, 1.8F);
    set_i(I, cSetting_spec_count, -1);
    set_f(I, cSetting_sculpt_min_scale, 0.975F);
    set_f(I, cSetting_sculpt_min_weight, 0.75F);
    set_f(I, cSetting_sculpt_min_min, 4.0F);
    set_f(I, cSetting_sculpt_min_max, 12.0F);
    set_f(I, cSetting_sculpt_max_scale, 1.025F);
    set_f(I, cSetting_sculpt_max_weight, 0.75F);
    set_f(I, cSetting_sculpt_max_min, 4.0F);
    set_f(I, cSetting_sculpt_max_max, 12.0F);
    set_i(I, cSetting_surface_circumscribe, -1);
    set_f(I, cSetting_sculpt_avd_weight, 4.0F);
    set_f(I, cSetting_sculpt_avd_gap, -1.0F);
    set_f(I, cSetting_sculpt_avd_range, -1.0F);
    set_i(I, cSetting_sculpt_avd_excl, 7);
    set_b(I, cSetting_async_builds, 0);
    set_s(I, cSetting_fetch_path, ".");
    set_s(I, cSetting_fetch_host, "pdb");
    set_f(I, cSetting_cartoon_ring_radius, -1.0F);
    set_b(I, cSetting_ray_color_ramps, 0);
    set_f(I, cSetting_ray_hint_camera, 2.15F);
    set_f(I, cSetting_ray_hint_shadow, 0.65F);
    set_f(I, cSetting_stick_valence_scale, 1.0F);
    set_s(I, cSetting_seq_view_alignment, "");
    set_i(I, cSetting_seq_view_unaligned_mode, 0);
    set_color(I, cSetting_seq_view_unaligned_color, "-1");
    set_s(I, cSetting_seq_view_fill_char, "-");
    set_color(I, cSetting_seq_view_fill_color, "104");  /* grey50 */
    set_color(I, cSetting_seq_view_label_color, "white");       /* grey50 */
    set_f(I, cSetting_surface_carve_normal_cutoff, -1.0F);
    set_i(I, cSetting_trace_atoms_mode, 5);
    set_b(I, cSetting_session_changed, 0);
    set_b(I, cSetting_ray_clip_shadows, 0);
    set_f(I, cSetting_mouse_wheel_scale, 0.5F);
    set_f(I, cSetting_nonbonded_transparency, 0.0F);
    set_b(I, cSetting_ray_spec_local, 0);
    set_color(I, cSetting_line_color, "-1");
    set_f(I, cSetting_ray_label_specular, 1.0F);
    set_i(I, cSetting_mesh_skip, 0);
    set_i(I, cSetting_label_digits, 1);
    set_i(I, cSetting_label_distance_digits, -1);
    set_i(I, cSetting_label_angle_digits, -1);
    set_i(I, cSetting_label_dihedral_digits, -1);
    set_s(I, cSetting_label_anchor, "CA");
    set_b(I, cSetting_surface_negative_visible, 0);
    set_color(I, cSetting_surface_negative_color, "grey50");
    set_b(I, cSetting_mesh_negative_visible, 0);
    set_color(I, cSetting_mesh_negative_color, "grey30");
    set_i(I, cSetting_group_auto_mode, 1);
    set_i(I, cSetting_group_full_member_names, 0);
    set_f(I, cSetting_gradient_max_length, 100.0F);
    set_f(I, cSetting_gradient_min_length, 2.0F);
    set_f(I, cSetting_gradient_min_slope, 0.00001F);
    set_f(I, cSetting_gradient_normal_min_dot, 0.70F);
    set_f(I, cSetting_gradient_step_size, 0.25F);
    set_i(I, cSetting_gradient_spacing, 3);
    set_f(I, cSetting_gradient_symmetry, 0.0F);
    set_color(I, cSetting_ray_trace_color, "-6");
    set_b(I, cSetting_group_arrow_prefix, 0);
    set_b(I, cSetting_suppress_hidden, true);
    set_b(I, cSetting_session_compression, 0);
    set_f(I, cSetting_movie_fps, 30.0);
    set_f(I, cSetting_ray_transparency_oblique, 0.0F);
    set_f(I, cSetting_ray_trace_trans_cutoff, 0.05F);
    set_f(I, cSetting_ray_trace_persist_cutoff, 0.10F);
    set_f(I, cSetting_ray_transparency_oblique_power, 1.0F);
    set_f(I, cSetting_ray_scatter, 0.0F);
    set_b(I, cSetting_h_bond_from_proton, 1);
    set_b(I, cSetting_auto_copy_images, 0);
    set_i(I, cSetting_moe_separate_chains, -1);
    set_b(I, cSetting_transparency_global_sort, 0);
    set_b(I, cSetting_hide_long_bonds, 0);
    set_b(I, cSetting_auto_rename_duplicate_objects, 0);        /* to do */
    set_b(I, cSetting_pdb_hetatm_guess_valences, 1);
    set_i(I, cSetting_ellipsoid_quality, 1);
    set_i(I, cSetting_cgo_ellipsoid_quality, -1);
    set_b(I, cSetting_movie_animate_by_frame, 0);
    set_b(I, cSetting_ramp_blend_nearby_colors, 0);
    set_i(I, cSetting_auto_defer_builds, 500);  /* 500 or more states, then automatically defer builds */
    set_f(I, cSetting_ellipsoid_probability, 0.5F);
    set_f(I, cSetting_ellipsoid_scale, 1.0F);
    set_color(I, cSetting_ellipsoid_color, "-1");
    set_f(I, cSetting_ellipsoid_transparency, 0.0F);
    set_i(I, cSetting_movie_rock, -1);
    set_i(I, cSetting_cache_mode, 0);
    set_color(I, cSetting_dash_color, "-1");
    set_color(I, cSetting_angle_color, "-1");
    set_color(I, cSetting_dihedral_color, "-1");
    set_i(I, cSetting_grid_mode, 0);
    set_i(I, cSetting_cache_max, 25000000);     /* default: ~100 MB cache */
    set_i(I, cSetting_grid_slot, -1);
    set_i(I, cSetting_grid_max, -1);
    set_i(I, cSetting_cartoon_putty_transform, cPuttyTransformNormalizedNonlinear);
    set_b(I, cSetting_rock, 0);
    set_i(I, cSetting_cone_quality, 18);
    set_b(I, cSetting_pdb_formal_charges, 1);
    set_i(I, cSetting_ati_bugs, 0);
    set_i(I, cSetting_geometry_export_mode, 0);
    set_b(I, cSetting_mouse_grid, 1);
    set_s(I, cSetting_mesh_carve_selection, "");
    set_i(I, cSetting_mesh_carve_state, 0);
    set_f(I, cSetting_mesh_carve_cutoff, 0.0F);
    set_s(I, cSetting_mesh_clear_selection, "");
    set_i(I, cSetting_mesh_clear_state, 0);
    set_f(I, cSetting_mesh_clear_cutoff, 0.0F);
    set_f(I, cSetting_mesh_cutoff, 0.0F);
    set_i(I, cSetting_mesh_grid_max, 80);
    set_i(I, cSetting_session_cache_optimize, 0);
    set_f(I, cSetting_sdof_drag_scale, 0.5F);
    set_i(I, cSetting_scene_buttons_mode, 1);
    set_b(I, cSetting_scene_buttons, 0);
    set_b(I, cSetting_map_auto_expand_sym, 1);
    set_b(I, cSetting_image_copy_always, 0);
    set_i(I, cSetting_max_ups, 0);
    set_i(I, cSetting_auto_overlay, 0);
    set_color(I, cSetting_stick_ball_color, "-1");
    set_f(I, cSetting_stick_h_scale, 0.4F);
    set_f(I, cSetting_sculpt_pyra_inv_weight, 10.0F);
    set_b(I, cSetting_keep_alive, 0);
    set_i(I, cSetting_fit_kabsch, 0);
    set_f(I, cSetting_stereo_dynamic_strength, 0.5F);
    set_b(I, cSetting_dynamic_width, 1);
    set_f(I, cSetting_dynamic_width_factor, 0.06);
    set_f(I, cSetting_dynamic_width_min, 0.75);
    set_f(I, cSetting_dynamic_width_max, 2.5);
    set_i(I, cSetting_draw_mode, 0);
    set_i(I, cSetting_clean_electro_mode, 1);
    set_i(I, cSetting_valence_mode, 1);
    set_b(I, cSetting_show_frame_rate, 0);
    set_i(I, cSetting_movie_panel, 1);
    set_f(I, cSetting_mouse_z_scale,1.0);
    set_b(I, cSetting_movie_auto_store, -1);
    set_b(I, cSetting_movie_auto_interpolate, 1);
    set_i(I, cSetting_movie_panel_row_height, 15);
    set_i(I, cSetting_movie_quality, 60);
    set_i(I, cSetting_scene_frame_mode,-1);
    set_i(I, cSetting_surface_cavity_mode,0);
    set_f(I, cSetting_surface_cavity_radius, 7.0F);
    set_f(I, cSetting_surface_cavity_cutoff, -3.0F);
    set_f(I, cSetting_motion_power, 0.0F);
    set_f(I, cSetting_motion_bias, -1.0F);
    set_i(I, cSetting_motion_simple, 0);
    set_f(I, cSetting_motion_linear, 0.0F);
    set_i(I, cSetting_motion_hand, 1);
    set_b(I, cSetting_pdb_ignore_conect, 0);
    set_b(I, cSetting_editor_bond_cycle_mode, 1); /* >0 -> include aromatic */
    set_b(I, cSetting_dynamic_measures, 0);
    set_f(I, cSetting_neighbor_cutoff, 3.5F);
    set_f(I, cSetting_heavy_neighbor_cutoff, 3.5F);
    set_f(I, cSetting_polar_neighbor_cutoff, 3.5F);
    set_f(I, cSetting_surface_residue_cutoff, 2.5F);
    set_b(I, cSetting_surface_use_shader, 1);
    set_b(I, cSetting_cartoon_use_shader, 1);
    set_b(I, cSetting_stick_use_shader, 1);
    set_b(I, cSetting_line_use_shader, 1);
    set_b(I, cSetting_sphere_use_shader, 1);
    set_b(I, cSetting_use_shaders, 0);  /* disable by default until optimized shaders present; doesn't effect vol */
    set_s(I, cSetting_shader_path, "data/shaders");
    set_i(I, cSetting_volume_bit_depth, 8);
    set_color(I, cSetting_volume_color, "-1");
    set_f(I, cSetting_volume_layers, 256);
    set_f(I, cSetting_volume_data_range, 5.0);
    set_i(I, cSetting_auto_defer_atom_count, 0);
    set_s(I, cSetting_default_refmac_names, "FWT PHWT DELFWT PHDELWT");
    set_s(I, cSetting_default_phenix_names, "2FOFCWT PH2FOFCWT FOFCWT PHFOFCWT");
    set_s(I, cSetting_default_phenix_no_fill_names, "2FOFCWT_no_fil PH2FOFCWT_no_fill None None");
    set_s(I, cSetting_default_buster_names, "2FOFCWT PH2FOFCWT FOFCWT PHFOFCWT");
    set_s(I, cSetting_default_fofc_map_rep, "volume");
    set_s(I, cSetting_default_2fofc_map_rep, "volume");
    set_s(I, cSetting_atom_type_format, "mol2");

    set_b(I, cSetting_autoclose_dialogs, 1);

    set_b(I, cSetting_bg_gradient, 0);
    set_3f(I, cSetting_bg_rgb_top, 0.0F, 0.0F, 0.3F);
    set_3f(I, cSetting_bg_rgb_bottom, 0.2F, 0.2F, 0.5F);

    set_b(I, cSetting_ray_volume, 0);
    
    set_f(I, cSetting_ribbon_transparency, 0.0F);

    set_i(I, cSetting_state_counter_mode, -1);

  }
}