/*****************************************************************************
#   Copyright (C) 1994-2008 by David Gordon.
#   All rights reserved.                           
#                                                                           
#   This software is part of a beta-test version of the Consed/Autofinish
#   package.  It should not be redistributed or
#   used for any commercial purpose, including commercially funded
#   sequencing, without written permission from the author and the
#   University of Washington.
#   
#   This software is provided ``AS IS'' and any express or implied
#   warranties, including, but not limited to, the implied warranties of
#   merchantability and fitness for a particular purpose, are disclaimed.
#   In no event shall the authors or the University of Washington be
#   liable for any direct, indirect, incidental, special, exemplary, or
#   consequential damages (including, but not limited to, procurement of
#   substitute goods or services; loss of use, data, or profits; or
#   business interruption) however caused and on any theory of liability,
#   whether in contract, strict liability, or tort (including negligence
#   or otherwise) arising in any way out of the use of this software, even
#   if advised of the possibility of such damage.
#
#   Building Consed from source is error prone and not simple which is
#   why I provide executables.  Due to time limitations I cannot
#   provide any assistance in building Consed.  Even if you do not
#   modify the source, you may introduce errors due to using a
#   different version of the compiler, a different version of motif,
#   different versions of other libraries than I used, etc.  For this
#   reason, if you discover Consed bugs, I can only offer help with
#   those bugs if you first reproduce those bugs with an executable
#   provided by me--not an executable you have built.
# 
#   Modifying Consed is also difficult.  Although Consed is modular,
#   some modules are used by many other modules.  Thus making a change
#   in one place can have unforeseen effects on many other features.
#   It may takes months for you to notice these other side-effects
#   which may not seen connected at all.  It is not feasable for me to
#   provide help with modifying Consed sources because of the
#   potentially huge amount of time involved.
#
#*****************************************************************************/
#include    "guiEditResources.h"
#include    <Xm/ScrolledW.h>
#include    <Xm/Form.h>
#include    <Xm/RowColumn.h>
#include    <Xm/TextF.h>
#include    <Xm/Label.h>
#include    <Xm/Xm.h>
#include    <Xm/PushB.h>
#include    <Xm/ToggleB.h>
#include    "bIsNumericMaybeWithWhitespace.h"
#include    "popupErrorMessage.h"
#include    "bIsNumericDouble.h"
#include    "consedResources.h"
#include    "guiapp.h"
#include    "handleWindowManagerDelete2.h"
#include    "hp_exception_kludge.h"
#include    "consedParameters.h"
#include    "guiapp.h"
#include    "assert.h"
#include    <Xm/FileSB.h>
#include    "please_wait.h"
#include    "textbox.h"
#include    <Xm/Text.h>
#include    <unistd.h>
#include    "waitUntilDialogIsVisible.h"
#include    "popupInfoMessage.h"
#include    "guiTopWindow.h"
#include    <unistd.h>
#include    "defaultResources.h"



class helpCallbackInfo {
public:
   RWCString soResource_;
   guiEditResources* pGuiEditResources_;
};







#define makeWidgetTypeDouble( RESOURCE, PARAMETER_WITHOUT_PREFIX ) \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## Form = XtVaCreateManagedWidget( \
                   "form1", \
                   xmFormWidgetClass, \
                   widRowCol, \
                   XmNshadowThickness, 0, /* otherwise black line segments*/ \
                   NULL ); \
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## Label = XtVaCreateManagedWidget( \
                   #RESOURCE , \
                   xmLabelWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_FORM, \
                   XmNrightAttachment, XmATTACH_FORM, \
                   XmNtopAttachment, XmATTACH_FORM, \
                   XmNtopOffset, 20, \
                   XmNalignment, XmALIGNMENT_BEGINNING, \
                   NULL ); \
\
    getColors( resources_.d ## PARAMETER_WITHOUT_PREFIX ## _ , \
               CONDEF->d ## PARAMETER_WITHOUT_PREFIX ## _, \
               pixForeground,  \
               pixBackground  ); \
\
    wid ## PARAMETER_WITHOUT_PREFIX ## _ = XtVaCreateManagedWidget( \
                   #RESOURCE "Input", \
                   xmTextFieldWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_FORM,  \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                  XmNbottomAttachment, XmATTACH_FORM, \
                   XmNvalue, RWCString( resources_.d ## PARAMETER_WITHOUT_PREFIX ## _ ).data(), \
                   XmNforeground, pixForeground, \
                   XmNbackground, pixBackground, \
                   NULL ); \
\
    XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## _ , \
                   XmNlosingFocusCallback,  \
                   cb ## PARAMETER_WITHOUT_PREFIX , \
                   this ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## Default = XtVaCreateManagedWidget( \
                   #RESOURCE "Default", \
                   xmTextFieldWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 50, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNvalue, RWCString( CONDEF->d ## PARAMETER_WITHOUT_PREFIX ## _ ).data(), \
                   XmNeditable, False, \
                   XmNcursorPositionVisible, False, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton = XtVaCreateManagedWidget( \
                   "?", \
                   xmPushButtonWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 46, \
                   XmNrightPosition, 49, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
     \
     pHelp = new helpCallbackInfo();\
     pHelp->soResource_ = #RESOURCE ;\
     pHelp->pGuiEditResources_ = this;\
\
     XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton,\
                   XmNactivateCallback,\
                   cbUserPushedHelp,\
                   pHelp );\




// This will translate to this:
//    Widget widResourceForm = XtVaCreateManagedWidget(
//                   "form",
//                   xmFormWidgetClass,
//                   widRowCol,
//                   XmNshadowThickness, 0, // otherwise black line segments
//                   NULL );

//    Widget widLabel1 = XtVaCreateManagedWidget(
//                   "consed.autoFinishMinNumberOfErrorsFixedByAnExp",
//                   xmLabelWidgetClass,
//                   widResourceForm1,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNrightAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_FORM,
//                   XmNtopOffset, 20,
//                   XmNalignment, XmALIGNMENT_BEGINNING,
//                   NULL );

//    getColors( resources_.dAutoFinishMinNumberOfErrorsFixedByAnExp_,
//               CONDEF->dAutoFinishMinNumberOfErrorsFixedByAnExp_,
//               pixForeground, 
//               pixBackground  );

//    widAutoFinishMinNumberOfErrorsFixedByAnExp_ = XtVaCreateManagedWidget(
//                   "consed.autoFinishMinNumberOfErrorsFixedByAnExpInput",
//                   xmTextFieldWidgetClass,
//                   widResourceForm1,
//                   XmNleftAttachment, XmATTACH_FORM, 
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel1,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, RWCString( resources_dAutoFinishMinNumberOfErrorsFixedByAnExp_ ).data(),
//                   XmNforeground, pixForeground,
//                   XmNbackground, pixBackground,
//                   NULL );

//    XtAddCallback( widAutoFinishMinNumberOfErrorsFixedByAnExp_,
//                   XmNlosingFocusCallback, 
//                   cbAutoFinishMinNumberOfErrorsFixedByAnExp,
//                   this );


//    Widget widDefault1 = XtVaCreateManagedWidget(
//                   "consed.autoFinishMinNumberOfErrorsFixedByAnExpDefault",
//                   xmTextFieldWidgetClass,
//                   widResourceForm1,
//                   XmNleftAttachment, XmATTACH_POSITION,
//                   XmNleftPosition, 50,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel1,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, RWCString( consedResources::pDefaultResources_->dAutoFinishMinNumberOfErrorsFixedByAnExp_ ).data(),
//                   XmNeditable, False,
//                   XmNcursorPositionVisible, False,
//                   XmNtraversalOn, False,
//                   NULL );




#define makeWidgetTypeInt( RESOURCE, PARAMETER_WITHOUT_PREFIX ) \
 \
   getColors( resources_.n ## PARAMETER_WITHOUT_PREFIX ## _ ,  \
              CONDEF->n ## PARAMETER_WITHOUT_PREFIX ## _ ,  \
              pixForeground, \
              pixBackground ); \
 \
 \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Form = XtVaCreateManagedWidget( \
                  "form", \
                  xmFormWidgetClass, \
                  widRowCol, \
                  XmNshadowThickness, 0, /* otherwise black line segments*/  \
                  NULL ); \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Label = XtVaCreateManagedWidget( \
                  #RESOURCE , \
                  xmLabelWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_FORM, \
                  XmNtopOffset, 20, \
                  XmNalignment, XmALIGNMENT_BEGINNING, \
                  NULL ); \
 \
 \
   wid ## PARAMETER_WITHOUT_PREFIX ## _ = XtVaCreateManagedWidget( \
                  #RESOURCE "Input", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, RWCString( (long) resources_.n ## PARAMETER_WITHOUT_PREFIX ## _ ).data(), \
                  XmNforeground, pixForeground, \
                  XmNbackground, pixBackground, \
                  NULL ); \
 \
 \
   XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## _, \
                  XmNlosingFocusCallback, \
                  cb ## PARAMETER_WITHOUT_PREFIX, \
                  this ); \
 \
   Widget wid ## PARAMETER_WITHOUT_PREFIX ## Default = XtVaCreateManagedWidget( \
                  #RESOURCE "Default", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_POSITION, \
                  XmNleftPosition, 50, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, RWCString( (long) CONDEF->n ## PARAMETER_WITHOUT_PREFIX ## _ ).data(), \
                  XmNeditable, False, \
                  XmNcursorPositionVisible, False, \
                  XmNtraversalOn, False, \
                  NULL ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton = XtVaCreateManagedWidget( \
                   "?", \
                   xmPushButtonWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 46, \
                   XmNrightPosition, 49, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
\
     pHelp = new helpCallbackInfo(); \
     pHelp->soResource_ = #RESOURCE ; \
     pHelp->pGuiEditResources_ = this; \
\
     XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton, \
                   XmNactivateCallback, \
                   cbUserPushedHelp, \
                   pHelp ); \
   
  



// will convert to this:

   // consed.autoFinishAverageInsertSize
   // int

//    getColors( resources_.nAutoFinishAverageInsertSize_,
//               CONDEF->nAutoFinishAverageInsertSize_,
//               pixForeground,
//               pixBackground );


   
//    Widget widResourceForm2 = XtVaCreateManagedWidget(
//                   "form2",
//                   xmFormWidgetClass,
//                   widRowCol,
//                   XmNshadowThickness, 0, // otherwise black line segments
//                   NULL );

//    Widget widLabel2 = XtVaCreateManagedWidget(
//                   "consed.autoFinishAverageInsertSize",
//                   xmLabelWidgetClass,
//                   widResourceForm2,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNrightAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_FORM,
//                   XmNtopOffset, 20,
//                   XmNalignment, XmALIGNMENT_BEGINNING,
//                   NULL );


//    widAutoFinishAverageInsertSize_ = XtVaCreateManagedWidget(
//                   "consed.autoFinishAverageInsertSizeInput",
//                   xmTextFieldWidgetClass,
//                   widResourceForm2,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel2,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, RWCString( (long) resources_.nAutoFinishAverageInsertSize_ ).data(),
//                   XmNforeground, pixForeground,
//                   XmNbackground, pixBackground,
//                   NULL );


//    XtAddCallback( widAutoFinishAverageInsertSize_,
//                   XmNlosingFocusCallback,
//                   cbAutoFinishAverageInsertSize,
//                   this );

//    Widget widDefault2 = XtVaCreateManagedWidget(
//                   "consed.autoFinishAverageInsertSizeInputDefault",
//                   xmTextFieldWidgetClass,
//                   widResourceForm2,
//                   XmNleftAttachment, XmATTACH_POSITION,
//                   XmNleftPosition, 50,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel2,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, RWCString( (long) CONDEF->nAutoFinishAverageInsertSize_ ).data(),
//                   XmNeditable, False,
//                   XmNcursorPositionVisible, False,
//                   XmNtraversalOn, False,
//                   NULL );

   



   // consed.primersPickTemplatesForPrimers: true
   // bool

#define makeWidgetTypeBool( RESOURCE, PARAMETER_WITHOUT_PREFIX ) \
\
   getColors( resources_.b ## PARAMETER_WITHOUT_PREFIX ## _, \
              CONDEF->b  ## PARAMETER_WITHOUT_PREFIX ## _, \
              pixForeground, \
              pixBackground ); \
 \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Form = XtVaCreateManagedWidget( \
                  "form", \
                  xmFormWidgetClass, \
                  widRowCol, \
                  XmNshadowThickness, 0, /* otherwise black line segments */ \
                  NULL ); \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Label = XtVaCreateManagedWidget( \
                  #RESOURCE, \
                  xmLabelWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_FORM, \
                  XmNtopOffset, 20, \
                  XmNalignment, XmALIGNMENT_BEGINNING, \
                  NULL ); \
 \
   wid ##  PARAMETER_WITHOUT_PREFIX ## RadioBox_ = XmCreateRadioBox( \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  "radio", \
                  NULL, \
                  0 ); \
 \
   XtVaSetValues( wid ##  PARAMETER_WITHOUT_PREFIX ## RadioBox_, \
                  XmNtraversalOn, True, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNorientation, XmHORIZONTAL, \
                  XmNforeground, pixForeground, \
                  XmNbackground, pixBackground, \
                  NULL ); \
 \
   wid ##  PARAMETER_WITHOUT_PREFIX ## True_ = XtVaCreateManagedWidget( \
                  "True", \
                  xmToggleButtonWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## RadioBox_, \
                  XmNset, ( resources_.b ##  PARAMETER_WITHOUT_PREFIX ## _ ? True : False ), \
                  NULL ); \
 \
   XtAddCallback( wid ##  PARAMETER_WITHOUT_PREFIX ## True_, \
                  XmNvalueChangedCallback, \
                  cb ## PARAMETER_WITHOUT_PREFIX , \
                  this ); \
 \
 \
   Widget wid ## PARAMETER_WITHOUT_PREFIX ## FalseButton = XtVaCreateManagedWidget( \
                  "False", \
                  xmToggleButtonWidgetClass, \
                  wid ## PARAMETER_WITHOUT_PREFIX ## RadioBox_, \
                  XmNset, ( resources_.b ## PARAMETER_WITHOUT_PREFIX ## _ ? False : True ), \
                  NULL ); \
 \
   XtManageChild( wid ## PARAMETER_WITHOUT_PREFIX ## RadioBox_ ); \
 \
 \
   Widget wid ## PARAMETER_WITHOUT_PREFIX ## Default = XtVaCreateManagedWidget( \
                  #RESOURCE , \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_POSITION, \
                  XmNleftPosition, 50, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, ( CONDEF->b ## PARAMETER_WITHOUT_PREFIX ## _ ? "True" : "False" ), \
                  XmNeditable, False, \
                  XmNcursorPositionVisible, False, \
                  XmNtraversalOn, False, \
                  NULL ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton = XtVaCreateManagedWidget( \
                   "?", \
                   xmPushButtonWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 46, \
                   XmNrightPosition, 49, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
\
     pHelp = new helpCallbackInfo(); \
     pHelp->soResource_ = #RESOURCE ; \
     pHelp->pGuiEditResources_ = this; \
\
     XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton, \
                   XmNactivateCallback, \
                   cbUserPushedHelp, \
                   pHelp ); \



// this will translate to the following:

   // consed.primersPickTemplatesForPrimers: true
   // bool


//    getColors( resources_.bPrimersPickTemplatesForPrimers_,
//               CONDEF->bPrimersPickTemplatesForPrimers_,
//               pixForeground,
//               pixBackground );


//    Widget widResourceForm3 = XtVaCreateManagedWidget(
//                   "form3",
//                   xmFormWidgetClass,
//                   widRowCol,
//                   XmNshadowThickness, 0, // otherwise black line segments
//                   NULL );

//    Widget widLabel3 = XtVaCreateManagedWidget(
//                   "consed.primersPickTemplatesForPrimers",
//                   xmLabelWidgetClass,
//                   widResourceForm3,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNrightAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_FORM,
//                   XmNtopOffset, 20,
//                   XmNalignment, XmALIGNMENT_BEGINNING,
//                   NULL );

//    widPrimersPickTemplatesForPrimersRadioBox_ = XmCreateRadioBox(
//                   widResourceForm3,
//                   "radio",
//                   NULL,
//                   0 );

//    XtVaSetValues( widPrimersPickTemplatesForPrimersRadioBox_,
//                   XmNtraversalOn, True,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel3,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNorientation, XmHORIZONTAL,
//                   XmNforeground, pixForeground,
//                   XmNbackground, pixBackground,
//                   NULL );

//    widPrimersPickTemplatesForPrimersTrue_ = XtVaCreateManagedWidget(
//                   "True",
//                   xmToggleButtonWidgetClass,
//                   widPrimersPickTemplatesForPrimersRadioBox_,
//                   XmNset, ( resources_.bPrimersPickTemplatesForPrimers_ ? True : False ),
//                   NULL );

//    XtAddCallback( widPrimersPickTemplatesForPrimersTrue_,
//                   XmNvalueChangedCallback,
//                   cbPrimersPickTemplatesForPrimers,
//                   this );


//    widFalseButton = XtVaCreateManagedWidget(
//                   "False",
//                   xmToggleButtonWidgetClass,
//                   widPrimersPickTemplatesForPrimersRadioBox_,
//                   XmNset, ( consedResources::pCurrentResources_->bPrimersPickTemplatesForPrimers_ ? False : True ),
//                   NULL );

//    XtManageChild( widPrimersPickTemplatesForPrimersRadioBox_ );


//    Widget widDefault3 = XtVaCreateManagedWidget(
//                   "consed.primersPickTemplatesForPrimers",
//                   xmTextFieldWidgetClass,
//                   widResourceForm3,
//                   XmNleftAttachment, XmATTACH_POSITION,
//                   XmNleftPosition, 50,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel3,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, ( consedResources::pDefaultResources_->bPrimersPickTemplatesForPrimers_ ? "True" : "False" ),
//                   XmNeditable, False,
//                   XmNcursorPositionVisible, False,
//                   XmNtraversalOn, False,
//                   NULL );


#define makeWidgetTypeRWCString( RESOURCE, PARAMETER_WITHOUT_PREFIX ) \
\
   getColors( resources_.so ## PARAMETER_WITHOUT_PREFIX ## _, \
              CONDEF->so  ## PARAMETER_WITHOUT_PREFIX ## _, \
              pixForeground, \
              pixBackground ); \
 \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Form = XtVaCreateManagedWidget( \
                  "form", \
                  xmFormWidgetClass, \
                  widRowCol, \
                  XmNshadowThickness, 0, /* otherwise black line segments */ \
                  NULL ); \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Label = XtVaCreateManagedWidget( \
                  #RESOURCE, \
                  xmLabelWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_FORM, \
                  XmNtopOffset, 20, \
                  XmNalignment, XmALIGNMENT_BEGINNING, \
                  NULL ); \
 \
   wid ## PARAMETER_WITHOUT_PREFIX ## _ = \
      XtVaCreateManagedWidget( \
                  #RESOURCE "Input", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_POSITION, \
                  XmNrightPosition, 45, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, resources_.so ## PARAMETER_WITHOUT_PREFIX ## _.data(), \
                  XmNforeground, pixForeground, \
                  XmNbackground, pixBackground, \
                  NULL ); \
 \
 \
   XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## _, \
                  XmNlosingFocusCallback, \
                  cb ## PARAMETER_WITHOUT_PREFIX, \
                  this ); \
 \
 \
   Widget wid ## PARAMETER_WITHOUT_PREFIX ## Default = XtVaCreateManagedWidget( \
                  #RESOURCE "Default", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_POSITION, \
                  XmNleftPosition, 50, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNrightOffset, 10, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, CONDEF->so ## PARAMETER_WITHOUT_PREFIX ## _.data(), \
                  XmNeditable, False, \
                  XmNcursorPositionVisible, False, \
                  XmNtraversalOn, False, \
                  NULL ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton = XtVaCreateManagedWidget( \
                   "?", \
                   xmPushButtonWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 46, \
                   XmNrightPosition, 49, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
\
     pHelp = new helpCallbackInfo(); \
     pHelp->soResource_ = #RESOURCE ; \
     pHelp->pGuiEditResources_ = this; \
\
     XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton, \
                   XmNactivateCallback, \
                   cbUserPushedHelp, \
                   pHelp ); \




// this translates to this:




   // consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening
   // RWCString

//    getColors( resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
//               CONDEF->soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
//               pixForeground,
//               pixBackground );


//    Widget widResourceForm4 = XtVaCreateManagedWidget(
//                   "form4",
//                   xmFormWidgetClass,
//                   widRowCol,
//                   XmNshadowThickness, 0, // otherwise black line segments
//                   NULL );

//    Widget widLabel4 = XtVaCreateManagedWidget(
//                   "consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening",
//                   xmLabelWidgetClass,
//                   widResourceForm4,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNrightAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_FORM,
//                   XmNtopOffset, 20,
//                   XmNalignment, XmALIGNMENT_BEGINNING,
//                   NULL );

//    widPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_ =
//       XtVaCreateManagedWidget(
//                   "consed.primersSubcloneFullPathnameOfFileOfSequencesForScreeningInput",
//                   xmTextFieldWidgetClass,
//                   widResourceForm4,
//                   XmNleftAttachment, XmATTACH_FORM,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel4,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_.data(),
//                   XmNforeground, pixForeground,
//                   XmNbackground, pixBackground,
//                   NULL );


//    XtAddCallback( widPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
//                   XmNlosingFocusCallback,
//                   cbPrimersSubcloneFullPathnameOfFileOfSequencesForScreening,
//                   this );


//    Widget widDefault4 = XtVaCreateManagedWidget(
//                   "consed.primersSubcloneFullPathnameOfFileOfSequencesForScreeningDefault",
//                   xmTextFieldWidgetClass,
//                   widResourceForm4,
//                   XmNleftAttachment, XmATTACH_POSITION,
//                   XmNleftPosition, 50,
//                   XmNtopAttachment, XmATTACH_WIDGET,
//                   XmNtopWidget, widLabel4,
//                   XmNbottomAttachment, XmATTACH_FORM,
//                   XmNvalue, CONDEF->soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_.data(),
//                   XmNeditable, False,
//                   XmNcursorPositionVisible, False,
//                   XmNtraversalOn, False,
//                   NULL );


// consed.primersBadLibrariesFile: badLibraries.txt
// FileName

#define makeWidgetTypeFileName( RESOURCE, PARAMETER_WITHOUT_PREFIX ) \
\
   getColors( resources_.fil ## PARAMETER_WITHOUT_PREFIX ## _, \
              CONDEF->fil ## PARAMETER_WITHOUT_PREFIX ## _, \
              pixForeground, \
              pixBackground ); \
\
\
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Form = XtVaCreateManagedWidget( \
                  "form", \
                  xmFormWidgetClass, \
                  widRowCol, \
                  XmNshadowThickness, 0, /* otherwise black line segments */ \
                  NULL ); \
 \
   Widget wid ##  PARAMETER_WITHOUT_PREFIX ## Label = XtVaCreateManagedWidget( \
                  #RESOURCE, \
                  xmLabelWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNtopAttachment, XmATTACH_FORM, \
                  XmNtopOffset, 20, \
                  XmNalignment, XmALIGNMENT_BEGINNING, \
                  NULL ); \
 \
   wid ## PARAMETER_WITHOUT_PREFIX ## _ = \
      XtVaCreateManagedWidget( \
                  #RESOURCE "Input", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_FORM, \
                  XmNrightAttachment, XmATTACH_POSITION, \
                  XmNrightPosition, 45, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, resources_.fil ## PARAMETER_WITHOUT_PREFIX ## _.data(), \
                  XmNforeground, pixForeground, \
                  XmNbackground, pixBackground, \
                  NULL ); \
 \
 \
   XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## _, \
                  XmNlosingFocusCallback, \
                  cb ## PARAMETER_WITHOUT_PREFIX, \
                  this ); \
 \
 \
   Widget wid ## PARAMETER_WITHOUT_PREFIX ## Default = XtVaCreateManagedWidget( \
                  #RESOURCE "Default", \
                  xmTextFieldWidgetClass, \
                  wid ##  PARAMETER_WITHOUT_PREFIX ## Form, \
                  XmNleftAttachment, XmATTACH_POSITION, \
                  XmNleftPosition, 50, \
                  XmNrightAttachment, XmATTACH_FORM, \
                  XmNrightOffset, 10, \
                  XmNtopAttachment, XmATTACH_WIDGET, \
                  XmNtopWidget, wid ##  PARAMETER_WITHOUT_PREFIX ## Label, \
                  XmNbottomAttachment, XmATTACH_FORM, \
                  XmNvalue, CONDEF->fil ## PARAMETER_WITHOUT_PREFIX ## _.data(), \
                  XmNeditable, False, \
                  XmNcursorPositionVisible, False, \
                  XmNtraversalOn, False, \
                  NULL ); \
\
\
    Widget wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton = XtVaCreateManagedWidget( \
                   "?", \
                   xmPushButtonWidgetClass, \
                   wid ## PARAMETER_WITHOUT_PREFIX ## Form, \
                   XmNleftAttachment, XmATTACH_POSITION, \
                   XmNleftPosition, 46, \
                   XmNrightPosition, 49, \
                   XmNtopAttachment, XmATTACH_WIDGET, \
                   XmNtopWidget, wid ## PARAMETER_WITHOUT_PREFIX ## Label , \
                   XmNbottomAttachment, XmATTACH_FORM, \
                   XmNtraversalOn, False, \
                   NULL ); \
\
\
     pHelp = new helpCallbackInfo(); \
     pHelp->soResource_ = #RESOURCE ; \
     pHelp->pGuiEditResources_ = this; \
\
     XtAddCallback( wid ## PARAMETER_WITHOUT_PREFIX ## HelpButton, \
                   XmNactivateCallback, \
                   cbUserPushedHelp, \
                   pHelp ); \



static void cbUserPushedHelp( Widget wid,
                              XtPointer pClientData,
                              XtPointer pCallData ) {
   
   helpCallbackInfo* pHelp = (helpCallbackInfo*) pClientData;

   TRY_CATCH_WRAPPER(
   pHelp->pGuiEditResources_->userPushedHelp( pHelp->soResource_ );
                     );
}





static void cbResize( Widget wid,
                      XtPointer pClientData,
                      XtPointer pCallData ) {
   
   guiEditResources* pGuiEditResources = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGuiEditResources->userResizedWindow() );
}





static void cbFindFirstButton( Widget wid,
                               XtPointer pClientData,
                               XtPointer pCallData ) {
   guiEditResources* pGuiEditResources = (guiEditResources*) pClientData;

   TRY_CATCH_WRAPPER( pGuiEditResources->userPushedFindButton( true ) );
}



static void cbFindNextButton( Widget wid,
                              XtPointer pClientData,
                              XtPointer pCallData ) {

   guiEditResources* pGuiEditResources = (guiEditResources*) pClientData;

   TRY_CATCH_WRAPPER( pGuiEditResources->userPushedFindButton( false ) );
}



    
static void cbCancelButton( Widget wid,
                            XtPointer pClientData,
                            XtPointer pCallData ) {

   guiEditResources* pGuiEditResources = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( delete pGuiEditResources );
}

static void cbUserPushedSaveButton( Widget wid,
                                  XtPointer pClientData,
                                  XtPointer pCallData ) {

   guiEditResources* pGuiEditResources = (guiEditResources*) pClientData;
   pGuiEditResources->userPushedSave();
}



static void cbFileSelectionOK( Widget wid,
                               XtPointer pClientData,
                               XtPointer pCallData ) {

   guiEditResources* pGER = (guiEditResources*) pClientData;

   TRY_CATCH_WRAPPER( pGER->userChoseFileAndPushedOK( 
                          wid,
                          (XmFileSelectionBoxCallbackStruct*)  pCallData ) );
}


static void cbFileSelectionCancel( Widget wid,
                                   XtPointer pClientData,
                                   XtPointer pCallData ) {

   XtUnmanageChild( wid );
   XtDestroyWidget( wid );
}

static void cbPrintPS( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrintPS() );
}
void guiEditResources :: checkPrintPS() {



   bool b =
      XmToggleButtonGetState( widPrintPSTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrintPS_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrintPS_,
              CONDEF->bPrintPS_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrintPSRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDefaultTagType( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDefaultTagType() );
}
void guiEditResources :: checkDefaultTagType() {



   char* szValue =
   XmTextFieldGetString( widDefaultTagType_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soDefaultTagType_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soDefaultTagType_,
              CONDEF->soDefaultTagType_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDefaultTagType_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDefaultTagOnConsensusNotReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDefaultTagOnConsensusNotReads() );
}
void guiEditResources :: checkDefaultTagOnConsensusNotReads() {



   bool b =
      XmToggleButtonGetState( widDefaultTagOnConsensusNotReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bDefaultTagOnConsensusNotReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bDefaultTagOnConsensusNotReads_,
              CONDEF->bDefaultTagOnConsensusNotReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDefaultTagOnConsensusNotReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinNumberOfErrorsFixedByAnExp( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinNumberOfErrorsFixedByAnExp() );
}
void guiEditResources :: checkAutoFinishMinNumberOfErrorsFixedByAnExp() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinNumberOfErrorsFixedByAnExp_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishMinNumberOfErrorsFixedByAnExp must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishMinNumberOfErrorsFixedByAnExp_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishMinNumberOfErrorsFixedByAnExp_,
               CONDEF->dAutoFinishMinNumberOfErrorsFixedByAnExp_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinNumberOfErrorsFixedByAnExp_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishRedundancy( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishRedundancy() );
}
void guiEditResources :: checkAutoFinishRedundancy() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishRedundancy_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishRedundancy must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishRedundancy_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishRedundancy_,
               CONDEF->dAutoFinishRedundancy_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishRedundancy_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAverageInsertSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAverageInsertSize() );
}
void guiEditResources :: checkAutoFinishAverageInsertSize() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishAverageInsertSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishAverageInsertSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishAverageInsertSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishAverageInsertSize_,
              CONDEF->nAutoFinishAverageInsertSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAverageInsertSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxInsertSizeOfASubclone( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxInsertSizeOfASubclone() );
}
void guiEditResources :: checkPrimersMaxInsertSizeOfASubclone() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxInsertSizeOfASubclone_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxInsertSizeOfASubclone must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxInsertSizeOfASubclone_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxInsertSizeOfASubclone_,
              CONDEF->nPrimersMaxInsertSizeOfASubclone_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxInsertSizeOfASubclone_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxMeltingTemp( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxMeltingTemp() );
}
void guiEditResources :: checkPrimersMaxMeltingTemp() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxMeltingTemp_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxMeltingTemp must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxMeltingTemp_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxMeltingTemp_,
              CONDEF->nPrimersMaxMeltingTemp_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxMeltingTemp_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxMeltingTempForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxMeltingTempForPCR() );
}
void guiEditResources :: checkPrimersMaxMeltingTempForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxMeltingTempForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxMeltingTempForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxMeltingTempForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxMeltingTempForPCR_,
              CONDEF->nPrimersMaxMeltingTempForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxMeltingTempForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersPickTemplatesForPrimers( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersPickTemplatesForPrimers() );
}
void guiEditResources :: checkPrimersPickTemplatesForPrimers() {



   bool b =
      XmToggleButtonGetState( widPrimersPickTemplatesForPrimersTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersPickTemplatesForPrimers_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersPickTemplatesForPrimers_,
              CONDEF->bPrimersPickTemplatesForPrimers_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersPickTemplatesForPrimersRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersSubcloneFullPathnameOfFileOfSequencesForScreening( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersSubcloneFullPathnameOfFileOfSequencesForScreening() );
}
void guiEditResources :: checkPrimersSubcloneFullPathnameOfFileOfSequencesForScreening() {



   char* szValue =
   XmTextFieldGetString( widPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
              CONDEF->soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersCloneFullPathnameOfFileOfSequencesForScreening( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersCloneFullPathnameOfFileOfSequencesForScreening() );
}
void guiEditResources :: checkPrimersCloneFullPathnameOfFileOfSequencesForScreening() {



   char* szValue =
   XmTextFieldGetString( widPrimersCloneFullPathnameOfFileOfSequencesForScreening_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPrimersCloneFullPathnameOfFileOfSequencesForScreening_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPrimersCloneFullPathnameOfFileOfSequencesForScreening_,
              CONDEF->soPrimersCloneFullPathnameOfFileOfSequencesForScreening_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersCloneFullPathnameOfFileOfSequencesForScreening_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinMeltingTemp( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinMeltingTemp() );
}
void guiEditResources :: checkPrimersMinMeltingTemp() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinMeltingTemp_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinMeltingTemp must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinMeltingTemp_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinMeltingTemp_,
              CONDEF->nPrimersMinMeltingTemp_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinMeltingTemp_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinMeltingTempForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinMeltingTempForPCR() );
}
void guiEditResources :: checkPrimersMinMeltingTempForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinMeltingTempForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinMeltingTempForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinMeltingTempForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinMeltingTempForPCR_,
              CONDEF->nPrimersMinMeltingTempForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinMeltingTempForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSearchFunctionsUseUnalignedEndsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSearchFunctionsUseUnalignedEndsOfReads() );
}
void guiEditResources :: checkSearchFunctionsUseUnalignedEndsOfReads() {



   bool b =
      XmToggleButtonGetState( widSearchFunctionsUseUnalignedEndsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bSearchFunctionsUseUnalignedEndsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bSearchFunctionsUseUnalignedEndsOfReads_,
              CONDEF->bSearchFunctionsUseUnalignedEndsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSearchFunctionsUseUnalignedEndsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSearchFunctionsUseLowQualityEndsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSearchFunctionsUseLowQualityEndsOfReads() );
}
void guiEditResources :: checkSearchFunctionsUseLowQualityEndsOfReads() {



   bool b =
      XmToggleButtonGetState( widSearchFunctionsUseLowQualityEndsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bSearchFunctionsUseLowQualityEndsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bSearchFunctionsUseLowQualityEndsOfReads_,
              CONDEF->bSearchFunctionsUseLowQualityEndsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSearchFunctionsUseLowQualityEndsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbInexactSearchForStringMaxPerCentMismatch( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkInexactSearchForStringMaxPerCentMismatch() );
}
void guiEditResources :: checkInexactSearchForStringMaxPerCentMismatch() {



   char* szValue =
   XmTextFieldGetString( widInexactSearchForStringMaxPerCentMismatch_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.InexactSearchForStringMaxPerCentMismatch must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nInexactSearchForStringMaxPerCentMismatch_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nInexactSearchForStringMaxPerCentMismatch_,
              CONDEF->nInexactSearchForStringMaxPerCentMismatch_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widInexactSearchForStringMaxPerCentMismatch_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbOnlyAllowOneReadWriteConsedAtATime( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkOnlyAllowOneReadWriteConsedAtATime() );
}
void guiEditResources :: checkOnlyAllowOneReadWriteConsedAtATime() {



   bool b =
      XmToggleButtonGetState( widOnlyAllowOneReadWriteConsedAtATimeTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bOnlyAllowOneReadWriteConsedAtATime_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bOnlyAllowOneReadWriteConsedAtATime_,
              CONDEF->bOnlyAllowOneReadWriteConsedAtATime_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widOnlyAllowOneReadWriteConsedAtATimeRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair() );
}
void guiEditResources :: checkAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePairTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_,
              CONDEF->bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePairRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrintWindowCommand( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrintWindowCommand() );
}
void guiEditResources :: checkPrintWindowCommand() {



   char* szValue =
   XmTextFieldGetString( widPrintWindowCommand_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPrintWindowCommand_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPrintWindowCommand_,
              CONDEF->soPrintWindowCommand_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrintWindowCommand_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFileOfTagTypes( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFileOfTagTypes() );
}
void guiEditResources :: checkFileOfTagTypes() {



   char* szValue =
   XmTextFieldGetString( widFileOfTagTypes_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFileOfTagTypes_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFileOfTagTypes_,
              CONDEF->filFileOfTagTypes_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFileOfTagTypes_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowConsistentFwdRevPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowConsistentFwdRevPairs() );
}
void guiEditResources :: checkAssemblyViewShowConsistentFwdRevPairs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowConsistentFwdRevPairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowConsistentFwdRevPairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowConsistentFwdRevPairs_,
              CONDEF->bAssemblyViewShowConsistentFwdRevPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowConsistentFwdRevPairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowConsistentFwdRevPairDepth( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowConsistentFwdRevPairDepth() );
}
void guiEditResources :: checkAssemblyViewShowConsistentFwdRevPairDepth() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowConsistentFwdRevPairDepthTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowConsistentFwdRevPairDepth_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowConsistentFwdRevPairDepth_,
              CONDEF->bAssemblyViewShowConsistentFwdRevPairDepth_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowConsistentFwdRevPairDepthRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds() );
}
void guiEditResources :: checkAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffoldsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_,
              CONDEF->bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffoldsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs() );
}
void guiEditResources :: checkAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_,
              CONDEF->bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowGapSpanningFwdRevPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowGapSpanningFwdRevPairs() );
}
void guiEditResources :: checkAssemblyViewShowGapSpanningFwdRevPairs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowGapSpanningFwdRevPairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowGapSpanningFwdRevPairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowGapSpanningFwdRevPairs_,
              CONDEF->bAssemblyViewShowGapSpanningFwdRevPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowGapSpanningFwdRevPairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowWhichInconsistentFwdRevPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowWhichInconsistentFwdRevPairs() );
}
void guiEditResources :: checkAssemblyViewShowWhichInconsistentFwdRevPairs() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewShowWhichInconsistentFwdRevPairs_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAssemblyViewShowWhichInconsistentFwdRevPairs_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAssemblyViewShowWhichInconsistentFwdRevPairs_,
              CONDEF->soAssemblyViewShowWhichInconsistentFwdRevPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowWhichInconsistentFwdRevPairs_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowReadDepth( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowReadDepth() );
}
void guiEditResources :: checkAssemblyViewShowReadDepth() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowReadDepthTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowReadDepth_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowReadDepth_,
              CONDEF->bAssemblyViewShowReadDepth_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowReadDepthRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowMultipleHighQualityDiscrepancies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowMultipleHighQualityDiscrepancies() );
}
void guiEditResources :: checkAssemblyViewShowMultipleHighQualityDiscrepancies() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowMultipleHighQualityDiscrepanciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowMultipleHighQualityDiscrepancies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowMultipleHighQualityDiscrepancies_,
              CONDEF->bAssemblyViewShowMultipleHighQualityDiscrepancies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowMultipleHighQualityDiscrepanciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowRestrictionDigestCutSites( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowRestrictionDigestCutSites() );
}
void guiEditResources :: checkAssemblyViewShowRestrictionDigestCutSites() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowRestrictionDigestCutSitesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowRestrictionDigestCutSites_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowRestrictionDigestCutSites_,
              CONDEF->bAssemblyViewShowRestrictionDigestCutSites_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowRestrictionDigestCutSitesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewFilterSequenceMatchesBySize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewFilterSequenceMatchesBySize() );
}
void guiEditResources :: checkAssemblyViewFilterSequenceMatchesBySize() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewFilterSequenceMatchesBySizeTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewFilterSequenceMatchesBySize_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewFilterSequenceMatchesBySize_,
              CONDEF->bAssemblyViewFilterSequenceMatchesBySize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewFilterSequenceMatchesBySizeRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewSequenceMatchesMinSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewSequenceMatchesMinSize() );
}
void guiEditResources :: checkAssemblyViewSequenceMatchesMinSize() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewSequenceMatchesMinSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewSequenceMatchesMinSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewSequenceMatchesMinSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewSequenceMatchesMinSize_,
              CONDEF->nAssemblyViewSequenceMatchesMinSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewSequenceMatchesMinSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewSequenceMatchesMaxSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewSequenceMatchesMaxSize() );
}
void guiEditResources :: checkAssemblyViewSequenceMatchesMaxSize() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewSequenceMatchesMaxSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewSequenceMatchesMaxSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewSequenceMatchesMaxSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewSequenceMatchesMaxSize_,
              CONDEF->nAssemblyViewSequenceMatchesMaxSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewSequenceMatchesMaxSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewAutomaticallyStartWithConsed( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewAutomaticallyStartWithConsed() );
}
void guiEditResources :: checkAssemblyViewAutomaticallyStartWithConsed() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewAutomaticallyStartWithConsedTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewAutomaticallyStartWithConsed_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewAutomaticallyStartWithConsed_,
              CONDEF->bAssemblyViewAutomaticallyStartWithConsed_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewAutomaticallyStartWithConsedRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewDisplayTheseTagTypesOnTheseLines( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewDisplayTheseTagTypesOnTheseLines() );
}
void guiEditResources :: checkAssemblyViewDisplayTheseTagTypesOnTheseLines() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewDisplayTheseTagTypesOnTheseLines_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAssemblyViewDisplayTheseTagTypesOnTheseLines_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAssemblyViewDisplayTheseTagTypesOnTheseLines_,
              CONDEF->soAssemblyViewDisplayTheseTagTypesOnTheseLines_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewDisplayTheseTagTypesOnTheseLines_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowTags( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowTags() );
}
void guiEditResources :: checkAssemblyViewShowTags() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowTagsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowTags_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowTags_,
              CONDEF->bAssemblyViewShowTags_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowTagsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditRecalculateHighQualitySegmentsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditRecalculateHighQualitySegmentsOfReads() );
}
void guiEditResources :: checkAutoEditRecalculateHighQualitySegmentsOfReads() {



   bool b =
      XmToggleButtonGetState( widAutoEditRecalculateHighQualitySegmentsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditRecalculateHighQualitySegmentsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditRecalculateHighQualitySegmentsOfReads_,
              CONDEF->bAutoEditRecalculateHighQualitySegmentsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditRecalculateHighQualitySegmentsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditConvertCloneEndBasesToXs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditConvertCloneEndBasesToXs() );
}
void guiEditResources :: checkAutoEditConvertCloneEndBasesToXs() {



   bool b =
      XmToggleButtonGetState( widAutoEditConvertCloneEndBasesToXsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditConvertCloneEndBasesToXs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditConvertCloneEndBasesToXs_,
              CONDEF->bAutoEditConvertCloneEndBasesToXs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditConvertCloneEndBasesToXsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads() );
}
void guiEditResources :: checkAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads() {



   bool b =
      XmToggleButtonGetState( widAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_,
              CONDEF->bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditTagEditableLowConsensusQualityRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditTagEditableLowConsensusQualityRegions() );
}
void guiEditResources :: checkAutoEditTagEditableLowConsensusQualityRegions() {



   bool b =
      XmToggleButtonGetState( widAutoEditTagEditableLowConsensusQualityRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditTagEditableLowConsensusQualityRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditTagEditableLowConsensusQualityRegions_,
              CONDEF->bAutoEditTagEditableLowConsensusQualityRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditTagEditableLowConsensusQualityRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMakeFakeRead( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMakeFakeRead() );
}
void guiEditResources :: checkAutoEditMakeFakeRead() {



   bool b =
      XmToggleButtonGetState( widAutoEditMakeFakeReadTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditMakeFakeRead_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditMakeFakeRead_,
              CONDEF->bAutoEditMakeFakeRead_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMakeFakeReadRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMakeFakeReadFromRead1( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMakeFakeReadFromRead1() );
}
void guiEditResources :: checkAutoEditMakeFakeReadFromRead1() {



   char* szValue =
   XmTextFieldGetString( widAutoEditMakeFakeReadFromRead1_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoEditMakeFakeReadFromRead1_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoEditMakeFakeReadFromRead1_,
              CONDEF->soAutoEditMakeFakeReadFromRead1_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMakeFakeReadFromRead1_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMakeFakeReadFromRead2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMakeFakeReadFromRead2() );
}
void guiEditResources :: checkAutoEditMakeFakeReadFromRead2() {



   char* szValue =
   XmTextFieldGetString( widAutoEditMakeFakeReadFromRead2_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoEditMakeFakeReadFromRead2_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoEditMakeFakeReadFromRead2_,
              CONDEF->soAutoEditMakeFakeReadFromRead2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMakeFakeReadFromRead2_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMakeFakeReadName( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMakeFakeReadName() );
}
void guiEditResources :: checkAutoEditMakeFakeReadName() {



   char* szValue =
   XmTextFieldGetString( widAutoEditMakeFakeReadName_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoEditMakeFakeReadName_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoEditMakeFakeReadName_,
              CONDEF->soAutoEditMakeFakeReadName_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMakeFakeReadName_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMakeFakeReadFastaFilename( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMakeFakeReadFastaFilename() );
}
void guiEditResources :: checkAutoEditMakeFakeReadFastaFilename() {



   char* szValue =
   XmTextFieldGetString( widAutoEditMakeFakeReadFastaFilename_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoEditMakeFakeReadFastaFilename_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoEditMakeFakeReadFastaFilename_,
              CONDEF->filAutoEditMakeFakeReadFastaFilename_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMakeFakeReadFastaFilename_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditMergeAssembly( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditMergeAssembly() );
}
void guiEditResources :: checkAutoEditMergeAssembly() {



   bool b =
      XmToggleButtonGetState( widAutoEditMergeAssemblyTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditMergeAssembly_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditMergeAssembly_,
              CONDEF->bAutoEditMergeAssembly_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditMergeAssemblyRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditSecondaryAceFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditSecondaryAceFile() );
}
void guiEditResources :: checkAutoEditSecondaryAceFile() {



   char* szValue =
   XmTextFieldGetString( widAutoEditSecondaryAceFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoEditSecondaryAceFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoEditSecondaryAceFile_,
              CONDEF->filAutoEditSecondaryAceFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditSecondaryAceFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoEditFixRunsInConsensus( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoEditFixRunsInConsensus() );
}
void guiEditResources :: checkAutoEditFixRunsInConsensus() {



   bool b =
      XmToggleButtonGetState( widAutoEditFixRunsInConsensusTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoEditFixRunsInConsensus_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoEditFixRunsInConsensus_,
              CONDEF->bAutoEditFixRunsInConsensus_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoEditFixRunsInConsensusRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowAllTracesJustShowGoodTraces( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowAllTracesJustShowGoodTraces() );
}
void guiEditResources :: checkShowAllTracesJustShowGoodTraces() {



   bool b =
      XmToggleButtonGetState( widShowAllTracesJustShowGoodTracesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bShowAllTracesJustShowGoodTraces_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bShowAllTracesJustShowGoodTraces_,
              CONDEF->bShowAllTracesJustShowGoodTraces_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowAllTracesJustShowGoodTracesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAddAlignedSequenceQualityOfBases( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAddAlignedSequenceQualityOfBases() );
}
void guiEditResources :: checkAddAlignedSequenceQualityOfBases() {



   char* szValue =
   XmTextFieldGetString( widAddAlignedSequenceQualityOfBases_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AddAlignedSequenceQualityOfBases must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAddAlignedSequenceQualityOfBases_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAddAlignedSequenceQualityOfBases_,
              CONDEF->nAddAlignedSequenceQualityOfBases_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAddAlignedSequenceQualityOfBases_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMakeLightBackgroundInAlignedReadsWindowAndTracesWindow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMakeLightBackgroundInAlignedReadsWindowAndTracesWindow() );
}
void guiEditResources :: checkMakeLightBackgroundInAlignedReadsWindowAndTracesWindow() {



   bool b =
      XmToggleButtonGetState( widMakeLightBackgroundInAlignedReadsWindowAndTracesWindowTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_,
              CONDEF->bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMakeLightBackgroundInAlignedReadsWindowAndTracesWindowRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPutVerticalLineAtCursor( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPutVerticalLineAtCursor() );
}
void guiEditResources :: checkPutVerticalLineAtCursor() {



   bool b =
      XmToggleButtonGetState( widPutVerticalLineAtCursorTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPutVerticalLineAtCursor_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPutVerticalLineAtCursor_,
              CONDEF->bPutVerticalLineAtCursor_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPutVerticalLineAtCursorRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPutHorizontalLineAtCursor( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPutHorizontalLineAtCursor() );
}
void guiEditResources :: checkPutHorizontalLineAtCursor() {



   bool b =
      XmToggleButtonGetState( widPutHorizontalLineAtCursorTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPutHorizontalLineAtCursor_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPutHorizontalLineAtCursor_,
              CONDEF->bPutHorizontalLineAtCursor_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPutHorizontalLineAtCursorRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbHighlightedReadsFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkHighlightedReadsFile() );
}
void guiEditResources :: checkHighlightedReadsFile() {



   char* szValue =
   XmTextFieldGetString( widHighlightedReadsFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filHighlightedReadsFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filHighlightedReadsFile_,
              CONDEF->filHighlightedReadsFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widHighlightedReadsFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadNamesInRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadNamesInRegion() );
}
void guiEditResources :: checkAutoReportPrintReadNamesInRegion() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintReadNamesInRegionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintReadNamesInRegion_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintReadNamesInRegion_,
              CONDEF->bAutoReportPrintReadNamesInRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadNamesInRegionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadNamesInRegionContig( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadNamesInRegionContig() );
}
void guiEditResources :: checkAutoReportPrintReadNamesInRegionContig() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrintReadNamesInRegionContig_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportPrintReadNamesInRegionContig_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportPrintReadNamesInRegionContig_,
              CONDEF->soAutoReportPrintReadNamesInRegionContig_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadNamesInRegionContig_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadNamesInRegionLeftPos( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadNamesInRegionLeftPos() );
}
void guiEditResources :: checkAutoReportPrintReadNamesInRegionLeftPos() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrintReadNamesInRegionLeftPos_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportPrintReadNamesInRegionLeftPos must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportPrintReadNamesInRegionLeftPos_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportPrintReadNamesInRegionLeftPos_,
              CONDEF->nAutoReportPrintReadNamesInRegionLeftPos_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadNamesInRegionLeftPos_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadNamesInRegionRightPos( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadNamesInRegionRightPos() );
}
void guiEditResources :: checkAutoReportPrintReadNamesInRegionRightPos() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrintReadNamesInRegionRightPos_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportPrintReadNamesInRegionRightPos must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportPrintReadNamesInRegionRightPos_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportPrintReadNamesInRegionRightPos_,
              CONDEF->nAutoReportPrintReadNamesInRegionRightPos_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadNamesInRegionRightPos_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintHighlyDiscrepantRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintHighlyDiscrepantRegions() );
}
void guiEditResources :: checkAutoReportPrintHighlyDiscrepantRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintHighlyDiscrepantRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintHighlyDiscrepantRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintHighlyDiscrepantRegions_,
              CONDEF->bAutoReportPrintHighlyDiscrepantRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintHighlyDiscrepantRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintScaffolds( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintScaffolds() );
}
void guiEditResources :: checkAutoReportPrintScaffolds() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintScaffoldsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintScaffolds_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintScaffolds_,
              CONDEF->bAutoReportPrintScaffolds_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintScaffoldsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNumberUnpaddedConsensusAtUserDefined( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNumberUnpaddedConsensusAtUserDefined() );
}
void guiEditResources :: checkNumberUnpaddedConsensusAtUserDefined() {



   bool b =
      XmToggleButtonGetState( widNumberUnpaddedConsensusAtUserDefinedTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNumberUnpaddedConsensusAtUserDefined_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNumberUnpaddedConsensusAtUserDefined_,
              CONDEF->bNumberUnpaddedConsensusAtUserDefined_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNumberUnpaddedConsensusAtUserDefinedRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintHighQualityDiscrepancies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintHighQualityDiscrepancies() );
}
void guiEditResources :: checkAutoReportPrintHighQualityDiscrepancies() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintHighQualityDiscrepanciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintHighQualityDiscrepancies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintHighQualityDiscrepancies_,
              CONDEF->bAutoReportPrintHighQualityDiscrepancies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintHighQualityDiscrepanciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags() );
}
void guiEditResources :: checkAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags() {



   bool b =
      XmToggleButtonGetState( widAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTagsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_,
              CONDEF->bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTagsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportHighQualityDiscrepanciesExcludeMostPads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportHighQualityDiscrepanciesExcludeMostPads() );
}
void guiEditResources :: checkAutoReportHighQualityDiscrepanciesExcludeMostPads() {



   bool b =
      XmToggleButtonGetState( widAutoReportHighQualityDiscrepanciesExcludeMostPadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportHighQualityDiscrepanciesExcludeMostPads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportHighQualityDiscrepanciesExcludeMostPads_,
              CONDEF->bAutoReportHighQualityDiscrepanciesExcludeMostPads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportHighQualityDiscrepanciesExcludeMostPadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintLowConsensusQualityRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintLowConsensusQualityRegions() );
}
void guiEditResources :: checkAutoReportPrintLowConsensusQualityRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintLowConsensusQualityRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintLowConsensusQualityRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintLowConsensusQualityRegions_,
              CONDEF->bAutoReportPrintLowConsensusQualityRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintLowConsensusQualityRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintSingleSubcloneRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintSingleSubcloneRegions() );
}
void guiEditResources :: checkAutoReportPrintSingleSubcloneRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintSingleSubcloneRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintSingleSubcloneRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintSingleSubcloneRegions_,
              CONDEF->bAutoReportPrintSingleSubcloneRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintSingleSubcloneRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintSingleStrandedRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintSingleStrandedRegions() );
}
void guiEditResources :: checkAutoReportPrintSingleStrandedRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintSingleStrandedRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintSingleStrandedRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintSingleStrandedRegions_,
              CONDEF->bAutoReportPrintSingleStrandedRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintSingleStrandedRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintLinkingForwardReversePairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintLinkingForwardReversePairs() );
}
void guiEditResources :: checkAutoReportPrintLinkingForwardReversePairs() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintLinkingForwardReversePairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintLinkingForwardReversePairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintLinkingForwardReversePairs_,
              CONDEF->bAutoReportPrintLinkingForwardReversePairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintLinkingForwardReversePairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintFilteredInconsistentForwardReversePairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintFilteredInconsistentForwardReversePairs() );
}
void guiEditResources :: checkAutoReportPrintFilteredInconsistentForwardReversePairs() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintFilteredInconsistentForwardReversePairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintFilteredInconsistentForwardReversePairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintFilteredInconsistentForwardReversePairs_,
              CONDEF->bAutoReportPrintFilteredInconsistentForwardReversePairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintFilteredInconsistentForwardReversePairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintAssemblySummary( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintAssemblySummary() );
}
void guiEditResources :: checkAutoReportPrintAssemblySummary() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintAssemblySummaryTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintAssemblySummary_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintAssemblySummary_,
              CONDEF->bAutoReportPrintAssemblySummary_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintAssemblySummaryRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowAllTracesDoNotShowTraceIfTheseTagsPresent( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowAllTracesDoNotShowTraceIfTheseTagsPresent() );
}
void guiEditResources :: checkShowAllTracesDoNotShowTraceIfTheseTagsPresent() {



   char* szValue =
   XmTextFieldGetString( widShowAllTracesDoNotShowTraceIfTheseTagsPresent_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soShowAllTracesDoNotShowTraceIfTheseTagsPresent_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soShowAllTracesDoNotShowTraceIfTheseTagsPresent_,
              CONDEF->soShowAllTracesDoNotShowTraceIfTheseTagsPresent_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowAllTracesDoNotShowTraceIfTheseTagsPresent_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNameOfFakeJoiningReadsIncludesAceFileName( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNameOfFakeJoiningReadsIncludesAceFileName() );
}
void guiEditResources :: checkNameOfFakeJoiningReadsIncludesAceFileName() {



   bool b =
      XmToggleButtonGetState( widNameOfFakeJoiningReadsIncludesAceFileNameTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNameOfFakeJoiningReadsIncludesAceFileName_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNameOfFakeJoiningReadsIncludesAceFileName_,
              CONDEF->bNameOfFakeJoiningReadsIncludesAceFileName_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNameOfFakeJoiningReadsIncludesAceFileNameRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWhenUserScrollsOffWindowMillisecondsBetweenScrolling( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWhenUserScrollsOffWindowMillisecondsBetweenScrolling() );
}
void guiEditResources :: checkWhenUserScrollsOffWindowMillisecondsBetweenScrolling() {



   char* szValue =
   XmTextFieldGetString( widWhenUserScrollsOffWindowMillisecondsBetweenScrolling_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.WhenUserScrollsOffWindowMillisecondsBetweenScrolling must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_,
              CONDEF->nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWhenUserScrollsOffWindowMillisecondsBetweenScrolling_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWhenUserScrollsOffWindowBasesToScrollEachTime( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWhenUserScrollsOffWindowBasesToScrollEachTime() );
}
void guiEditResources :: checkWhenUserScrollsOffWindowBasesToScrollEachTime() {



   char* szValue =
   XmTextFieldGetString( widWhenUserScrollsOffWindowBasesToScrollEachTime_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.WhenUserScrollsOffWindowBasesToScrollEachTime must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nWhenUserScrollsOffWindowBasesToScrollEachTime_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nWhenUserScrollsOffWindowBasesToScrollEachTime_,
              CONDEF->nWhenUserScrollsOffWindowBasesToScrollEachTime_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWhenUserScrollsOffWindowBasesToScrollEachTime_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCompareContigsUseBandedRatherThanFullSmithWaterman( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCompareContigsUseBandedRatherThanFullSmithWaterman() );
}
void guiEditResources :: checkCompareContigsUseBandedRatherThanFullSmithWaterman() {



   bool b =
      XmToggleButtonGetState( widCompareContigsUseBandedRatherThanFullSmithWatermanTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bCompareContigsUseBandedRatherThanFullSmithWaterman_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bCompareContigsUseBandedRatherThanFullSmithWaterman_,
              CONDEF->bCompareContigsUseBandedRatherThanFullSmithWaterman_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCompareContigsUseBandedRatherThanFullSmithWatermanRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCompareContigsBandSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCompareContigsBandSize() );
}
void guiEditResources :: checkCompareContigsBandSize() {



   char* szValue =
   XmTextFieldGetString( widCompareContigsBandSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.CompareContigsBandSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nCompareContigsBandSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nCompareContigsBandSize_,
              CONDEF->nCompareContigsBandSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCompareContigsBandSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany() );
}
void guiEditResources :: checkAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_,
              CONDEF->nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewShowSequenceMatches( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewShowSequenceMatches() );
}
void guiEditResources :: checkAssemblyViewShowSequenceMatches() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewShowSequenceMatchesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewShowSequenceMatches_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewShowSequenceMatches_,
              CONDEF->bAssemblyViewShowSequenceMatches_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewShowSequenceMatchesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOKToShowSequenceMatchesBetweenContigs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOKToShowSequenceMatchesBetweenContigs() );
}
void guiEditResources :: checkAssemblyViewOKToShowSequenceMatchesBetweenContigs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOKToShowSequenceMatchesBetweenContigsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOKToShowSequenceMatchesBetweenContigs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOKToShowSequenceMatchesBetweenContigs_,
              CONDEF->bAssemblyViewOKToShowSequenceMatchesBetweenContigs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOKToShowSequenceMatchesBetweenContigsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOKToShowSequenceMatchesWithinContigs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOKToShowSequenceMatchesWithinContigs() );
}
void guiEditResources :: checkAssemblyViewOKToShowSequenceMatchesWithinContigs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOKToShowSequenceMatchesWithinContigsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOKToShowSequenceMatchesWithinContigs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOKToShowSequenceMatchesWithinContigs_,
              CONDEF->bAssemblyViewOKToShowSequenceMatchesWithinContigs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOKToShowSequenceMatchesWithinContigsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOKToShowDirectSequenceMatches( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOKToShowDirectSequenceMatches() );
}
void guiEditResources :: checkAssemblyViewOKToShowDirectSequenceMatches() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOKToShowDirectSequenceMatchesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOKToShowDirectSequenceMatches_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOKToShowDirectSequenceMatches_,
              CONDEF->bAssemblyViewOKToShowDirectSequenceMatches_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOKToShowDirectSequenceMatchesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOKToShowInvertedSequenceMatches( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOKToShowInvertedSequenceMatches() );
}
void guiEditResources :: checkAssemblyViewOKToShowInvertedSequenceMatches() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOKToShowInvertedSequenceMatchesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOKToShowInvertedSequenceMatches_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOKToShowInvertedSequenceMatches_,
              CONDEF->bAssemblyViewOKToShowInvertedSequenceMatches_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOKToShowInvertedSequenceMatchesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToAParticularRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToAParticularRegion() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToAParticularRegion() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOnlyShowSequenceMatchesToAParticularRegionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_,
              CONDEF->bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToAParticularRegionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToThisContig( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToThisContig() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToThisContig() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewOnlyShowSequenceMatchesToThisContig_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAssemblyViewOnlyShowSequenceMatchesToThisContig_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAssemblyViewOnlyShowSequenceMatchesToThisContig_,
              CONDEF->soAssemblyViewOnlyShowSequenceMatchesToThisContig_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToThisContig_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewOnlyShowSequenceMatchesToThisRegionLeft must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_,
              CONDEF->nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToThisRegionRight( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToThisRegionRight() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToThisRegionRight() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewOnlyShowSequenceMatchesToThisRegionRight must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_,
              CONDEF->nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs() {



   bool b =
      XmToggleButtonGetState( widAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_,
              CONDEF->bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar() );
}
void guiEditResources :: checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_,
              CONDEF->nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDefaultReadPrefix( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDefaultReadPrefix() );
}
void guiEditResources :: checkDefaultReadPrefix() {



   char* szValue =
   XmTextFieldGetString( widDefaultReadPrefix_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soDefaultReadPrefix_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soDefaultReadPrefix_,
              CONDEF->soDefaultReadPrefix_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDefaultReadPrefix_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbReadPrefixesFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkReadPrefixesFile() );
}
void guiEditResources :: checkReadPrefixesFile() {



   char* szValue =
   XmTextFieldGetString( widReadPrefixesFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filReadPrefixesFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filReadPrefixesFile_,
              CONDEF->filReadPrefixesFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widReadPrefixesFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaxCharsDisplayedForReadPrefix( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaxCharsDisplayedForReadPrefix() );
}
void guiEditResources :: checkMaxCharsDisplayedForReadPrefix() {



   char* szValue =
   XmTextFieldGetString( widMaxCharsDisplayedForReadPrefix_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaxCharsDisplayedForReadPrefix must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaxCharsDisplayedForReadPrefix_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaxCharsDisplayedForReadPrefix_,
              CONDEF->nMaxCharsDisplayedForReadPrefix_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaxCharsDisplayedForReadPrefix_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates() );
}
void guiEditResources :: checkAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_,
              CONDEF->nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions() );
}
void guiEditResources :: checkAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_,
              CONDEF->nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis() );
}
void guiEditResources :: checkAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_,
              CONDEF->nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotDoPCRIfEndIsExtendedByReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotDoPCRIfEndIsExtendedByReads() );
}
void guiEditResources :: checkAutoFinishDoNotDoPCRIfEndIsExtendedByReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishDoNotDoPCRIfEndIsExtendedByReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_,
              CONDEF->bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotDoPCRIfEndIsExtendedByReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMaxAcceptableErrorsPerMegabase( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMaxAcceptableErrorsPerMegabase() );
}
void guiEditResources :: checkAutoFinishMaxAcceptableErrorsPerMegabase() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMaxAcceptableErrorsPerMegabase_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMaxAcceptableErrorsPerMegabase must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMaxAcceptableErrorsPerMegabase_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMaxAcceptableErrorsPerMegabase_,
              CONDEF->nAutoFinishMaxAcceptableErrorsPerMegabase_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMaxAcceptableErrorsPerMegabase_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize() );
}
void guiEditResources :: checkAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_,
              CONDEF->nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersNumberOfBasesToBackUpToStartLooking( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersNumberOfBasesToBackUpToStartLooking() );
}
void guiEditResources :: checkPrimersNumberOfBasesToBackUpToStartLooking() {



   char* szValue =
   XmTextFieldGetString( widPrimersNumberOfBasesToBackUpToStartLooking_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersNumberOfBasesToBackUpToStartLooking must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersNumberOfBasesToBackUpToStartLooking_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersNumberOfBasesToBackUpToStartLooking_,
              CONDEF->nPrimersNumberOfBasesToBackUpToStartLooking_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersNumberOfBasesToBackUpToStartLooking_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment() );
}
void guiEditResources :: checkPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment() {



   char* szValue =
   XmTextFieldGetString( widPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_,
              CONDEF->nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersOKToChoosePrimersInSingleSubcloneRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersOKToChoosePrimersInSingleSubcloneRegion() );
}
void guiEditResources :: checkPrimersOKToChoosePrimersInSingleSubcloneRegion() {



   bool b =
      XmToggleButtonGetState( widPrimersOKToChoosePrimersInSingleSubcloneRegionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersOKToChoosePrimersInSingleSubcloneRegion_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersOKToChoosePrimersInSingleSubcloneRegion_,
              CONDEF->bPrimersOKToChoosePrimersInSingleSubcloneRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersOKToChoosePrimersInSingleSubcloneRegionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersOKToChoosePrimersWhereHighQualityDiscrepancies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersOKToChoosePrimersWhereHighQualityDiscrepancies() );
}
void guiEditResources :: checkPrimersOKToChoosePrimersWhereHighQualityDiscrepancies() {



   bool b =
      XmToggleButtonGetState( widPrimersOKToChoosePrimersWhereHighQualityDiscrepanciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_,
              CONDEF->bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersOKToChoosePrimersWhereHighQualityDiscrepanciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion() );
}
void guiEditResources :: checkPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion() {



   bool b =
      XmToggleButtonGetState( widPrimersOKToChoosePrimersWhereUnalignedHighQualityRegionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_,
              CONDEF->bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersOKToChoosePrimersWhereUnalignedHighQualityRegionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCallReversesToFlankGaps( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCallReversesToFlankGaps() );
}
void guiEditResources :: checkAutoFinishCallReversesToFlankGaps() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCallReversesToFlankGapsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCallReversesToFlankGaps_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCallReversesToFlankGaps_,
              CONDEF->bAutoFinishCallReversesToFlankGaps_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCallReversesToFlankGapsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowWholeCloneReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowWholeCloneReads() );
}
void guiEditResources :: checkAutoFinishAllowWholeCloneReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowWholeCloneReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowWholeCloneReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowWholeCloneReads_,
              CONDEF->bAutoFinishAllowWholeCloneReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowWholeCloneReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowCustomPrimerSubcloneReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowCustomPrimerSubcloneReads() );
}
void guiEditResources :: checkAutoFinishAllowCustomPrimerSubcloneReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowCustomPrimerSubcloneReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowCustomPrimerSubcloneReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowCustomPrimerSubcloneReads_,
              CONDEF->bAutoFinishAllowCustomPrimerSubcloneReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowCustomPrimerSubcloneReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowResequencingReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowResequencingReads() );
}
void guiEditResources :: checkAutoFinishAllowResequencingReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowResequencingReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowResequencingReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowResequencingReads_,
              CONDEF->bAutoFinishAllowResequencingReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowResequencingReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowResequencingReadsOnlyForRunsAndStops( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowResequencingReadsOnlyForRunsAndStops() );
}
void guiEditResources :: checkAutoFinishAllowResequencingReadsOnlyForRunsAndStops() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowResequencingReadsOnlyForRunsAndStopsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_,
              CONDEF->bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowResequencingReadsOnlyForRunsAndStopsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowDeNovoUniversalPrimerSubcloneReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowDeNovoUniversalPrimerSubcloneReads() );
}
void guiEditResources :: checkAutoFinishAllowDeNovoUniversalPrimerSubcloneReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowDeNovoUniversalPrimerSubcloneReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_,
              CONDEF->bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowDeNovoUniversalPrimerSubcloneReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowMinilibraries( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowMinilibraries() );
}
void guiEditResources :: checkAutoFinishAllowMinilibraries() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowMinilibrariesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowMinilibraries_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowMinilibraries_,
              CONDEF->bAutoFinishAllowMinilibraries_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowMinilibrariesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowPCR() );
}
void guiEditResources :: checkAutoFinishAllowPCR() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowPCRTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowPCR_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowPCR_,
              CONDEF->bAutoFinishAllowPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowPCRRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowUnorientedPCRReactions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowUnorientedPCRReactions() );
}
void guiEditResources :: checkAutoFinishAllowUnorientedPCRReactions() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowUnorientedPCRReactionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowUnorientedPCRReactions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowUnorientedPCRReactions_,
              CONDEF->bAutoFinishAllowUnorientedPCRReactions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowUnorientedPCRReactionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowResequencingAUniversalPrimerAutofinishRead( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowResequencingAUniversalPrimerAutofinishRead() );
}
void guiEditResources :: checkAutoFinishAllowResequencingAUniversalPrimerAutofinishRead() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowResequencingAUniversalPrimerAutofinishReadTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_,
              CONDEF->bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowResequencingAUniversalPrimerAutofinishReadRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAlwaysCloseGapsUsingMinilibraries( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAlwaysCloseGapsUsingMinilibraries() );
}
void guiEditResources :: checkAutoFinishAlwaysCloseGapsUsingMinilibraries() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAlwaysCloseGapsUsingMinilibrariesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAlwaysCloseGapsUsingMinilibraries_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAlwaysCloseGapsUsingMinilibraries_,
              CONDEF->bAutoFinishAlwaysCloseGapsUsingMinilibraries_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAlwaysCloseGapsUsingMinilibrariesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMaximumFinishingReadLength( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMaximumFinishingReadLength() );
}
void guiEditResources :: checkAutoFinishMaximumFinishingReadLength() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMaximumFinishingReadLength_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMaximumFinishingReadLength must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMaximumFinishingReadLength_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMaximumFinishingReadLength_,
              CONDEF->nAutoFinishMaximumFinishingReadLength_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMaximumFinishingReadLength_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger() );
}
void guiEditResources :: checkAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_,
              CONDEF->nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishSuggestSpecialChemistryForRunsAndStops( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishSuggestSpecialChemistryForRunsAndStops() );
}
void guiEditResources :: checkAutoFinishSuggestSpecialChemistryForRunsAndStops() {



   bool b =
      XmToggleButtonGetState( widAutoFinishSuggestSpecialChemistryForRunsAndStopsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishSuggestSpecialChemistryForRunsAndStops_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishSuggestSpecialChemistryForRunsAndStops_,
              CONDEF->bAutoFinishSuggestSpecialChemistryForRunsAndStops_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishSuggestSpecialChemistryForRunsAndStopsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishSuggestThisManyMinilibrariesPerGap( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishSuggestThisManyMinilibrariesPerGap() );
}
void guiEditResources :: checkAutoFinishSuggestThisManyMinilibrariesPerGap() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishSuggestThisManyMinilibrariesPerGap_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishSuggestThisManyMinilibrariesPerGap must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishSuggestThisManyMinilibrariesPerGap_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishSuggestThisManyMinilibrariesPerGap_,
              CONDEF->nAutoFinishSuggestThisManyMinilibrariesPerGap_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishSuggestThisManyMinilibrariesPerGap_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersWindowSizeInLooking( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersWindowSizeInLooking() );
}
void guiEditResources :: checkPrimersWindowSizeInLooking() {



   char* szValue =
   XmTextFieldGetString( widPrimersWindowSizeInLooking_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersWindowSizeInLooking must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersWindowSizeInLooking_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersWindowSizeInLooking_,
              CONDEF->nPrimersWindowSizeInLooking_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersWindowSizeInLooking_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified() );
}
void guiEditResources :: checkPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified() {



   bool b =
      XmToggleButtonGetState( widPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecifiedTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_,
              CONDEF->bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecifiedRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAlignedReadsWindowInitialCharsWide( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAlignedReadsWindowInitialCharsWide() );
}
void guiEditResources :: checkAlignedReadsWindowInitialCharsWide() {



   char* szValue =
   XmTextFieldGetString( widAlignedReadsWindowInitialCharsWide_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AlignedReadsWindowInitialCharsWide must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAlignedReadsWindowInitialCharsWide_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAlignedReadsWindowInitialCharsWide_,
              CONDEF->nAlignedReadsWindowInitialCharsWide_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAlignedReadsWindowInitialCharsWide_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAlignedReadsWindowInitialCharsHigh( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAlignedReadsWindowInitialCharsHigh() );
}
void guiEditResources :: checkAlignedReadsWindowInitialCharsHigh() {



   char* szValue =
   XmTextFieldGetString( widAlignedReadsWindowInitialCharsHigh_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AlignedReadsWindowInitialCharsHigh must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAlignedReadsWindowInitialCharsHigh_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAlignedReadsWindowInitialCharsHigh_,
              CONDEF->nAlignedReadsWindowInitialCharsHigh_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAlignedReadsWindowInitialCharsHigh_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAlignedReadsWindowMaxCharsForReadNames( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAlignedReadsWindowMaxCharsForReadNames() );
}
void guiEditResources :: checkAlignedReadsWindowMaxCharsForReadNames() {



   char* szValue =
   XmTextFieldGetString( widAlignedReadsWindowMaxCharsForReadNames_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AlignedReadsWindowMaxCharsForReadNames must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAlignedReadsWindowMaxCharsForReadNames_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAlignedReadsWindowMaxCharsForReadNames_,
              CONDEF->nAlignedReadsWindowMaxCharsForReadNames_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAlignedReadsWindowMaxCharsForReadNames_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAlignedReadsWindowAutomaticallyExpandRoomForReadNames( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAlignedReadsWindowAutomaticallyExpandRoomForReadNames() );
}
void guiEditResources :: checkAlignedReadsWindowAutomaticallyExpandRoomForReadNames() {



   bool b =
      XmToggleButtonGetState( widAlignedReadsWindowAutomaticallyExpandRoomForReadNamesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_,
              CONDEF->bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAlignedReadsWindowAutomaticallyExpandRoomForReadNamesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishAllowResequencingReadsToExtendContigs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishAllowResequencingReadsToExtendContigs() );
}
void guiEditResources :: checkAutoFinishAllowResequencingReadsToExtendContigs() {



   bool b =
      XmToggleButtonGetState( widAutoFinishAllowResequencingReadsToExtendContigsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishAllowResequencingReadsToExtendContigs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishAllowResequencingReadsToExtendContigs_,
              CONDEF->bAutoFinishAllowResequencingReadsToExtendContigs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishAllowResequencingReadsToExtendContigsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCallHowManyReversesToFlankGaps( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCallHowManyReversesToFlankGaps() );
}
void guiEditResources :: checkAutoFinishCallHowManyReversesToFlankGaps() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCallHowManyReversesToFlankGaps_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishCallHowManyReversesToFlankGaps must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishCallHowManyReversesToFlankGaps_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishCallHowManyReversesToFlankGaps_,
              CONDEF->nAutoFinishCallHowManyReversesToFlankGaps_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCallHowManyReversesToFlankGaps_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCloseGaps( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCloseGaps() );
}
void guiEditResources :: checkAutoFinishCloseGaps() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCloseGapsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCloseGaps_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCloseGaps_,
              CONDEF->bAutoFinishCloseGaps_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCloseGapsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense() );
}
void guiEditResources :: checkAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense() {



   bool b =
      XmToggleButtonGetState( widAutoFinishContinueEvenThoughReadInfoDoesNotMakeSenseTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_,
              CONDEF->bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishContinueEvenThoughReadInfoDoesNotMakeSenseRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction() );
}
void guiEditResources :: checkAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishCostOfResequencingUniversalPrimerSubcloneReaction must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_,
               CONDEF->dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCostOfCustomPrimerSubcloneReaction( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCostOfCustomPrimerSubcloneReaction() );
}
void guiEditResources :: checkAutoFinishCostOfCustomPrimerSubcloneReaction() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCostOfCustomPrimerSubcloneReaction_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishCostOfCustomPrimerSubcloneReaction must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishCostOfCustomPrimerSubcloneReaction_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishCostOfCustomPrimerSubcloneReaction_,
               CONDEF->dAutoFinishCostOfCustomPrimerSubcloneReaction_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCostOfCustomPrimerSubcloneReaction_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCostOfCustomPrimerCloneReaction( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCostOfCustomPrimerCloneReaction() );
}
void guiEditResources :: checkAutoFinishCostOfCustomPrimerCloneReaction() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCostOfCustomPrimerCloneReaction_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishCostOfCustomPrimerCloneReaction must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishCostOfCustomPrimerCloneReaction_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishCostOfCustomPrimerCloneReaction_,
               CONDEF->dAutoFinishCostOfCustomPrimerCloneReaction_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCostOfCustomPrimerCloneReaction_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction() );
}
void guiEditResources :: checkAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_,
               CONDEF->dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCostOfMinilibrary( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCostOfMinilibrary() );
}
void guiEditResources :: checkAutoFinishCostOfMinilibrary() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishCostOfMinilibrary_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishCostOfMinilibrary must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishCostOfMinilibrary_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishCostOfMinilibrary_,
               CONDEF->dAutoFinishCostOfMinilibrary_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCostOfMinilibrary_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCoverSingleSubcloneRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCoverSingleSubcloneRegions() );
}
void guiEditResources :: checkAutoFinishCoverSingleSubcloneRegions() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCoverSingleSubcloneRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCoverSingleSubcloneRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCoverSingleSubcloneRegions_,
              CONDEF->bAutoFinishCoverSingleSubcloneRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCoverSingleSubcloneRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCoverLowConsensusQualityRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCoverLowConsensusQualityRegions() );
}
void guiEditResources :: checkAutoFinishCoverLowConsensusQualityRegions() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCoverLowConsensusQualityRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCoverLowConsensusQualityRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCoverLowConsensusQualityRegions_,
              CONDEF->bAutoFinishCoverLowConsensusQualityRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCoverLowConsensusQualityRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDebugUniversalPrimerReadsFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDebugUniversalPrimerReadsFile() );
}
void guiEditResources :: checkAutoFinishDebugUniversalPrimerReadsFile() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDebugUniversalPrimerReadsFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoFinishDebugUniversalPrimerReadsFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoFinishDebugUniversalPrimerReadsFile_,
              CONDEF->filAutoFinishDebugUniversalPrimerReadsFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDebugUniversalPrimerReadsFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDebugCustomPrimerReadsFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDebugCustomPrimerReadsFile() );
}
void guiEditResources :: checkAutoFinishDebugCustomPrimerReadsFile() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDebugCustomPrimerReadsFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoFinishDebugCustomPrimerReadsFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoFinishDebugCustomPrimerReadsFile_,
              CONDEF->filAutoFinishDebugCustomPrimerReadsFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDebugCustomPrimerReadsFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases() );
}
void guiEditResources :: checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_,
              CONDEF->nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases() );
}
void guiEditResources :: checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_,
              CONDEF->nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotFinishWhereTheseTagsAre( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotFinishWhereTheseTagsAre() );
}
void guiEditResources :: checkAutoFinishDoNotFinishWhereTheseTagsAre() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotFinishWhereTheseTagsAre_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoFinishDoNotFinishWhereTheseTagsAre_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoFinishDoNotFinishWhereTheseTagsAre_,
              CONDEF->soAutoFinishDoNotFinishWhereTheseTagsAre_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotFinishWhereTheseTagsAre_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotExtendContigsWhereTheseTagsAre( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotExtendContigsWhereTheseTagsAre() );
}
void guiEditResources :: checkAutoFinishDoNotExtendContigsWhereTheseTagsAre() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotExtendContigsWhereTheseTagsAre_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoFinishDoNotExtendContigsWhereTheseTagsAre_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoFinishDoNotExtendContigsWhereTheseTagsAre_,
              CONDEF->soAutoFinishDoNotExtendContigsWhereTheseTagsAre_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotExtendContigsWhereTheseTagsAre_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd() );
}
void guiEditResources :: checkAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_,
              CONDEF->nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDumpContigOrderAndOrientationInfoToThisFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDumpContigOrderAndOrientationInfoToThisFile() );
}
void guiEditResources :: checkDumpContigOrderAndOrientationInfoToThisFile() {



   char* szValue =
   XmTextFieldGetString( widDumpContigOrderAndOrientationInfoToThisFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filDumpContigOrderAndOrientationInfoToThisFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filDumpContigOrderAndOrientationInfoToThisFile_,
              CONDEF->filDumpContigOrderAndOrientationInfoToThisFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDumpContigOrderAndOrientationInfoToThisFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDumpTemplates( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDumpTemplates() );
}
void guiEditResources :: checkAutoFinishDumpTemplates() {



   bool b =
      XmToggleButtonGetState( widAutoFinishDumpTemplatesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishDumpTemplates_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishDumpTemplates_,
              CONDEF->bAutoFinishDumpTemplates_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDumpTemplatesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishExcludeContigIfOnlyThisManyReadsOrLess( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishExcludeContigIfOnlyThisManyReadsOrLess() );
}
void guiEditResources :: checkAutoFinishExcludeContigIfOnlyThisManyReadsOrLess() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishExcludeContigIfOnlyThisManyReadsOrLess must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_,
              CONDEF->nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis() );
}
void guiEditResources :: checkAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_,
               CONDEF->dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishExcludeContigIfThisManyBasesOrLess( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishExcludeContigIfThisManyBasesOrLess() );
}
void guiEditResources :: checkAutoFinishExcludeContigIfThisManyBasesOrLess() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishExcludeContigIfThisManyBasesOrLess_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishExcludeContigIfThisManyBasesOrLess must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishExcludeContigIfThisManyBasesOrLess_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishExcludeContigIfThisManyBasesOrLess_,
              CONDEF->nAutoFinishExcludeContigIfThisManyBasesOrLess_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishExcludeContigIfThisManyBasesOrLess_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions() );
}
void guiEditResources :: checkAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_,
              CONDEF->nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinNumberOfTemplatesForPrimers( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinNumberOfTemplatesForPrimers() );
}
void guiEditResources :: checkPrimersMinNumberOfTemplatesForPrimers() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinNumberOfTemplatesForPrimers_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinNumberOfTemplatesForPrimers must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinNumberOfTemplatesForPrimers_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinNumberOfTemplatesForPrimers_,
              CONDEF->nPrimersMinNumberOfTemplatesForPrimers_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinNumberOfTemplatesForPrimers_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus() );
}
void guiEditResources :: checkAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_,
              CONDEF->nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead() );
}
void guiEditResources :: checkAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_,
              CONDEF->nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCDNANotGenomic( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCDNANotGenomic() );
}
void guiEditResources :: checkAutoFinishCDNANotGenomic() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCDNANotGenomicTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCDNANotGenomic_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCDNANotGenomic_,
              CONDEF->bAutoFinishCDNANotGenomic_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCDNANotGenomicRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion() );
}
void guiEditResources :: checkAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_,
              CONDEF->nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads() );
}
void guiEditResources :: checkAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_,
              CONDEF->bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishPrintMinilibrariesSummaryFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishPrintMinilibrariesSummaryFile() );
}
void guiEditResources :: checkAutoFinishPrintMinilibrariesSummaryFile() {



   bool b =
      XmToggleButtonGetState( widAutoFinishPrintMinilibrariesSummaryFileTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishPrintMinilibrariesSummaryFile_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishPrintMinilibrariesSummaryFile_,
              CONDEF->bAutoFinishPrintMinilibrariesSummaryFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishPrintMinilibrariesSummaryFileRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishNearGapsSuggestEachMissingReadOfReadPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishNearGapsSuggestEachMissingReadOfReadPairs() );
}
void guiEditResources :: checkAutoFinishNearGapsSuggestEachMissingReadOfReadPairs() {



   bool b =
      XmToggleButtonGetState( widAutoFinishNearGapsSuggestEachMissingReadOfReadPairsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_,
              CONDEF->bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishNearGapsSuggestEachMissingReadOfReadPairsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger() );
}
void guiEditResources :: checkAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_,
              CONDEF->nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCheckIfTooManyWalks( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCheckIfTooManyWalks() );
}
void guiEditResources :: checkCheckIfTooManyWalks() {



   bool b =
      XmToggleButtonGetState( widCheckIfTooManyWalksTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bCheckIfTooManyWalks_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bCheckIfTooManyWalks_,
              CONDEF->bCheckIfTooManyWalks_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCheckIfTooManyWalksRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNumberOfColumnsBeforeReadNameInAlignedReadsWindow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNumberOfColumnsBeforeReadNameInAlignedReadsWindow() );
}
void guiEditResources :: checkNumberOfColumnsBeforeReadNameInAlignedReadsWindow() {



   char* szValue =
   XmTextFieldGetString( widNumberOfColumnsBeforeReadNameInAlignedReadsWindow_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.NumberOfColumnsBeforeReadNameInAlignedReadsWindow must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_,
              CONDEF->nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNumberOfColumnsBeforeReadNameInAlignedReadsWindow_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCompareContigsAlignsThisManyBasesMax( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCompareContigsAlignsThisManyBasesMax() );
}
void guiEditResources :: checkCompareContigsAlignsThisManyBasesMax() {



   char* szValue =
   XmTextFieldGetString( widCompareContigsAlignsThisManyBasesMax_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.CompareContigsAlignsThisManyBasesMax must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nCompareContigsAlignsThisManyBasesMax_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nCompareContigsAlignsThisManyBasesMax_,
              CONDEF->nCompareContigsAlignsThisManyBasesMax_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCompareContigsAlignsThisManyBasesMax_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCompressedChromatExtension( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCompressedChromatExtension() );
}
void guiEditResources :: checkCompressedChromatExtension() {



   char* szValue =
   XmTextFieldGetString( widCompressedChromatExtension_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soCompressedChromatExtension_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soCompressedChromatExtension_,
              CONDEF->soCompressedChromatExtension_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCompressedChromatExtension_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDimLowQualityEndsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDimLowQualityEndsOfReads() );
}
void guiEditResources :: checkDimLowQualityEndsOfReads() {



   bool b =
      XmToggleButtonGetState( widDimLowQualityEndsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bDimLowQualityEndsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bDimLowQualityEndsOfReads_,
              CONDEF->bDimLowQualityEndsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDimLowQualityEndsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDimUnalignedEndsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDimUnalignedEndsOfReads() );
}
void guiEditResources :: checkDimUnalignedEndsOfReads() {



   bool b =
      XmToggleButtonGetState( widDimUnalignedEndsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bDimUnalignedEndsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bDimUnalignedEndsOfReads_,
              CONDEF->bDimUnalignedEndsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDimUnalignedEndsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFakeReadsSpecifiedByFilenameExtension( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFakeReadsSpecifiedByFilenameExtension() );
}
void guiEditResources :: checkFakeReadsSpecifiedByFilenameExtension() {



   bool b =
      XmToggleButtonGetState( widFakeReadsSpecifiedByFilenameExtensionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bFakeReadsSpecifiedByFilenameExtension_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bFakeReadsSpecifiedByFilenameExtension_,
              CONDEF->bFakeReadsSpecifiedByFilenameExtension_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFakeReadsSpecifiedByFilenameExtensionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfAddReads2ConsedScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfAddReads2ConsedScript() );
}
void guiEditResources :: checkFullPathnameOfAddReads2ConsedScript() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfAddReads2ConsedScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfAddReads2ConsedScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfAddReads2ConsedScript_,
              CONDEF->filFullPathnameOfAddReads2ConsedScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfAddReads2ConsedScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfFixContigEndScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfFixContigEndScript() );
}
void guiEditResources :: checkFullPathnameOfFixContigEndScript() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfFixContigEndScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfFixContigEndScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfFixContigEndScript_,
              CONDEF->filFullPathnameOfFixContigEndScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfFixContigEndScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFixContigEndsCleanUpTemporaryFiles( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFixContigEndsCleanUpTemporaryFiles() );
}
void guiEditResources :: checkFixContigEndsCleanUpTemporaryFiles() {



   bool b =
      XmToggleButtonGetState( widFixContigEndsCleanUpTemporaryFilesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bFixContigEndsCleanUpTemporaryFiles_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bFixContigEndsCleanUpTemporaryFiles_,
              CONDEF->bFixContigEndsCleanUpTemporaryFiles_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFixContigEndsCleanUpTemporaryFilesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFixContigEndsMinSmithWatermanScoreToMakeJoin( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFixContigEndsMinSmithWatermanScoreToMakeJoin() );
}
void guiEditResources :: checkFixContigEndsMinSmithWatermanScoreToMakeJoin() {



   char* szValue =
   XmTextFieldGetString( widFixContigEndsMinSmithWatermanScoreToMakeJoin_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.FixContigEndsMinSmithWatermanScoreToMakeJoin must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nFixContigEndsMinSmithWatermanScoreToMakeJoin_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nFixContigEndsMinSmithWatermanScoreToMakeJoin_,
              CONDEF->nFixContigEndsMinSmithWatermanScoreToMakeJoin_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFixContigEndsMinSmithWatermanScoreToMakeJoin_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFixContigEndsMinNumberOfReadsInContig( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFixContigEndsMinNumberOfReadsInContig() );
}
void guiEditResources :: checkFixContigEndsMinNumberOfReadsInContig() {



   char* szValue =
   XmTextFieldGetString( widFixContigEndsMinNumberOfReadsInContig_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.FixContigEndsMinNumberOfReadsInContig must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nFixContigEndsMinNumberOfReadsInContig_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nFixContigEndsMinNumberOfReadsInContig_,
              CONDEF->nFixContigEndsMinNumberOfReadsInContig_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFixContigEndsMinNumberOfReadsInContig_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfCrossMatch( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfCrossMatch() );
}
void guiEditResources :: checkFullPathnameOfCrossMatch() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfCrossMatch_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfCrossMatch_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfCrossMatch_,
              CONDEF->filFullPathnameOfCrossMatch_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfCrossMatch_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfPhred( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfPhred() );
}
void guiEditResources :: checkFullPathnameOfPhred() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfPhred_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfPhred_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfPhred_,
              CONDEF->filFullPathnameOfPhred_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfPhred_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfMiniassemblyScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfMiniassemblyScript() );
}
void guiEditResources :: checkFullPathnameOfMiniassemblyScript() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfMiniassemblyScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfMiniassemblyScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfMiniassemblyScript_,
              CONDEF->filFullPathnameOfMiniassemblyScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfMiniassemblyScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbGunzipFullPath( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkGunzipFullPath() );
}
void guiEditResources :: checkGunzipFullPath() {



   char* szValue =
   XmTextFieldGetString( widGunzipFullPath_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soGunzipFullPath_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soGunzipFullPath_,
              CONDEF->soGunzipFullPath_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widGunzipFullPath_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFullPathnameOfFilter454ReadsScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFullPathnameOfFilter454ReadsScript() );
}
void guiEditResources :: checkFullPathnameOfFilter454ReadsScript() {



   char* szValue =
   XmTextFieldGetString( widFullPathnameOfFilter454ReadsScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFullPathnameOfFilter454ReadsScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFullPathnameOfFilter454ReadsScript_,
              CONDEF->filFullPathnameOfFilter454ReadsScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFullPathnameOfFilter454ReadsScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFilter454ReadsAgainstThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFilter454ReadsAgainstThis() );
}
void guiEditResources :: checkFilter454ReadsAgainstThis() {



   char* szValue =
   XmTextFieldGetString( widFilter454ReadsAgainstThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFilter454ReadsAgainstThis_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFilter454ReadsAgainstThis_,
              CONDEF->filFilter454ReadsAgainstThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFilter454ReadsAgainstThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cb454LinkerSequences( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->check454LinkerSequences() );
}
void guiEditResources :: check454LinkerSequences() {



   char* szValue =
   XmTextFieldGetString( wid454LinkerSequences_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.fil454LinkerSequences_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.fil454LinkerSequences_,
              CONDEF->fil454LinkerSequences_,
              pixForeground,
              pixBackground );

   XtVaSetValues( wid454LinkerSequences_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbHideSomeTagTypesAtStartup( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkHideSomeTagTypesAtStartup() );
}
void guiEditResources :: checkHideSomeTagTypesAtStartup() {



   bool b =
      XmToggleButtonGetState( widHideSomeTagTypesAtStartupTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bHideSomeTagTypesAtStartup_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bHideSomeTagTypesAtStartup_,
              CONDEF->bHideSomeTagTypesAtStartup_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widHideSomeTagTypesAtStartupRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaximumNumberOfTracesShown( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaximumNumberOfTracesShown() );
}
void guiEditResources :: checkMaximumNumberOfTracesShown() {



   char* szValue =
   XmTextFieldGetString( widMaximumNumberOfTracesShown_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaximumNumberOfTracesShown must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaximumNumberOfTracesShown_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaximumNumberOfTracesShown_,
              CONDEF->nMaximumNumberOfTracesShown_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaximumNumberOfTracesShown_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateAutomaticTracePopup( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateAutomaticTracePopup() );
}
void guiEditResources :: checkNavigateAutomaticTracePopup() {



   bool b =
      XmToggleButtonGetState( widNavigateAutomaticTracePopupTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateAutomaticTracePopup_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateAutomaticTracePopup_,
              CONDEF->bNavigateAutomaticTracePopup_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateAutomaticTracePopupRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateAutomaticAllTracesPopup( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateAutomaticAllTracesPopup() );
}
void guiEditResources :: checkNavigateAutomaticAllTracesPopup() {



   bool b =
      XmToggleButtonGetState( widNavigateAutomaticAllTracesPopupTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateAutomaticAllTracesPopup_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateAutomaticAllTracesPopup_,
              CONDEF->bNavigateAutomaticAllTracesPopup_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateAutomaticAllTracesPopupRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinimumLengthOfAPrimer( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinimumLengthOfAPrimer() );
}
void guiEditResources :: checkPrimersMinimumLengthOfAPrimer() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinimumLengthOfAPrimer_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinimumLengthOfAPrimer must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinimumLengthOfAPrimer_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinimumLengthOfAPrimer_,
              CONDEF->nPrimersMinimumLengthOfAPrimer_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinimumLengthOfAPrimer_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaximumLengthOfAPrimer( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaximumLengthOfAPrimer() );
}
void guiEditResources :: checkPrimersMaximumLengthOfAPrimer() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaximumLengthOfAPrimer_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaximumLengthOfAPrimer must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaximumLengthOfAPrimer_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaximumLengthOfAPrimer_,
              CONDEF->nPrimersMaximumLengthOfAPrimer_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaximumLengthOfAPrimer_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinimumLengthOfAPrimerForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinimumLengthOfAPrimerForPCR() );
}
void guiEditResources :: checkPrimersMinimumLengthOfAPrimerForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinimumLengthOfAPrimerForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinimumLengthOfAPrimerForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinimumLengthOfAPrimerForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinimumLengthOfAPrimerForPCR_,
              CONDEF->nPrimersMinimumLengthOfAPrimerForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinimumLengthOfAPrimerForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaximumLengthOfAPrimerForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaximumLengthOfAPrimerForPCR() );
}
void guiEditResources :: checkPrimersMaximumLengthOfAPrimerForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaximumLengthOfAPrimerForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaximumLengthOfAPrimerForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaximumLengthOfAPrimerForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaximumLengthOfAPrimerForPCR_,
              CONDEF->nPrimersMaximumLengthOfAPrimerForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaximumLengthOfAPrimerForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxMeltingTempDifferenceForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxMeltingTempDifferenceForPCR() );
}
void guiEditResources :: checkPrimersMaxMeltingTempDifferenceForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxMeltingTempDifferenceForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "PrimersMaxMeltingTempDifferenceForPCR must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dPrimersMaxMeltingTempDifferenceForPCR_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dPrimersMaxMeltingTempDifferenceForPCR_,
               CONDEF->dPrimersMaxMeltingTempDifferenceForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxMeltingTempDifferenceForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxPCRPrimerPairsToDisplay( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxPCRPrimerPairsToDisplay() );
}
void guiEditResources :: checkPrimersMaxPCRPrimerPairsToDisplay() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxPCRPrimerPairsToDisplay_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxPCRPrimerPairsToDisplay must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxPCRPrimerPairsToDisplay_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxPCRPrimerPairsToDisplay_,
              CONDEF->nPrimersMaxPCRPrimerPairsToDisplay_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxPCRPrimerPairsToDisplay_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersCheckJustSomePCRPrimerPairsRatherThanAll( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersCheckJustSomePCRPrimerPairsRatherThanAll() );
}
void guiEditResources :: checkPrimersCheckJustSomePCRPrimerPairsRatherThanAll() {



   bool b =
      XmToggleButtonGetState( widPrimersCheckJustSomePCRPrimerPairsRatherThanAllTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_,
              CONDEF->bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersCheckJustSomePCRPrimerPairsRatherThanAllRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersNumberOfTemplatesToDisplayInFront( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersNumberOfTemplatesToDisplayInFront() );
}
void guiEditResources :: checkPrimersNumberOfTemplatesToDisplayInFront() {



   char* szValue =
   XmTextFieldGetString( widPrimersNumberOfTemplatesToDisplayInFront_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersNumberOfTemplatesToDisplayInFront must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersNumberOfTemplatesToDisplayInFront_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersNumberOfTemplatesToDisplayInFront_,
              CONDEF->nPrimersNumberOfTemplatesToDisplayInFront_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersNumberOfTemplatesToDisplayInFront_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxLengthOfMononucleotideRepeat( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxLengthOfMononucleotideRepeat() );
}
void guiEditResources :: checkPrimersMaxLengthOfMononucleotideRepeat() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxLengthOfMononucleotideRepeat_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxLengthOfMononucleotideRepeat must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxLengthOfMononucleotideRepeat_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxLengthOfMononucleotideRepeat_,
              CONDEF->nPrimersMaxLengthOfMononucleotideRepeat_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxLengthOfMononucleotideRepeat_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersBadLibrariesFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersBadLibrariesFile() );
}
void guiEditResources :: checkPrimersBadLibrariesFile() {



   char* szValue =
   XmTextFieldGetString( widPrimersBadLibrariesFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filPrimersBadLibrariesFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filPrimersBadLibrariesFile_,
              CONDEF->filPrimersBadLibrariesFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersBadLibrariesFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersLibrariesInfoFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersLibrariesInfoFile() );
}
void guiEditResources :: checkPrimersLibrariesInfoFile() {



   char* szValue =
   XmTextFieldGetString( widPrimersLibrariesInfoFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filPrimersLibrariesInfoFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filPrimersLibrariesInfoFile_,
              CONDEF->filPrimersLibrariesInfoFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersLibrariesInfoFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersBadTemplatesFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersBadTemplatesFile() );
}
void guiEditResources :: checkPrimersBadTemplatesFile() {



   char* szValue =
   XmTextFieldGetString( widPrimersBadTemplatesFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filPrimersBadTemplatesFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filPrimersBadTemplatesFile_,
              CONDEF->filPrimersBadTemplatesFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersBadTemplatesFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersChooseTemplatesByPositionInsteadOfQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersChooseTemplatesByPositionInsteadOfQuality() );
}
void guiEditResources :: checkPrimersChooseTemplatesByPositionInsteadOfQuality() {



   bool b =
      XmToggleButtonGetState( widPrimersChooseTemplatesByPositionInsteadOfQualityTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersChooseTemplatesByPositionInsteadOfQuality_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersChooseTemplatesByPositionInsteadOfQuality_,
              CONDEF->bPrimersChooseTemplatesByPositionInsteadOfQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersChooseTemplatesByPositionInsteadOfQualityRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersWhenChoosingATemplateMinPotentialReadLength( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersWhenChoosingATemplateMinPotentialReadLength() );
}
void guiEditResources :: checkPrimersWhenChoosingATemplateMinPotentialReadLength() {



   char* szValue =
   XmTextFieldGetString( widPrimersWhenChoosingATemplateMinPotentialReadLength_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersWhenChoosingATemplateMinPotentialReadLength must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersWhenChoosingATemplateMinPotentialReadLength_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersWhenChoosingATemplateMinPotentialReadLength_,
              CONDEF->nPrimersWhenChoosingATemplateMinPotentialReadLength_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersWhenChoosingATemplateMinPotentialReadLength_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersWindowSizeInLookingForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersWindowSizeInLookingForPCR() );
}
void guiEditResources :: checkPrimersWindowSizeInLookingForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersWindowSizeInLookingForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersWindowSizeInLookingForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersWindowSizeInLookingForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersWindowSizeInLookingForPCR_,
              CONDEF->nPrimersWindowSizeInLookingForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersWindowSizeInLookingForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbQualityThresholdForFindingHighQualityDiscrepancies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkQualityThresholdForFindingHighQualityDiscrepancies() );
}
void guiEditResources :: checkQualityThresholdForFindingHighQualityDiscrepancies() {



   char* szValue =
   XmTextFieldGetString( widQualityThresholdForFindingHighQualityDiscrepancies_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.QualityThresholdForFindingHighQualityDiscrepancies must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nQualityThresholdForFindingHighQualityDiscrepancies_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nQualityThresholdForFindingHighQualityDiscrepancies_,
              CONDEF->nQualityThresholdForFindingHighQualityDiscrepancies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widQualityThresholdForFindingHighQualityDiscrepancies_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbQualityThresholdForNavigateByDepthOfCoverage( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkQualityThresholdForNavigateByDepthOfCoverage() );
}
void guiEditResources :: checkQualityThresholdForNavigateByDepthOfCoverage() {



   char* szValue =
   XmTextFieldGetString( widQualityThresholdForNavigateByDepthOfCoverage_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.QualityThresholdForNavigateByDepthOfCoverage must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nQualityThresholdForNavigateByDepthOfCoverage_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nQualityThresholdForNavigateByDepthOfCoverage_,
              CONDEF->nQualityThresholdForNavigateByDepthOfCoverage_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widQualityThresholdForNavigateByDepthOfCoverage_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighDepthOfCoverageNotLow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighDepthOfCoverageNotLow() );
}
void guiEditResources :: checkNavigateByHighDepthOfCoverageNotLow() {



   bool b =
      XmToggleButtonGetState( widNavigateByHighDepthOfCoverageNotLowTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateByHighDepthOfCoverageNotLow_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateByHighDepthOfCoverageNotLow_,
              CONDEF->bNavigateByHighDepthOfCoverageNotLow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighDepthOfCoverageNotLowRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMinDepthForNavigateByDepthOfCoverage( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMinDepthForNavigateByDepthOfCoverage() );
}
void guiEditResources :: checkMinDepthForNavigateByDepthOfCoverage() {



   char* szValue =
   XmTextFieldGetString( widMinDepthForNavigateByDepthOfCoverage_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MinDepthForNavigateByDepthOfCoverage must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMinDepthForNavigateByDepthOfCoverage_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMinDepthForNavigateByDepthOfCoverage_,
              CONDEF->nMinDepthForNavigateByDepthOfCoverage_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMinDepthForNavigateByDepthOfCoverage_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDefaultVectorPathnameForRestrictionFragments( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDefaultVectorPathnameForRestrictionFragments() );
}
void guiEditResources :: checkDefaultVectorPathnameForRestrictionFragments() {



   char* szValue =
   XmTextFieldGetString( widDefaultVectorPathnameForRestrictionFragments_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filDefaultVectorPathnameForRestrictionFragments_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filDefaultVectorPathnameForRestrictionFragments_,
              CONDEF->filDefaultVectorPathnameForRestrictionFragments_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDefaultVectorPathnameForRestrictionFragments_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFileOfAdditionalRestrictionEnzymes( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFileOfAdditionalRestrictionEnzymes() );
}
void guiEditResources :: checkFileOfAdditionalRestrictionEnzymes() {



   char* szValue =
   XmTextFieldGetString( widFileOfAdditionalRestrictionEnzymes_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFileOfAdditionalRestrictionEnzymes_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFileOfAdditionalRestrictionEnzymes_,
              CONDEF->filFileOfAdditionalRestrictionEnzymes_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFileOfAdditionalRestrictionEnzymes_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCommonRestrictionEnzymes( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCommonRestrictionEnzymes() );
}
void guiEditResources :: checkCommonRestrictionEnzymes() {



   char* szValue =
   XmTextFieldGetString( widCommonRestrictionEnzymes_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soCommonRestrictionEnzymes_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soCommonRestrictionEnzymes_,
              CONDEF->soCommonRestrictionEnzymes_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCommonRestrictionEnzymes_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDefaultSelectedRestrictionEnzymes( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDefaultSelectedRestrictionEnzymes() );
}
void guiEditResources :: checkDefaultSelectedRestrictionEnzymes() {



   char* szValue =
   XmTextFieldGetString( widDefaultSelectedRestrictionEnzymes_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soDefaultSelectedRestrictionEnzymes_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soDefaultSelectedRestrictionEnzymes_,
              CONDEF->soDefaultSelectedRestrictionEnzymes_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDefaultSelectedRestrictionEnzymes_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionEnzymesActualFragmentsFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionEnzymesActualFragmentsFile() );
}
void guiEditResources :: checkRestrictionEnzymesActualFragmentsFile() {



   char* szValue =
   XmTextFieldGetString( widRestrictionEnzymesActualFragmentsFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filRestrictionEnzymesActualFragmentsFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filRestrictionEnzymesActualFragmentsFile_,
              CONDEF->filRestrictionEnzymesActualFragmentsFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionEnzymesActualFragmentsFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestInitialWindowSizeInTextRows( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestInitialWindowSizeInTextRows() );
}
void guiEditResources :: checkRestrictionDigestInitialWindowSizeInTextRows() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestInitialWindowSizeInTextRows_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.RestrictionDigestInitialWindowSizeInTextRows must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nRestrictionDigestInitialWindowSizeInTextRows_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nRestrictionDigestInitialWindowSizeInTextRows_,
              CONDEF->nRestrictionDigestInitialWindowSizeInTextRows_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestInitialWindowSizeInTextRows_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize() );
}
void guiEditResources :: checkRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.RestrictionDigestDoNoShowAreaOfFragmentsOverThisSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_,
              CONDEF->nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowReadsAlphabetically( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowReadsAlphabetically() );
}
void guiEditResources :: checkShowReadsAlphabetically() {



   bool b =
      XmToggleButtonGetState( widShowReadsAlphabeticallyTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bShowReadsAlphabetically_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bShowReadsAlphabetically_,
              CONDEF->bShowReadsAlphabetically_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowReadsAlphabeticallyRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowReadsInAlignedReadsWindowOrderedByFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowReadsInAlignedReadsWindowOrderedByFile() );
}
void guiEditResources :: checkShowReadsInAlignedReadsWindowOrderedByFile() {



   bool b =
      XmToggleButtonGetState( widShowReadsInAlignedReadsWindowOrderedByFileTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bShowReadsInAlignedReadsWindowOrderedByFile_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bShowReadsInAlignedReadsWindowOrderedByFile_,
              CONDEF->bShowReadsInAlignedReadsWindowOrderedByFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowReadsInAlignedReadsWindowOrderedByFileRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowReadsInAlignedReadsWindowOrderedByThisFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowReadsInAlignedReadsWindowOrderedByThisFile() );
}
void guiEditResources :: checkShowReadsInAlignedReadsWindowOrderedByThisFile() {



   char* szValue =
   XmTextFieldGetString( widShowReadsInAlignedReadsWindowOrderedByThisFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filShowReadsInAlignedReadsWindowOrderedByThisFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filShowReadsInAlignedReadsWindowOrderedByThisFile_,
              CONDEF->filShowReadsInAlignedReadsWindowOrderedByThisFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowReadsInAlignedReadsWindowOrderedByThisFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowReadsAtCursorSortedHow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowReadsAtCursorSortedHow() );
}
void guiEditResources :: checkShowReadsAtCursorSortedHow() {



   char* szValue =
   XmTextFieldGetString( widShowReadsAtCursorSortedHow_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soShowReadsAtCursorSortedHow_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soShowReadsAtCursorSortedHow_,
              CONDEF->soShowReadsAtCursorSortedHow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowReadsAtCursorSortedHow_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowABIBasesInTraceWindow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowABIBasesInTraceWindow() );
}
void guiEditResources :: checkShowABIBasesInTraceWindow() {



   bool b =
      XmToggleButtonGetState( widShowABIBasesInTraceWindowTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bShowABIBasesInTraceWindow_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bShowABIBasesInTraceWindow_,
              CONDEF->bShowABIBasesInTraceWindow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowABIBasesInTraceWindowRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbTracesWindowInitialPixelHeight( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkTracesWindowInitialPixelHeight() );
}
void guiEditResources :: checkTracesWindowInitialPixelHeight() {



   char* szValue =
   XmTextFieldGetString( widTracesWindowInitialPixelHeight_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.TracesWindowInitialPixelHeight must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nTracesWindowInitialPixelHeight_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nTracesWindowInitialPixelHeight_,
              CONDEF->nTracesWindowInitialPixelHeight_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widTracesWindowInitialPixelHeight_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewWindowInitialPixelHeight( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewWindowInitialPixelHeight() );
}
void guiEditResources :: checkAssemblyViewWindowInitialPixelHeight() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewWindowInitialPixelHeight_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewWindowInitialPixelHeight must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewWindowInitialPixelHeight_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewWindowInitialPixelHeight_,
              CONDEF->nAssemblyViewWindowInitialPixelHeight_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewWindowInitialPixelHeight_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewFileOfTemplatesToNotShow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewFileOfTemplatesToNotShow() );
}
void guiEditResources :: checkAssemblyViewFileOfTemplatesToNotShow() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewFileOfTemplatesToNotShow_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAssemblyViewFileOfTemplatesToNotShow_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAssemblyViewFileOfTemplatesToNotShow_,
              CONDEF->filAssemblyViewFileOfTemplatesToNotShow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewFileOfTemplatesToNotShow_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewCrossMatchMinmatch( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewCrossMatchMinmatch() );
}
void guiEditResources :: checkAssemblyViewCrossMatchMinmatch() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewCrossMatchMinmatch_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewCrossMatchMinmatch must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewCrossMatchMinmatch_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewCrossMatchMinmatch_,
              CONDEF->nAssemblyViewCrossMatchMinmatch_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewCrossMatchMinmatch_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewCrossMatchMinscore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewCrossMatchMinscore() );
}
void guiEditResources :: checkAssemblyViewCrossMatchMinscore() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewCrossMatchMinscore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewCrossMatchMinscore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewCrossMatchMinscore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewCrossMatchMinscore_,
              CONDEF->nAssemblyViewCrossMatchMinscore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewCrossMatchMinscore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewFindSequenceMatchesForConsedScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewFindSequenceMatchesForConsedScript() );
}
void guiEditResources :: checkAssemblyViewFindSequenceMatchesForConsedScript() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewFindSequenceMatchesForConsedScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAssemblyViewFindSequenceMatchesForConsedScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAssemblyViewFindSequenceMatchesForConsedScript_,
              CONDEF->filAssemblyViewFindSequenceMatchesForConsedScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewFindSequenceMatchesForConsedScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewCrossmatchMinmatch( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewCrossmatchMinmatch() );
}
void guiEditResources :: checkAssemblyViewCrossmatchMinmatch() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewCrossmatchMinmatch_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewCrossmatchMinmatch must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewCrossmatchMinmatch_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewCrossmatchMinmatch_,
              CONDEF->nAssemblyViewCrossmatchMinmatch_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewCrossmatchMinmatch_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewCrossmatchMinscore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewCrossmatchMinscore() );
}
void guiEditResources :: checkAssemblyViewCrossmatchMinscore() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewCrossmatchMinscore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewCrossmatchMinscore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewCrossmatchMinscore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewCrossmatchMinscore_,
              CONDEF->nAssemblyViewCrossmatchMinscore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewCrossmatchMinscore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewSequenceMatchesMinimumSimilarity( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewSequenceMatchesMinimumSimilarity() );
}
void guiEditResources :: checkAssemblyViewSequenceMatchesMinimumSimilarity() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewSequenceMatchesMinimumSimilarity_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewSequenceMatchesMinimumSimilarity must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewSequenceMatchesMinimumSimilarity_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewSequenceMatchesMinimumSimilarity_,
              CONDEF->nAssemblyViewSequenceMatchesMinimumSimilarity_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewSequenceMatchesMinimumSimilarity_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbTracesWindowInitialPixelWidth( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkTracesWindowInitialPixelWidth() );
}
void guiEditResources :: checkTracesWindowInitialPixelWidth() {



   char* szValue =
   XmTextFieldGetString( widTracesWindowInitialPixelWidth_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.TracesWindowInitialPixelWidth must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nTracesWindowInitialPixelWidth_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nTracesWindowInitialPixelWidth_,
              CONDEF->nTracesWindowInitialPixelWidth_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widTracesWindowInitialPixelWidth_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewWindowInitialPixelWidth( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewWindowInitialPixelWidth() );
}
void guiEditResources :: checkAssemblyViewWindowInitialPixelWidth() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewWindowInitialPixelWidth_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewWindowInitialPixelWidth must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewWindowInitialPixelWidth_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewWindowInitialPixelWidth_,
              CONDEF->nAssemblyViewWindowInitialPixelWidth_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewWindowInitialPixelWidth_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutomaticallyScaleTraces( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutomaticallyScaleTraces() );
}
void guiEditResources :: checkAutomaticallyScaleTraces() {



   bool b =
      XmToggleButtonGetState( widAutomaticallyScaleTracesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutomaticallyScaleTraces_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutomaticallyScaleTraces_,
              CONDEF->bAutomaticallyScaleTraces_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutomaticallyScaleTracesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight() );
}
void guiEditResources :: checkAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight() {



   char* szValue =
   XmTextFieldGetString( widAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_,
               CONDEF->dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutomaticallyScaleTracesSamplePeakPercentile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutomaticallyScaleTracesSamplePeakPercentile() );
}
void guiEditResources :: checkAutomaticallyScaleTracesSamplePeakPercentile() {



   char* szValue =
   XmTextFieldGetString( widAutomaticallyScaleTracesSamplePeakPercentile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutomaticallyScaleTracesSamplePeakPercentile must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutomaticallyScaleTracesSamplePeakPercentile_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutomaticallyScaleTracesSamplePeakPercentile_,
              CONDEF->nAutomaticallyScaleTracesSamplePeakPercentile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutomaticallyScaleTracesSamplePeakPercentile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbVerticalTraceMagnification( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkVerticalTraceMagnification() );
}
void guiEditResources :: checkVerticalTraceMagnification() {



   char* szValue =
   XmTextFieldGetString( widVerticalTraceMagnification_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.VerticalTraceMagnification must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nVerticalTraceMagnification_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nVerticalTraceMagnification_,
              CONDEF->nVerticalTraceMagnification_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widVerticalTraceMagnification_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbUserDefinedKeys( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkUserDefinedKeys() );
}
void guiEditResources :: checkUserDefinedKeys() {



   char* szValue =
   XmTextFieldGetString( widUserDefinedKeys_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soUserDefinedKeys_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soUserDefinedKeys_,
              CONDEF->soUserDefinedKeys_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widUserDefinedKeys_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbProgramsForUserDefinedKeys( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkProgramsForUserDefinedKeys() );
}
void guiEditResources :: checkProgramsForUserDefinedKeys() {



   char* szValue =
   XmTextFieldGetString( widProgramsForUserDefinedKeys_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soProgramsForUserDefinedKeys_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soProgramsForUserDefinedKeys_,
              CONDEF->soProgramsForUserDefinedKeys_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widProgramsForUserDefinedKeys_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbArgumentsToPassToUserDefinedPrograms( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkArgumentsToPassToUserDefinedPrograms() );
}
void guiEditResources :: checkArgumentsToPassToUserDefinedPrograms() {



   char* szValue =
   XmTextFieldGetString( widArgumentsToPassToUserDefinedPrograms_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soArgumentsToPassToUserDefinedPrograms_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soArgumentsToPassToUserDefinedPrograms_,
              CONDEF->soArgumentsToPassToUserDefinedPrograms_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widArgumentsToPassToUserDefinedPrograms_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbTagsToApplyWithUserDefinedKeys( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkTagsToApplyWithUserDefinedKeys() );
}
void guiEditResources :: checkTagsToApplyWithUserDefinedKeys() {



   char* szValue =
   XmTextFieldGetString( widTagsToApplyWithUserDefinedKeys_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soTagsToApplyWithUserDefinedKeys_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soTagsToApplyWithUserDefinedKeys_,
              CONDEF->soTagsToApplyWithUserDefinedKeys_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widTagsToApplyWithUserDefinedKeys_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSnpGenomeUseInsertionPolymorphisms( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSnpGenomeUseInsertionPolymorphisms() );
}
void guiEditResources :: checkSnpGenomeUseInsertionPolymorphisms() {



   bool b =
      XmToggleButtonGetState( widSnpGenomeUseInsertionPolymorphismsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bSnpGenomeUseInsertionPolymorphisms_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bSnpGenomeUseInsertionPolymorphisms_,
              CONDEF->bSnpGenomeUseInsertionPolymorphisms_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSnpGenomeUseInsertionPolymorphismsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbListOfTagTypesToHide( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkListOfTagTypesToHide() );
}
void guiEditResources :: checkListOfTagTypesToHide() {



   char* szValue =
   XmTextFieldGetString( widListOfTagTypesToHide_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soListOfTagTypesToHide_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soListOfTagTypesToHide_,
              CONDEF->soListOfTagTypesToHide_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widListOfTagTypesToHide_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbListOfOptionalWordsToSaveInListOfReadNames( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkListOfOptionalWordsToSaveInListOfReadNames() );
}
void guiEditResources :: checkListOfOptionalWordsToSaveInListOfReadNames() {



   char* szValue =
   XmTextFieldGetString( widListOfOptionalWordsToSaveInListOfReadNames_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soListOfOptionalWordsToSaveInListOfReadNames_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soListOfOptionalWordsToSaveInListOfReadNames_,
              CONDEF->soListOfOptionalWordsToSaveInListOfReadNames_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widListOfOptionalWordsToSaveInListOfReadNames_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbExtendConsensusWithHighQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkExtendConsensusWithHighQuality() );
}
void guiEditResources :: checkExtendConsensusWithHighQuality() {



   bool b =
      XmToggleButtonGetState( widExtendConsensusWithHighQualityTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bExtendConsensusWithHighQuality_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bExtendConsensusWithHighQuality_,
              CONDEF->bExtendConsensusWithHighQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widExtendConsensusWithHighQualityRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFastStartup( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFastStartup() );
}
void guiEditResources :: checkFastStartup() {



   bool b =
      XmToggleButtonGetState( widFastStartupTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bFastStartup_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bFastStartup_,
              CONDEF->bFastStartup_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFastStartupRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFastStartupFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFastStartupFile() );
}
void guiEditResources :: checkFastStartupFile() {



   char* szValue =
   XmTextFieldGetString( widFastStartupFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filFastStartupFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filFastStartupFile_,
              CONDEF->filFastStartupFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFastStartupFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAlwaysRunProgramToGetChromats( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAlwaysRunProgramToGetChromats() );
}
void guiEditResources :: checkAlwaysRunProgramToGetChromats() {



   char* szValue =
   XmTextFieldGetString( widAlwaysRunProgramToGetChromats_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAlwaysRunProgramToGetChromats_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAlwaysRunProgramToGetChromats_,
              CONDEF->soAlwaysRunProgramToGetChromats_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAlwaysRunProgramToGetChromats_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbProgramToRunToGetChromats( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkProgramToRunToGetChromats() );
}
void guiEditResources :: checkProgramToRunToGetChromats() {



   char* szValue =
   XmTextFieldGetString( widProgramToRunToGetChromats_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filProgramToRunToGetChromats_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filProgramToRunToGetChromats_,
              CONDEF->filProgramToRunToGetChromats_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widProgramToRunToGetChromats_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbProgramToRunToGetChromatsOf454Reads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkProgramToRunToGetChromatsOf454Reads() );
}
void guiEditResources :: checkProgramToRunToGetChromatsOf454Reads() {



   char* szValue =
   XmTextFieldGetString( widProgramToRunToGetChromatsOf454Reads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filProgramToRunToGetChromatsOf454Reads_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filProgramToRunToGetChromatsOf454Reads_,
              CONDEF->filProgramToRunToGetChromatsOf454Reads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widProgramToRunToGetChromatsOf454Reads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCreateFakeChromatsForSolexaReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCreateFakeChromatsForSolexaReads() );
}
void guiEditResources :: checkCreateFakeChromatsForSolexaReads() {



   bool b =
      XmToggleButtonGetState( widCreateFakeChromatsForSolexaReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bCreateFakeChromatsForSolexaReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bCreateFakeChromatsForSolexaReads_,
              CONDEF->bCreateFakeChromatsForSolexaReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCreateFakeChromatsForSolexaReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishUseLongModelReadRatherThanShort( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishUseLongModelReadRatherThanShort() );
}
void guiEditResources :: checkAutoFinishUseLongModelReadRatherThanShort() {



   bool b =
      XmToggleButtonGetState( widAutoFinishUseLongModelReadRatherThanShortTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishUseLongModelReadRatherThanShort_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishUseLongModelReadRatherThanShort_,
              CONDEF->bAutoFinishUseLongModelReadRatherThanShort_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishUseLongModelReadRatherThanShortRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAskAgainIfWantToQuitConsedIfThisManyReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAskAgainIfWantToQuitConsedIfThisManyReads() );
}
void guiEditResources :: checkAskAgainIfWantToQuitConsedIfThisManyReads() {



   char* szValue =
   XmTextFieldGetString( widAskAgainIfWantToQuitConsedIfThisManyReads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AskAgainIfWantToQuitConsedIfThisManyReads must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAskAgainIfWantToQuitConsedIfThisManyReads_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAskAgainIfWantToQuitConsedIfThisManyReads_,
              CONDEF->nAskAgainIfWantToQuitConsedIfThisManyReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAskAgainIfWantToQuitConsedIfThisManyReads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrintWindowInstructions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrintWindowInstructions() );
}
void guiEditResources :: checkPrintWindowInstructions() {



   char* szValue =
   XmTextFieldGetString( widPrintWindowInstructions_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPrintWindowInstructions_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPrintWindowInstructions_,
              CONDEF->soPrintWindowInstructions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrintWindowInstructions_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAllowMultipleSearchForStringWindows( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAllowMultipleSearchForStringWindows() );
}
void guiEditResources :: checkAllowMultipleSearchForStringWindows() {



   bool b =
      XmToggleButtonGetState( widAllowMultipleSearchForStringWindowsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAllowMultipleSearchForStringWindows_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAllowMultipleSearchForStringWindows_,
              CONDEF->bAllowMultipleSearchForStringWindows_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAllowMultipleSearchForStringWindowsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoPCRAmplifyFalseProductsOKIfLargerThanThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoPCRAmplifyFalseProductsOKIfLargerThanThis() );
}
void guiEditResources :: checkAutoPCRAmplifyFalseProductsOKIfLargerThanThis() {



   char* szValue =
   XmTextFieldGetString( widAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoPCRAmplifyFalseProductsOKIfLargerThanThis must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_,
              CONDEF->nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoPCRAmplifyFalseProductsOKIfLargerThanThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoPCRAmplifyMakePrimerOutOfFirstRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoPCRAmplifyMakePrimerOutOfFirstRegion() );
}
void guiEditResources :: checkAutoPCRAmplifyMakePrimerOutOfFirstRegion() {



   bool b =
      XmToggleButtonGetState( widAutoPCRAmplifyMakePrimerOutOfFirstRegionTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoPCRAmplifyMakePrimerOutOfFirstRegion_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoPCRAmplifyMakePrimerOutOfFirstRegion_,
              CONDEF->bAutoPCRAmplifyMakePrimerOutOfFirstRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoPCRAmplifyMakePrimerOutOfFirstRegionRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct() );
}
void guiEditResources :: checkAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct() {



   char* szValue =
   XmTextFieldGetString( widAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_,
              CONDEF->nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAddNewReadsRecalculateConsensusQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAddNewReadsRecalculateConsensusQuality() );
}
void guiEditResources :: checkAddNewReadsRecalculateConsensusQuality() {



   bool b =
      XmToggleButtonGetState( widAddNewReadsRecalculateConsensusQualityTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAddNewReadsRecalculateConsensusQuality_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAddNewReadsRecalculateConsensusQuality_,
              CONDEF->bAddNewReadsRecalculateConsensusQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAddNewReadsRecalculateConsensusQualityRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAddNewReadsPutReadIntoItsOwnContig( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAddNewReadsPutReadIntoItsOwnContig() );
}
void guiEditResources :: checkAddNewReadsPutReadIntoItsOwnContig() {



   char* szValue =
   XmTextFieldGetString( widAddNewReadsPutReadIntoItsOwnContig_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAddNewReadsPutReadIntoItsOwnContig_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAddNewReadsPutReadIntoItsOwnContig_,
              CONDEF->soAddNewReadsPutReadIntoItsOwnContig_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAddNewReadsPutReadIntoItsOwnContig_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAddNewReadsCheckThatCrossMatchRunCorrectly( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAddNewReadsCheckThatCrossMatchRunCorrectly() );
}
void guiEditResources :: checkAddNewReadsCheckThatCrossMatchRunCorrectly() {



   bool b =
      XmToggleButtonGetState( widAddNewReadsCheckThatCrossMatchRunCorrectlyTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAddNewReadsCheckThatCrossMatchRunCorrectly_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAddNewReadsCheckThatCrossMatchRunCorrectly_,
              CONDEF->bAddNewReadsCheckThatCrossMatchRunCorrectly_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAddNewReadsCheckThatCrossMatchRunCorrectlyRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewNumberOfRowsOfTags( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewNumberOfRowsOfTags() );
}
void guiEditResources :: checkAssemblyViewNumberOfRowsOfTags() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewNumberOfRowsOfTags_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewNumberOfRowsOfTags must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewNumberOfRowsOfTags_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewNumberOfRowsOfTags_,
              CONDEF->nAssemblyViewNumberOfRowsOfTags_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewNumberOfRowsOfTags_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWarnUserWhenTryingToEditAllReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWarnUserWhenTryingToEditAllReads() );
}
void guiEditResources :: checkWarnUserWhenTryingToEditAllReads() {



   bool b =
      XmToggleButtonGetState( widWarnUserWhenTryingToEditAllReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bWarnUserWhenTryingToEditAllReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bWarnUserWhenTryingToEditAllReads_,
              CONDEF->bWarnUserWhenTryingToEditAllReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWarnUserWhenTryingToEditAllReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaybeXKEYSYMDBPath( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaybeXKEYSYMDBPath() );
}
void guiEditResources :: checkMaybeXKEYSYMDBPath() {



   char* szValue =
   XmTextFieldGetString( widMaybeXKEYSYMDBPath_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filMaybeXKEYSYMDBPath_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filMaybeXKEYSYMDBPath_,
              CONDEF->filMaybeXKEYSYMDBPath_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaybeXKEYSYMDBPath_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaybeXKEYSYMDBPath2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaybeXKEYSYMDBPath2() );
}
void guiEditResources :: checkMaybeXKEYSYMDBPath2() {



   char* szValue =
   XmTextFieldGetString( widMaybeXKEYSYMDBPath2_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filMaybeXKEYSYMDBPath2_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filMaybeXKEYSYMDBPath2_,
              CONDEF->filMaybeXKEYSYMDBPath2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaybeXKEYSYMDBPath2_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAmountToMoveWithBigLeftAndRightArrows( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAmountToMoveWithBigLeftAndRightArrows() );
}
void guiEditResources :: checkAmountToMoveWithBigLeftAndRightArrows() {



   char* szValue =
   XmTextFieldGetString( widAmountToMoveWithBigLeftAndRightArrows_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AmountToMoveWithBigLeftAndRightArrows must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAmountToMoveWithBigLeftAndRightArrows_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAmountToMoveWithBigLeftAndRightArrows_,
              CONDEF->nAmountToMoveWithBigLeftAndRightArrows_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAmountToMoveWithBigLeftAndRightArrows_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsMinDiscrepantReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsMinDiscrepantReads() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsMinDiscrepantReads() {



   char* szValue =
   XmTextFieldGetString( widNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.NavigateByHighlyDiscrepantPositionsMinDiscrepantReads must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_,
              CONDEF->nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage() {



   char* szValue =
   XmTextFieldGetString( widNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.NavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_,
              CONDEF->nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality() {



   char* szValue =
   XmTextFieldGetString( widNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.NavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_,
              CONDEF->nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsJustListIndels( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsJustListIndels() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsJustListIndels() {



   bool b =
      XmToggleButtonGetState( widNavigateByHighlyDiscrepantPositionsJustListIndelsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateByHighlyDiscrepantPositionsJustListIndels_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateByHighlyDiscrepantPositionsJustListIndels_,
              CONDEF->bNavigateByHighlyDiscrepantPositionsJustListIndels_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsJustListIndelsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation() {



   bool b =
      XmToggleButtonGetState( widNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocationTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_,
              CONDEF->bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocationRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus() {



   bool b =
      XmToggleButtonGetState( widNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensusTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_,
              CONDEF->bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensusRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus() );
}
void guiEditResources :: checkNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus() {



   char* szValue =
   XmTextFieldGetString( widNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_,
              CONDEF->soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhdBallDirectory( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhdBallDirectory() );
}
void guiEditResources :: checkPhdBallDirectory() {



   char* szValue =
   XmTextFieldGetString( widPhdBallDirectory_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filPhdBallDirectory_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filPhdBallDirectory_,
              CONDEF->filPhdBallDirectory_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhdBallDirectory_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNewAceFileFOF( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNewAceFileFOF() );
}
void guiEditResources :: checkNewAceFileFOF() {



   char* szValue =
   XmTextFieldGetString( widNewAceFileFOF_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filNewAceFileFOF_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filNewAceFileFOF_,
              CONDEF->filNewAceFileFOF_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNewAceFileFOF_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNavigateByHighOrLowDepthCoalesceRegionsIfThisClose( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNavigateByHighOrLowDepthCoalesceRegionsIfThisClose() );
}
void guiEditResources :: checkNavigateByHighOrLowDepthCoalesceRegionsIfThisClose() {



   char* szValue =
   XmTextFieldGetString( widNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.NavigateByHighOrLowDepthCoalesceRegionsIfThisClose must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_,
              CONDEF->nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRemoveReadsDeleteNotJustPutInOwnContig( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRemoveReadsDeleteNotJustPutInOwnContig() );
}
void guiEditResources :: checkRemoveReadsDeleteNotJustPutInOwnContig() {



   bool b =
      XmToggleButtonGetState( widRemoveReadsDeleteNotJustPutInOwnContigTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bRemoveReadsDeleteNotJustPutInOwnContig_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bRemoveReadsDeleteNotJustPutInOwnContig_,
              CONDEF->bRemoveReadsDeleteNotJustPutInOwnContig_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRemoveReadsDeleteNotJustPutInOwnContigRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPaired454LeftReadExtension( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPaired454LeftReadExtension() );
}
void guiEditResources :: checkPaired454LeftReadExtension() {



   char* szValue =
   XmTextFieldGetString( widPaired454LeftReadExtension_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPaired454LeftReadExtension_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPaired454LeftReadExtension_,
              CONDEF->soPaired454LeftReadExtension_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPaired454LeftReadExtension_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPaired454RightReadExtension( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPaired454RightReadExtension() );
}
void guiEditResources :: checkPaired454RightReadExtension() {



   char* szValue =
   XmTextFieldGetString( widPaired454RightReadExtension_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPaired454RightReadExtension_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPaired454RightReadExtension_,
              CONDEF->soPaired454RightReadExtension_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPaired454RightReadExtension_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSnpGenome1MSnps( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSnpGenome1MSnps() );
}
void guiEditResources :: checkSnpGenome1MSnps() {



   char* szValue =
   XmTextFieldGetString( widSnpGenome1MSnps_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filSnpGenome1MSnps_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filSnpGenome1MSnps_,
              CONDEF->filSnpGenome1MSnps_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSnpGenome1MSnps_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDiffChromosomesExcludeDeletions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDiffChromosomesExcludeDeletions() );
}
void guiEditResources :: checkDiffChromosomesExcludeDeletions() {



   bool b =
      XmToggleButtonGetState( widDiffChromosomesExcludeDeletionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bDiffChromosomesExcludeDeletions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bDiffChromosomesExcludeDeletions_,
              CONDEF->bDiffChromosomesExcludeDeletions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDiffChromosomesExcludeDeletionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSnpGenomeFilterByWeight( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSnpGenomeFilterByWeight() );
}
void guiEditResources :: checkSnpGenomeFilterByWeight() {



   bool b =
      XmToggleButtonGetState( widSnpGenomeFilterByWeightTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bSnpGenomeFilterByWeight_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bSnpGenomeFilterByWeight_,
              CONDEF->bSnpGenomeFilterByWeight_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSnpGenomeFilterByWeightRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWantReadsUpToThisFarFromSnps( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWantReadsUpToThisFarFromSnps() );
}
void guiEditResources :: checkWantReadsUpToThisFarFromSnps() {



   char* szValue =
   XmTextFieldGetString( widWantReadsUpToThisFarFromSnps_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.WantReadsUpToThisFarFromSnps must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nWantReadsUpToThisFarFromSnps_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nWantReadsUpToThisFarFromSnps_,
              CONDEF->nWantReadsUpToThisFarFromSnps_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWantReadsUpToThisFarFromSnps_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhaster2PhdBallSaveWhichMate( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhaster2PhdBallSaveWhichMate() );
}
void guiEditResources :: checkPhaster2PhdBallSaveWhichMate() {



   char* szValue =
   XmTextFieldGetString( widPhaster2PhdBallSaveWhichMate_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soPhaster2PhdBallSaveWhichMate_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soPhaster2PhdBallSaveWhichMate_,
              CONDEF->soPhaster2PhdBallSaveWhichMate_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhaster2PhdBallSaveWhichMate_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhaster2PhdBallSaveInPhasterFormat( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhaster2PhdBallSaveInPhasterFormat() );
}
void guiEditResources :: checkPhaster2PhdBallSaveInPhasterFormat() {



   bool b =
      XmToggleButtonGetState( widPhaster2PhdBallSaveInPhasterFormatTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPhaster2PhdBallSaveInPhasterFormat_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPhaster2PhdBallSaveInPhasterFormat_,
              CONDEF->bPhaster2PhdBallSaveInPhasterFormat_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhaster2PhdBallSaveInPhasterFormatRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhaster2PhdBallCalculateNewLocationsFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhaster2PhdBallCalculateNewLocationsFile() );
}
void guiEditResources :: checkPhaster2PhdBallCalculateNewLocationsFile() {



   bool b =
      XmToggleButtonGetState( widPhaster2PhdBallCalculateNewLocationsFileTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPhaster2PhdBallCalculateNewLocationsFile_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPhaster2PhdBallCalculateNewLocationsFile_,
              CONDEF->bPhaster2PhdBallCalculateNewLocationsFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhaster2PhdBallCalculateNewLocationsFileRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhdBall2FastaIgnoreLowQualityReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhdBall2FastaIgnoreLowQualityReads() );
}
void guiEditResources :: checkPhdBall2FastaIgnoreLowQualityReads() {



   bool b =
      XmToggleButtonGetState( widPhdBall2FastaIgnoreLowQualityReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPhdBall2FastaIgnoreLowQualityReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPhdBall2FastaIgnoreLowQualityReads_,
              CONDEF->bPhdBall2FastaIgnoreLowQualityReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhdBall2FastaIgnoreLowQualityReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPhdBall2FastaLowestAverageQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPhdBall2FastaLowestAverageQuality() );
}
void guiEditResources :: checkPhdBall2FastaLowestAverageQuality() {



   char* szValue =
   XmTextFieldGetString( widPhdBall2FastaLowestAverageQuality_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PhdBall2FastaLowestAverageQuality must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPhdBall2FastaLowestAverageQuality_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPhdBall2FastaLowestAverageQuality_,
              CONDEF->nPhdBall2FastaLowestAverageQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPhdBall2FastaLowestAverageQuality_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNextPhredPipelineControlFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNextPhredPipelineControlFile() );
}
void guiEditResources :: checkNextPhredPipelineControlFile() {



   char* szValue =
   XmTextFieldGetString( widNextPhredPipelineControlFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filNextPhredPipelineControlFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filNextPhredPipelineControlFile_,
              CONDEF->filNextPhredPipelineControlFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNextPhredPipelineControlFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNextPhredPipelineTiffPerlScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNextPhredPipelineTiffPerlScript() );
}
void guiEditResources :: checkNextPhredPipelineTiffPerlScript() {



   char* szValue =
   XmTextFieldGetString( widNextPhredPipelineTiffPerlScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filNextPhredPipelineTiffPerlScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filNextPhredPipelineTiffPerlScript_,
              CONDEF->filNextPhredPipelineTiffPerlScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNextPhredPipelineTiffPerlScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNextPhredPipelinePhasterPerlScript( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNextPhredPipelinePhasterPerlScript() );
}
void guiEditResources :: checkNextPhredPipelinePhasterPerlScript() {



   char* szValue =
   XmTextFieldGetString( widNextPhredPipelinePhasterPerlScript_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filNextPhredPipelinePhasterPerlScript_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filNextPhredPipelinePhasterPerlScript_,
              CONDEF->filNextPhredPipelinePhasterPerlScript_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNextPhredPipelinePhasterPerlScript_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNextPhredPipelineVersion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNextPhredPipelineVersion() );
}
void guiEditResources :: checkNextPhredPipelineVersion() {



   char* szValue =
   XmTextFieldGetString( widNextPhredPipelineVersion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soNextPhredPipelineVersion_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soNextPhredPipelineVersion_,
              CONDEF->soNextPhredPipelineVersion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNextPhredPipelineVersion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbNextPhredPipelineMainDirectory( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkNextPhredPipelineMainDirectory() );
}
void guiEditResources :: checkNextPhredPipelineMainDirectory() {



   char* szValue =
   XmTextFieldGetString( widNextPhredPipelineMainDirectory_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soNextPhredPipelineMainDirectory_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soNextPhredPipelineMainDirectory_,
              CONDEF->soNextPhredPipelineMainDirectory_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widNextPhredPipelineMainDirectory_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaxNumberOfReadsPerPhdBall( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaxNumberOfReadsPerPhdBall() );
}
void guiEditResources :: checkMaxNumberOfReadsPerPhdBall() {



   char* szValue =
   XmTextFieldGetString( widMaxNumberOfReadsPerPhdBall_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaxNumberOfReadsPerPhdBall must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaxNumberOfReadsPerPhdBall_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaxNumberOfReadsPerPhdBall_,
              CONDEF->nMaxNumberOfReadsPerPhdBall_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaxNumberOfReadsPerPhdBall_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbUserWantsToSaveToThisAceFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkUserWantsToSaveToThisAceFile() );
}
void guiEditResources :: checkUserWantsToSaveToThisAceFile() {



   char* szValue =
   XmTextFieldGetString( widUserWantsToSaveToThisAceFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filUserWantsToSaveToThisAceFile_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filUserWantsToSaveToThisAceFile_,
              CONDEF->filUserWantsToSaveToThisAceFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widUserWantsToSaveToThisAceFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishEmulate9_66Behavior( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishEmulate9_66Behavior() );
}
void guiEditResources :: checkAutoFinishEmulate9_66Behavior() {



   bool b =
      XmToggleButtonGetState( widAutoFinishEmulate9_66BehaviorTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishEmulate9_66Behavior_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishEmulate9_66Behavior_,
              CONDEF->bAutoFinishEmulate9_66Behavior_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishEmulate9_66BehaviorRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersPCRPrimersGroupedIntoWindowOfThisManyBases( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersPCRPrimersGroupedIntoWindowOfThisManyBases() );
}
void guiEditResources :: checkPrimersPCRPrimersGroupedIntoWindowOfThisManyBases() {



   char* szValue =
   XmTextFieldGetString( widPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersPCRPrimersGroupedIntoWindowOfThisManyBases must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_,
              CONDEF->nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups() );
}
void guiEditResources :: checkPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups() {



   char* szValue =
   XmTextFieldGetString( widPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersLookForThisManyPCRPrimerPairsPerPairOfGroups must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_,
              CONDEF->nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs() );
}
void guiEditResources :: checkAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_,
               CONDEF->dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent() );
}
void guiEditResources :: checkAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent() {



   bool b =
      XmToggleButtonGetState( widAutoFinishCheckThatReadsFromTheSameTemplateAreConsistentTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_,
              CONDEF->bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishCheckThatReadsFromTheSameTemplateAreConsistentRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether() );
}
void guiEditResources :: checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether() {



   bool b =
      XmToggleButtonGetState( widAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogetherTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_,
              CONDEF->bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogetherRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether() );
}
void guiEditResources :: checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether() {



   bool b =
      XmToggleButtonGetState( widAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogetherTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_,
              CONDEF->bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogetherRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean() );
}
void guiEditResources :: checkAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_,
               CONDEF->dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize() );
}
void guiEditResources :: checkAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_,
              CONDEF->nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize() );
}
void guiEditResources :: checkAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_,
               CONDEF->dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead() );
}
void guiEditResources :: checkAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_,
              CONDEF->nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp() );
}
void guiEditResources :: checkAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_,
              CONDEF->nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishNumberOfBasesBetweenContigsAssumed( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishNumberOfBasesBetweenContigsAssumed() );
}
void guiEditResources :: checkAutoFinishNumberOfBasesBetweenContigsAssumed() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishNumberOfBasesBetweenContigsAssumed_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishNumberOfBasesBetweenContigsAssumed must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishNumberOfBasesBetweenContigsAssumed_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishNumberOfBasesBetweenContigsAssumed_,
              CONDEF->nAutoFinishNumberOfBasesBetweenContigsAssumed_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishNumberOfBasesBetweenContigsAssumed_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishPotentialHighQualityPartOfReadStart( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishPotentialHighQualityPartOfReadStart() );
}
void guiEditResources :: checkAutoFinishPotentialHighQualityPartOfReadStart() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishPotentialHighQualityPartOfReadStart_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishPotentialHighQualityPartOfReadStart must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishPotentialHighQualityPartOfReadStart_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishPotentialHighQualityPartOfReadStart_,
              CONDEF->nAutoFinishPotentialHighQualityPartOfReadStart_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishPotentialHighQualityPartOfReadStart_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishPotentialHighQualityPartOfReadEnd( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishPotentialHighQualityPartOfReadEnd() );
}
void guiEditResources :: checkAutoFinishPotentialHighQualityPartOfReadEnd() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishPotentialHighQualityPartOfReadEnd_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishPotentialHighQualityPartOfReadEnd must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishPotentialHighQualityPartOfReadEnd_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishPotentialHighQualityPartOfReadEnd_,
              CONDEF->nAutoFinishPotentialHighQualityPartOfReadEnd_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishPotentialHighQualityPartOfReadEnd_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishPrintCustomNavigationFileForChosenReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishPrintCustomNavigationFileForChosenReads() );
}
void guiEditResources :: checkAutoFinishPrintCustomNavigationFileForChosenReads() {



   bool b =
      XmToggleButtonGetState( widAutoFinishPrintCustomNavigationFileForChosenReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishPrintCustomNavigationFileForChosenReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishPrintCustomNavigationFileForChosenReads_,
              CONDEF->bAutoFinishPrintCustomNavigationFileForChosenReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishPrintCustomNavigationFileForChosenReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch() );
}
void guiEditResources :: checkAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_,
              CONDEF->nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishTagOligosWhenDoExperiments( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishTagOligosWhenDoExperiments() );
}
void guiEditResources :: checkAutoFinishTagOligosWhenDoExperiments() {



   bool b =
      XmToggleButtonGetState( widAutoFinishTagOligosWhenDoExperimentsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoFinishTagOligosWhenDoExperiments_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoFinishTagOligosWhenDoExperiments_,
              CONDEF->bAutoFinishTagOligosWhenDoExperiments_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishTagOligosWhenDoExperimentsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbCountPads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkCountPads() );
}
void guiEditResources :: checkCountPads() {



   bool b =
      XmToggleButtonGetState( widCountPadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bCountPads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bCountPads_,
              CONDEF->bCountPads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widCountPadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDebugging( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDebugging() );
}
void guiEditResources :: checkDebugging() {



   char* szValue =
   XmTextFieldGetString( widDebugging_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.Debugging must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nDebugging_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nDebugging_,
              CONDEF->nDebugging_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDebugging_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDebugging2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDebugging2() );
}
void guiEditResources :: checkDebugging2() {



   char* szValue =
   XmTextFieldGetString( widDebugging2_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.Debugging2 must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nDebugging2_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nDebugging2_,
              CONDEF->nDebugging2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDebugging2_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDebugging3( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDebugging3() );
}
void guiEditResources :: checkDebugging3() {



   char* szValue =
   XmTextFieldGetString( widDebugging3_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.Debugging3 must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nDebugging3_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nDebugging3_,
              CONDEF->nDebugging3_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDebugging3_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDebuggingString( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDebuggingString() );
}
void guiEditResources :: checkDebuggingString() {



   char* szValue =
   XmTextFieldGetString( widDebuggingString_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soDebuggingString_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soDebuggingString_,
              CONDEF->soDebuggingString_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDebuggingString_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion() );
}
void guiEditResources :: checkIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion() {



   char* szValue =
   XmTextFieldGetString( widIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.IgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_,
              CONDEF->nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbIgnoreUnalignedHighQualitySegmentsShorterThanThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkIgnoreUnalignedHighQualitySegmentsShorterThanThis() );
}
void guiEditResources :: checkIgnoreUnalignedHighQualitySegmentsShorterThanThis() {



   char* szValue =
   XmTextFieldGetString( widIgnoreUnalignedHighQualitySegmentsShorterThanThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.IgnoreUnalignedHighQualitySegmentsShorterThanThis must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nIgnoreUnalignedHighQualitySegmentsShorterThanThis_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nIgnoreUnalignedHighQualitySegmentsShorterThanThis_,
              CONDEF->nIgnoreUnalignedHighQualitySegmentsShorterThanThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widIgnoreUnalignedHighQualitySegmentsShorterThanThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersLookThisFarForForwardVectorInsertJunction( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersLookThisFarForForwardVectorInsertJunction() );
}
void guiEditResources :: checkPrimersLookThisFarForForwardVectorInsertJunction() {



   char* szValue =
   XmTextFieldGetString( widPrimersLookThisFarForForwardVectorInsertJunction_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersLookThisFarForForwardVectorInsertJunction must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersLookThisFarForForwardVectorInsertJunction_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersLookThisFarForForwardVectorInsertJunction_,
              CONDEF->nPrimersLookThisFarForForwardVectorInsertJunction_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersLookThisFarForForwardVectorInsertJunction_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersDNAConcentrationNanomolar( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersDNAConcentrationNanomolar() );
}
void guiEditResources :: checkPrimersDNAConcentrationNanomolar() {



   char* szValue =
   XmTextFieldGetString( widPrimersDNAConcentrationNanomolar_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "PrimersDNAConcentrationNanomolar must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dPrimersDNAConcentrationNanomolar_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dPrimersDNAConcentrationNanomolar_,
               CONDEF->dPrimersDNAConcentrationNanomolar_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersDNAConcentrationNanomolar_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxMatchElsewhereScore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxMatchElsewhereScore() );
}
void guiEditResources :: checkPrimersMaxMatchElsewhereScore() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxMatchElsewhereScore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxMatchElsewhereScore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxMatchElsewhereScore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxMatchElsewhereScore_,
              CONDEF->nPrimersMaxMatchElsewhereScore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxMatchElsewhereScore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxMatchElsewhereScoreForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxMatchElsewhereScoreForPCR() );
}
void guiEditResources :: checkPrimersMaxMatchElsewhereScoreForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxMatchElsewhereScoreForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxMatchElsewhereScoreForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxMatchElsewhereScoreForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxMatchElsewhereScoreForPCR_,
              CONDEF->nPrimersMaxMatchElsewhereScoreForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxMatchElsewhereScoreForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxSelfMatchScore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxSelfMatchScore() );
}
void guiEditResources :: checkPrimersMaxSelfMatchScore() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxSelfMatchScore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxSelfMatchScore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxSelfMatchScore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxSelfMatchScore_,
              CONDEF->nPrimersMaxSelfMatchScore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxSelfMatchScore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMaxPrimerDimerScoreForPCR( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMaxPrimerDimerScoreForPCR() );
}
void guiEditResources :: checkPrimersMaxPrimerDimerScoreForPCR() {



   char* szValue =
   XmTextFieldGetString( widPrimersMaxPrimerDimerScoreForPCR_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMaxPrimerDimerScoreForPCR must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMaxPrimerDimerScoreForPCR_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMaxPrimerDimerScoreForPCR_,
              CONDEF->nPrimersMaxPrimerDimerScoreForPCR_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMaxPrimerDimerScoreForPCR_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersMinQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersMinQuality() );
}
void guiEditResources :: checkPrimersMinQuality() {



   char* szValue =
   XmTextFieldGetString( widPrimersMinQuality_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersMinQuality must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersMinQuality_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersMinQuality_,
              CONDEF->nPrimersMinQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersMinQuality_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersPrintInfoOnRejectedTemplates( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersPrintInfoOnRejectedTemplates() );
}
void guiEditResources :: checkPrimersPrintInfoOnRejectedTemplates() {



   bool b =
      XmToggleButtonGetState( widPrimersPrintInfoOnRejectedTemplatesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersPrintInfoOnRejectedTemplates_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersPrintInfoOnRejectedTemplates_,
              CONDEF->bPrimersPrintInfoOnRejectedTemplates_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersPrintInfoOnRejectedTemplatesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersSaltConcentrationMillimolar( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersSaltConcentrationMillimolar() );
}
void guiEditResources :: checkPrimersSaltConcentrationMillimolar() {



   char* szValue =
   XmTextFieldGetString( widPrimersSaltConcentrationMillimolar_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "PrimersSaltConcentrationMillimolar must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dPrimersSaltConcentrationMillimolar_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dPrimersSaltConcentrationMillimolar_,
               CONDEF->dPrimersSaltConcentrationMillimolar_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersSaltConcentrationMillimolar_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersScreenForVector( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersScreenForVector() );
}
void guiEditResources :: checkPrimersScreenForVector() {



   bool b =
      XmToggleButtonGetState( widPrimersScreenForVectorTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bPrimersScreenForVector_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bPrimersScreenForVector_,
              CONDEF->bPrimersScreenForVector_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersScreenForVectorRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads() );
}
void guiEditResources :: checkPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads() {



   char* szValue =
   XmTextFieldGetString( widPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_,
              CONDEF->nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbPrimersTooManyVectorBasesInWalkingRead( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkPrimersTooManyVectorBasesInWalkingRead() );
}
void guiEditResources :: checkPrimersTooManyVectorBasesInWalkingRead() {



   char* szValue =
   XmTextFieldGetString( widPrimersTooManyVectorBasesInWalkingRead_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.PrimersTooManyVectorBasesInWalkingRead must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nPrimersTooManyVectorBasesInWalkingRead_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nPrimersTooManyVectorBasesInWalkingRead_,
              CONDEF->nPrimersTooManyVectorBasesInWalkingRead_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widPrimersTooManyVectorBasesInWalkingRead_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbQualityThresholdForLowConsensusQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkQualityThresholdForLowConsensusQuality() );
}
void guiEditResources :: checkQualityThresholdForLowConsensusQuality() {



   char* szValue =
   XmTextFieldGetString( widQualityThresholdForLowConsensusQuality_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.QualityThresholdForLowConsensusQuality must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nQualityThresholdForLowConsensusQuality_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nQualityThresholdForLowConsensusQuality_,
              CONDEF->nQualityThresholdForLowConsensusQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widQualityThresholdForLowConsensusQuality_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbTagColorPerCentOfBase( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkTagColorPerCentOfBase() );
}
void guiEditResources :: checkTagColorPerCentOfBase() {



   char* szValue =
   XmTextFieldGetString( widTagColorPerCentOfBase_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.TagColorPerCentOfBase must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nTagColorPerCentOfBase_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nTagColorPerCentOfBase_,
              CONDEF->nTagColorPerCentOfBase_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widTagColorPerCentOfBase_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbUncompressedChromatDirectory( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkUncompressedChromatDirectory() );
}
void guiEditResources :: checkUncompressedChromatDirectory() {



   char* szValue =
   XmTextFieldGetString( widUncompressedChromatDirectory_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soUncompressedChromatDirectory_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soUncompressedChromatDirectory_,
              CONDEF->soUncompressedChromatDirectory_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widUncompressedChromatDirectory_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cb454sff2scfDirectory( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->check454sff2scfDirectory() );
}
void guiEditResources :: check454sff2scfDirectory() {



   char* szValue =
   XmTextFieldGetString( wid454sff2scfDirectory_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.fil454sff2scfDirectory_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.fil454sff2scfDirectory_,
              CONDEF->fil454sff2scfDirectory_,
              pixForeground,
              pixBackground );

   XtVaSetValues( wid454sff2scfDirectory_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion() );
}
void guiEditResources :: checkWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion() {



   char* szValue =
   XmTextFieldGetString( widWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.WhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_,
              CONDEF->nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbWriteThisAceFormat( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkWriteThisAceFormat() );
}
void guiEditResources :: checkWriteThisAceFormat() {



   char* szValue =
   XmTextFieldGetString( widWriteThisAceFormat_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.WriteThisAceFormat must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nWriteThisAceFormat_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nWriteThisAceFormat_,
              CONDEF->nWriteThisAceFormat_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widWriteThisAceFormat_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbDumpCoreIfBoundsError( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkDumpCoreIfBoundsError() );
}
void guiEditResources :: checkDumpCoreIfBoundsError() {



   bool b =
      XmToggleButtonGetState( widDumpCoreIfBoundsErrorTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bDumpCoreIfBoundsError_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bDumpCoreIfBoundsError_,
              CONDEF->bDumpCoreIfBoundsError_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widDumpCoreIfBoundsErrorRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishMinSmithWatermanScoreOfARun( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishMinSmithWatermanScoreOfARun() );
}
void guiEditResources :: checkAutoFinishMinSmithWatermanScoreOfARun() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishMinSmithWatermanScoreOfARun_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoFinishMinSmithWatermanScoreOfARun must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoFinishMinSmithWatermanScoreOfARun_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoFinishMinSmithWatermanScoreOfARun_,
              CONDEF->nAutoFinishMinSmithWatermanScoreOfARun_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishMinSmithWatermanScoreOfARun_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes() );
}
void guiEditResources :: checkAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes() {



   char* szValue =
   XmTextFieldGetString( widAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_,
               CONDEF->dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestMaximumBasesToCompareToVector( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestMaximumBasesToCompareToVector() );
}
void guiEditResources :: checkRestrictionDigestMaximumBasesToCompareToVector() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestMaximumBasesToCompareToVector_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.RestrictionDigestMaximumBasesToCompareToVector must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nRestrictionDigestMaximumBasesToCompareToVector_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nRestrictionDigestMaximumBasesToCompareToVector_,
              CONDEF->nRestrictionDigestMaximumBasesToCompareToVector_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestMaximumBasesToCompareToVector_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestZoomFactor( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestZoomFactor() );
}
void guiEditResources :: checkRestrictionDigestZoomFactor() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestZoomFactor_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "RestrictionDigestZoomFactor must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dRestrictionDigestZoomFactor_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dRestrictionDigestZoomFactor_,
               CONDEF->dRestrictionDigestZoomFactor_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestZoomFactor_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestZoomFactorForNavigate( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestZoomFactorForNavigate() );
}
void guiEditResources :: checkRestrictionDigestZoomFactorForNavigate() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestZoomFactorForNavigate_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "RestrictionDigestZoomFactorForNavigate must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dRestrictionDigestZoomFactorForNavigate_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dRestrictionDigestZoomFactorForNavigate_,
               CONDEF->dRestrictionDigestZoomFactorForNavigate_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestZoomFactorForNavigate_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbRestrictionDigestToleranceInPositionUnits( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkRestrictionDigestToleranceInPositionUnits() );
}
void guiEditResources :: checkRestrictionDigestToleranceInPositionUnits() {



   char* szValue =
   XmTextFieldGetString( widRestrictionDigestToleranceInPositionUnits_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.RestrictionDigestToleranceInPositionUnits must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nRestrictionDigestToleranceInPositionUnits_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nRestrictionDigestToleranceInPositionUnits_,
              CONDEF->nRestrictionDigestToleranceInPositionUnits_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widRestrictionDigestToleranceInPositionUnits_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoPCRAmplifyTooManySeriousFalseMatches( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoPCRAmplifyTooManySeriousFalseMatches() );
}
void guiEditResources :: checkAutoPCRAmplifyTooManySeriousFalseMatches() {



   char* szValue =
   XmTextFieldGetString( widAutoPCRAmplifyTooManySeriousFalseMatches_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoPCRAmplifyTooManySeriousFalseMatches must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoPCRAmplifyTooManySeriousFalseMatches_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoPCRAmplifyTooManySeriousFalseMatches_,
              CONDEF->nAutoPCRAmplifyTooManySeriousFalseMatches_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoPCRAmplifyTooManySeriousFalseMatches_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewZoomFactor( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewZoomFactor() );
}
void guiEditResources :: checkAssemblyViewZoomFactor() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewZoomFactor_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AssemblyViewZoomFactor must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAssemblyViewZoomFactor_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAssemblyViewZoomFactor_,
               CONDEF->dAssemblyViewZoomFactor_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewZoomFactor_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewFilterInconsistentFwdRevPairsIfThisClose( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewFilterInconsistentFwdRevPairsIfThisClose() );
}
void guiEditResources :: checkAssemblyViewFilterInconsistentFwdRevPairsIfThisClose() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewFilterInconsistentFwdRevPairsIfThisClose must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_,
              CONDEF->nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewGridCellWidthInPixels( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewGridCellWidthInPixels() );
}
void guiEditResources :: checkAssemblyViewGridCellWidthInPixels() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewGridCellWidthInPixels_ );
   RWCString soValue = szValue;
   XtFree( szValue );
    double d;
    if ( !bIsNumericDouble( soValue, d ) ) {
       RWCString soError = "AssemblyViewGridCellWidthInPixels must be floating point numeric";       THROW_ERROR( soError );
    }


    resources_.dAssemblyViewGridCellWidthInPixels_ = d;


    Pixel pixForeground;
    Pixel pixBackground;

    getColors( resources_.dAssemblyViewGridCellWidthInPixels_,
               CONDEF->dAssemblyViewGridCellWidthInPixels_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewGridCellWidthInPixels_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewCursorSensitivityInPixels( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewCursorSensitivityInPixels() );
}
void guiEditResources :: checkAssemblyViewCursorSensitivityInPixels() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewCursorSensitivityInPixels_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewCursorSensitivityInPixels must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewCursorSensitivityInPixels_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewCursorSensitivityInPixels_,
              CONDEF->nAssemblyViewCursorSensitivityInPixels_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewCursorSensitivityInPixels_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAssemblyViewReadDepthQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAssemblyViewReadDepthQuality() );
}
void guiEditResources :: checkAssemblyViewReadDepthQuality() {



   char* szValue =
   XmTextFieldGetString( widAssemblyViewReadDepthQuality_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AssemblyViewReadDepthQuality must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAssemblyViewReadDepthQuality_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAssemblyViewReadDepthQuality_,
              CONDEF->nAssemblyViewReadDepthQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAssemblyViewReadDepthQuality_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbShowAllTracesMaxNumberOfTracesToShowAtOnce( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkShowAllTracesMaxNumberOfTracesToShowAtOnce() );
}
void guiEditResources :: checkShowAllTracesMaxNumberOfTracesToShowAtOnce() {



   char* szValue =
   XmTextFieldGetString( widShowAllTracesMaxNumberOfTracesToShowAtOnce_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.ShowAllTracesMaxNumberOfTracesToShowAtOnce must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nShowAllTracesMaxNumberOfTracesToShowAtOnce_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nShowAllTracesMaxNumberOfTracesToShowAtOnce_,
              CONDEF->nShowAllTracesMaxNumberOfTracesToShowAtOnce_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widShowAllTracesMaxNumberOfTracesToShowAtOnce_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess() );
}
void guiEditResources :: checkAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess() {



   char* szValue =
   XmTextFieldGetString( widAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_,
              CONDEF->nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbJustForPrimateProject( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkJustForPrimateProject() );
}
void guiEditResources :: checkJustForPrimateProject() {



   bool b =
      XmToggleButtonGetState( widJustForPrimateProjectTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bJustForPrimateProject_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bJustForPrimateProject_,
              CONDEF->bJustForPrimateProject_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widJustForPrimateProjectRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSolexaFilesAreAssumedToBeHere( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSolexaFilesAreAssumedToBeHere() );
}
void guiEditResources :: checkSolexaFilesAreAssumedToBeHere() {



   char* szValue =
   XmTextFieldGetString( widSolexaFilesAreAssumedToBeHere_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filSolexaFilesAreAssumedToBeHere_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filSolexaFilesAreAssumedToBeHere_,
              CONDEF->filSolexaFilesAreAssumedToBeHere_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSolexaFilesAreAssumedToBeHere_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSolexaAlignmentFilesPerInsertingPadsCycle( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSolexaAlignmentFilesPerInsertingPadsCycle() );
}
void guiEditResources :: checkSolexaAlignmentFilesPerInsertingPadsCycle() {



   char* szValue =
   XmTextFieldGetString( widSolexaAlignmentFilesPerInsertingPadsCycle_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.SolexaAlignmentFilesPerInsertingPadsCycle must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nSolexaAlignmentFilesPerInsertingPadsCycle_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nSolexaAlignmentFilesPerInsertingPadsCycle_,
              CONDEF->nSolexaAlignmentFilesPerInsertingPadsCycle_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSolexaAlignmentFilesPerInsertingPadsCycle_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSolexaAlignmentsPerAlignmentFile( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSolexaAlignmentsPerAlignmentFile() );
}
void guiEditResources :: checkSolexaAlignmentsPerAlignmentFile() {



   char* szValue =
   XmTextFieldGetString( widSolexaAlignmentsPerAlignmentFile_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.SolexaAlignmentsPerAlignmentFile must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nSolexaAlignmentsPerAlignmentFile_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nSolexaAlignmentsPerAlignmentFile_,
              CONDEF->nSolexaAlignmentsPerAlignmentFile_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSolexaAlignmentsPerAlignmentFile_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSolexaFastqFilesArePhredQualityNotSolexaQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSolexaFastqFilesArePhredQualityNotSolexaQuality() );
}
void guiEditResources :: checkSolexaFastqFilesArePhredQualityNotSolexaQuality() {



   bool b =
      XmToggleButtonGetState( widSolexaFastqFilesArePhredQualityNotSolexaQualityTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bSolexaFastqFilesArePhredQualityNotSolexaQuality_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bSolexaFastqFilesArePhredQualityNotSolexaQuality_,
              CONDEF->bSolexaFastqFilesArePhredQualityNotSolexaQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSolexaFastqFilesArePhredQualityNotSolexaQualityRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbSolexa64FastqOrSanger33Fastq( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkSolexa64FastqOrSanger33Fastq() );
}
void guiEditResources :: checkSolexa64FastqOrSanger33Fastq() {



   char* szValue =
   XmTextFieldGetString( widSolexa64FastqOrSanger33Fastq_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soSolexa64FastqOrSanger33Fastq_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soSolexa64FastqOrSanger33Fastq_,
              CONDEF->soSolexa64FastqOrSanger33Fastq_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widSolexa64FastqOrSanger33Fastq_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaximumReadsInReadList( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaximumReadsInReadList() );
}
void guiEditResources :: checkMaximumReadsInReadList() {



   char* szValue =
   XmTextFieldGetString( widMaximumReadsInReadList_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaximumReadsInReadList must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaximumReadsInReadList_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaximumReadsInReadList_,
              CONDEF->nMaximumReadsInReadList_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaximumReadsInReadList_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaxLengthOfReadsInapLocatedFragment2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaxLengthOfReadsInapLocatedFragment2() );
}
void guiEditResources :: checkMaxLengthOfReadsInapLocatedFragment2() {



   char* szValue =
   XmTextFieldGetString( widMaxLengthOfReadsInapLocatedFragment2_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaxLengthOfReadsInapLocatedFragment2 must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaxLengthOfReadsInapLocatedFragment2_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaxLengthOfReadsInapLocatedFragment2_,
              CONDEF->nMaxLengthOfReadsInapLocatedFragment2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaxLengthOfReadsInapLocatedFragment2_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbMaximumStartupErrorsToReport( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkMaximumStartupErrorsToReport() );
}
void guiEditResources :: checkMaximumStartupErrorsToReport() {



   char* szValue =
   XmTextFieldGetString( widMaximumStartupErrorsToReport_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.MaximumStartupErrorsToReport must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nMaximumStartupErrorsToReport_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nMaximumStartupErrorsToReport_,
              CONDEF->nMaximumStartupErrorsToReport_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widMaximumStartupErrorsToReport_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cb454LinkerAlignmentMatchScore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->check454LinkerAlignmentMatchScore() );
}
void guiEditResources :: check454LinkerAlignmentMatchScore() {



   char* szValue =
   XmTextFieldGetString( wid454LinkerAlignmentMatchScore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.454LinkerAlignmentMatchScore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.n454LinkerAlignmentMatchScore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.n454LinkerAlignmentMatchScore_,
              CONDEF->n454LinkerAlignmentMatchScore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( wid454LinkerAlignmentMatchScore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cb454LinkerAlignmentMismatchScore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->check454LinkerAlignmentMismatchScore() );
}
void guiEditResources :: check454LinkerAlignmentMismatchScore() {



   char* szValue =
   XmTextFieldGetString( wid454LinkerAlignmentMismatchScore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.454LinkerAlignmentMismatchScore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.n454LinkerAlignmentMismatchScore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.n454LinkerAlignmentMismatchScore_,
              CONDEF->n454LinkerAlignmentMismatchScore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( wid454LinkerAlignmentMismatchScore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cb454LinkerAlignmentIndelScore( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->check454LinkerAlignmentIndelScore() );
}
void guiEditResources :: check454LinkerAlignmentIndelScore() {



   char* szValue =
   XmTextFieldGetString( wid454LinkerAlignmentIndelScore_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.454LinkerAlignmentIndelScore must be numeric";
      THROW_ERROR( soError );
   }

   resources_.n454LinkerAlignmentIndelScore_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.n454LinkerAlignmentIndelScore_,
              CONDEF->n454LinkerAlignmentIndelScore_,
              pixForeground,
              pixBackground );

   XtVaSetValues( wid454LinkerAlignmentIndelScore_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbFilter454ReadsDeleteCrossMatchOutput( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkFilter454ReadsDeleteCrossMatchOutput() );
}
void guiEditResources :: checkFilter454ReadsDeleteCrossMatchOutput() {



   bool b =
      XmToggleButtonGetState( widFilter454ReadsDeleteCrossMatchOutputTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bFilter454ReadsDeleteCrossMatchOutput_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bFilter454ReadsDeleteCrossMatchOutput_,
              CONDEF->bFilter454ReadsDeleteCrossMatchOutput_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widFilter454ReadsDeleteCrossMatchOutputRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportAllNeededSpeciesCode( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportAllNeededSpeciesCode() );
}
void guiEditResources :: checkAutoReportAllNeededSpeciesCode() {



   char* szValue =
   XmTextFieldGetString( widAutoReportAllNeededSpeciesCode_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportAllNeededSpeciesCode must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportAllNeededSpeciesCode_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportAllNeededSpeciesCode_,
              CONDEF->nAutoReportAllNeededSpeciesCode_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportAllNeededSpeciesCode_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportUseCommasInBigNumbers( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportUseCommasInBigNumbers() );
}
void guiEditResources :: checkAutoReportUseCommasInBigNumbers() {



   bool b =
      XmToggleButtonGetState( widAutoReportUseCommasInBigNumbersTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportUseCommasInBigNumbers_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportUseCommasInBigNumbers_,
              CONDEF->bAutoReportUseCommasInBigNumbers_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportUseCommasInBigNumbersRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintToCompareToReich( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintToCompareToReich() );
}
void guiEditResources :: checkAutoReportPrintToCompareToReich() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintToCompareToReichTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintToCompareToReich_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintToCompareToReich_,
              CONDEF->bAutoReportPrintToCompareToReich_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintToCompareToReichRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites() );
}
void guiEditResources :: checkAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites() {



   bool b =
      XmToggleButtonGetState( widAutoReportOnlyAllowSitesThatAreBetweenAcceptableSitesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_,
              CONDEF->bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportOnlyAllowSitesThatAreBetweenAcceptableSitesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod() );
}
void guiEditResources :: checkAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod() {



   bool b =
      XmToggleButtonGetState( widAutoReportDeaminationMutationsDeterminedByMoreAccurateMethodTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_,
              CONDEF->bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDeaminationMutationsDeterminedByMoreAccurateMethodRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportChooseTreesUsingBadData( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportChooseTreesUsingBadData() );
}
void guiEditResources :: checkAutoReportChooseTreesUsingBadData() {



   bool b =
      XmToggleButtonGetState( widAutoReportChooseTreesUsingBadDataTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportChooseTreesUsingBadData_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportChooseTreesUsingBadData_,
              CONDEF->bAutoReportChooseTreesUsingBadData_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportChooseTreesUsingBadDataRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportChooseTreesByCountingDeaminationMutations( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportChooseTreesByCountingDeaminationMutations() );
}
void guiEditResources :: checkAutoReportChooseTreesByCountingDeaminationMutations() {



   bool b =
      XmToggleButtonGetState( widAutoReportChooseTreesByCountingDeaminationMutationsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportChooseTreesByCountingDeaminationMutations_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportChooseTreesByCountingDeaminationMutations_,
              CONDEF->bAutoReportChooseTreesByCountingDeaminationMutations_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportChooseTreesByCountingDeaminationMutationsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportChooseTreesUsingKimura( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportChooseTreesUsingKimura() );
}
void guiEditResources :: checkAutoReportChooseTreesUsingKimura() {



   bool b =
      XmToggleButtonGetState( widAutoReportChooseTreesUsingKimuraTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportChooseTreesUsingKimura_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportChooseTreesUsingKimura_,
              CONDEF->bAutoReportChooseTreesUsingKimura_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportChooseTreesUsingKimuraRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintCrudeChimpHumanMutations( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintCrudeChimpHumanMutations() );
}
void guiEditResources :: checkAutoReportPrintCrudeChimpHumanMutations() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintCrudeChimpHumanMutationsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintCrudeChimpHumanMutations_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintCrudeChimpHumanMutations_,
              CONDEF->bAutoReportPrintCrudeChimpHumanMutations_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintCrudeChimpHumanMutationsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintPositionsForGraham( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintPositionsForGraham() );
}
void guiEditResources :: checkAutoReportPrintPositionsForGraham() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintPositionsForGrahamTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintPositionsForGraham_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintPositionsForGraham_,
              CONDEF->bAutoReportPrintPositionsForGraham_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintPositionsForGrahamRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintAncestralCpGs( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintAncestralCpGs() );
}
void guiEditResources :: checkAutoReportPrintAncestralCpGs() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintAncestralCpGsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintAncestralCpGs_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintAncestralCpGs_,
              CONDEF->bAutoReportPrintAncestralCpGs_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintAncestralCpGsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintCpGMutations( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintCpGMutations() );
}
void guiEditResources :: checkAutoReportPrintCpGMutations() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintCpGMutationsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintCpGMutations_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintCpGMutations_,
              CONDEF->bAutoReportPrintCpGMutations_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintCpGMutationsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintMutationsWithContext( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintMutationsWithContext() );
}
void guiEditResources :: checkAutoReportPrintMutationsWithContext() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintMutationsWithContextTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintMutationsWithContext_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintMutationsWithContext_,
              CONDEF->bAutoReportPrintMutationsWithContext_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintMutationsWithContextRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCountAllMutationsML( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCountAllMutationsML() );
}
void guiEditResources :: checkAutoReportCountAllMutationsML() {



   bool b =
      XmToggleButtonGetState( widAutoReportCountAllMutationsMLTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCountAllMutationsML_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCountAllMutationsML_,
              CONDEF->bAutoReportCountAllMutationsML_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCountAllMutationsMLRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCountAllMutations( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCountAllMutations() );
}
void guiEditResources :: checkAutoReportCountAllMutations() {



   bool b =
      XmToggleButtonGetState( widAutoReportCountAllMutationsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCountAllMutations_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCountAllMutations_,
              CONDEF->bAutoReportCountAllMutations_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCountAllMutationsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportIgnoreMultipleTrees( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportIgnoreMultipleTrees() );
}
void guiEditResources :: checkAutoReportIgnoreMultipleTrees() {



   bool b =
      XmToggleButtonGetState( widAutoReportIgnoreMultipleTreesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportIgnoreMultipleTrees_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportIgnoreMultipleTrees_,
              CONDEF->bAutoReportIgnoreMultipleTrees_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportIgnoreMultipleTreesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCountAcceptableColumnsWithNoneOnLeft( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCountAcceptableColumnsWithNoneOnLeft() );
}
void guiEditResources :: checkAutoReportCountAcceptableColumnsWithNoneOnLeft() {



   bool b =
      XmToggleButtonGetState( widAutoReportCountAcceptableColumnsWithNoneOnLeftTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCountAcceptableColumnsWithNoneOnLeft_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCountAcceptableColumnsWithNoneOnLeft_,
              CONDEF->bAutoReportCountAcceptableColumnsWithNoneOnLeft_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCountAcceptableColumnsWithNoneOnLeftRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintFlankedColumns4( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintFlankedColumns4() );
}
void guiEditResources :: checkAutoReportPrintFlankedColumns4() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintFlankedColumns4True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintFlankedColumns4_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintFlankedColumns4_,
              CONDEF->bAutoReportPrintFlankedColumns4_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintFlankedColumns4RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportUseAnnotationFormat( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportUseAnnotationFormat() );
}
void guiEditResources :: checkAutoReportUseAnnotationFormat() {



   bool b =
      XmToggleButtonGetState( widAutoReportUseAnnotationFormatTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportUseAnnotationFormat_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportUseAnnotationFormat_,
              CONDEF->bAutoReportUseAnnotationFormat_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportUseAnnotationFormatRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintFlankedColumns3( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintFlankedColumns3() );
}
void guiEditResources :: checkAutoReportPrintFlankedColumns3() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintFlankedColumns3True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintFlankedColumns3_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintFlankedColumns3_,
              CONDEF->bAutoReportPrintFlankedColumns3_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintFlankedColumns3RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintFlankedColumns2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintFlankedColumns2() );
}
void guiEditResources :: checkAutoReportPrintFlankedColumns2() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintFlankedColumns2True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintFlankedColumns2_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintFlankedColumns2_,
              CONDEF->bAutoReportPrintFlankedColumns2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintFlankedColumns2RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintFlankedColumns( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintFlankedColumns() );
}
void guiEditResources :: checkAutoReportPrintFlankedColumns() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintFlankedColumnsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintFlankedColumns_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintFlankedColumns_,
              CONDEF->bAutoReportPrintFlankedColumns_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintFlankedColumnsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportHighQualitySegmentData( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportHighQualitySegmentData() );
}
void guiEditResources :: checkAutoReportHighQualitySegmentData() {



   bool b =
      XmToggleButtonGetState( widAutoReportHighQualitySegmentDataTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportHighQualitySegmentData_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportHighQualitySegmentData_,
              CONDEF->bAutoReportHighQualitySegmentData_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportHighQualitySegmentDataRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportGoodReadsBug( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportGoodReadsBug() );
}
void guiEditResources :: checkAutoReportGoodReadsBug() {



   bool b =
      XmToggleButtonGetState( widAutoReportGoodReadsBugTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportGoodReadsBug_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportGoodReadsBug_,
              CONDEF->bAutoReportGoodReadsBug_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportGoodReadsBugRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDiscrepancyRateInFlankedRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDiscrepancyRateInFlankedRegions() );
}
void guiEditResources :: checkAutoReportDiscrepancyRateInFlankedRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportDiscrepancyRateInFlankedRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDiscrepancyRateInFlankedRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDiscrepancyRateInFlankedRegions_,
              CONDEF->bAutoReportDiscrepancyRateInFlankedRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDiscrepancyRateInFlankedRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDiscrepancyRateInFlankedRegions2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDiscrepancyRateInFlankedRegions2() );
}
void guiEditResources :: checkAutoReportDiscrepancyRateInFlankedRegions2() {



   bool b =
      XmToggleButtonGetState( widAutoReportDiscrepancyRateInFlankedRegions2True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDiscrepancyRateInFlankedRegions2_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDiscrepancyRateInFlankedRegions2_,
              CONDEF->bAutoReportDiscrepancyRateInFlankedRegions2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDiscrepancyRateInFlankedRegions2RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDiscrepancyRateInFlankedRegions4( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDiscrepancyRateInFlankedRegions4() );
}
void guiEditResources :: checkAutoReportDiscrepancyRateInFlankedRegions4() {



   bool b =
      XmToggleButtonGetState( widAutoReportDiscrepancyRateInFlankedRegions4True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDiscrepancyRateInFlankedRegions4_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDiscrepancyRateInFlankedRegions4_,
              CONDEF->bAutoReportDiscrepancyRateInFlankedRegions4_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDiscrepancyRateInFlankedRegions4RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDiscrepancyRateInFlankedRegions5( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDiscrepancyRateInFlankedRegions5() );
}
void guiEditResources :: checkAutoReportDiscrepancyRateInFlankedRegions5() {



   bool b =
      XmToggleButtonGetState( widAutoReportDiscrepancyRateInFlankedRegions5True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDiscrepancyRateInFlankedRegions5_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDiscrepancyRateInFlankedRegions5_,
              CONDEF->bAutoReportDiscrepancyRateInFlankedRegions5_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDiscrepancyRateInFlankedRegions5RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportSingleSignalOrQuality( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportSingleSignalOrQuality() );
}
void guiEditResources :: checkAutoReportSingleSignalOrQuality() {



   bool b =
      XmToggleButtonGetState( widAutoReportSingleSignalOrQualityTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportSingleSignalOrQuality_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportSingleSignalOrQuality_,
              CONDEF->bAutoReportSingleSignalOrQuality_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportSingleSignalOrQualityRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportLowQualityBasesInHQS( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportLowQualityBasesInHQS() );
}
void guiEditResources :: checkAutoReportLowQualityBasesInHQS() {



   bool b =
      XmToggleButtonGetState( widAutoReportLowQualityBasesInHQSTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportLowQualityBasesInHQS_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportLowQualityBasesInHQS_,
              CONDEF->bAutoReportLowQualityBasesInHQS_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportLowQualityBasesInHQSRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareHQSWithLQS( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareHQSWithLQS() );
}
void guiEditResources :: checkAutoReportCompareHQSWithLQS() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareHQSWithLQSTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareHQSWithLQS_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareHQSWithLQS_,
              CONDEF->bAutoReportCompareHQSWithLQS_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareHQSWithLQSRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCountColumnsForGroupsOfSpecies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCountColumnsForGroupsOfSpecies() );
}
void guiEditResources :: checkAutoReportCountColumnsForGroupsOfSpecies() {



   bool b =
      XmToggleButtonGetState( widAutoReportCountColumnsForGroupsOfSpeciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCountColumnsForGroupsOfSpecies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCountColumnsForGroupsOfSpecies_,
              CONDEF->bAutoReportCountColumnsForGroupsOfSpecies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCountColumnsForGroupsOfSpeciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportSingleSignalInfo( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportSingleSignalInfo() );
}
void guiEditResources :: checkAutoReportSingleSignalInfo() {



   bool b =
      XmToggleButtonGetState( widAutoReportSingleSignalInfoTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportSingleSignalInfo_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportSingleSignalInfo_,
              CONDEF->bAutoReportSingleSignalInfo_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportSingleSignalInfoRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportSingleSignalInfo2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportSingleSignalInfo2() );
}
void guiEditResources :: checkAutoReportSingleSignalInfo2() {



   bool b =
      XmToggleButtonGetState( widAutoReportSingleSignalInfo2True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportSingleSignalInfo2_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportSingleSignalInfo2_,
              CONDEF->bAutoReportSingleSignalInfo2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportSingleSignalInfo2RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrands( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrands() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrands() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrandsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrands_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrands_,
              CONDEF->bAutoReportCompareTopAndBottomStrands_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrandsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrandsNoHuman( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrandsNoHuman() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrandsNoHuman() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrandsNoHumanTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrandsNoHuman_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrandsNoHuman_,
              CONDEF->bAutoReportCompareTopAndBottomStrandsNoHuman_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrandsNoHumanRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrands2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrands2() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrands2() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrands2True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrands2_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrands2_,
              CONDEF->bAutoReportCompareTopAndBottomStrands2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrands2RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrands3( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrands3() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrands3() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrands3True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrands3_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrands3_,
              CONDEF->bAutoReportCompareTopAndBottomStrands3_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrands3RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrands4( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrands4() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrands4() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrands4True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrands4_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrands4_,
              CONDEF->bAutoReportCompareTopAndBottomStrands4_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrands4RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportTopStrandPinnedPosition( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportTopStrandPinnedPosition() );
}
void guiEditResources :: checkAutoReportTopStrandPinnedPosition() {



   char* szValue =
   XmTextFieldGetString( widAutoReportTopStrandPinnedPosition_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportTopStrandPinnedPosition must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportTopStrandPinnedPosition_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportTopStrandPinnedPosition_,
              CONDEF->nAutoReportTopStrandPinnedPosition_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportTopStrandPinnedPosition_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportBottomStrandPinnedPosition( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportBottomStrandPinnedPosition() );
}
void guiEditResources :: checkAutoReportBottomStrandPinnedPosition() {



   char* szValue =
   XmTextFieldGetString( widAutoReportBottomStrandPinnedPosition_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportBottomStrandPinnedPosition must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportBottomStrandPinnedPosition_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportBottomStrandPinnedPosition_,
              CONDEF->nAutoReportBottomStrandPinnedPosition_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportBottomStrandPinnedPosition_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCompareTopAndBottomStrandsWithHuman( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCompareTopAndBottomStrandsWithHuman() );
}
void guiEditResources :: checkAutoReportCompareTopAndBottomStrandsWithHuman() {



   bool b =
      XmToggleButtonGetState( widAutoReportCompareTopAndBottomStrandsWithHumanTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCompareTopAndBottomStrandsWithHuman_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCompareTopAndBottomStrandsWithHuman_,
              CONDEF->bAutoReportCompareTopAndBottomStrandsWithHuman_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCompareTopAndBottomStrandsWithHumanRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintLengthsOfAlignedSegmentsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintLengthsOfAlignedSegmentsOfReads() );
}
void guiEditResources :: checkAutoReportPrintLengthsOfAlignedSegmentsOfReads() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintLengthsOfAlignedSegmentsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintLengthsOfAlignedSegmentsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintLengthsOfAlignedSegmentsOfReads_,
              CONDEF->bAutoReportPrintLengthsOfAlignedSegmentsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintLengthsOfAlignedSegmentsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads() );
}
void guiEditResources :: checkAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_,
              CONDEF->bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintIfReadsAreCorrectlyAligned( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintIfReadsAreCorrectlyAligned() );
}
void guiEditResources :: checkAutoReportPrintIfReadsAreCorrectlyAligned() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintIfReadsAreCorrectlyAlignedTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintIfReadsAreCorrectlyAligned_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintIfReadsAreCorrectlyAligned_,
              CONDEF->bAutoReportPrintIfReadsAreCorrectlyAligned_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintIfReadsAreCorrectlyAlignedRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportCalculateErrorProbabilitiesByComparingPTroPPan( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportCalculateErrorProbabilitiesByComparingPTroPPan() );
}
void guiEditResources :: checkAutoReportCalculateErrorProbabilitiesByComparingPTroPPan() {



   bool b =
      XmToggleButtonGetState( widAutoReportCalculateErrorProbabilitiesByComparingPTroPPanTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_,
              CONDEF->bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportCalculateErrorProbabilitiesByComparingPTroPPanRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies() );
}
void guiEditResources :: checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintAgreeDisagreeBetweenPairsOfSpeciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_,
              CONDEF->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintAgreeDisagreeBetweenPairsOfSpeciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2() );
}
void guiEditResources :: checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2True_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_,
              CONDEF->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2RadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportFilterSingleSignal( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportFilterSingleSignal() );
}
void guiEditResources :: checkAutoReportFilterSingleSignal() {



   bool b =
      XmToggleButtonGetState( widAutoReportFilterSingleSignalTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportFilterSingleSignal_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportFilterSingleSignal_,
              CONDEF->bAutoReportFilterSingleSignal_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportFilterSingleSignalRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportGoodHitReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportGoodHitReads() );
}
void guiEditResources :: checkAutoReportGoodHitReads() {



   char* szValue =
   XmTextFieldGetString( widAutoReportGoodHitReads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoReportGoodHitReads_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoReportGoodHitReads_,
              CONDEF->filAutoReportGoodHitReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportGoodHitReads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportQualityWindowLow( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportQualityWindowLow() );
}
void guiEditResources :: checkAutoReportQualityWindowLow() {



   char* szValue =
   XmTextFieldGetString( widAutoReportQualityWindowLow_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportQualityWindowLow must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportQualityWindowLow_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportQualityWindowLow_,
              CONDEF->nAutoReportQualityWindowLow_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportQualityWindowLow_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportQualityWindowHigh( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportQualityWindowHigh() );
}
void guiEditResources :: checkAutoReportQualityWindowHigh() {



   char* szValue =
   XmTextFieldGetString( widAutoReportQualityWindowHigh_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportQualityWindowHigh must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportQualityWindowHigh_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportQualityWindowHigh_,
              CONDEF->nAutoReportQualityWindowHigh_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportQualityWindowHigh_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintNumberOfIsolatedPadsForEachSpecies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintNumberOfIsolatedPadsForEachSpecies() );
}
void guiEditResources :: checkAutoReportPrintNumberOfIsolatedPadsForEachSpecies() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintNumberOfIsolatedPadsForEachSpeciesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_,
              CONDEF->bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintNumberOfIsolatedPadsForEachSpeciesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintNumberOfIsolatedPads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintNumberOfIsolatedPads() );
}
void guiEditResources :: checkAutoReportPrintNumberOfIsolatedPads() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintNumberOfIsolatedPadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintNumberOfIsolatedPads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintNumberOfIsolatedPads_,
              CONDEF->bAutoReportPrintNumberOfIsolatedPads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintNumberOfIsolatedPadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportIsolatedPadsOfReadsWithThisPattern( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportIsolatedPadsOfReadsWithThisPattern() );
}
void guiEditResources :: checkAutoReportIsolatedPadsOfReadsWithThisPattern() {



   char* szValue =
   XmTextFieldGetString( widAutoReportIsolatedPadsOfReadsWithThisPattern_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportIsolatedPadsOfReadsWithThisPattern_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportIsolatedPadsOfReadsWithThisPattern_,
              CONDEF->soAutoReportIsolatedPadsOfReadsWithThisPattern_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportIsolatedPadsOfReadsWithThisPattern_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy() );
}
void guiEditResources :: checkAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy() {



   char* szValue =
   XmTextFieldGetString( widAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_,
              CONDEF->nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportMaxSizeOfDiscrepantRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportMaxSizeOfDiscrepantRegion() );
}
void guiEditResources :: checkAutoReportMaxSizeOfDiscrepantRegion() {



   char* szValue =
   XmTextFieldGetString( widAutoReportMaxSizeOfDiscrepantRegion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportMaxSizeOfDiscrepantRegion must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportMaxSizeOfDiscrepantRegion_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportMaxSizeOfDiscrepantRegion_,
              CONDEF->nAutoReportMaxSizeOfDiscrepantRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportMaxSizeOfDiscrepantRegion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportSizeOfDiscrepantRegion( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportSizeOfDiscrepantRegion() );
}
void guiEditResources :: checkAutoReportSizeOfDiscrepantRegion() {



   char* szValue =
   XmTextFieldGetString( widAutoReportSizeOfDiscrepantRegion_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportSizeOfDiscrepantRegion must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportSizeOfDiscrepantRegion_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportSizeOfDiscrepantRegion_,
              CONDEF->nAutoReportSizeOfDiscrepantRegion_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportSizeOfDiscrepantRegion_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintMinimumQualityHistogram( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintMinimumQualityHistogram() );
}
void guiEditResources :: checkAutoReportPrintMinimumQualityHistogram() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintMinimumQualityHistogramTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintMinimumQualityHistogram_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintMinimumQualityHistogram_,
              CONDEF->bAutoReportPrintMinimumQualityHistogram_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintMinimumQualityHistogramRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintDiscrepantRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintDiscrepantRegions() );
}
void guiEditResources :: checkAutoReportPrintDiscrepantRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintDiscrepantRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintDiscrepantRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintDiscrepantRegions_,
              CONDEF->bAutoReportPrintDiscrepantRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintDiscrepantRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintBasesInDiscrepantRegions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintBasesInDiscrepantRegions() );
}
void guiEditResources :: checkAutoReportPrintBasesInDiscrepantRegions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintBasesInDiscrepantRegionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintBasesInDiscrepantRegions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintBasesInDiscrepantRegions_,
              CONDEF->bAutoReportPrintBasesInDiscrepantRegions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintBasesInDiscrepantRegionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis() );
}
void guiEditResources :: checkAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_,
              CONDEF->soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportBackboneReadHasThisStringInIt( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportBackboneReadHasThisStringInIt() );
}
void guiEditResources :: checkAutoReportBackboneReadHasThisStringInIt() {



   char* szValue =
   XmTextFieldGetString( widAutoReportBackboneReadHasThisStringInIt_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportBackboneReadHasThisStringInIt_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportBackboneReadHasThisStringInIt_,
              CONDEF->soAutoReportBackboneReadHasThisStringInIt_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportBackboneReadHasThisStringInIt_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold() );
}
void guiEditResources :: checkAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThresholdTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_,
              CONDEF->bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThresholdRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintSpeciesAlignment( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintSpeciesAlignment() );
}
void guiEditResources :: checkAutoReportPrintSpeciesAlignment() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintSpeciesAlignmentTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintSpeciesAlignment_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintSpeciesAlignment_,
              CONDEF->bAutoReportPrintSpeciesAlignment_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintSpeciesAlignmentRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadAlignment( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadAlignment() );
}
void guiEditResources :: checkAutoReportPrintReadAlignment() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintReadAlignmentTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintReadAlignment_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintReadAlignment_,
              CONDEF->bAutoReportPrintReadAlignment_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadAlignmentRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintTheseReads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintTheseReads() );
}
void guiEditResources :: checkAutoReportPrintTheseReads() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrintTheseReads_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.filAutoReportPrintTheseReads_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.filAutoReportPrintTheseReads_,
              CONDEF->filAutoReportPrintTheseReads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintTheseReads_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintReadPositions( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintReadPositions() );
}
void guiEditResources :: checkAutoReportPrintReadPositions() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintReadPositionsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintReadPositions_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintReadPositions_,
              CONDEF->bAutoReportPrintReadPositions_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintReadPositionsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrintChosenReadName( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrintChosenReadName() );
}
void guiEditResources :: checkAutoReportPrintChosenReadName() {



   bool b =
      XmToggleButtonGetState( widAutoReportPrintChosenReadNameTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportPrintChosenReadName_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportPrintChosenReadName_,
              CONDEF->bAutoReportPrintChosenReadName_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrintChosenReadNameRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted() );
}
void guiEditResources :: checkAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted() {



   char* szValue =
   XmTextFieldGetString( widAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportNumbersOfCharactersOfChosenReadNameToBePrinted must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_,
              CONDEF->nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportPrefix( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportPrefix() );
}
void guiEditResources :: checkAutoReportPrefix() {



   char* szValue =
   XmTextFieldGetString( widAutoReportPrefix_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportPrefix_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportPrefix_,
              CONDEF->soAutoReportPrefix_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportPrefix_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportUseOldCriteriaForDeletingColumnsOfPads( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportUseOldCriteriaForDeletingColumnsOfPads() );
}
void guiEditResources :: checkAutoReportUseOldCriteriaForDeletingColumnsOfPads() {



   bool b =
      XmToggleButtonGetState( widAutoReportUseOldCriteriaForDeletingColumnsOfPadsTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportUseOldCriteriaForDeletingColumnsOfPads_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportUseOldCriteriaForDeletingColumnsOfPads_,
              CONDEF->bAutoReportUseOldCriteriaForDeletingColumnsOfPads_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportUseOldCriteriaForDeletingColumnsOfPadsRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues() );
}
void guiEditResources :: checkAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues() {



   bool b =
      XmToggleButtonGetState( widAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValuesTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_,
              CONDEF->bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValuesRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportFlankingBasesMustBeSingleSignal( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportFlankingBasesMustBeSingleSignal() );
}
void guiEditResources :: checkAutoReportFlankingBasesMustBeSingleSignal() {



   bool b =
      XmToggleButtonGetState( widAutoReportFlankingBasesMustBeSingleSignalTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportFlankingBasesMustBeSingleSignal_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportFlankingBasesMustBeSingleSignal_,
              CONDEF->bAutoReportFlankingBasesMustBeSingleSignal_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportFlankingBasesMustBeSingleSignalRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportMinimumQualityOfFlankingBases( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportMinimumQualityOfFlankingBases() );
}
void guiEditResources :: checkAutoReportMinimumQualityOfFlankingBases() {



   char* szValue =
   XmTextFieldGetString( widAutoReportMinimumQualityOfFlankingBases_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   int n;

   if ( !bIsNumericMaybeWithWhitespace( soValue, n ) ) {
      RWCString soError = "consed.AutoReportMinimumQualityOfFlankingBases must be numeric";
      THROW_ERROR( soError );
   }

   resources_.nAutoReportMinimumQualityOfFlankingBases_ = n;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.nAutoReportMinimumQualityOfFlankingBases_,
              CONDEF->nAutoReportMinimumQualityOfFlankingBases_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportMinimumQualityOfFlankingBases_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportFlankingBasesMustBeInHighQualitySegment( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportFlankingBasesMustBeInHighQualitySegment() );
}
void guiEditResources :: checkAutoReportFlankingBasesMustBeInHighQualitySegment() {



   bool b =
      XmToggleButtonGetState( widAutoReportFlankingBasesMustBeInHighQualitySegmentTrue_ );

      // this is no way this can be invalid, so no checks are needed

   resources_.bAutoReportFlankingBasesMustBeInHighQualitySegment_ = b;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.bAutoReportFlankingBasesMustBeInHighQualitySegment_,
              CONDEF->bAutoReportFlankingBasesMustBeInHighQualitySegment_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportFlankingBasesMustBeInHighQualitySegmentRadioBox_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
static void cbAutoReportSpecies( Widget wid,
                                                    XtPointer pClientData,
                                                    XtPointer pCallData ) {
                                                    
   guiEditResources* pGER = (guiEditResources*) pClientData;
   TRY_CATCH_WRAPPER( pGER->checkAutoReportSpecies() );
}
void guiEditResources :: checkAutoReportSpecies() {



   char* szValue =
   XmTextFieldGetString( widAutoReportSpecies_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   resources_.soAutoReportSpecies_ =
      soValue;

   Pixel pixForeground;
   Pixel pixBackground;
   getColors( resources_.soAutoReportSpecies_,
              CONDEF->soAutoReportSpecies_,
              pixForeground,
              pixBackground );

   XtVaSetValues( widAutoReportSpecies_,
                  XmNforeground, pixForeground,
                  XmNbackground, pixBackground,
                  NULL );

}
// guiEditResources.cpp.part3



void guiEditResources :: createWindow() {

   PleaseWait* pPleaseWait = new PleaseWait();

   resources_ = *consedResources::pCurrentResources_;

   Widget widFalseButton;

   // these are needed by the makeWidget... macros
   Pixel pixForeground;
   Pixel pixBackground;

   // get colors for when the resource is different

   pixValueChangedForegroundColor_ = ulGetXColorForColorName( "cornsilk" );
   pixValueChangedBackgroundColor_ = ulGetXColorForColorName( "red" );



   int nArgs;
   Arg aArg[50];



   if ( bStandAlone_ ) {
      widPopupShell_ = GAPP->widGetTopLevel();
   }
   else {
      widPopupShell_ = XtVaCreatePopupShell( "Edit Consed/Autofinish Parameters",
                                           topLevelShellWidgetClass,
                                           GAPP->widGetTopLevel(),
                                           XmNtitle, "Edit Parameters", 
                                           XmNnoResize, False,
                                           XmNtransient, False,
                                           XmNdeleteResponse, XmDO_NOTHING,
                                           NULL );

      handleWindowManagerDelete2( widPopupShell_,
                                  cbCancelButton,
                                  this );
   }


   // create a form widget

   Widget widTopForm = XtVaCreateManagedWidget( "top form",
                                                xmFormWidgetClass,
                                                widPopupShell_,
                                                XmNshadowThickness, 0,
                                                XmNborderWidth, 0,
                                                NULL );


   XtVaGetValues( widTopForm,
                  XmNforeground, &pixValueUnchangedForegroundColor_,
                  XmNbackground, &pixValueUnchangedBackgroundColor_,
                  NULL );


   // labels on the top of the form

   Widget widColumn1Label = XtVaCreateManagedWidget( 
                  "current values:",
                  xmLabelWidgetClass,
                  widTopForm,
                  XmNtopAttachment, XmATTACH_FORM,
                  XmNleftAttachment, XmATTACH_FORM,
                  XmNalignment, XmALIGNMENT_BEGINNING,
                  NULL );

   Widget widAttachWidgetToBottomOfThis = widColumn1Label;

   Widget widColumn2Label = XtVaCreateManagedWidget(
                  "default values:",
                  xmLabelWidgetClass,
                  widTopForm,
                  XmNtopAttachment, XmATTACH_FORM,
                  XmNleftAttachment, XmATTACH_POSITION,
                  XmNleftPosition, 50,
                  XmNalignment, XmALIGNMENT_BEGINNING,
                  NULL );
   
   // put buttons on the bottom of the form

   widSaveButton_ = XtVaCreateManagedWidget( 
                  "Save",
                  xmPushButtonWidgetClass,
                  widTopForm,
                  XmNbottomAttachment, XmATTACH_FORM,
                  XmNbottomOffset, 10,
                  XmNleftAttachment, XmATTACH_POSITION,
                  XmNleftPosition, 4,
                  XmNrightAttachment, XmATTACH_POSITION,
                  XmNrightPosition, 16,
                  NULL );

   Widget widAttachWidgetsToTopOfThis = widSaveButton_;

   XtAddCallback( widSaveButton_,
                  XmNactivateCallback,
                  cbUserPushedSaveButton,
                  this );

   widCancelButton_ = XtVaCreateManagedWidget(
                  "Dismiss",
                  xmPushButtonWidgetClass,
                  widTopForm,
                  XmNbottomAttachment, XmATTACH_FORM,
                  XmNbottomOffset, 10,
                  XmNleftAttachment, XmATTACH_POSITION,
                  XmNleftPosition, 84,
                  XmNrightAttachment, XmATTACH_POSITION,
                  XmNrightPosition, 96,
                  NULL );


   XtAddCallback( widCancelButton_,
                  XmNactivateCallback,
                  cbCancelButton,
                  this );

   
   // create a set of 3 radio buttons:  one for just user
   // one for project
   // one for all users and all projects


   Widget widWhichConsedrcRadioBox = XmCreateRadioBox( 
                  widTopForm,
                  "radio", NULL, 0 );

   XtVaSetValues( widWhichConsedrcRadioBox,
                  XmNtraversalOn, True,
                  XmNbottomAttachment, XmATTACH_WIDGET,
                  XmNbottomOffset, 20,
                  XmNbottomWidget, widAttachWidgetsToTopOfThis,
                  XmNleftAttachment, XmATTACH_FORM,
                  XmNrightAttachment, XmATTACH_FORM,
                  XmNorientation, XmHORIZONTAL,
                  NULL );

   XtManageChild( widWhichConsedrcRadioBox );

   widAttachWidgetsToTopOfThis = widWhichConsedrcRadioBox;

   widUserRadioButton_ = XtVaCreateManagedWidget( 
                  "just user",
                  xmToggleButtonWidgetClass,
                  widWhichConsedrcRadioBox,
                  XmNset, True,
                  NULL );

   widProjectRadioButton_ = XtVaCreateManagedWidget(
                  "just project",
                  xmToggleButtonWidgetClass,
                  widWhichConsedrcRadioBox,
                  XmNset, False,
                  NULL );

   widAllUsersAllProjectsRadioButton_ = XtVaCreateManagedWidget(
                  "all users/all projects",
                  xmToggleButtonWidgetClass,
                  widWhichConsedrcRadioBox,
                  XmNset, False,
                  NULL );


   Widget widEnterParameterLabel = XtVaCreateManagedWidget( 
                  "Find Parameter:",
                  xmLabelWidgetClass,
                  widTopForm,
                  XmNleftAttachment, XmATTACH_FORM,
                  XmNleftOffset, 10,
                  NULL );

   widEnterParameter_ = XtVaCreateManagedWidget(
                  "Find Parameter",
                  xmTextFieldWidgetClass,
                  widTopForm,
                  XmNbottomAttachment, XmATTACH_WIDGET,
                  XmNbottomWidget, widAttachWidgetsToTopOfThis,
                  XmNbottomOffset, 10,
                  NULL );

   XtAddCallback( widEnterParameter_,
                  XmNactivateCallback,
                  cbFindFirstButton,
                  this );
  

   // funny business to avoid circular dependency of
   // widEnterParameter_ and widEnterParameterLabel

   Dimension dimWidthOfLabel;
   XtVaGetValues( widEnterParameterLabel,
                  XmNwidth, &dimWidthOfLabel,
                  NULL );

   XtVaSetValues( widEnterParameter_,
                  XmNleftAttachment, XmATTACH_FORM,
                  XmNleftOffset, ( dimWidthOfLabel + 10 + 10 ),
                  NULL );

   XtVaSetValues( widEnterParameterLabel,
                  XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNbottomWidget, widEnterParameter_,
                  XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNtopWidget, widEnterParameter_,
                  NULL );

   widAttachWidgetsToTopOfThis = widEnterParameterLabel;


   Widget widFindFirst = XtVaCreateManagedWidget(
                  "Find First",
                  xmPushButtonWidgetClass,
                  widTopForm,
                  XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNtopWidget, widEnterParameter_,
                  XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNbottomWidget, widEnterParameter_,
                  XmNleftAttachment, XmATTACH_WIDGET,
                  XmNleftWidget, widEnterParameter_,
                  XmNleftOffset, 10,
                  NULL );

   XtAddCallback( widFindFirst,
                  XmNactivateCallback,
                  cbFindFirstButton,
                  this );


   Widget widFindNext =  XtVaCreateManagedWidget(
                  "Find Next",
                  xmPushButtonWidgetClass,
                  widTopForm,
                  XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNtopWidget, widEnterParameter_,
                  XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
                  XmNbottomWidget, widEnterParameter_,
                  XmNleftAttachment, XmATTACH_WIDGET,
                  XmNleftWidget, widFindFirst,
                  XmNleftOffset, 10,
                  NULL );

   XtAddCallback( widFindNext,
                  XmNactivateCallback,
                  cbFindNextButton,
                  this );

   widScrolledWindow_ = XtVaCreateManagedWidget(
                  "scrolled",
                  xmScrolledWindowWidgetClass,
                  widTopForm,
                  XmNtopAttachment, XmATTACH_WIDGET,
                  XmNtopWidget, widAttachWidgetToBottomOfThis,
                  XmNleftAttachment, XmATTACH_FORM,
                  XmNrightAttachment, XmATTACH_FORM,
                  XmNbottomAttachment, XmATTACH_WIDGET,
                  XmNbottomWidget, widAttachWidgetsToTopOfThis,
                  XmNbottomOffset, 20,
                  XmNscrollingPolicy, XmAUTOMATIC,
                  XmNscrollBarDisplayPolicy, XmSTATIC,
                  XmNheight, (Dimension) GuiApp::nGetFontHeight() * 50,
                  NULL );

   
   Widget widRowCol = XtVaCreateManagedWidget(
                  "rowcol",
                  xmRowColumnWidgetClass,
                  widScrolledWindow_,
                  XmNorientation, XmVERTICAL,
                  XmNnumColumns, 1,
                  XmNpacking, XmPACK_COLUMN,
                  NULL );



   // this funny business is to make boxes expand when the user expands
   // the scrolling window

   XmScrolledWindowSetAreas( widScrolledWindow_,
                             NULL,
                             NULL,
                             widRowCol );


   XtVaGetValues( widScrolledWindow_, XmNclipWindow, &widClipWindow_, NULL );

   XtAddCallback( widClipWindow_,
                  XmNresizeCallback,
                  cbResize,
                  this );



   helpCallbackInfo* pHelp = NULL;


   // this is where all the of the computer-generated widgets go
   // guiEditResources.cpp.part4
   makeWidgetTypeBool( consed.printPS,
                          PrintPS );
   makeWidgetTypeRWCString( consed.defaultTagType,
                          DefaultTagType );
   makeWidgetTypeBool( consed.defaultTagOnConsensusNotReads,
                          DefaultTagOnConsensusNotReads );
   makeWidgetTypeDouble( consed.autoFinishMinNumberOfErrorsFixedByAnExp,
                          AutoFinishMinNumberOfErrorsFixedByAnExp );
   makeWidgetTypeDouble( consed.autoFinishRedundancy,
                          AutoFinishRedundancy );
   makeWidgetTypeInt( consed.autoFinishAverageInsertSize,
                          AutoFinishAverageInsertSize );
   makeWidgetTypeInt( consed.primersMaxInsertSizeOfASubclone,
                          PrimersMaxInsertSizeOfASubclone );
   makeWidgetTypeInt( consed.primersMaxMeltingTemp,
                          PrimersMaxMeltingTemp );
   makeWidgetTypeInt( consed.primersMaxMeltingTempForPCR,
                          PrimersMaxMeltingTempForPCR );
   makeWidgetTypeBool( consed.primersPickTemplatesForPrimers,
                          PrimersPickTemplatesForPrimers );
   makeWidgetTypeRWCString( consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening,
                          PrimersSubcloneFullPathnameOfFileOfSequencesForScreening );
   makeWidgetTypeRWCString( consed.primersCloneFullPathnameOfFileOfSequencesForScreening,
                          PrimersCloneFullPathnameOfFileOfSequencesForScreening );
   makeWidgetTypeInt( consed.primersMinMeltingTemp,
                          PrimersMinMeltingTemp );
   makeWidgetTypeInt( consed.primersMinMeltingTempForPCR,
                          PrimersMinMeltingTempForPCR );
   makeWidgetTypeBool( consed.searchFunctionsUseUnalignedEndsOfReads,
                          SearchFunctionsUseUnalignedEndsOfReads );
   makeWidgetTypeBool( consed.searchFunctionsUseLowQualityEndsOfReads,
                          SearchFunctionsUseLowQualityEndsOfReads );
   makeWidgetTypeInt( consed.inexactSearchForStringMaxPerCentMismatch,
                          InexactSearchForStringMaxPerCentMismatch );
   makeWidgetTypeBool( consed.onlyAllowOneReadWriteConsedAtATime,
                          OnlyAllowOneReadWriteConsedAtATime );
   makeWidgetTypeBool( consed.autoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair,
                          AutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair );
   makeWidgetTypeRWCString( consed.printWindowCommand,
                          PrintWindowCommand );
   makeWidgetTypeFileName( consed.fileOfTagTypes,
                          FileOfTagTypes );
   makeWidgetTypeBool( consed.assemblyViewShowConsistentFwdRevPairs,
                          AssemblyViewShowConsistentFwdRevPairs );
   makeWidgetTypeBool( consed.assemblyViewShowConsistentFwdRevPairDepth,
                          AssemblyViewShowConsistentFwdRevPairDepth );
   makeWidgetTypeBool( consed.assemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds,
                          AssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds );
   makeWidgetTypeBool( consed.assemblyViewShowLegsOnSquaresForConsistentFwdRevPairs,
                          AssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs );
   makeWidgetTypeBool( consed.assemblyViewShowGapSpanningFwdRevPairs,
                          AssemblyViewShowGapSpanningFwdRevPairs );
   makeWidgetTypeRWCString( consed.assemblyViewShowWhichInconsistentFwdRevPairs,
                          AssemblyViewShowWhichInconsistentFwdRevPairs );
   makeWidgetTypeBool( consed.assemblyViewShowReadDepth,
                          AssemblyViewShowReadDepth );
   makeWidgetTypeBool( consed.assemblyViewShowMultipleHighQualityDiscrepancies,
                          AssemblyViewShowMultipleHighQualityDiscrepancies );
   makeWidgetTypeBool( consed.assemblyViewShowRestrictionDigestCutSites,
                          AssemblyViewShowRestrictionDigestCutSites );
   makeWidgetTypeBool( consed.assemblyViewFilterSequenceMatchesBySize,
                          AssemblyViewFilterSequenceMatchesBySize );
   makeWidgetTypeInt( consed.assemblyViewSequenceMatchesMinSize,
                          AssemblyViewSequenceMatchesMinSize );
   makeWidgetTypeInt( consed.assemblyViewSequenceMatchesMaxSize,
                          AssemblyViewSequenceMatchesMaxSize );
   makeWidgetTypeBool( consed.assemblyViewAutomaticallyStartWithConsed,
                          AssemblyViewAutomaticallyStartWithConsed );
   makeWidgetTypeRWCString( consed.assemblyViewDisplayTheseTagTypesOnTheseLines,
                          AssemblyViewDisplayTheseTagTypesOnTheseLines );
   makeWidgetTypeBool( consed.assemblyViewShowTags,
                          AssemblyViewShowTags );
   makeWidgetTypeBool( consed.autoEditRecalculateHighQualitySegmentsOfReads,
                          AutoEditRecalculateHighQualitySegmentsOfReads );
   makeWidgetTypeBool( consed.autoEditConvertCloneEndBasesToXs,
                          AutoEditConvertCloneEndBasesToXs );
   makeWidgetTypeBool( consed.autoEditTellPhrapNotToOverlapMultiplyDiscrepantReads,
                          AutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads );
   makeWidgetTypeBool( consed.autoEditTagEditableLowConsensusQualityRegions,
                          AutoEditTagEditableLowConsensusQualityRegions );
   makeWidgetTypeBool( consed.autoEditMakeFakeRead,
                          AutoEditMakeFakeRead );
   makeWidgetTypeRWCString( consed.autoEditMakeFakeReadFromRead1,
                          AutoEditMakeFakeReadFromRead1 );
   makeWidgetTypeRWCString( consed.autoEditMakeFakeReadFromRead2,
                          AutoEditMakeFakeReadFromRead2 );
   makeWidgetTypeRWCString( consed.autoEditMakeFakeReadName,
                          AutoEditMakeFakeReadName );
   makeWidgetTypeFileName( consed.autoEditMakeFakeReadFastaFilename,
                          AutoEditMakeFakeReadFastaFilename );
   makeWidgetTypeBool( consed.autoEditMergeAssembly,
                          AutoEditMergeAssembly );
   makeWidgetTypeFileName( consed.autoEditSecondaryAceFile,
                          AutoEditSecondaryAceFile );
   makeWidgetTypeBool( consed.autoEditFixRunsInConsensus,
                          AutoEditFixRunsInConsensus );
   makeWidgetTypeBool( consed.showAllTracesJustShowGoodTraces,
                          ShowAllTracesJustShowGoodTraces );
   makeWidgetTypeInt( consed.addAlignedSequenceQualityOfBases,
                          AddAlignedSequenceQualityOfBases );
   makeWidgetTypeBool( consed.makeLightBackgroundInAlignedReadsWindowAndTracesWindow,
                          MakeLightBackgroundInAlignedReadsWindowAndTracesWindow );
   makeWidgetTypeBool( consed.putVerticalLineAtCursor,
                          PutVerticalLineAtCursor );
   makeWidgetTypeBool( consed.putHorizontalLineAtCursor,
                          PutHorizontalLineAtCursor );
   makeWidgetTypeFileName( consed.highlightedReadsFile,
                          HighlightedReadsFile );
   makeWidgetTypeBool( consed.autoReportPrintReadNamesInRegion,
                          AutoReportPrintReadNamesInRegion );
   makeWidgetTypeRWCString( consed.autoReportPrintReadNamesInRegionContig,
                          AutoReportPrintReadNamesInRegionContig );
   makeWidgetTypeInt( consed.autoReportPrintReadNamesInRegionLeftPos,
                          AutoReportPrintReadNamesInRegionLeftPos );
   makeWidgetTypeInt( consed.autoReportPrintReadNamesInRegionRightPos,
                          AutoReportPrintReadNamesInRegionRightPos );
   makeWidgetTypeBool( consed.autoReportPrintHighlyDiscrepantRegions,
                          AutoReportPrintHighlyDiscrepantRegions );
   makeWidgetTypeBool( consed.autoReportPrintScaffolds,
                          AutoReportPrintScaffolds );
   makeWidgetTypeBool( consed.numberUnpaddedConsensusAtUserDefined,
                          NumberUnpaddedConsensusAtUserDefined );
   makeWidgetTypeBool( consed.autoReportPrintHighQualityDiscrepancies,
                          AutoReportPrintHighQualityDiscrepancies );
   makeWidgetTypeBool( consed.autoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags,
                          AutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags );
   makeWidgetTypeBool( consed.autoReportHighQualityDiscrepanciesExcludeMostPads,
                          AutoReportHighQualityDiscrepanciesExcludeMostPads );
   makeWidgetTypeBool( consed.autoReportPrintLowConsensusQualityRegions,
                          AutoReportPrintLowConsensusQualityRegions );
   makeWidgetTypeBool( consed.autoReportPrintSingleSubcloneRegions,
                          AutoReportPrintSingleSubcloneRegions );
   makeWidgetTypeBool( consed.autoReportPrintSingleStrandedRegions,
                          AutoReportPrintSingleStrandedRegions );
   makeWidgetTypeBool( consed.autoReportPrintLinkingForwardReversePairs,
                          AutoReportPrintLinkingForwardReversePairs );
   makeWidgetTypeBool( consed.autoReportPrintFilteredInconsistentForwardReversePairs,
                          AutoReportPrintFilteredInconsistentForwardReversePairs );
   makeWidgetTypeBool( consed.autoReportPrintAssemblySummary,
                          AutoReportPrintAssemblySummary );
   makeWidgetTypeRWCString( consed.showAllTracesDoNotShowTraceIfTheseTagsPresent,
                          ShowAllTracesDoNotShowTraceIfTheseTagsPresent );
   makeWidgetTypeBool( consed.nameOfFakeJoiningReadsIncludesAceFileName,
                          NameOfFakeJoiningReadsIncludesAceFileName );
   makeWidgetTypeInt( consed.whenUserScrollsOffWindowMillisecondsBetweenScrolling,
                          WhenUserScrollsOffWindowMillisecondsBetweenScrolling );
   makeWidgetTypeInt( consed.whenUserScrollsOffWindowBasesToScrollEachTime,
                          WhenUserScrollsOffWindowBasesToScrollEachTime );
   makeWidgetTypeBool( consed.compareContigsUseBandedRatherThanFullSmithWaterman,
                          CompareContigsUseBandedRatherThanFullSmithWaterman );
   makeWidgetTypeInt( consed.compareContigsBandSize,
                          CompareContigsBandSize );
   makeWidgetTypeInt( consed.assemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany,
                          AssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany );
   makeWidgetTypeBool( consed.assemblyViewShowSequenceMatches,
                          AssemblyViewShowSequenceMatches );
   makeWidgetTypeBool( consed.assemblyViewOKToShowSequenceMatchesBetweenContigs,
                          AssemblyViewOKToShowSequenceMatchesBetweenContigs );
   makeWidgetTypeBool( consed.assemblyViewOKToShowSequenceMatchesWithinContigs,
                          AssemblyViewOKToShowSequenceMatchesWithinContigs );
   makeWidgetTypeBool( consed.assemblyViewOKToShowDirectSequenceMatches,
                          AssemblyViewOKToShowDirectSequenceMatches );
   makeWidgetTypeBool( consed.assemblyViewOKToShowInvertedSequenceMatches,
                          AssemblyViewOKToShowInvertedSequenceMatches );
   makeWidgetTypeBool( consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion,
                          AssemblyViewOnlyShowSequenceMatchesToAParticularRegion );
   makeWidgetTypeRWCString( consed.assemblyViewOnlyShowSequenceMatchesToThisContig,
                          AssemblyViewOnlyShowSequenceMatchesToThisContig );
   makeWidgetTypeInt( consed.assemblyViewOnlyShowSequenceMatchesToThisRegionLeft,
                          AssemblyViewOnlyShowSequenceMatchesToThisRegionLeft );
   makeWidgetTypeInt( consed.assemblyViewOnlyShowSequenceMatchesToThisRegionRight,
                          AssemblyViewOnlyShowSequenceMatchesToThisRegionRight );
   makeWidgetTypeBool( consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigs,
                          AssemblyViewOnlyShowSequenceMatchesToEndsOfContigs );
   makeWidgetTypeInt( consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar,
                          AssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar );
   makeWidgetTypeRWCString( consed.defaultReadPrefix,
                          DefaultReadPrefix );
   makeWidgetTypeFileName( consed.readPrefixesFile,
                          ReadPrefixesFile );
   makeWidgetTypeInt( consed.maxCharsDisplayedForReadPrefix,
                          MaxCharsDisplayedForReadPrefix );
   makeWidgetTypeInt( consed.autoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates,
                          AutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates );
   makeWidgetTypeInt( consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions,
                          AutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions );
   makeWidgetTypeInt( consed.autoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis,
                          AutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis );
   makeWidgetTypeBool( consed.autoFinishDoNotDoPCRIfEndIsExtendedByReads,
                          AutoFinishDoNotDoPCRIfEndIsExtendedByReads );
   makeWidgetTypeInt( consed.autoFinishMaxAcceptableErrorsPerMegabase,
                          AutoFinishMaxAcceptableErrorsPerMegabase );
   makeWidgetTypeInt( consed.autoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize,
                          AutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize );
   makeWidgetTypeInt( consed.primersNumberOfBasesToBackUpToStartLooking,
                          PrimersNumberOfBasesToBackUpToStartLooking );
   makeWidgetTypeInt( consed.primersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment,
                          PrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment );
   makeWidgetTypeBool( consed.primersOKToChoosePrimersInSingleSubcloneRegion,
                          PrimersOKToChoosePrimersInSingleSubcloneRegion );
   makeWidgetTypeBool( consed.primersOKToChoosePrimersWhereHighQualityDiscrepancies,
                          PrimersOKToChoosePrimersWhereHighQualityDiscrepancies );
   makeWidgetTypeBool( consed.primersOKToChoosePrimersWhereUnalignedHighQualityRegion,
                          PrimersOKToChoosePrimersWhereUnalignedHighQualityRegion );
   makeWidgetTypeBool( consed.autoFinishCallReversesToFlankGaps,
                          AutoFinishCallReversesToFlankGaps );
   makeWidgetTypeBool( consed.autoFinishAllowWholeCloneReads,
                          AutoFinishAllowWholeCloneReads );
   makeWidgetTypeBool( consed.autoFinishAllowCustomPrimerSubcloneReads,
                          AutoFinishAllowCustomPrimerSubcloneReads );
   makeWidgetTypeBool( consed.autoFinishAllowResequencingReads,
                          AutoFinishAllowResequencingReads );
   makeWidgetTypeBool( consed.autoFinishAllowResequencingReadsOnlyForRunsAndStops,
                          AutoFinishAllowResequencingReadsOnlyForRunsAndStops );
   makeWidgetTypeBool( consed.autoFinishAllowDeNovoUniversalPrimerSubcloneReads,
                          AutoFinishAllowDeNovoUniversalPrimerSubcloneReads );
   makeWidgetTypeBool( consed.autoFinishAllowMinilibraries,
                          AutoFinishAllowMinilibraries );
   makeWidgetTypeBool( consed.autoFinishAllowPCR,
                          AutoFinishAllowPCR );
   makeWidgetTypeBool( consed.autoFinishAllowUnorientedPCRReactions,
                          AutoFinishAllowUnorientedPCRReactions );
   makeWidgetTypeBool( consed.autoFinishAllowResequencingAUniversalPrimerAutofinishRead,
                          AutoFinishAllowResequencingAUniversalPrimerAutofinishRead );
   makeWidgetTypeBool( consed.autoFinishAlwaysCloseGapsUsingMinilibraries,
                          AutoFinishAlwaysCloseGapsUsingMinilibraries );
   makeWidgetTypeInt( consed.autoFinishMaximumFinishingReadLength,
                          AutoFinishMaximumFinishingReadLength );
   makeWidgetTypeInt( consed.autoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger,
                          AutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger );
   makeWidgetTypeBool( consed.autoFinishSuggestSpecialChemistryForRunsAndStops,
                          AutoFinishSuggestSpecialChemistryForRunsAndStops );
   makeWidgetTypeInt( consed.autoFinishSuggestThisManyMinilibrariesPerGap,
                          AutoFinishSuggestThisManyMinilibrariesPerGap );
   makeWidgetTypeInt( consed.primersWindowSizeInLooking,
                          PrimersWindowSizeInLooking );
   makeWidgetTypeBool( consed.primersAssumeTemplatesAreDoubleStrandedUnlessSpecified,
                          PrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified );
   makeWidgetTypeInt( consed.alignedReadsWindowInitialCharsWide,
                          AlignedReadsWindowInitialCharsWide );
   makeWidgetTypeInt( consed.alignedReadsWindowInitialCharsHigh,
                          AlignedReadsWindowInitialCharsHigh );
   makeWidgetTypeInt( consed.alignedReadsWindowMaxCharsForReadNames,
                          AlignedReadsWindowMaxCharsForReadNames );
   makeWidgetTypeBool( consed.alignedReadsWindowAutomaticallyExpandRoomForReadNames,
                          AlignedReadsWindowAutomaticallyExpandRoomForReadNames );
   makeWidgetTypeBool( consed.autoFinishAllowResequencingReadsToExtendContigs,
                          AutoFinishAllowResequencingReadsToExtendContigs );
   makeWidgetTypeInt( consed.autoFinishCallHowManyReversesToFlankGaps,
                          AutoFinishCallHowManyReversesToFlankGaps );
   makeWidgetTypeBool( consed.autoFinishCloseGaps,
                          AutoFinishCloseGaps );
   makeWidgetTypeBool( consed.autoFinishContinueEvenThoughReadInfoDoesNotMakeSense,
                          AutoFinishContinueEvenThoughReadInfoDoesNotMakeSense );
   makeWidgetTypeDouble( consed.autoFinishCostOfResequencingUniversalPrimerSubcloneReaction,
                          AutoFinishCostOfResequencingUniversalPrimerSubcloneReaction );
   makeWidgetTypeDouble( consed.autoFinishCostOfCustomPrimerSubcloneReaction,
                          AutoFinishCostOfCustomPrimerSubcloneReaction );
   makeWidgetTypeDouble( consed.autoFinishCostOfCustomPrimerCloneReaction,
                          AutoFinishCostOfCustomPrimerCloneReaction );
   makeWidgetTypeDouble( consed.autoFinishCostOfDeNovoUniversalPrimerSubcloneReaction,
                          AutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction );
   makeWidgetTypeDouble( consed.autoFinishCostOfMinilibrary,
                          AutoFinishCostOfMinilibrary );
   makeWidgetTypeBool( consed.autoFinishCoverSingleSubcloneRegions,
                          AutoFinishCoverSingleSubcloneRegions );
   makeWidgetTypeBool( consed.autoFinishCoverLowConsensusQualityRegions,
                          AutoFinishCoverLowConsensusQualityRegions );
   makeWidgetTypeFileName( consed.autoFinishDebugUniversalPrimerReadsFile,
                          AutoFinishDebugUniversalPrimerReadsFile );
   makeWidgetTypeFileName( consed.autoFinishDebugCustomPrimerReadsFile,
                          AutoFinishDebugCustomPrimerReadsFile );
   makeWidgetTypeInt( consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases,
                          AutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases );
   makeWidgetTypeInt( consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases,
                          AutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases );
   makeWidgetTypeRWCString( consed.autoFinishDoNotFinishWhereTheseTagsAre,
                          AutoFinishDoNotFinishWhereTheseTagsAre );
   makeWidgetTypeRWCString( consed.autoFinishDoNotExtendContigsWhereTheseTagsAre,
                          AutoFinishDoNotExtendContigsWhereTheseTagsAre );
   makeWidgetTypeInt( consed.autoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd,
                          AutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd );
   makeWidgetTypeFileName( consed.dumpContigOrderAndOrientationInfoToThisFile,
                          DumpContigOrderAndOrientationInfoToThisFile );
   makeWidgetTypeBool( consed.autoFinishDumpTemplates,
                          AutoFinishDumpTemplates );
   makeWidgetTypeInt( consed.autoFinishExcludeContigIfOnlyThisManyReadsOrLess,
                          AutoFinishExcludeContigIfOnlyThisManyReadsOrLess );
   makeWidgetTypeDouble( consed.autoFinishExcludeContigIfDepthOfCoverageGreaterThanThis,
                          AutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis );
   makeWidgetTypeInt( consed.autoFinishExcludeContigIfThisManyBasesOrLess,
                          AutoFinishExcludeContigIfThisManyBasesOrLess );
   makeWidgetTypeInt( consed.autoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions,
                          AutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions );
   makeWidgetTypeInt( consed.primersMinNumberOfTemplatesForPrimers,
                          PrimersMinNumberOfTemplatesForPrimers );
   makeWidgetTypeInt( consed.autoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus,
                          AutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus );
   makeWidgetTypeInt( consed.autoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead,
                          AutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead );
   makeWidgetTypeBool( consed.autoFinishCDNANotGenomic,
                          AutoFinishCDNANotGenomic );
   makeWidgetTypeInt( consed.autoFinishConfidenceThatReadWillCoverSingleSubcloneRegion,
                          AutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion );
   makeWidgetTypeBool( consed.autoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads,
                          AutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads );
   makeWidgetTypeBool( consed.autoFinishPrintMinilibrariesSummaryFile,
                          AutoFinishPrintMinilibrariesSummaryFile );
   makeWidgetTypeBool( consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs,
                          AutoFinishNearGapsSuggestEachMissingReadOfReadPairs );
   makeWidgetTypeInt( consed.autoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger,
                          AutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger );
   makeWidgetTypeBool( consed.checkIfTooManyWalks,
                          CheckIfTooManyWalks );
   makeWidgetTypeInt( consed.numberOfColumnsBeforeReadNameInAlignedReadsWindow,
                          NumberOfColumnsBeforeReadNameInAlignedReadsWindow );
   makeWidgetTypeInt( consed.compareContigsAlignsThisManyBasesMax,
                          CompareContigsAlignsThisManyBasesMax );
   makeWidgetTypeRWCString( consed.compressedChromatExtension,
                          CompressedChromatExtension );
   makeWidgetTypeBool( consed.dimLowQualityEndsOfReads,
                          DimLowQualityEndsOfReads );
   makeWidgetTypeBool( consed.dimUnalignedEndsOfReads,
                          DimUnalignedEndsOfReads );
   makeWidgetTypeBool( consed.fakeReadsSpecifiedByFilenameExtension,
                          FakeReadsSpecifiedByFilenameExtension );
   makeWidgetTypeFileName( consed.fullPathnameOfAddReads2ConsedScript,
                          FullPathnameOfAddReads2ConsedScript );
   makeWidgetTypeFileName( consed.fullPathnameOfFixContigEndScript,
                          FullPathnameOfFixContigEndScript );
   makeWidgetTypeBool( consed.fixContigEndsCleanUpTemporaryFiles,
                          FixContigEndsCleanUpTemporaryFiles );
   makeWidgetTypeInt( consed.fixContigEndsMinSmithWatermanScoreToMakeJoin,
                          FixContigEndsMinSmithWatermanScoreToMakeJoin );
   makeWidgetTypeInt( consed.fixContigEndsMinNumberOfReadsInContig,
                          FixContigEndsMinNumberOfReadsInContig );
   makeWidgetTypeFileName( consed.fullPathnameOfCrossMatch,
                          FullPathnameOfCrossMatch );
   makeWidgetTypeFileName( consed.fullPathnameOfPhred,
                          FullPathnameOfPhred );
   makeWidgetTypeFileName( consed.fullPathnameOfMiniassemblyScript,
                          FullPathnameOfMiniassemblyScript );
   makeWidgetTypeRWCString( consed.gunzipFullPath,
                          GunzipFullPath );
   makeWidgetTypeFileName( consed.fullPathnameOfFilter454ReadsScript,
                          FullPathnameOfFilter454ReadsScript );
   makeWidgetTypeFileName( consed.filter454ReadsAgainstThis,
                          Filter454ReadsAgainstThis );
   makeWidgetTypeFileName( consed.454LinkerSequences,
                          454LinkerSequences );
   makeWidgetTypeBool( consed.hideSomeTagTypesAtStartup,
                          HideSomeTagTypesAtStartup );
   makeWidgetTypeInt( consed.maximumNumberOfTracesShown,
                          MaximumNumberOfTracesShown );
   makeWidgetTypeBool( consed.navigateAutomaticTracePopup,
                          NavigateAutomaticTracePopup );
   makeWidgetTypeBool( consed.navigateAutomaticAllTracesPopup,
                          NavigateAutomaticAllTracesPopup );
   makeWidgetTypeInt( consed.primersMinimumLengthOfAPrimer,
                          PrimersMinimumLengthOfAPrimer );
   makeWidgetTypeInt( consed.primersMaximumLengthOfAPrimer,
                          PrimersMaximumLengthOfAPrimer );
   makeWidgetTypeInt( consed.primersMinimumLengthOfAPrimerForPCR,
                          PrimersMinimumLengthOfAPrimerForPCR );
   makeWidgetTypeInt( consed.primersMaximumLengthOfAPrimerForPCR,
                          PrimersMaximumLengthOfAPrimerForPCR );
   makeWidgetTypeDouble( consed.primersMaxMeltingTempDifferenceForPCR,
                          PrimersMaxMeltingTempDifferenceForPCR );
   makeWidgetTypeInt( consed.primersMaxPCRPrimerPairsToDisplay,
                          PrimersMaxPCRPrimerPairsToDisplay );
   makeWidgetTypeBool( consed.primersCheckJustSomePCRPrimerPairsRatherThanAll,
                          PrimersCheckJustSomePCRPrimerPairsRatherThanAll );
   makeWidgetTypeInt( consed.primersNumberOfTemplatesToDisplayInFront,
                          PrimersNumberOfTemplatesToDisplayInFront );
   makeWidgetTypeInt( consed.primersMaxLengthOfMononucleotideRepeat,
                          PrimersMaxLengthOfMononucleotideRepeat );
   makeWidgetTypeFileName( consed.primersBadLibrariesFile,
                          PrimersBadLibrariesFile );
   makeWidgetTypeFileName( consed.primersLibrariesInfoFile,
                          PrimersLibrariesInfoFile );
   makeWidgetTypeFileName( consed.primersBadTemplatesFile,
                          PrimersBadTemplatesFile );
   makeWidgetTypeBool( consed.primersChooseTemplatesByPositionInsteadOfQuality,
                          PrimersChooseTemplatesByPositionInsteadOfQuality );
   makeWidgetTypeInt( consed.primersWhenChoosingATemplateMinPotentialReadLength,
                          PrimersWhenChoosingATemplateMinPotentialReadLength );
   makeWidgetTypeInt( consed.primersWindowSizeInLookingForPCR,
                          PrimersWindowSizeInLookingForPCR );
   makeWidgetTypeInt( consed.qualityThresholdForFindingHighQualityDiscrepancies,
                          QualityThresholdForFindingHighQualityDiscrepancies );
   makeWidgetTypeInt( consed.qualityThresholdForNavigateByDepthOfCoverage,
                          QualityThresholdForNavigateByDepthOfCoverage );
   makeWidgetTypeBool( consed.navigateByHighDepthOfCoverageNotLow,
                          NavigateByHighDepthOfCoverageNotLow );
   makeWidgetTypeInt( consed.MinDepthForNavigateByDepthOfCoverage,
                          MinDepthForNavigateByDepthOfCoverage );
   makeWidgetTypeFileName( consed.defaultVectorPathnameForRestrictionFragments,
                          DefaultVectorPathnameForRestrictionFragments );
   makeWidgetTypeFileName( consed.fileOfAdditionalRestrictionEnzymes,
                          FileOfAdditionalRestrictionEnzymes );
   makeWidgetTypeRWCString( consed.commonRestrictionEnzymes,
                          CommonRestrictionEnzymes );
   makeWidgetTypeRWCString( consed.defaultSelectedRestrictionEnzymes,
                          DefaultSelectedRestrictionEnzymes );
   makeWidgetTypeFileName( consed.restrictionEnzymesActualFragmentsFile,
                          RestrictionEnzymesActualFragmentsFile );
   makeWidgetTypeInt( consed.restrictionDigestInitialWindowSizeInTextRows,
                          RestrictionDigestInitialWindowSizeInTextRows );
   makeWidgetTypeInt( consed.restrictionDigestDoNoShowAreaOfFragmentsOverThisSize,
                          RestrictionDigestDoNoShowAreaOfFragmentsOverThisSize );
   makeWidgetTypeBool( consed.showReadsAlphabetically,
                          ShowReadsAlphabetically );
   makeWidgetTypeBool( consed.showReadsInAlignedReadsWindowOrderedByFile,
                          ShowReadsInAlignedReadsWindowOrderedByFile );
   makeWidgetTypeFileName( consed.showReadsInAlignedReadsWindowOrderedByThisFile,
                          ShowReadsInAlignedReadsWindowOrderedByThisFile );
   makeWidgetTypeRWCString( consed.showReadsAtCursorSortedHow,
                          ShowReadsAtCursorSortedHow );
   makeWidgetTypeBool( consed.showABIBasesInTraceWindow,
                          ShowABIBasesInTraceWindow );
   makeWidgetTypeInt( consed.tracesWindowInitialPixelHeight,
                          TracesWindowInitialPixelHeight );
   makeWidgetTypeInt( consed.assemblyViewWindowInitialPixelHeight,
                          AssemblyViewWindowInitialPixelHeight );
   makeWidgetTypeFileName( consed.assemblyViewFileOfTemplatesToNotShow,
                          AssemblyViewFileOfTemplatesToNotShow );
   makeWidgetTypeInt( consed.assemblyViewCrossMatchMinmatch,
                          AssemblyViewCrossMatchMinmatch );
   makeWidgetTypeInt( consed.assemblyViewCrossMatchMinscore,
                          AssemblyViewCrossMatchMinscore );
   makeWidgetTypeFileName( consed.assemblyViewFindSequenceMatchesForConsedScript,
                          AssemblyViewFindSequenceMatchesForConsedScript );
   makeWidgetTypeInt( consed.assemblyViewCrossmatchMinmatch,
                          AssemblyViewCrossmatchMinmatch );
   makeWidgetTypeInt( consed.assemblyViewCrossmatchMinscore,
                          AssemblyViewCrossmatchMinscore );
   makeWidgetTypeInt( consed.assemblyViewSequenceMatchesMinimumSimilarity,
                          AssemblyViewSequenceMatchesMinimumSimilarity );
   makeWidgetTypeInt( consed.tracesWindowInitialPixelWidth,
                          TracesWindowInitialPixelWidth );
   makeWidgetTypeInt( consed.assemblyViewWindowInitialPixelWidth,
                          AssemblyViewWindowInitialPixelWidth );
   makeWidgetTypeBool( consed.automaticallyScaleTraces,
                          AutomaticallyScaleTraces );
   makeWidgetTypeDouble( consed.automaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight,
                          AutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight );
   makeWidgetTypeInt( consed.automaticallyScaleTracesSamplePeakPercentile,
                          AutomaticallyScaleTracesSamplePeakPercentile );
   makeWidgetTypeInt( consed.verticalTraceMagnification,
                          VerticalTraceMagnification );
   makeWidgetTypeRWCString( consed.userDefinedKeys,
                          UserDefinedKeys );
   makeWidgetTypeRWCString( consed.programsForUserDefinedKeys,
                          ProgramsForUserDefinedKeys );
   makeWidgetTypeRWCString( consed.argumentsToPassToUserDefinedPrograms,
                          ArgumentsToPassToUserDefinedPrograms );
   makeWidgetTypeRWCString( consed.tagsToApplyWithUserDefinedKeys,
                          TagsToApplyWithUserDefinedKeys );
   makeWidgetTypeBool( consed.snpGenomeUseInsertionPolymorphisms,
                          SnpGenomeUseInsertionPolymorphisms );
   makeWidgetTypeRWCString( consed.listOfTagTypesToHide,
                          ListOfTagTypesToHide );
   makeWidgetTypeRWCString( consed.listOfOptionalWordsToSaveInListOfReadNames,
                          ListOfOptionalWordsToSaveInListOfReadNames );
   makeWidgetTypeBool( consed.extendConsensusWithHighQuality,
                          ExtendConsensusWithHighQuality );
   makeWidgetTypeBool( consed.fastStartup,
                          FastStartup );
   makeWidgetTypeFileName( consed.fastStartupFile,
                          FastStartupFile );
   makeWidgetTypeRWCString( consed.alwaysRunProgramToGetChromats,
                          AlwaysRunProgramToGetChromats );
   makeWidgetTypeFileName( consed.programToRunToGetChromats,
                          ProgramToRunToGetChromats );
   makeWidgetTypeFileName( consed.programToRunToGetChromatsOf454Reads,
                          ProgramToRunToGetChromatsOf454Reads );
   makeWidgetTypeBool( consed.createFakeChromatsForSolexaReads,
                          CreateFakeChromatsForSolexaReads );
   makeWidgetTypeBool( consed.autoFinishUseLongModelReadRatherThanShort,
                          AutoFinishUseLongModelReadRatherThanShort );
   makeWidgetTypeInt( consed.askAgainIfWantToQuitConsedIfThisManyReads,
                          AskAgainIfWantToQuitConsedIfThisManyReads );
   makeWidgetTypeRWCString( consed.printWindowInstructions,
                          PrintWindowInstructions );
   makeWidgetTypeBool( consed.allowMultipleSearchForStringWindows,
                          AllowMultipleSearchForStringWindows );
   makeWidgetTypeInt( consed.autoPCRAmplifyFalseProductsOKIfLargerThanThis,
                          AutoPCRAmplifyFalseProductsOKIfLargerThanThis );
   makeWidgetTypeBool( consed.autoPCRAmplifyMakePrimerOutOfFirstRegion,
                          AutoPCRAmplifyMakePrimerOutOfFirstRegion );
   makeWidgetTypeInt( consed.autoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct,
                          AutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct );
   makeWidgetTypeBool( consed.addNewReadsRecalculateConsensusQuality,
                          AddNewReadsRecalculateConsensusQuality );
   makeWidgetTypeRWCString( consed.addNewReadsPutReadIntoItsOwnContig,
                          AddNewReadsPutReadIntoItsOwnContig );
   makeWidgetTypeBool( consed.addNewReadsCheckThatCrossMatchRunCorrectly,
                          AddNewReadsCheckThatCrossMatchRunCorrectly );
   makeWidgetTypeInt( consed.assemblyViewNumberOfRowsOfTags,
                          AssemblyViewNumberOfRowsOfTags );
   makeWidgetTypeBool( consed.warnUserWhenTryingToEditAllReads,
                          WarnUserWhenTryingToEditAllReads );
   makeWidgetTypeFileName( consed.maybeXKEYSYMDBPath,
                          MaybeXKEYSYMDBPath );
   makeWidgetTypeFileName( consed.maybeXKEYSYMDBPath2,
                          MaybeXKEYSYMDBPath2 );
   makeWidgetTypeInt( consed.amountToMoveWithBigLeftAndRightArrows,
                          AmountToMoveWithBigLeftAndRightArrows );
   makeWidgetTypeInt( consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads,
                          NavigateByHighlyDiscrepantPositionsMinDiscrepantReads );
   makeWidgetTypeInt( consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage,
                          NavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage );
   makeWidgetTypeInt( consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality,
                          NavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality );
   makeWidgetTypeBool( consed.navigateByHighlyDiscrepantPositionsJustListIndels,
                          NavigateByHighlyDiscrepantPositionsJustListIndels );
   makeWidgetTypeBool( consed.navigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation,
                          NavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation );
   makeWidgetTypeBool( consed.navigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus,
                          NavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus );
   makeWidgetTypeRWCString( consed.navigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus,
                          NavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus );
   makeWidgetTypeFileName( consed.phdBallDirectory,
                          PhdBallDirectory );
   makeWidgetTypeFileName( consed.newAceFileFOF,
                          NewAceFileFOF );
   makeWidgetTypeInt( consed.navigateByHighOrLowDepthCoalesceRegionsIfThisClose,
                          NavigateByHighOrLowDepthCoalesceRegionsIfThisClose );
   makeWidgetTypeBool( consed.removeReadsDeleteNotJustPutInOwnContig,
                          RemoveReadsDeleteNotJustPutInOwnContig );
   makeWidgetTypeRWCString( consed.paired454LeftReadExtension,
                          Paired454LeftReadExtension );
   makeWidgetTypeRWCString( consed.paired454RightReadExtension,
                          Paired454RightReadExtension );
   makeWidgetTypeFileName( consed.snpGenome1MSnps,
                          SnpGenome1MSnps );
   makeWidgetTypeBool( consed.diffChromosomesExcludeDeletions,
                          DiffChromosomesExcludeDeletions );
   makeWidgetTypeBool( consed.snpGenomeFilterByWeight,
                          SnpGenomeFilterByWeight );
   makeWidgetTypeInt( consed.wantReadsUpToThisFarFromSnps,
                          WantReadsUpToThisFarFromSnps );
   makeWidgetTypeRWCString( consed.phaster2PhdBallSaveWhichMate,
                          Phaster2PhdBallSaveWhichMate );
   makeWidgetTypeBool( consed.phaster2PhdBallSaveInPhasterFormat,
                          Phaster2PhdBallSaveInPhasterFormat );
   makeWidgetTypeBool( consed.phaster2PhdBallCalculateNewLocationsFile,
                          Phaster2PhdBallCalculateNewLocationsFile );
   makeWidgetTypeBool( consed.phdBall2FastaIgnoreLowQualityReads,
                          PhdBall2FastaIgnoreLowQualityReads );
   makeWidgetTypeInt( consed.phdBall2FastaLowestAverageQuality,
                          PhdBall2FastaLowestAverageQuality );
   makeWidgetTypeFileName( consed.nextPhredPipelineControlFile,
                          NextPhredPipelineControlFile );
   makeWidgetTypeFileName( consed.nextPhredPipelineTiffPerlScript,
                          NextPhredPipelineTiffPerlScript );
   makeWidgetTypeFileName( consed.nextPhredPipelinePhasterPerlScript,
                          NextPhredPipelinePhasterPerlScript );
   makeWidgetTypeRWCString( consed.nextPhredPipelineVersion,
                          NextPhredPipelineVersion );
   makeWidgetTypeRWCString( consed.nextPhredPipelineMainDirectory,
                          NextPhredPipelineMainDirectory );
   makeWidgetTypeInt( consed.maxNumberOfReadsPerPhdBall,
                          MaxNumberOfReadsPerPhdBall );
   makeWidgetTypeFileName( consed.userWantsToSaveToThisAceFile,
                          UserWantsToSaveToThisAceFile );
   makeWidgetTypeBool( consed.autoFinishEmulate9_66Behavior,
                          AutoFinishEmulate9_66Behavior );
   makeWidgetTypeInt( consed.primersPCRPrimersGroupedIntoWindowOfThisManyBases,
                          PrimersPCRPrimersGroupedIntoWindowOfThisManyBases );
   makeWidgetTypeInt( consed.primersLookForThisManyPCRPrimerPairsPerPairOfGroups,
                          PrimersLookForThisManyPCRPrimerPairsPerPairOfGroups );
   makeWidgetTypeDouble( consed.autoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs,
                          AutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs );
   makeWidgetTypeBool( consed.autoFinishCheckThatReadsFromTheSameTemplateAreConsistent,
                          AutoFinishCheckThatReadsFromTheSameTemplateAreConsistent );
   makeWidgetTypeBool( consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether,
                          AutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether );
   makeWidgetTypeBool( consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether,
                          AutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether );
   makeWidgetTypeDouble( consed.autoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean,
                          AutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean );
   makeWidgetTypeInt( consed.autoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize,
                          AutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize );
   makeWidgetTypeDouble( consed.autoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize,
                          AutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize );
   makeWidgetTypeInt( consed.autoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead,
                          AutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead );
   makeWidgetTypeInt( consed.autoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp,
                          AutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp );
   makeWidgetTypeInt( consed.autoFinishNumberOfBasesBetweenContigsAssumed,
                          AutoFinishNumberOfBasesBetweenContigsAssumed );
   makeWidgetTypeInt( consed.autoFinishPotentialHighQualityPartOfReadStart,
                          AutoFinishPotentialHighQualityPartOfReadStart );
   makeWidgetTypeInt( consed.autoFinishPotentialHighQualityPartOfReadEnd,
                          AutoFinishPotentialHighQualityPartOfReadEnd );
   makeWidgetTypeBool( consed.autoFinishPrintCustomNavigationFileForChosenReads,
                          AutoFinishPrintCustomNavigationFileForChosenReads );
   makeWidgetTypeInt( consed.autoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch,
                          AutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch );
   makeWidgetTypeBool( consed.autoFinishTagOligosWhenDoExperiments,
                          AutoFinishTagOligosWhenDoExperiments );
   makeWidgetTypeBool( consed.countPads,
                          CountPads );
   makeWidgetTypeInt( consed.debugging,
                          Debugging );
   makeWidgetTypeInt( consed.debugging2,
                          Debugging2 );
   makeWidgetTypeInt( consed.debugging3,
                          Debugging3 );
   makeWidgetTypeRWCString( consed.debuggingString,
                          DebuggingString );
   makeWidgetTypeInt( consed.ignoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion,
                          IgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion );
   makeWidgetTypeInt( consed.ignoreUnalignedHighQualitySegmentsShorterThanThis,
                          IgnoreUnalignedHighQualitySegmentsShorterThanThis );
   makeWidgetTypeInt( consed.primersLookThisFarForForwardVectorInsertJunction,
                          PrimersLookThisFarForForwardVectorInsertJunction );
   makeWidgetTypeDouble( consed.primersDNAConcentrationNanomolar,
                          PrimersDNAConcentrationNanomolar );
   makeWidgetTypeInt( consed.primersMaxMatchElsewhereScore,
                          PrimersMaxMatchElsewhereScore );
   makeWidgetTypeInt( consed.primersMaxMatchElsewhereScoreForPCR,
                          PrimersMaxMatchElsewhereScoreForPCR );
   makeWidgetTypeInt( consed.primersMaxSelfMatchScore,
                          PrimersMaxSelfMatchScore );
   makeWidgetTypeInt( consed.primersMaxPrimerDimerScoreForPCR,
                          PrimersMaxPrimerDimerScoreForPCR );
   makeWidgetTypeInt( consed.primersMinQuality,
                          PrimersMinQuality );
   makeWidgetTypeBool( consed.primersPrintInfoOnRejectedTemplates,
                          PrimersPrintInfoOnRejectedTemplates );
   makeWidgetTypeDouble( consed.primersSaltConcentrationMillimolar,
                          PrimersSaltConcentrationMillimolar );
   makeWidgetTypeBool( consed.primersScreenForVector,
                          PrimersScreenForVector );
   makeWidgetTypeInt( consed.primersToleranceForDifferentBeginningLocationOfUniversalPrimerReads,
                          PrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads );
   makeWidgetTypeInt( consed.primersTooManyVectorBasesInWalkingRead,
                          PrimersTooManyVectorBasesInWalkingRead );
   makeWidgetTypeInt( consed.qualityThresholdForLowConsensusQuality,
                          QualityThresholdForLowConsensusQuality );
   makeWidgetTypeInt( consed.tagColorPerCentOfBase,
                          TagColorPerCentOfBase );
   makeWidgetTypeRWCString( consed.uncompressedChromatDirectory,
                          UncompressedChromatDirectory );
   makeWidgetTypeFileName( consed.454sff2scfDirectory,
                          454sff2scfDirectory );
   makeWidgetTypeInt( consed.whenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion,
                          WhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion );
   makeWidgetTypeInt( consed.writeThisAceFormat,
                          WriteThisAceFormat );
   makeWidgetTypeBool( consed.dumpCoreIfBoundsError,
                          DumpCoreIfBoundsError );
   makeWidgetTypeInt( consed.autoFinishMinSmithWatermanScoreOfARun,
                          AutoFinishMinSmithWatermanScoreOfARun );
   makeWidgetTypeDouble( consed.autoFinishDoNotComparePCRPrimersMoreThanThisManyTimes,
                          AutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes );
   makeWidgetTypeInt( consed.restrictionDigestMaximumBasesToCompareToVector,
                          RestrictionDigestMaximumBasesToCompareToVector );
   makeWidgetTypeDouble( consed.restrictionDigestZoomFactor,
                          RestrictionDigestZoomFactor );
   makeWidgetTypeDouble( consed.restrictionDigestZoomFactorForNavigate,
                          RestrictionDigestZoomFactorForNavigate );
   makeWidgetTypeInt( consed.restrictionDigestToleranceInPositionUnits,
                          RestrictionDigestToleranceInPositionUnits );
   makeWidgetTypeInt( consed.autoPCRAmplifyTooManySeriousFalseMatches,
                          AutoPCRAmplifyTooManySeriousFalseMatches );
   makeWidgetTypeDouble( consed.assemblyViewZoomFactor,
                          AssemblyViewZoomFactor );
   makeWidgetTypeInt( consed.assemblyViewFilterInconsistentFwdRevPairsIfThisClose,
                          AssemblyViewFilterInconsistentFwdRevPairsIfThisClose );
   makeWidgetTypeDouble( consed.assemblyViewGridCellWidthInPixels,
                          AssemblyViewGridCellWidthInPixels );
   makeWidgetTypeInt( consed.assemblyViewCursorSensitivityInPixels,
                          AssemblyViewCursorSensitivityInPixels );
   makeWidgetTypeInt( consed.assemblyViewReadDepthQuality,
                          AssemblyViewReadDepthQuality );
   makeWidgetTypeInt( consed.showAllTracesMaxNumberOfTracesToShowAtOnce,
                          ShowAllTracesMaxNumberOfTracesToShowAtOnce );
   makeWidgetTypeInt( consed.allowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess,
                          AllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess );
   makeWidgetTypeBool( consed.justForPrimateProject,
                          JustForPrimateProject );
   makeWidgetTypeFileName( consed.solexaFilesAreAssumedToBeHere,
                          SolexaFilesAreAssumedToBeHere );
   makeWidgetTypeInt( consed.solexaAlignmentFilesPerInsertingPadsCycle,
                          SolexaAlignmentFilesPerInsertingPadsCycle );
   makeWidgetTypeInt( consed.solexaAlignmentsPerAlignmentFile,
                          SolexaAlignmentsPerAlignmentFile );
   makeWidgetTypeBool( consed.solexaFastqFilesArePhredQualityNotSolexaQuality,
                          SolexaFastqFilesArePhredQualityNotSolexaQuality );
   makeWidgetTypeRWCString( consed.solexa64FastqOrSanger33Fastq,
                          Solexa64FastqOrSanger33Fastq );
   makeWidgetTypeInt( consed.maximumReadsInReadList,
                          MaximumReadsInReadList );
   makeWidgetTypeInt( consed.maxLengthOfReadsInapLocatedFragment2,
                          MaxLengthOfReadsInapLocatedFragment2 );
   makeWidgetTypeInt( consed.maximumStartupErrorsToReport,
                          MaximumStartupErrorsToReport );
   makeWidgetTypeInt( consed.454LinkerAlignmentMatchScore,
                          454LinkerAlignmentMatchScore );
   makeWidgetTypeInt( consed.454LinkerAlignmentMismatchScore,
                          454LinkerAlignmentMismatchScore );
   makeWidgetTypeInt( consed.454LinkerAlignmentIndelScore,
                          454LinkerAlignmentIndelScore );
   makeWidgetTypeBool( consed.filter454ReadsDeleteCrossMatchOutput,
                          Filter454ReadsDeleteCrossMatchOutput );
   makeWidgetTypeInt( consed.autoReportAllNeededSpeciesCode,
                          AutoReportAllNeededSpeciesCode );
   makeWidgetTypeBool( consed.autoReportUseCommasInBigNumbers,
                          AutoReportUseCommasInBigNumbers );
   makeWidgetTypeBool( consed.autoReportPrintToCompareToReich,
                          AutoReportPrintToCompareToReich );
   makeWidgetTypeBool( consed.autoReportOnlyAllowSitesThatAreBetweenAcceptableSites,
                          AutoReportOnlyAllowSitesThatAreBetweenAcceptableSites );
   makeWidgetTypeBool( consed.autoReportDeaminationMutationsDeterminedByMoreAccurateMethod,
                          AutoReportDeaminationMutationsDeterminedByMoreAccurateMethod );
   makeWidgetTypeBool( consed.autoReportChooseTreesUsingBadData,
                          AutoReportChooseTreesUsingBadData );
   makeWidgetTypeBool( consed.autoReportChooseTreesByCountingDeaminationMutations,
                          AutoReportChooseTreesByCountingDeaminationMutations );
   makeWidgetTypeBool( consed.autoReportChooseTreesUsingKimura,
                          AutoReportChooseTreesUsingKimura );
   makeWidgetTypeBool( consed.autoReportPrintCrudeChimpHumanMutations,
                          AutoReportPrintCrudeChimpHumanMutations );
   makeWidgetTypeBool( consed.autoReportPrintPositionsForGraham,
                          AutoReportPrintPositionsForGraham );
   makeWidgetTypeBool( consed.autoReportPrintAncestralCpGs,
                          AutoReportPrintAncestralCpGs );
   makeWidgetTypeBool( consed.autoReportPrintCpGMutations,
                          AutoReportPrintCpGMutations );
   makeWidgetTypeBool( consed.autoReportPrintMutationsWithContext,
                          AutoReportPrintMutationsWithContext );
   makeWidgetTypeBool( consed.autoReportCountAllMutationsML,
                          AutoReportCountAllMutationsML );
   makeWidgetTypeBool( consed.autoReportCountAllMutations,
                          AutoReportCountAllMutations );
   makeWidgetTypeBool( consed.autoReportIgnoreMultipleTrees,
                          AutoReportIgnoreMultipleTrees );
   makeWidgetTypeBool( consed.autoReportCountAcceptableColumnsWithNoneOnLeft,
                          AutoReportCountAcceptableColumnsWithNoneOnLeft );
   makeWidgetTypeBool( consed.autoReportPrintFlankedColumns4,
                          AutoReportPrintFlankedColumns4 );
   makeWidgetTypeBool( consed.autoReportUseAnnotationFormat,
                          AutoReportUseAnnotationFormat );
   makeWidgetTypeBool( consed.autoReportPrintFlankedColumns3,
                          AutoReportPrintFlankedColumns3 );
   makeWidgetTypeBool( consed.autoReportPrintFlankedColumns2,
                          AutoReportPrintFlankedColumns2 );
   makeWidgetTypeBool( consed.autoReportPrintFlankedColumns,
                          AutoReportPrintFlankedColumns );
   makeWidgetTypeBool( consed.autoReportHighQualitySegmentData,
                          AutoReportHighQualitySegmentData );
   makeWidgetTypeBool( consed.autoReportGoodReadsBug,
                          AutoReportGoodReadsBug );
   makeWidgetTypeBool( consed.autoReportDiscrepancyRateInFlankedRegions,
                          AutoReportDiscrepancyRateInFlankedRegions );
   makeWidgetTypeBool( consed.autoReportDiscrepancyRateInFlankedRegions2,
                          AutoReportDiscrepancyRateInFlankedRegions2 );
   makeWidgetTypeBool( consed.autoReportDiscrepancyRateInFlankedRegions4,
                          AutoReportDiscrepancyRateInFlankedRegions4 );
   makeWidgetTypeBool( consed.autoReportDiscrepancyRateInFlankedRegions5,
                          AutoReportDiscrepancyRateInFlankedRegions5 );
   makeWidgetTypeBool( consed.autoReportSingleSignalOrQuality,
                          AutoReportSingleSignalOrQuality );
   makeWidgetTypeBool( consed.autoReportLowQualityBasesInHQS,
                          AutoReportLowQualityBasesInHQS );
   makeWidgetTypeBool( consed.autoReportCompareHQSWithLQS,
                          AutoReportCompareHQSWithLQS );
   makeWidgetTypeBool( consed.autoReportCountColumnsForGroupsOfSpecies,
                          AutoReportCountColumnsForGroupsOfSpecies );
   makeWidgetTypeBool( consed.autoReportSingleSignalInfo,
                          AutoReportSingleSignalInfo );
   makeWidgetTypeBool( consed.autoReportSingleSignalInfo2,
                          AutoReportSingleSignalInfo2 );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrands,
                          AutoReportCompareTopAndBottomStrands );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrandsNoHuman,
                          AutoReportCompareTopAndBottomStrandsNoHuman );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrands2,
                          AutoReportCompareTopAndBottomStrands2 );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrands3,
                          AutoReportCompareTopAndBottomStrands3 );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrands4,
                          AutoReportCompareTopAndBottomStrands4 );
   makeWidgetTypeInt( consed.autoReportTopStrandPinnedPosition,
                          AutoReportTopStrandPinnedPosition );
   makeWidgetTypeInt( consed.autoReportBottomStrandPinnedPosition,
                          AutoReportBottomStrandPinnedPosition );
   makeWidgetTypeBool( consed.autoReportCompareTopAndBottomStrandsWithHuman,
                          AutoReportCompareTopAndBottomStrandsWithHuman );
   makeWidgetTypeBool( consed.autoReportPrintLengthsOfAlignedSegmentsOfReads,
                          AutoReportPrintLengthsOfAlignedSegmentsOfReads );
   makeWidgetTypeBool( consed.autoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads,
                          AutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads );
   makeWidgetTypeBool( consed.autoReportPrintIfReadsAreCorrectlyAligned,
                          AutoReportPrintIfReadsAreCorrectlyAligned );
   makeWidgetTypeBool( consed.autoReportCalculateErrorProbabilitiesByComparingPTroPPan,
                          AutoReportCalculateErrorProbabilitiesByComparingPTroPPan );
   makeWidgetTypeBool( consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies,
                          AutoReportPrintAgreeDisagreeBetweenPairsOfSpecies );
   makeWidgetTypeBool( consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies2,
                          AutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2 );
   makeWidgetTypeBool( consed.autoReportFilterSingleSignal,
                          AutoReportFilterSingleSignal );
   makeWidgetTypeFileName( consed.autoReportGoodHitReads,
                          AutoReportGoodHitReads );
   makeWidgetTypeInt( consed.autoReportQualityWindowLow,
                          AutoReportQualityWindowLow );
   makeWidgetTypeInt( consed.autoReportQualityWindowHigh,
                          AutoReportQualityWindowHigh );
   makeWidgetTypeBool( consed.autoReportPrintNumberOfIsolatedPadsForEachSpecies,
                          AutoReportPrintNumberOfIsolatedPadsForEachSpecies );
   makeWidgetTypeBool( consed.autoReportPrintNumberOfIsolatedPads,
                          AutoReportPrintNumberOfIsolatedPads );
   makeWidgetTypeRWCString( consed.autoReportIsolatedPadsOfReadsWithThisPattern,
                          AutoReportIsolatedPadsOfReadsWithThisPattern );
   makeWidgetTypeInt( consed.autoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy,
                          AutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy );
   makeWidgetTypeInt( consed.autoReportMaxSizeOfDiscrepantRegion,
                          AutoReportMaxSizeOfDiscrepantRegion );
   makeWidgetTypeInt( consed.autoReportSizeOfDiscrepantRegion,
                          AutoReportSizeOfDiscrepantRegion );
   makeWidgetTypeBool( consed.autoReportPrintMinimumQualityHistogram,
                          AutoReportPrintMinimumQualityHistogram );
   makeWidgetTypeBool( consed.autoReportPrintDiscrepantRegions,
                          AutoReportPrintDiscrepantRegions );
   makeWidgetTypeBool( consed.autoReportPrintBasesInDiscrepantRegions,
                          AutoReportPrintBasesInDiscrepantRegions );
   makeWidgetTypeRWCString( consed.autoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis,
                          AutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis );
   makeWidgetTypeRWCString( consed.autoReportBackboneReadHasThisStringInIt,
                          AutoReportBackboneReadHasThisStringInIt );
   makeWidgetTypeBool( consed.autoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold,
                          AutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold );
   makeWidgetTypeBool( consed.autoReportPrintSpeciesAlignment,
                          AutoReportPrintSpeciesAlignment );
   makeWidgetTypeBool( consed.autoReportPrintReadAlignment,
                          AutoReportPrintReadAlignment );
   makeWidgetTypeFileName( consed.autoReportPrintTheseReads,
                          AutoReportPrintTheseReads );
   makeWidgetTypeBool( consed.autoReportPrintReadPositions,
                          AutoReportPrintReadPositions );
   makeWidgetTypeBool( consed.autoReportPrintChosenReadName,
                          AutoReportPrintChosenReadName );
   makeWidgetTypeInt( consed.autoReportNumbersOfCharactersOfChosenReadNameToBePrinted,
                          AutoReportNumbersOfCharactersOfChosenReadNameToBePrinted );
   makeWidgetTypeRWCString( consed.autoReportPrefix,
                          AutoReportPrefix );
   makeWidgetTypeBool( consed.autoReportUseOldCriteriaForDeletingColumnsOfPads,
                          AutoReportUseOldCriteriaForDeletingColumnsOfPads );
   makeWidgetTypeBool( consed.autoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues,
                          AutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues );
   makeWidgetTypeBool( consed.autoReportFlankingBasesMustBeSingleSignal,
                          AutoReportFlankingBasesMustBeSingleSignal );
   makeWidgetTypeInt( consed.autoReportMinimumQualityOfFlankingBases,
                          AutoReportMinimumQualityOfFlankingBases );
   makeWidgetTypeBool( consed.autoReportFlankingBasesMustBeInHighQualitySegment,
                          AutoReportFlankingBasesMustBeInHighQualitySegment );
   makeWidgetTypeRWCString( consed.autoReportSpecies,
                          AutoReportSpecies );
    // guiEditResources.cpp.part5


    // this needs to be saved for use in the resize callback

    widPrimersSubcloneFullPathnameForm_ = widPrimersSubcloneFullPathnameOfFileOfSequencesForScreeningForm;


    if ( !bStandAlone_ )   XtPopup( widPopupShell_, XtGrabNone );


   delete pPleaseWait;


   createResourceArray();   
   waitUntilDialogIsVisible( widPopupShell_ );



   windowCameUp(); 
   bAllTheWayUp_ = true;

}
                  
                                           
                                          
guiEditResources :: ~guiEditResources() {


   // segmentation fault without this because cbResize gets called
   // after popping down the window
   XtRemoveCallback( widClipWindow_,
                     XmNresizeCallback,
                     cbResize,
                     this );



   XtPopdown( widPopupShell_ );
   XtDestroyWidget( widPopupShell_ );

   if ( bStandAlone_ ) _exit( 0 );
}



void guiEditResources :: userPushedSave() {

   checkEverything();

   // open the appropriate file and check with the user that this
   // is really the one they want--put up a Motif file dialog box.

   FileName filToWrite;

   if ( XmToggleButtonGetState( widUserRadioButton_ ) == True  ) {
      // thus we want to write to $HOME/.consedrc
      // translate $HOME
      char* pHOME = getenv( "HOME" );
      

      if ( !pHOME ) {
         popupErrorMessage( "something is really screwed up because $HOME is not set.  Thus no user-defined parameters can be set" );
         return;
      }
      
      
      filToWrite = pHOME;
      filToWrite += "/.consedrc";
   }
   else if ( XmToggleButtonGetState( widProjectRadioButton_ ) == True ) {

      const int nBigNumber = 1000;
      char szCurrentDirectory[ nBigNumber + 1 ];
      getcwd( szCurrentDirectory, nBigNumber );

      filToWrite = szCurrentDirectory;
      filToWrite += "/.consedrc";
   }
   else if ( XmToggleButtonGetState( widAllUsersAllProjectsRadioButton_ ) ) {

      char* pConsedParameters = getenv( "CONSED_PARAMETERS" );

      
      if ( !pConsedParameters ) {
         popupErrorMessage( "environment variable CONSED_PARAMETERS is not set so I don't know where to write the parameters:  you will have to tell me" );
         filToWrite = "./.consedrc";
      }
      else {
         filToWrite = pConsedParameters;
      }

   }
   else
      assert( false );


   int nArgs = 0;
   Arg aArg[50];

   //   XtSetArg( aArg[ nArgs ], XmNdialogTitle, xmsTitle ); ++nArgs;
   
   Widget widFileSelectionBox = 
      XmCreateFileSelectionDialog( widPopupShell_,
                                   "Parameter Filename",
                                   NULL,
                                   0 );

   XtAddCallback( widFileSelectionBox,
                  XmNokCallback,
                  cbFileSelectionOK,
                  this );

   XtAddCallback( widFileSelectionBox,
                  XmNcancelCallback,
                  cbFileSelectionCancel,
                  this );

   XmString xmsTitle = XmStringCreateSimple( "Name of parameter file to write" );
   RWCString soDirMask = filToWrite.soGetDirectory() + "*.*";
   XmString xmsDirMask = XmStringCreateSimple( soDirMask.data() );

   XmString xmsDirSpec = XmStringCreateSimple( filToWrite.data() );

   XmString xmsDirectory = XmStringCreateSimple( filToWrite.soGetDirectory().data() );

   XtVaSetValues( widFileSelectionBox,
                  XmNdialogTitle, xmsTitle,
                  XmNselectionLabelString, xmsTitle,
                  XmNdirMask, xmsDirMask,
                  XmNdirectory, xmsDirectory,
                  NULL );

   XtVaSetValues( widFileSelectionBox,
                  XmNdirSpec, xmsDirSpec,
                  NULL );


   XtManageChild( widFileSelectionBox );



   XmStringFree( xmsDirSpec );
   XmStringFree( xmsTitle );
   XmStringFree( xmsDirMask );


}


   
void guiEditResources :: userChoseFileAndPushedOK( 
              const Widget wid,
              XmFileSelectionBoxCallbackStruct* pCallbackStruct ) {


   char* szFullPath;
   assert( XmStringGetLtoR( pCallbackStruct->value,
                            XmSTRING_DEFAULT_CHARSET,
                            &szFullPath ) );

   FileName filToWrite( szFullPath );

   cerr << "user selected file" << filToWrite << endl;

   if ( filToWrite.bFileByThisNameExists() ) {
      bool bGoAhead = GuiApp::popupDecisionMessage( "File %s exists.  Save anyway?",
                                                    filToWrite.data() );
      if ( !bGoAhead ) {
         return;
      }
   }

   // no more user input below here


   // this might throw an exception
   checkEverything(); // once more


   // since the user is satisfied with this file, we don't need the
   // file dialog box any longer:
   
   XtUnmanageChild( wid );
   XtDestroyWidget( wid );

   FILE* pFileToWrite = fopen( szFullPath, "w" );

   
   // now write the changed resources
   // guiEditResources.cpp.part6



   // consed.printPS
   if ( resources_.bPrintPS_ !=
        CONDEF->bPrintPS_ ) {

      fprintf( pFileToWrite,
               "consed.printPS: %s\n",
               ( resources_.bPrintPS_ ?
                     "true" : "false" ) );
   }

   // consed.defaultTagType
   if ( resources_.soDefaultTagType_ !=
        CONDEF->soDefaultTagType_ ) {

        fprintf( pFileToWrite,
              "consed.defaultTagType: %s\n",
              resources_.soDefaultTagType_.data() );
   }

   // consed.defaultTagOnConsensusNotReads
   if ( resources_.bDefaultTagOnConsensusNotReads_ !=
        CONDEF->bDefaultTagOnConsensusNotReads_ ) {

      fprintf( pFileToWrite,
               "consed.defaultTagOnConsensusNotReads: %s\n",
               ( resources_.bDefaultTagOnConsensusNotReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishMinNumberOfErrorsFixedByAnExp
   if ( resources_.dAutoFinishMinNumberOfErrorsFixedByAnExp_ !=
        CONDEF->dAutoFinishMinNumberOfErrorsFixedByAnExp_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinNumberOfErrorsFixedByAnExp: %f\n",
        resources_.dAutoFinishMinNumberOfErrorsFixedByAnExp_ );
   }

   // consed.autoFinishRedundancy
   if ( resources_.dAutoFinishRedundancy_ !=
        CONDEF->dAutoFinishRedundancy_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishRedundancy: %f\n",
        resources_.dAutoFinishRedundancy_ );
   }

   // consed.autoFinishAverageInsertSize
   if ( resources_.nAutoFinishAverageInsertSize_ !=
        CONDEF->nAutoFinishAverageInsertSize_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishAverageInsertSize: %d\n",
        resources_.nAutoFinishAverageInsertSize_ );
   }

   // consed.primersMaxInsertSizeOfASubclone
   if ( resources_.nPrimersMaxInsertSizeOfASubclone_ !=
        CONDEF->nPrimersMaxInsertSizeOfASubclone_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxInsertSizeOfASubclone: %d\n",
        resources_.nPrimersMaxInsertSizeOfASubclone_ );
   }

   // consed.primersMaxMeltingTemp
   if ( resources_.nPrimersMaxMeltingTemp_ !=
        CONDEF->nPrimersMaxMeltingTemp_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxMeltingTemp: %d\n",
        resources_.nPrimersMaxMeltingTemp_ );
   }

   // consed.primersMaxMeltingTempForPCR
   if ( resources_.nPrimersMaxMeltingTempForPCR_ !=
        CONDEF->nPrimersMaxMeltingTempForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxMeltingTempForPCR: %d\n",
        resources_.nPrimersMaxMeltingTempForPCR_ );
   }

   // consed.primersPickTemplatesForPrimers
   if ( resources_.bPrimersPickTemplatesForPrimers_ !=
        CONDEF->bPrimersPickTemplatesForPrimers_ ) {

      fprintf( pFileToWrite,
               "consed.primersPickTemplatesForPrimers: %s\n",
               ( resources_.bPrimersPickTemplatesForPrimers_ ?
                     "true" : "false" ) );
   }

   // consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening
   if ( resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_ !=
        CONDEF->soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_ ) {

        fprintf( pFileToWrite,
              "consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening: %s\n",
              resources_.soPrimersSubcloneFullPathnameOfFileOfSequencesForScreening_.data() );
   }

   // consed.primersCloneFullPathnameOfFileOfSequencesForScreening
   if ( resources_.soPrimersCloneFullPathnameOfFileOfSequencesForScreening_ !=
        CONDEF->soPrimersCloneFullPathnameOfFileOfSequencesForScreening_ ) {

        fprintf( pFileToWrite,
              "consed.primersCloneFullPathnameOfFileOfSequencesForScreening: %s\n",
              resources_.soPrimersCloneFullPathnameOfFileOfSequencesForScreening_.data() );
   }

   // consed.primersMinMeltingTemp
   if ( resources_.nPrimersMinMeltingTemp_ !=
        CONDEF->nPrimersMinMeltingTemp_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinMeltingTemp: %d\n",
        resources_.nPrimersMinMeltingTemp_ );
   }

   // consed.primersMinMeltingTempForPCR
   if ( resources_.nPrimersMinMeltingTempForPCR_ !=
        CONDEF->nPrimersMinMeltingTempForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinMeltingTempForPCR: %d\n",
        resources_.nPrimersMinMeltingTempForPCR_ );
   }

   // consed.searchFunctionsUseUnalignedEndsOfReads
   if ( resources_.bSearchFunctionsUseUnalignedEndsOfReads_ !=
        CONDEF->bSearchFunctionsUseUnalignedEndsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.searchFunctionsUseUnalignedEndsOfReads: %s\n",
               ( resources_.bSearchFunctionsUseUnalignedEndsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.searchFunctionsUseLowQualityEndsOfReads
   if ( resources_.bSearchFunctionsUseLowQualityEndsOfReads_ !=
        CONDEF->bSearchFunctionsUseLowQualityEndsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.searchFunctionsUseLowQualityEndsOfReads: %s\n",
               ( resources_.bSearchFunctionsUseLowQualityEndsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.inexactSearchForStringMaxPerCentMismatch
   if ( resources_.nInexactSearchForStringMaxPerCentMismatch_ !=
        CONDEF->nInexactSearchForStringMaxPerCentMismatch_ ) {
     fprintf( pFileToWrite, 
        "consed.inexactSearchForStringMaxPerCentMismatch: %d\n",
        resources_.nInexactSearchForStringMaxPerCentMismatch_ );
   }

   // consed.onlyAllowOneReadWriteConsedAtATime
   if ( resources_.bOnlyAllowOneReadWriteConsedAtATime_ !=
        CONDEF->bOnlyAllowOneReadWriteConsedAtATime_ ) {

      fprintf( pFileToWrite,
               "consed.onlyAllowOneReadWriteConsedAtATime: %s\n",
               ( resources_.bOnlyAllowOneReadWriteConsedAtATime_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair
   if ( resources_.bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_ !=
        CONDEF->bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair: %s\n",
               ( resources_.bAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair_ ?
                     "true" : "false" ) );
   }

   // consed.printWindowCommand
   if ( resources_.soPrintWindowCommand_ !=
        CONDEF->soPrintWindowCommand_ ) {

        fprintf( pFileToWrite,
              "consed.printWindowCommand: %s\n",
              resources_.soPrintWindowCommand_.data() );
   }

   // consed.fileOfTagTypes
   if ( resources_.filFileOfTagTypes_ !=
        CONDEF->filFileOfTagTypes_ ) {

        fprintf( pFileToWrite,
              "consed.fileOfTagTypes: %s\n",
              resources_.filFileOfTagTypes_.data() );
   }

   // consed.assemblyViewShowConsistentFwdRevPairs
   if ( resources_.bAssemblyViewShowConsistentFwdRevPairs_ !=
        CONDEF->bAssemblyViewShowConsistentFwdRevPairs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowConsistentFwdRevPairs: %s\n",
               ( resources_.bAssemblyViewShowConsistentFwdRevPairs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowConsistentFwdRevPairDepth
   if ( resources_.bAssemblyViewShowConsistentFwdRevPairDepth_ !=
        CONDEF->bAssemblyViewShowConsistentFwdRevPairDepth_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowConsistentFwdRevPairDepth: %s\n",
               ( resources_.bAssemblyViewShowConsistentFwdRevPairDepth_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds
   if ( resources_.bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_ !=
        CONDEF->bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds: %s\n",
               ( resources_.bAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowLegsOnSquaresForConsistentFwdRevPairs
   if ( resources_.bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_ !=
        CONDEF->bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowLegsOnSquaresForConsistentFwdRevPairs: %s\n",
               ( resources_.bAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowGapSpanningFwdRevPairs
   if ( resources_.bAssemblyViewShowGapSpanningFwdRevPairs_ !=
        CONDEF->bAssemblyViewShowGapSpanningFwdRevPairs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowGapSpanningFwdRevPairs: %s\n",
               ( resources_.bAssemblyViewShowGapSpanningFwdRevPairs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowWhichInconsistentFwdRevPairs
   if ( resources_.soAssemblyViewShowWhichInconsistentFwdRevPairs_ !=
        CONDEF->soAssemblyViewShowWhichInconsistentFwdRevPairs_ ) {

        fprintf( pFileToWrite,
              "consed.assemblyViewShowWhichInconsistentFwdRevPairs: %s\n",
              resources_.soAssemblyViewShowWhichInconsistentFwdRevPairs_.data() );
   }

   // consed.assemblyViewShowReadDepth
   if ( resources_.bAssemblyViewShowReadDepth_ !=
        CONDEF->bAssemblyViewShowReadDepth_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowReadDepth: %s\n",
               ( resources_.bAssemblyViewShowReadDepth_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowMultipleHighQualityDiscrepancies
   if ( resources_.bAssemblyViewShowMultipleHighQualityDiscrepancies_ !=
        CONDEF->bAssemblyViewShowMultipleHighQualityDiscrepancies_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowMultipleHighQualityDiscrepancies: %s\n",
               ( resources_.bAssemblyViewShowMultipleHighQualityDiscrepancies_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewShowRestrictionDigestCutSites
   if ( resources_.bAssemblyViewShowRestrictionDigestCutSites_ !=
        CONDEF->bAssemblyViewShowRestrictionDigestCutSites_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowRestrictionDigestCutSites: %s\n",
               ( resources_.bAssemblyViewShowRestrictionDigestCutSites_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewFilterSequenceMatchesBySize
   if ( resources_.bAssemblyViewFilterSequenceMatchesBySize_ !=
        CONDEF->bAssemblyViewFilterSequenceMatchesBySize_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewFilterSequenceMatchesBySize: %s\n",
               ( resources_.bAssemblyViewFilterSequenceMatchesBySize_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewSequenceMatchesMinSize
   if ( resources_.nAssemblyViewSequenceMatchesMinSize_ !=
        CONDEF->nAssemblyViewSequenceMatchesMinSize_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewSequenceMatchesMinSize: %d\n",
        resources_.nAssemblyViewSequenceMatchesMinSize_ );
   }

   // consed.assemblyViewSequenceMatchesMaxSize
   if ( resources_.nAssemblyViewSequenceMatchesMaxSize_ !=
        CONDEF->nAssemblyViewSequenceMatchesMaxSize_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewSequenceMatchesMaxSize: %d\n",
        resources_.nAssemblyViewSequenceMatchesMaxSize_ );
   }

   // consed.assemblyViewAutomaticallyStartWithConsed
   if ( resources_.bAssemblyViewAutomaticallyStartWithConsed_ !=
        CONDEF->bAssemblyViewAutomaticallyStartWithConsed_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewAutomaticallyStartWithConsed: %s\n",
               ( resources_.bAssemblyViewAutomaticallyStartWithConsed_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewDisplayTheseTagTypesOnTheseLines
   if ( resources_.soAssemblyViewDisplayTheseTagTypesOnTheseLines_ !=
        CONDEF->soAssemblyViewDisplayTheseTagTypesOnTheseLines_ ) {

        fprintf( pFileToWrite,
              "consed.assemblyViewDisplayTheseTagTypesOnTheseLines: %s\n",
              resources_.soAssemblyViewDisplayTheseTagTypesOnTheseLines_.data() );
   }

   // consed.assemblyViewShowTags
   if ( resources_.bAssemblyViewShowTags_ !=
        CONDEF->bAssemblyViewShowTags_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowTags: %s\n",
               ( resources_.bAssemblyViewShowTags_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditRecalculateHighQualitySegmentsOfReads
   if ( resources_.bAutoEditRecalculateHighQualitySegmentsOfReads_ !=
        CONDEF->bAutoEditRecalculateHighQualitySegmentsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditRecalculateHighQualitySegmentsOfReads: %s\n",
               ( resources_.bAutoEditRecalculateHighQualitySegmentsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditConvertCloneEndBasesToXs
   if ( resources_.bAutoEditConvertCloneEndBasesToXs_ !=
        CONDEF->bAutoEditConvertCloneEndBasesToXs_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditConvertCloneEndBasesToXs: %s\n",
               ( resources_.bAutoEditConvertCloneEndBasesToXs_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditTellPhrapNotToOverlapMultiplyDiscrepantReads
   if ( resources_.bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_ !=
        CONDEF->bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditTellPhrapNotToOverlapMultiplyDiscrepantReads: %s\n",
               ( resources_.bAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditTagEditableLowConsensusQualityRegions
   if ( resources_.bAutoEditTagEditableLowConsensusQualityRegions_ !=
        CONDEF->bAutoEditTagEditableLowConsensusQualityRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditTagEditableLowConsensusQualityRegions: %s\n",
               ( resources_.bAutoEditTagEditableLowConsensusQualityRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditMakeFakeRead
   if ( resources_.bAutoEditMakeFakeRead_ !=
        CONDEF->bAutoEditMakeFakeRead_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditMakeFakeRead: %s\n",
               ( resources_.bAutoEditMakeFakeRead_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditMakeFakeReadFromRead1
   if ( resources_.soAutoEditMakeFakeReadFromRead1_ !=
        CONDEF->soAutoEditMakeFakeReadFromRead1_ ) {

        fprintf( pFileToWrite,
              "consed.autoEditMakeFakeReadFromRead1: %s\n",
              resources_.soAutoEditMakeFakeReadFromRead1_.data() );
   }

   // consed.autoEditMakeFakeReadFromRead2
   if ( resources_.soAutoEditMakeFakeReadFromRead2_ !=
        CONDEF->soAutoEditMakeFakeReadFromRead2_ ) {

        fprintf( pFileToWrite,
              "consed.autoEditMakeFakeReadFromRead2: %s\n",
              resources_.soAutoEditMakeFakeReadFromRead2_.data() );
   }

   // consed.autoEditMakeFakeReadName
   if ( resources_.soAutoEditMakeFakeReadName_ !=
        CONDEF->soAutoEditMakeFakeReadName_ ) {

        fprintf( pFileToWrite,
              "consed.autoEditMakeFakeReadName: %s\n",
              resources_.soAutoEditMakeFakeReadName_.data() );
   }

   // consed.autoEditMakeFakeReadFastaFilename
   if ( resources_.filAutoEditMakeFakeReadFastaFilename_ !=
        CONDEF->filAutoEditMakeFakeReadFastaFilename_ ) {

        fprintf( pFileToWrite,
              "consed.autoEditMakeFakeReadFastaFilename: %s\n",
              resources_.filAutoEditMakeFakeReadFastaFilename_.data() );
   }

   // consed.autoEditMergeAssembly
   if ( resources_.bAutoEditMergeAssembly_ !=
        CONDEF->bAutoEditMergeAssembly_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditMergeAssembly: %s\n",
               ( resources_.bAutoEditMergeAssembly_ ?
                     "true" : "false" ) );
   }

   // consed.autoEditSecondaryAceFile
   if ( resources_.filAutoEditSecondaryAceFile_ !=
        CONDEF->filAutoEditSecondaryAceFile_ ) {

        fprintf( pFileToWrite,
              "consed.autoEditSecondaryAceFile: %s\n",
              resources_.filAutoEditSecondaryAceFile_.data() );
   }

   // consed.autoEditFixRunsInConsensus
   if ( resources_.bAutoEditFixRunsInConsensus_ !=
        CONDEF->bAutoEditFixRunsInConsensus_ ) {

      fprintf( pFileToWrite,
               "consed.autoEditFixRunsInConsensus: %s\n",
               ( resources_.bAutoEditFixRunsInConsensus_ ?
                     "true" : "false" ) );
   }

   // consed.showAllTracesJustShowGoodTraces
   if ( resources_.bShowAllTracesJustShowGoodTraces_ !=
        CONDEF->bShowAllTracesJustShowGoodTraces_ ) {

      fprintf( pFileToWrite,
               "consed.showAllTracesJustShowGoodTraces: %s\n",
               ( resources_.bShowAllTracesJustShowGoodTraces_ ?
                     "true" : "false" ) );
   }

   // consed.addAlignedSequenceQualityOfBases
   if ( resources_.nAddAlignedSequenceQualityOfBases_ !=
        CONDEF->nAddAlignedSequenceQualityOfBases_ ) {
     fprintf( pFileToWrite, 
        "consed.addAlignedSequenceQualityOfBases: %d\n",
        resources_.nAddAlignedSequenceQualityOfBases_ );
   }

   // consed.makeLightBackgroundInAlignedReadsWindowAndTracesWindow
   if ( resources_.bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_ !=
        CONDEF->bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_ ) {

      fprintf( pFileToWrite,
               "consed.makeLightBackgroundInAlignedReadsWindowAndTracesWindow: %s\n",
               ( resources_.bMakeLightBackgroundInAlignedReadsWindowAndTracesWindow_ ?
                     "true" : "false" ) );
   }

   // consed.putVerticalLineAtCursor
   if ( resources_.bPutVerticalLineAtCursor_ !=
        CONDEF->bPutVerticalLineAtCursor_ ) {

      fprintf( pFileToWrite,
               "consed.putVerticalLineAtCursor: %s\n",
               ( resources_.bPutVerticalLineAtCursor_ ?
                     "true" : "false" ) );
   }

   // consed.putHorizontalLineAtCursor
   if ( resources_.bPutHorizontalLineAtCursor_ !=
        CONDEF->bPutHorizontalLineAtCursor_ ) {

      fprintf( pFileToWrite,
               "consed.putHorizontalLineAtCursor: %s\n",
               ( resources_.bPutHorizontalLineAtCursor_ ?
                     "true" : "false" ) );
   }

   // consed.highlightedReadsFile
   if ( resources_.filHighlightedReadsFile_ !=
        CONDEF->filHighlightedReadsFile_ ) {

        fprintf( pFileToWrite,
              "consed.highlightedReadsFile: %s\n",
              resources_.filHighlightedReadsFile_.data() );
   }

   // consed.autoReportPrintReadNamesInRegion
   if ( resources_.bAutoReportPrintReadNamesInRegion_ !=
        CONDEF->bAutoReportPrintReadNamesInRegion_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintReadNamesInRegion: %s\n",
               ( resources_.bAutoReportPrintReadNamesInRegion_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintReadNamesInRegionContig
   if ( resources_.soAutoReportPrintReadNamesInRegionContig_ !=
        CONDEF->soAutoReportPrintReadNamesInRegionContig_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportPrintReadNamesInRegionContig: %s\n",
              resources_.soAutoReportPrintReadNamesInRegionContig_.data() );
   }

   // consed.autoReportPrintReadNamesInRegionLeftPos
   if ( resources_.nAutoReportPrintReadNamesInRegionLeftPos_ !=
        CONDEF->nAutoReportPrintReadNamesInRegionLeftPos_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportPrintReadNamesInRegionLeftPos: %d\n",
        resources_.nAutoReportPrintReadNamesInRegionLeftPos_ );
   }

   // consed.autoReportPrintReadNamesInRegionRightPos
   if ( resources_.nAutoReportPrintReadNamesInRegionRightPos_ !=
        CONDEF->nAutoReportPrintReadNamesInRegionRightPos_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportPrintReadNamesInRegionRightPos: %d\n",
        resources_.nAutoReportPrintReadNamesInRegionRightPos_ );
   }

   // consed.autoReportPrintHighlyDiscrepantRegions
   if ( resources_.bAutoReportPrintHighlyDiscrepantRegions_ !=
        CONDEF->bAutoReportPrintHighlyDiscrepantRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintHighlyDiscrepantRegions: %s\n",
               ( resources_.bAutoReportPrintHighlyDiscrepantRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintScaffolds
   if ( resources_.bAutoReportPrintScaffolds_ !=
        CONDEF->bAutoReportPrintScaffolds_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintScaffolds: %s\n",
               ( resources_.bAutoReportPrintScaffolds_ ?
                     "true" : "false" ) );
   }

   // consed.numberUnpaddedConsensusAtUserDefined
   if ( resources_.bNumberUnpaddedConsensusAtUserDefined_ !=
        CONDEF->bNumberUnpaddedConsensusAtUserDefined_ ) {

      fprintf( pFileToWrite,
               "consed.numberUnpaddedConsensusAtUserDefined: %s\n",
               ( resources_.bNumberUnpaddedConsensusAtUserDefined_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintHighQualityDiscrepancies
   if ( resources_.bAutoReportPrintHighQualityDiscrepancies_ !=
        CONDEF->bAutoReportPrintHighQualityDiscrepancies_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintHighQualityDiscrepancies: %s\n",
               ( resources_.bAutoReportPrintHighQualityDiscrepancies_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags
   if ( resources_.bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_ !=
        CONDEF->bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags: %s\n",
               ( resources_.bAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportHighQualityDiscrepanciesExcludeMostPads
   if ( resources_.bAutoReportHighQualityDiscrepanciesExcludeMostPads_ !=
        CONDEF->bAutoReportHighQualityDiscrepanciesExcludeMostPads_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportHighQualityDiscrepanciesExcludeMostPads: %s\n",
               ( resources_.bAutoReportHighQualityDiscrepanciesExcludeMostPads_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintLowConsensusQualityRegions
   if ( resources_.bAutoReportPrintLowConsensusQualityRegions_ !=
        CONDEF->bAutoReportPrintLowConsensusQualityRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintLowConsensusQualityRegions: %s\n",
               ( resources_.bAutoReportPrintLowConsensusQualityRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintSingleSubcloneRegions
   if ( resources_.bAutoReportPrintSingleSubcloneRegions_ !=
        CONDEF->bAutoReportPrintSingleSubcloneRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintSingleSubcloneRegions: %s\n",
               ( resources_.bAutoReportPrintSingleSubcloneRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintSingleStrandedRegions
   if ( resources_.bAutoReportPrintSingleStrandedRegions_ !=
        CONDEF->bAutoReportPrintSingleStrandedRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintSingleStrandedRegions: %s\n",
               ( resources_.bAutoReportPrintSingleStrandedRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintLinkingForwardReversePairs
   if ( resources_.bAutoReportPrintLinkingForwardReversePairs_ !=
        CONDEF->bAutoReportPrintLinkingForwardReversePairs_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintLinkingForwardReversePairs: %s\n",
               ( resources_.bAutoReportPrintLinkingForwardReversePairs_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintFilteredInconsistentForwardReversePairs
   if ( resources_.bAutoReportPrintFilteredInconsistentForwardReversePairs_ !=
        CONDEF->bAutoReportPrintFilteredInconsistentForwardReversePairs_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintFilteredInconsistentForwardReversePairs: %s\n",
               ( resources_.bAutoReportPrintFilteredInconsistentForwardReversePairs_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintAssemblySummary
   if ( resources_.bAutoReportPrintAssemblySummary_ !=
        CONDEF->bAutoReportPrintAssemblySummary_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintAssemblySummary: %s\n",
               ( resources_.bAutoReportPrintAssemblySummary_ ?
                     "true" : "false" ) );
   }

   // consed.showAllTracesDoNotShowTraceIfTheseTagsPresent
   if ( resources_.soShowAllTracesDoNotShowTraceIfTheseTagsPresent_ !=
        CONDEF->soShowAllTracesDoNotShowTraceIfTheseTagsPresent_ ) {

        fprintf( pFileToWrite,
              "consed.showAllTracesDoNotShowTraceIfTheseTagsPresent: %s\n",
              resources_.soShowAllTracesDoNotShowTraceIfTheseTagsPresent_.data() );
   }

   // consed.nameOfFakeJoiningReadsIncludesAceFileName
   if ( resources_.bNameOfFakeJoiningReadsIncludesAceFileName_ !=
        CONDEF->bNameOfFakeJoiningReadsIncludesAceFileName_ ) {

      fprintf( pFileToWrite,
               "consed.nameOfFakeJoiningReadsIncludesAceFileName: %s\n",
               ( resources_.bNameOfFakeJoiningReadsIncludesAceFileName_ ?
                     "true" : "false" ) );
   }

   // consed.whenUserScrollsOffWindowMillisecondsBetweenScrolling
   if ( resources_.nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_ !=
        CONDEF->nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_ ) {
     fprintf( pFileToWrite, 
        "consed.whenUserScrollsOffWindowMillisecondsBetweenScrolling: %d\n",
        resources_.nWhenUserScrollsOffWindowMillisecondsBetweenScrolling_ );
   }

   // consed.whenUserScrollsOffWindowBasesToScrollEachTime
   if ( resources_.nWhenUserScrollsOffWindowBasesToScrollEachTime_ !=
        CONDEF->nWhenUserScrollsOffWindowBasesToScrollEachTime_ ) {
     fprintf( pFileToWrite, 
        "consed.whenUserScrollsOffWindowBasesToScrollEachTime: %d\n",
        resources_.nWhenUserScrollsOffWindowBasesToScrollEachTime_ );
   }

   // consed.compareContigsUseBandedRatherThanFullSmithWaterman
   if ( resources_.bCompareContigsUseBandedRatherThanFullSmithWaterman_ !=
        CONDEF->bCompareContigsUseBandedRatherThanFullSmithWaterman_ ) {

      fprintf( pFileToWrite,
               "consed.compareContigsUseBandedRatherThanFullSmithWaterman: %s\n",
               ( resources_.bCompareContigsUseBandedRatherThanFullSmithWaterman_ ?
                     "true" : "false" ) );
   }

   // consed.compareContigsBandSize
   if ( resources_.nCompareContigsBandSize_ !=
        CONDEF->nCompareContigsBandSize_ ) {
     fprintf( pFileToWrite, 
        "consed.compareContigsBandSize: %d\n",
        resources_.nCompareContigsBandSize_ );
   }

   // consed.assemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany
   if ( resources_.nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_ !=
        CONDEF->nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany: %d\n",
        resources_.nAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany_ );
   }

   // consed.assemblyViewShowSequenceMatches
   if ( resources_.bAssemblyViewShowSequenceMatches_ !=
        CONDEF->bAssemblyViewShowSequenceMatches_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewShowSequenceMatches: %s\n",
               ( resources_.bAssemblyViewShowSequenceMatches_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOKToShowSequenceMatchesBetweenContigs
   if ( resources_.bAssemblyViewOKToShowSequenceMatchesBetweenContigs_ !=
        CONDEF->bAssemblyViewOKToShowSequenceMatchesBetweenContigs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOKToShowSequenceMatchesBetweenContigs: %s\n",
               ( resources_.bAssemblyViewOKToShowSequenceMatchesBetweenContigs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOKToShowSequenceMatchesWithinContigs
   if ( resources_.bAssemblyViewOKToShowSequenceMatchesWithinContigs_ !=
        CONDEF->bAssemblyViewOKToShowSequenceMatchesWithinContigs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOKToShowSequenceMatchesWithinContigs: %s\n",
               ( resources_.bAssemblyViewOKToShowSequenceMatchesWithinContigs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOKToShowDirectSequenceMatches
   if ( resources_.bAssemblyViewOKToShowDirectSequenceMatches_ !=
        CONDEF->bAssemblyViewOKToShowDirectSequenceMatches_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOKToShowDirectSequenceMatches: %s\n",
               ( resources_.bAssemblyViewOKToShowDirectSequenceMatches_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOKToShowInvertedSequenceMatches
   if ( resources_.bAssemblyViewOKToShowInvertedSequenceMatches_ !=
        CONDEF->bAssemblyViewOKToShowInvertedSequenceMatches_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOKToShowInvertedSequenceMatches: %s\n",
               ( resources_.bAssemblyViewOKToShowInvertedSequenceMatches_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion
   if ( resources_.bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_ !=
        CONDEF->bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion: %s\n",
               ( resources_.bAssemblyViewOnlyShowSequenceMatchesToAParticularRegion_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToThisContig
   if ( resources_.soAssemblyViewOnlyShowSequenceMatchesToThisContig_ !=
        CONDEF->soAssemblyViewOnlyShowSequenceMatchesToThisContig_ ) {

        fprintf( pFileToWrite,
              "consed.assemblyViewOnlyShowSequenceMatchesToThisContig: %s\n",
              resources_.soAssemblyViewOnlyShowSequenceMatchesToThisContig_.data() );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToThisRegionLeft
   if ( resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_ !=
        CONDEF->nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewOnlyShowSequenceMatchesToThisRegionLeft: %d\n",
        resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft_ );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToThisRegionRight
   if ( resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_ !=
        CONDEF->nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewOnlyShowSequenceMatchesToThisRegionRight: %d\n",
        resources_.nAssemblyViewOnlyShowSequenceMatchesToThisRegionRight_ );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigs
   if ( resources_.bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_ !=
        CONDEF->bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_ ) {

      fprintf( pFileToWrite,
               "consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigs: %s\n",
               ( resources_.bAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar
   if ( resources_.nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_ !=
        CONDEF->nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar: %d\n",
        resources_.nAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar_ );
   }

   // consed.defaultReadPrefix
   if ( resources_.soDefaultReadPrefix_ !=
        CONDEF->soDefaultReadPrefix_ ) {

        fprintf( pFileToWrite,
              "consed.defaultReadPrefix: %s\n",
              resources_.soDefaultReadPrefix_.data() );
   }

   // consed.readPrefixesFile
   if ( resources_.filReadPrefixesFile_ !=
        CONDEF->filReadPrefixesFile_ ) {

        fprintf( pFileToWrite,
              "consed.readPrefixesFile: %s\n",
              resources_.filReadPrefixesFile_.data() );
   }

   // consed.maxCharsDisplayedForReadPrefix
   if ( resources_.nMaxCharsDisplayedForReadPrefix_ !=
        CONDEF->nMaxCharsDisplayedForReadPrefix_ ) {
     fprintf( pFileToWrite, 
        "consed.maxCharsDisplayedForReadPrefix: %d\n",
        resources_.nMaxCharsDisplayedForReadPrefix_ );
   }

   // consed.autoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates
   if ( resources_.nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ !=
        CONDEF->nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates: %d\n",
        resources_.nAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates_ );
   }

   // consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions
   if ( resources_.nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ !=
        CONDEF->nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions: %d\n",
        resources_.nAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions_ );
   }

   // consed.autoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis
   if ( resources_.nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ !=
        CONDEF->nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis: %d\n",
        resources_.nAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis_ );
   }

   // consed.autoFinishDoNotDoPCRIfEndIsExtendedByReads
   if ( resources_.bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_ !=
        CONDEF->bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishDoNotDoPCRIfEndIsExtendedByReads: %s\n",
               ( resources_.bAutoFinishDoNotDoPCRIfEndIsExtendedByReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishMaxAcceptableErrorsPerMegabase
   if ( resources_.nAutoFinishMaxAcceptableErrorsPerMegabase_ !=
        CONDEF->nAutoFinishMaxAcceptableErrorsPerMegabase_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMaxAcceptableErrorsPerMegabase: %d\n",
        resources_.nAutoFinishMaxAcceptableErrorsPerMegabase_ );
   }

   // consed.autoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize
   if ( resources_.nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ !=
        CONDEF->nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize: %d\n",
        resources_.nAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize_ );
   }

   // consed.primersNumberOfBasesToBackUpToStartLooking
   if ( resources_.nPrimersNumberOfBasesToBackUpToStartLooking_ !=
        CONDEF->nPrimersNumberOfBasesToBackUpToStartLooking_ ) {
     fprintf( pFileToWrite, 
        "consed.primersNumberOfBasesToBackUpToStartLooking: %d\n",
        resources_.nPrimersNumberOfBasesToBackUpToStartLooking_ );
   }

   // consed.primersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment
   if ( resources_.nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ !=
        CONDEF->nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment: %d\n",
        resources_.nPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment_ );
   }

   // consed.primersOKToChoosePrimersInSingleSubcloneRegion
   if ( resources_.bPrimersOKToChoosePrimersInSingleSubcloneRegion_ !=
        CONDEF->bPrimersOKToChoosePrimersInSingleSubcloneRegion_ ) {

      fprintf( pFileToWrite,
               "consed.primersOKToChoosePrimersInSingleSubcloneRegion: %s\n",
               ( resources_.bPrimersOKToChoosePrimersInSingleSubcloneRegion_ ?
                     "true" : "false" ) );
   }

   // consed.primersOKToChoosePrimersWhereHighQualityDiscrepancies
   if ( resources_.bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_ !=
        CONDEF->bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_ ) {

      fprintf( pFileToWrite,
               "consed.primersOKToChoosePrimersWhereHighQualityDiscrepancies: %s\n",
               ( resources_.bPrimersOKToChoosePrimersWhereHighQualityDiscrepancies_ ?
                     "true" : "false" ) );
   }

   // consed.primersOKToChoosePrimersWhereUnalignedHighQualityRegion
   if ( resources_.bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_ !=
        CONDEF->bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_ ) {

      fprintf( pFileToWrite,
               "consed.primersOKToChoosePrimersWhereUnalignedHighQualityRegion: %s\n",
               ( resources_.bPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishCallReversesToFlankGaps
   if ( resources_.bAutoFinishCallReversesToFlankGaps_ !=
        CONDEF->bAutoFinishCallReversesToFlankGaps_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCallReversesToFlankGaps: %s\n",
               ( resources_.bAutoFinishCallReversesToFlankGaps_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowWholeCloneReads
   if ( resources_.bAutoFinishAllowWholeCloneReads_ !=
        CONDEF->bAutoFinishAllowWholeCloneReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowWholeCloneReads: %s\n",
               ( resources_.bAutoFinishAllowWholeCloneReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowCustomPrimerSubcloneReads
   if ( resources_.bAutoFinishAllowCustomPrimerSubcloneReads_ !=
        CONDEF->bAutoFinishAllowCustomPrimerSubcloneReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowCustomPrimerSubcloneReads: %s\n",
               ( resources_.bAutoFinishAllowCustomPrimerSubcloneReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowResequencingReads
   if ( resources_.bAutoFinishAllowResequencingReads_ !=
        CONDEF->bAutoFinishAllowResequencingReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowResequencingReads: %s\n",
               ( resources_.bAutoFinishAllowResequencingReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowResequencingReadsOnlyForRunsAndStops
   if ( resources_.bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_ !=
        CONDEF->bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowResequencingReadsOnlyForRunsAndStops: %s\n",
               ( resources_.bAutoFinishAllowResequencingReadsOnlyForRunsAndStops_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowDeNovoUniversalPrimerSubcloneReads
   if ( resources_.bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_ !=
        CONDEF->bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowDeNovoUniversalPrimerSubcloneReads: %s\n",
               ( resources_.bAutoFinishAllowDeNovoUniversalPrimerSubcloneReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowMinilibraries
   if ( resources_.bAutoFinishAllowMinilibraries_ !=
        CONDEF->bAutoFinishAllowMinilibraries_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowMinilibraries: %s\n",
               ( resources_.bAutoFinishAllowMinilibraries_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowPCR
   if ( resources_.bAutoFinishAllowPCR_ !=
        CONDEF->bAutoFinishAllowPCR_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowPCR: %s\n",
               ( resources_.bAutoFinishAllowPCR_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowUnorientedPCRReactions
   if ( resources_.bAutoFinishAllowUnorientedPCRReactions_ !=
        CONDEF->bAutoFinishAllowUnorientedPCRReactions_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowUnorientedPCRReactions: %s\n",
               ( resources_.bAutoFinishAllowUnorientedPCRReactions_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowResequencingAUniversalPrimerAutofinishRead
   if ( resources_.bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_ !=
        CONDEF->bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowResequencingAUniversalPrimerAutofinishRead: %s\n",
               ( resources_.bAutoFinishAllowResequencingAUniversalPrimerAutofinishRead_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAlwaysCloseGapsUsingMinilibraries
   if ( resources_.bAutoFinishAlwaysCloseGapsUsingMinilibraries_ !=
        CONDEF->bAutoFinishAlwaysCloseGapsUsingMinilibraries_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAlwaysCloseGapsUsingMinilibraries: %s\n",
               ( resources_.bAutoFinishAlwaysCloseGapsUsingMinilibraries_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishMaximumFinishingReadLength
   if ( resources_.nAutoFinishMaximumFinishingReadLength_ !=
        CONDEF->nAutoFinishMaximumFinishingReadLength_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMaximumFinishingReadLength: %d\n",
        resources_.nAutoFinishMaximumFinishingReadLength_ );
   }

   // consed.autoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger
   if ( resources_.nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ !=
        CONDEF->nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger: %d\n",
        resources_.nAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger_ );
   }

   // consed.autoFinishSuggestSpecialChemistryForRunsAndStops
   if ( resources_.bAutoFinishSuggestSpecialChemistryForRunsAndStops_ !=
        CONDEF->bAutoFinishSuggestSpecialChemistryForRunsAndStops_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishSuggestSpecialChemistryForRunsAndStops: %s\n",
               ( resources_.bAutoFinishSuggestSpecialChemistryForRunsAndStops_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishSuggestThisManyMinilibrariesPerGap
   if ( resources_.nAutoFinishSuggestThisManyMinilibrariesPerGap_ !=
        CONDEF->nAutoFinishSuggestThisManyMinilibrariesPerGap_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishSuggestThisManyMinilibrariesPerGap: %d\n",
        resources_.nAutoFinishSuggestThisManyMinilibrariesPerGap_ );
   }

   // consed.primersWindowSizeInLooking
   if ( resources_.nPrimersWindowSizeInLooking_ !=
        CONDEF->nPrimersWindowSizeInLooking_ ) {
     fprintf( pFileToWrite, 
        "consed.primersWindowSizeInLooking: %d\n",
        resources_.nPrimersWindowSizeInLooking_ );
   }

   // consed.primersAssumeTemplatesAreDoubleStrandedUnlessSpecified
   if ( resources_.bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_ !=
        CONDEF->bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_ ) {

      fprintf( pFileToWrite,
               "consed.primersAssumeTemplatesAreDoubleStrandedUnlessSpecified: %s\n",
               ( resources_.bPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified_ ?
                     "true" : "false" ) );
   }

   // consed.alignedReadsWindowInitialCharsWide
   if ( resources_.nAlignedReadsWindowInitialCharsWide_ !=
        CONDEF->nAlignedReadsWindowInitialCharsWide_ ) {
     fprintf( pFileToWrite, 
        "consed.alignedReadsWindowInitialCharsWide: %d\n",
        resources_.nAlignedReadsWindowInitialCharsWide_ );
   }

   // consed.alignedReadsWindowInitialCharsHigh
   if ( resources_.nAlignedReadsWindowInitialCharsHigh_ !=
        CONDEF->nAlignedReadsWindowInitialCharsHigh_ ) {
     fprintf( pFileToWrite, 
        "consed.alignedReadsWindowInitialCharsHigh: %d\n",
        resources_.nAlignedReadsWindowInitialCharsHigh_ );
   }

   // consed.alignedReadsWindowMaxCharsForReadNames
   if ( resources_.nAlignedReadsWindowMaxCharsForReadNames_ !=
        CONDEF->nAlignedReadsWindowMaxCharsForReadNames_ ) {
     fprintf( pFileToWrite, 
        "consed.alignedReadsWindowMaxCharsForReadNames: %d\n",
        resources_.nAlignedReadsWindowMaxCharsForReadNames_ );
   }

   // consed.alignedReadsWindowAutomaticallyExpandRoomForReadNames
   if ( resources_.bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_ !=
        CONDEF->bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_ ) {

      fprintf( pFileToWrite,
               "consed.alignedReadsWindowAutomaticallyExpandRoomForReadNames: %s\n",
               ( resources_.bAlignedReadsWindowAutomaticallyExpandRoomForReadNames_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishAllowResequencingReadsToExtendContigs
   if ( resources_.bAutoFinishAllowResequencingReadsToExtendContigs_ !=
        CONDEF->bAutoFinishAllowResequencingReadsToExtendContigs_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishAllowResequencingReadsToExtendContigs: %s\n",
               ( resources_.bAutoFinishAllowResequencingReadsToExtendContigs_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishCallHowManyReversesToFlankGaps
   if ( resources_.nAutoFinishCallHowManyReversesToFlankGaps_ !=
        CONDEF->nAutoFinishCallHowManyReversesToFlankGaps_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCallHowManyReversesToFlankGaps: %d\n",
        resources_.nAutoFinishCallHowManyReversesToFlankGaps_ );
   }

   // consed.autoFinishCloseGaps
   if ( resources_.bAutoFinishCloseGaps_ !=
        CONDEF->bAutoFinishCloseGaps_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCloseGaps: %s\n",
               ( resources_.bAutoFinishCloseGaps_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishContinueEvenThoughReadInfoDoesNotMakeSense
   if ( resources_.bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_ !=
        CONDEF->bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishContinueEvenThoughReadInfoDoesNotMakeSense: %s\n",
               ( resources_.bAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishCostOfResequencingUniversalPrimerSubcloneReaction
   if ( resources_.dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ !=
        CONDEF->dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCostOfResequencingUniversalPrimerSubcloneReaction: %f\n",
        resources_.dAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction_ );
   }

   // consed.autoFinishCostOfCustomPrimerSubcloneReaction
   if ( resources_.dAutoFinishCostOfCustomPrimerSubcloneReaction_ !=
        CONDEF->dAutoFinishCostOfCustomPrimerSubcloneReaction_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCostOfCustomPrimerSubcloneReaction: %f\n",
        resources_.dAutoFinishCostOfCustomPrimerSubcloneReaction_ );
   }

   // consed.autoFinishCostOfCustomPrimerCloneReaction
   if ( resources_.dAutoFinishCostOfCustomPrimerCloneReaction_ !=
        CONDEF->dAutoFinishCostOfCustomPrimerCloneReaction_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCostOfCustomPrimerCloneReaction: %f\n",
        resources_.dAutoFinishCostOfCustomPrimerCloneReaction_ );
   }

   // consed.autoFinishCostOfDeNovoUniversalPrimerSubcloneReaction
   if ( resources_.dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ !=
        CONDEF->dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCostOfDeNovoUniversalPrimerSubcloneReaction: %f\n",
        resources_.dAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction_ );
   }

   // consed.autoFinishCostOfMinilibrary
   if ( resources_.dAutoFinishCostOfMinilibrary_ !=
        CONDEF->dAutoFinishCostOfMinilibrary_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishCostOfMinilibrary: %f\n",
        resources_.dAutoFinishCostOfMinilibrary_ );
   }

   // consed.autoFinishCoverSingleSubcloneRegions
   if ( resources_.bAutoFinishCoverSingleSubcloneRegions_ !=
        CONDEF->bAutoFinishCoverSingleSubcloneRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCoverSingleSubcloneRegions: %s\n",
               ( resources_.bAutoFinishCoverSingleSubcloneRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishCoverLowConsensusQualityRegions
   if ( resources_.bAutoFinishCoverLowConsensusQualityRegions_ !=
        CONDEF->bAutoFinishCoverLowConsensusQualityRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCoverLowConsensusQualityRegions: %s\n",
               ( resources_.bAutoFinishCoverLowConsensusQualityRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishDebugUniversalPrimerReadsFile
   if ( resources_.filAutoFinishDebugUniversalPrimerReadsFile_ !=
        CONDEF->filAutoFinishDebugUniversalPrimerReadsFile_ ) {

        fprintf( pFileToWrite,
              "consed.autoFinishDebugUniversalPrimerReadsFile: %s\n",
              resources_.filAutoFinishDebugUniversalPrimerReadsFile_.data() );
   }

   // consed.autoFinishDebugCustomPrimerReadsFile
   if ( resources_.filAutoFinishDebugCustomPrimerReadsFile_ !=
        CONDEF->filAutoFinishDebugCustomPrimerReadsFile_ ) {

        fprintf( pFileToWrite,
              "consed.autoFinishDebugCustomPrimerReadsFile: %s\n",
              resources_.filAutoFinishDebugCustomPrimerReadsFile_.data() );
   }

   // consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases
   if ( resources_.nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ !=
        CONDEF->nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases: %d\n",
        resources_.nAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases_ );
   }

   // consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases
   if ( resources_.nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ !=
        CONDEF->nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases: %d\n",
        resources_.nAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases_ );
   }

   // consed.autoFinishDoNotFinishWhereTheseTagsAre
   if ( resources_.soAutoFinishDoNotFinishWhereTheseTagsAre_ !=
        CONDEF->soAutoFinishDoNotFinishWhereTheseTagsAre_ ) {

        fprintf( pFileToWrite,
              "consed.autoFinishDoNotFinishWhereTheseTagsAre: %s\n",
              resources_.soAutoFinishDoNotFinishWhereTheseTagsAre_.data() );
   }

   // consed.autoFinishDoNotExtendContigsWhereTheseTagsAre
   if ( resources_.soAutoFinishDoNotExtendContigsWhereTheseTagsAre_ !=
        CONDEF->soAutoFinishDoNotExtendContigsWhereTheseTagsAre_ ) {

        fprintf( pFileToWrite,
              "consed.autoFinishDoNotExtendContigsWhereTheseTagsAre: %s\n",
              resources_.soAutoFinishDoNotExtendContigsWhereTheseTagsAre_.data() );
   }

   // consed.autoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd
   if ( resources_.nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ !=
        CONDEF->nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd: %d\n",
        resources_.nAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd_ );
   }

   // consed.dumpContigOrderAndOrientationInfoToThisFile
   if ( resources_.filDumpContigOrderAndOrientationInfoToThisFile_ !=
        CONDEF->filDumpContigOrderAndOrientationInfoToThisFile_ ) {

        fprintf( pFileToWrite,
              "consed.dumpContigOrderAndOrientationInfoToThisFile: %s\n",
              resources_.filDumpContigOrderAndOrientationInfoToThisFile_.data() );
   }

   // consed.autoFinishDumpTemplates
   if ( resources_.bAutoFinishDumpTemplates_ !=
        CONDEF->bAutoFinishDumpTemplates_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishDumpTemplates: %s\n",
               ( resources_.bAutoFinishDumpTemplates_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishExcludeContigIfOnlyThisManyReadsOrLess
   if ( resources_.nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ !=
        CONDEF->nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishExcludeContigIfOnlyThisManyReadsOrLess: %d\n",
        resources_.nAutoFinishExcludeContigIfOnlyThisManyReadsOrLess_ );
   }

   // consed.autoFinishExcludeContigIfDepthOfCoverageGreaterThanThis
   if ( resources_.dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ !=
        CONDEF->dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishExcludeContigIfDepthOfCoverageGreaterThanThis: %f\n",
        resources_.dAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis_ );
   }

   // consed.autoFinishExcludeContigIfThisManyBasesOrLess
   if ( resources_.nAutoFinishExcludeContigIfThisManyBasesOrLess_ !=
        CONDEF->nAutoFinishExcludeContigIfThisManyBasesOrLess_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishExcludeContigIfThisManyBasesOrLess: %d\n",
        resources_.nAutoFinishExcludeContigIfThisManyBasesOrLess_ );
   }

   // consed.autoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions
   if ( resources_.nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ !=
        CONDEF->nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions: %d\n",
        resources_.nAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions_ );
   }

   // consed.primersMinNumberOfTemplatesForPrimers
   if ( resources_.nPrimersMinNumberOfTemplatesForPrimers_ !=
        CONDEF->nPrimersMinNumberOfTemplatesForPrimers_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinNumberOfTemplatesForPrimers: %d\n",
        resources_.nPrimersMinNumberOfTemplatesForPrimers_ );
   }

   // consed.autoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus
   if ( resources_.nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ !=
        CONDEF->nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus: %d\n",
        resources_.nAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus_ );
   }

   // consed.autoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead
   if ( resources_.nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ !=
        CONDEF->nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead: %d\n",
        resources_.nAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead_ );
   }

   // consed.autoFinishCDNANotGenomic
   if ( resources_.bAutoFinishCDNANotGenomic_ !=
        CONDEF->bAutoFinishCDNANotGenomic_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCDNANotGenomic: %s\n",
               ( resources_.bAutoFinishCDNANotGenomic_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishConfidenceThatReadWillCoverSingleSubcloneRegion
   if ( resources_.nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ !=
        CONDEF->nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishConfidenceThatReadWillCoverSingleSubcloneRegion: %d\n",
        resources_.nAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion_ );
   }

   // consed.autoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads
   if ( resources_.bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_ !=
        CONDEF->bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads: %s\n",
               ( resources_.bAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishPrintMinilibrariesSummaryFile
   if ( resources_.bAutoFinishPrintMinilibrariesSummaryFile_ !=
        CONDEF->bAutoFinishPrintMinilibrariesSummaryFile_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishPrintMinilibrariesSummaryFile: %s\n",
               ( resources_.bAutoFinishPrintMinilibrariesSummaryFile_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs
   if ( resources_.bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_ !=
        CONDEF->bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs: %s\n",
               ( resources_.bAutoFinishNearGapsSuggestEachMissingReadOfReadPairs_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger
   if ( resources_.nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ !=
        CONDEF->nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger: %d\n",
        resources_.nAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger_ );
   }

   // consed.checkIfTooManyWalks
   if ( resources_.bCheckIfTooManyWalks_ !=
        CONDEF->bCheckIfTooManyWalks_ ) {

      fprintf( pFileToWrite,
               "consed.checkIfTooManyWalks: %s\n",
               ( resources_.bCheckIfTooManyWalks_ ?
                     "true" : "false" ) );
   }

   // consed.numberOfColumnsBeforeReadNameInAlignedReadsWindow
   if ( resources_.nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_ !=
        CONDEF->nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_ ) {
     fprintf( pFileToWrite, 
        "consed.numberOfColumnsBeforeReadNameInAlignedReadsWindow: %d\n",
        resources_.nNumberOfColumnsBeforeReadNameInAlignedReadsWindow_ );
   }

   // consed.compareContigsAlignsThisManyBasesMax
   if ( resources_.nCompareContigsAlignsThisManyBasesMax_ !=
        CONDEF->nCompareContigsAlignsThisManyBasesMax_ ) {
     fprintf( pFileToWrite, 
        "consed.compareContigsAlignsThisManyBasesMax: %d\n",
        resources_.nCompareContigsAlignsThisManyBasesMax_ );
   }

   // consed.compressedChromatExtension
   if ( resources_.soCompressedChromatExtension_ !=
        CONDEF->soCompressedChromatExtension_ ) {

        fprintf( pFileToWrite,
              "consed.compressedChromatExtension: %s\n",
              resources_.soCompressedChromatExtension_.data() );
   }

   // consed.dimLowQualityEndsOfReads
   if ( resources_.bDimLowQualityEndsOfReads_ !=
        CONDEF->bDimLowQualityEndsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.dimLowQualityEndsOfReads: %s\n",
               ( resources_.bDimLowQualityEndsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.dimUnalignedEndsOfReads
   if ( resources_.bDimUnalignedEndsOfReads_ !=
        CONDEF->bDimUnalignedEndsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.dimUnalignedEndsOfReads: %s\n",
               ( resources_.bDimUnalignedEndsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.fakeReadsSpecifiedByFilenameExtension
   if ( resources_.bFakeReadsSpecifiedByFilenameExtension_ !=
        CONDEF->bFakeReadsSpecifiedByFilenameExtension_ ) {

      fprintf( pFileToWrite,
               "consed.fakeReadsSpecifiedByFilenameExtension: %s\n",
               ( resources_.bFakeReadsSpecifiedByFilenameExtension_ ?
                     "true" : "false" ) );
   }

   // consed.fullPathnameOfAddReads2ConsedScript
   if ( resources_.filFullPathnameOfAddReads2ConsedScript_ !=
        CONDEF->filFullPathnameOfAddReads2ConsedScript_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfAddReads2ConsedScript: %s\n",
              resources_.filFullPathnameOfAddReads2ConsedScript_.data() );
   }

   // consed.fullPathnameOfFixContigEndScript
   if ( resources_.filFullPathnameOfFixContigEndScript_ !=
        CONDEF->filFullPathnameOfFixContigEndScript_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfFixContigEndScript: %s\n",
              resources_.filFullPathnameOfFixContigEndScript_.data() );
   }

   // consed.fixContigEndsCleanUpTemporaryFiles
   if ( resources_.bFixContigEndsCleanUpTemporaryFiles_ !=
        CONDEF->bFixContigEndsCleanUpTemporaryFiles_ ) {

      fprintf( pFileToWrite,
               "consed.fixContigEndsCleanUpTemporaryFiles: %s\n",
               ( resources_.bFixContigEndsCleanUpTemporaryFiles_ ?
                     "true" : "false" ) );
   }

   // consed.fixContigEndsMinSmithWatermanScoreToMakeJoin
   if ( resources_.nFixContigEndsMinSmithWatermanScoreToMakeJoin_ !=
        CONDEF->nFixContigEndsMinSmithWatermanScoreToMakeJoin_ ) {
     fprintf( pFileToWrite, 
        "consed.fixContigEndsMinSmithWatermanScoreToMakeJoin: %d\n",
        resources_.nFixContigEndsMinSmithWatermanScoreToMakeJoin_ );
   }

   // consed.fixContigEndsMinNumberOfReadsInContig
   if ( resources_.nFixContigEndsMinNumberOfReadsInContig_ !=
        CONDEF->nFixContigEndsMinNumberOfReadsInContig_ ) {
     fprintf( pFileToWrite, 
        "consed.fixContigEndsMinNumberOfReadsInContig: %d\n",
        resources_.nFixContigEndsMinNumberOfReadsInContig_ );
   }

   // consed.fullPathnameOfCrossMatch
   if ( resources_.filFullPathnameOfCrossMatch_ !=
        CONDEF->filFullPathnameOfCrossMatch_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfCrossMatch: %s\n",
              resources_.filFullPathnameOfCrossMatch_.data() );
   }

   // consed.fullPathnameOfPhred
   if ( resources_.filFullPathnameOfPhred_ !=
        CONDEF->filFullPathnameOfPhred_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfPhred: %s\n",
              resources_.filFullPathnameOfPhred_.data() );
   }

   // consed.fullPathnameOfMiniassemblyScript
   if ( resources_.filFullPathnameOfMiniassemblyScript_ !=
        CONDEF->filFullPathnameOfMiniassemblyScript_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfMiniassemblyScript: %s\n",
              resources_.filFullPathnameOfMiniassemblyScript_.data() );
   }

   // consed.gunzipFullPath
   if ( resources_.soGunzipFullPath_ !=
        CONDEF->soGunzipFullPath_ ) {

        fprintf( pFileToWrite,
              "consed.gunzipFullPath: %s\n",
              resources_.soGunzipFullPath_.data() );
   }

   // consed.fullPathnameOfFilter454ReadsScript
   if ( resources_.filFullPathnameOfFilter454ReadsScript_ !=
        CONDEF->filFullPathnameOfFilter454ReadsScript_ ) {

        fprintf( pFileToWrite,
              "consed.fullPathnameOfFilter454ReadsScript: %s\n",
              resources_.filFullPathnameOfFilter454ReadsScript_.data() );
   }

   // consed.filter454ReadsAgainstThis
   if ( resources_.filFilter454ReadsAgainstThis_ !=
        CONDEF->filFilter454ReadsAgainstThis_ ) {

        fprintf( pFileToWrite,
              "consed.filter454ReadsAgainstThis: %s\n",
              resources_.filFilter454ReadsAgainstThis_.data() );
   }

   // consed.454LinkerSequences
   if ( resources_.fil454LinkerSequences_ !=
        CONDEF->fil454LinkerSequences_ ) {

        fprintf( pFileToWrite,
              "consed.454LinkerSequences: %s\n",
              resources_.fil454LinkerSequences_.data() );
   }

   // consed.hideSomeTagTypesAtStartup
   if ( resources_.bHideSomeTagTypesAtStartup_ !=
        CONDEF->bHideSomeTagTypesAtStartup_ ) {

      fprintf( pFileToWrite,
               "consed.hideSomeTagTypesAtStartup: %s\n",
               ( resources_.bHideSomeTagTypesAtStartup_ ?
                     "true" : "false" ) );
   }

   // consed.maximumNumberOfTracesShown
   if ( resources_.nMaximumNumberOfTracesShown_ !=
        CONDEF->nMaximumNumberOfTracesShown_ ) {
     fprintf( pFileToWrite, 
        "consed.maximumNumberOfTracesShown: %d\n",
        resources_.nMaximumNumberOfTracesShown_ );
   }

   // consed.navigateAutomaticTracePopup
   if ( resources_.bNavigateAutomaticTracePopup_ !=
        CONDEF->bNavigateAutomaticTracePopup_ ) {

      fprintf( pFileToWrite,
               "consed.navigateAutomaticTracePopup: %s\n",
               ( resources_.bNavigateAutomaticTracePopup_ ?
                     "true" : "false" ) );
   }

   // consed.navigateAutomaticAllTracesPopup
   if ( resources_.bNavigateAutomaticAllTracesPopup_ !=
        CONDEF->bNavigateAutomaticAllTracesPopup_ ) {

      fprintf( pFileToWrite,
               "consed.navigateAutomaticAllTracesPopup: %s\n",
               ( resources_.bNavigateAutomaticAllTracesPopup_ ?
                     "true" : "false" ) );
   }

   // consed.primersMinimumLengthOfAPrimer
   if ( resources_.nPrimersMinimumLengthOfAPrimer_ !=
        CONDEF->nPrimersMinimumLengthOfAPrimer_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinimumLengthOfAPrimer: %d\n",
        resources_.nPrimersMinimumLengthOfAPrimer_ );
   }

   // consed.primersMaximumLengthOfAPrimer
   if ( resources_.nPrimersMaximumLengthOfAPrimer_ !=
        CONDEF->nPrimersMaximumLengthOfAPrimer_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaximumLengthOfAPrimer: %d\n",
        resources_.nPrimersMaximumLengthOfAPrimer_ );
   }

   // consed.primersMinimumLengthOfAPrimerForPCR
   if ( resources_.nPrimersMinimumLengthOfAPrimerForPCR_ !=
        CONDEF->nPrimersMinimumLengthOfAPrimerForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinimumLengthOfAPrimerForPCR: %d\n",
        resources_.nPrimersMinimumLengthOfAPrimerForPCR_ );
   }

   // consed.primersMaximumLengthOfAPrimerForPCR
   if ( resources_.nPrimersMaximumLengthOfAPrimerForPCR_ !=
        CONDEF->nPrimersMaximumLengthOfAPrimerForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaximumLengthOfAPrimerForPCR: %d\n",
        resources_.nPrimersMaximumLengthOfAPrimerForPCR_ );
   }

   // consed.primersMaxMeltingTempDifferenceForPCR
   if ( resources_.dPrimersMaxMeltingTempDifferenceForPCR_ !=
        CONDEF->dPrimersMaxMeltingTempDifferenceForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxMeltingTempDifferenceForPCR: %f\n",
        resources_.dPrimersMaxMeltingTempDifferenceForPCR_ );
   }

   // consed.primersMaxPCRPrimerPairsToDisplay
   if ( resources_.nPrimersMaxPCRPrimerPairsToDisplay_ !=
        CONDEF->nPrimersMaxPCRPrimerPairsToDisplay_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxPCRPrimerPairsToDisplay: %d\n",
        resources_.nPrimersMaxPCRPrimerPairsToDisplay_ );
   }

   // consed.primersCheckJustSomePCRPrimerPairsRatherThanAll
   if ( resources_.bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_ !=
        CONDEF->bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_ ) {

      fprintf( pFileToWrite,
               "consed.primersCheckJustSomePCRPrimerPairsRatherThanAll: %s\n",
               ( resources_.bPrimersCheckJustSomePCRPrimerPairsRatherThanAll_ ?
                     "true" : "false" ) );
   }

   // consed.primersNumberOfTemplatesToDisplayInFront
   if ( resources_.nPrimersNumberOfTemplatesToDisplayInFront_ !=
        CONDEF->nPrimersNumberOfTemplatesToDisplayInFront_ ) {
     fprintf( pFileToWrite, 
        "consed.primersNumberOfTemplatesToDisplayInFront: %d\n",
        resources_.nPrimersNumberOfTemplatesToDisplayInFront_ );
   }

   // consed.primersMaxLengthOfMononucleotideRepeat
   if ( resources_.nPrimersMaxLengthOfMononucleotideRepeat_ !=
        CONDEF->nPrimersMaxLengthOfMononucleotideRepeat_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxLengthOfMononucleotideRepeat: %d\n",
        resources_.nPrimersMaxLengthOfMononucleotideRepeat_ );
   }

   // consed.primersBadLibrariesFile
   if ( resources_.filPrimersBadLibrariesFile_ !=
        CONDEF->filPrimersBadLibrariesFile_ ) {

        fprintf( pFileToWrite,
              "consed.primersBadLibrariesFile: %s\n",
              resources_.filPrimersBadLibrariesFile_.data() );
   }

   // consed.primersLibrariesInfoFile
   if ( resources_.filPrimersLibrariesInfoFile_ !=
        CONDEF->filPrimersLibrariesInfoFile_ ) {

        fprintf( pFileToWrite,
              "consed.primersLibrariesInfoFile: %s\n",
              resources_.filPrimersLibrariesInfoFile_.data() );
   }

   // consed.primersBadTemplatesFile
   if ( resources_.filPrimersBadTemplatesFile_ !=
        CONDEF->filPrimersBadTemplatesFile_ ) {

        fprintf( pFileToWrite,
              "consed.primersBadTemplatesFile: %s\n",
              resources_.filPrimersBadTemplatesFile_.data() );
   }

   // consed.primersChooseTemplatesByPositionInsteadOfQuality
   if ( resources_.bPrimersChooseTemplatesByPositionInsteadOfQuality_ !=
        CONDEF->bPrimersChooseTemplatesByPositionInsteadOfQuality_ ) {

      fprintf( pFileToWrite,
               "consed.primersChooseTemplatesByPositionInsteadOfQuality: %s\n",
               ( resources_.bPrimersChooseTemplatesByPositionInsteadOfQuality_ ?
                     "true" : "false" ) );
   }

   // consed.primersWhenChoosingATemplateMinPotentialReadLength
   if ( resources_.nPrimersWhenChoosingATemplateMinPotentialReadLength_ !=
        CONDEF->nPrimersWhenChoosingATemplateMinPotentialReadLength_ ) {
     fprintf( pFileToWrite, 
        "consed.primersWhenChoosingATemplateMinPotentialReadLength: %d\n",
        resources_.nPrimersWhenChoosingATemplateMinPotentialReadLength_ );
   }

   // consed.primersWindowSizeInLookingForPCR
   if ( resources_.nPrimersWindowSizeInLookingForPCR_ !=
        CONDEF->nPrimersWindowSizeInLookingForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersWindowSizeInLookingForPCR: %d\n",
        resources_.nPrimersWindowSizeInLookingForPCR_ );
   }

   // consed.qualityThresholdForFindingHighQualityDiscrepancies
   if ( resources_.nQualityThresholdForFindingHighQualityDiscrepancies_ !=
        CONDEF->nQualityThresholdForFindingHighQualityDiscrepancies_ ) {
     fprintf( pFileToWrite, 
        "consed.qualityThresholdForFindingHighQualityDiscrepancies: %d\n",
        resources_.nQualityThresholdForFindingHighQualityDiscrepancies_ );
   }

   // consed.qualityThresholdForNavigateByDepthOfCoverage
   if ( resources_.nQualityThresholdForNavigateByDepthOfCoverage_ !=
        CONDEF->nQualityThresholdForNavigateByDepthOfCoverage_ ) {
     fprintf( pFileToWrite, 
        "consed.qualityThresholdForNavigateByDepthOfCoverage: %d\n",
        resources_.nQualityThresholdForNavigateByDepthOfCoverage_ );
   }

   // consed.navigateByHighDepthOfCoverageNotLow
   if ( resources_.bNavigateByHighDepthOfCoverageNotLow_ !=
        CONDEF->bNavigateByHighDepthOfCoverageNotLow_ ) {

      fprintf( pFileToWrite,
               "consed.navigateByHighDepthOfCoverageNotLow: %s\n",
               ( resources_.bNavigateByHighDepthOfCoverageNotLow_ ?
                     "true" : "false" ) );
   }

   // consed.MinDepthForNavigateByDepthOfCoverage
   if ( resources_.nMinDepthForNavigateByDepthOfCoverage_ !=
        CONDEF->nMinDepthForNavigateByDepthOfCoverage_ ) {
     fprintf( pFileToWrite, 
        "consed.MinDepthForNavigateByDepthOfCoverage: %d\n",
        resources_.nMinDepthForNavigateByDepthOfCoverage_ );
   }

   // consed.defaultVectorPathnameForRestrictionFragments
   if ( resources_.filDefaultVectorPathnameForRestrictionFragments_ !=
        CONDEF->filDefaultVectorPathnameForRestrictionFragments_ ) {

        fprintf( pFileToWrite,
              "consed.defaultVectorPathnameForRestrictionFragments: %s\n",
              resources_.filDefaultVectorPathnameForRestrictionFragments_.data() );
   }

   // consed.fileOfAdditionalRestrictionEnzymes
   if ( resources_.filFileOfAdditionalRestrictionEnzymes_ !=
        CONDEF->filFileOfAdditionalRestrictionEnzymes_ ) {

        fprintf( pFileToWrite,
              "consed.fileOfAdditionalRestrictionEnzymes: %s\n",
              resources_.filFileOfAdditionalRestrictionEnzymes_.data() );
   }

   // consed.commonRestrictionEnzymes
   if ( resources_.soCommonRestrictionEnzymes_ !=
        CONDEF->soCommonRestrictionEnzymes_ ) {

        fprintf( pFileToWrite,
              "consed.commonRestrictionEnzymes: %s\n",
              resources_.soCommonRestrictionEnzymes_.data() );
   }

   // consed.defaultSelectedRestrictionEnzymes
   if ( resources_.soDefaultSelectedRestrictionEnzymes_ !=
        CONDEF->soDefaultSelectedRestrictionEnzymes_ ) {

        fprintf( pFileToWrite,
              "consed.defaultSelectedRestrictionEnzymes: %s\n",
              resources_.soDefaultSelectedRestrictionEnzymes_.data() );
   }

   // consed.restrictionEnzymesActualFragmentsFile
   if ( resources_.filRestrictionEnzymesActualFragmentsFile_ !=
        CONDEF->filRestrictionEnzymesActualFragmentsFile_ ) {

        fprintf( pFileToWrite,
              "consed.restrictionEnzymesActualFragmentsFile: %s\n",
              resources_.filRestrictionEnzymesActualFragmentsFile_.data() );
   }

   // consed.restrictionDigestInitialWindowSizeInTextRows
   if ( resources_.nRestrictionDigestInitialWindowSizeInTextRows_ !=
        CONDEF->nRestrictionDigestInitialWindowSizeInTextRows_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestInitialWindowSizeInTextRows: %d\n",
        resources_.nRestrictionDigestInitialWindowSizeInTextRows_ );
   }

   // consed.restrictionDigestDoNoShowAreaOfFragmentsOverThisSize
   if ( resources_.nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_ !=
        CONDEF->nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestDoNoShowAreaOfFragmentsOverThisSize: %d\n",
        resources_.nRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize_ );
   }

   // consed.showReadsAlphabetically
   if ( resources_.bShowReadsAlphabetically_ !=
        CONDEF->bShowReadsAlphabetically_ ) {

      fprintf( pFileToWrite,
               "consed.showReadsAlphabetically: %s\n",
               ( resources_.bShowReadsAlphabetically_ ?
                     "true" : "false" ) );
   }

   // consed.showReadsInAlignedReadsWindowOrderedByFile
   if ( resources_.bShowReadsInAlignedReadsWindowOrderedByFile_ !=
        CONDEF->bShowReadsInAlignedReadsWindowOrderedByFile_ ) {

      fprintf( pFileToWrite,
               "consed.showReadsInAlignedReadsWindowOrderedByFile: %s\n",
               ( resources_.bShowReadsInAlignedReadsWindowOrderedByFile_ ?
                     "true" : "false" ) );
   }

   // consed.showReadsInAlignedReadsWindowOrderedByThisFile
   if ( resources_.filShowReadsInAlignedReadsWindowOrderedByThisFile_ !=
        CONDEF->filShowReadsInAlignedReadsWindowOrderedByThisFile_ ) {

        fprintf( pFileToWrite,
              "consed.showReadsInAlignedReadsWindowOrderedByThisFile: %s\n",
              resources_.filShowReadsInAlignedReadsWindowOrderedByThisFile_.data() );
   }

   // consed.showReadsAtCursorSortedHow
   if ( resources_.soShowReadsAtCursorSortedHow_ !=
        CONDEF->soShowReadsAtCursorSortedHow_ ) {

        fprintf( pFileToWrite,
              "consed.showReadsAtCursorSortedHow: %s\n",
              resources_.soShowReadsAtCursorSortedHow_.data() );
   }

   // consed.showABIBasesInTraceWindow
   if ( resources_.bShowABIBasesInTraceWindow_ !=
        CONDEF->bShowABIBasesInTraceWindow_ ) {

      fprintf( pFileToWrite,
               "consed.showABIBasesInTraceWindow: %s\n",
               ( resources_.bShowABIBasesInTraceWindow_ ?
                     "true" : "false" ) );
   }

   // consed.tracesWindowInitialPixelHeight
   if ( resources_.nTracesWindowInitialPixelHeight_ !=
        CONDEF->nTracesWindowInitialPixelHeight_ ) {
     fprintf( pFileToWrite, 
        "consed.tracesWindowInitialPixelHeight: %d\n",
        resources_.nTracesWindowInitialPixelHeight_ );
   }

   // consed.assemblyViewWindowInitialPixelHeight
   if ( resources_.nAssemblyViewWindowInitialPixelHeight_ !=
        CONDEF->nAssemblyViewWindowInitialPixelHeight_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewWindowInitialPixelHeight: %d\n",
        resources_.nAssemblyViewWindowInitialPixelHeight_ );
   }

   // consed.assemblyViewFileOfTemplatesToNotShow
   if ( resources_.filAssemblyViewFileOfTemplatesToNotShow_ !=
        CONDEF->filAssemblyViewFileOfTemplatesToNotShow_ ) {

        fprintf( pFileToWrite,
              "consed.assemblyViewFileOfTemplatesToNotShow: %s\n",
              resources_.filAssemblyViewFileOfTemplatesToNotShow_.data() );
   }

   // consed.assemblyViewCrossMatchMinmatch
   if ( resources_.nAssemblyViewCrossMatchMinmatch_ !=
        CONDEF->nAssemblyViewCrossMatchMinmatch_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewCrossMatchMinmatch: %d\n",
        resources_.nAssemblyViewCrossMatchMinmatch_ );
   }

   // consed.assemblyViewCrossMatchMinscore
   if ( resources_.nAssemblyViewCrossMatchMinscore_ !=
        CONDEF->nAssemblyViewCrossMatchMinscore_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewCrossMatchMinscore: %d\n",
        resources_.nAssemblyViewCrossMatchMinscore_ );
   }

   // consed.assemblyViewFindSequenceMatchesForConsedScript
   if ( resources_.filAssemblyViewFindSequenceMatchesForConsedScript_ !=
        CONDEF->filAssemblyViewFindSequenceMatchesForConsedScript_ ) {

        fprintf( pFileToWrite,
              "consed.assemblyViewFindSequenceMatchesForConsedScript: %s\n",
              resources_.filAssemblyViewFindSequenceMatchesForConsedScript_.data() );
   }

   // consed.assemblyViewCrossmatchMinmatch
   if ( resources_.nAssemblyViewCrossmatchMinmatch_ !=
        CONDEF->nAssemblyViewCrossmatchMinmatch_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewCrossmatchMinmatch: %d\n",
        resources_.nAssemblyViewCrossmatchMinmatch_ );
   }

   // consed.assemblyViewCrossmatchMinscore
   if ( resources_.nAssemblyViewCrossmatchMinscore_ !=
        CONDEF->nAssemblyViewCrossmatchMinscore_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewCrossmatchMinscore: %d\n",
        resources_.nAssemblyViewCrossmatchMinscore_ );
   }

   // consed.assemblyViewSequenceMatchesMinimumSimilarity
   if ( resources_.nAssemblyViewSequenceMatchesMinimumSimilarity_ !=
        CONDEF->nAssemblyViewSequenceMatchesMinimumSimilarity_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewSequenceMatchesMinimumSimilarity: %d\n",
        resources_.nAssemblyViewSequenceMatchesMinimumSimilarity_ );
   }

   // consed.tracesWindowInitialPixelWidth
   if ( resources_.nTracesWindowInitialPixelWidth_ !=
        CONDEF->nTracesWindowInitialPixelWidth_ ) {
     fprintf( pFileToWrite, 
        "consed.tracesWindowInitialPixelWidth: %d\n",
        resources_.nTracesWindowInitialPixelWidth_ );
   }

   // consed.assemblyViewWindowInitialPixelWidth
   if ( resources_.nAssemblyViewWindowInitialPixelWidth_ !=
        CONDEF->nAssemblyViewWindowInitialPixelWidth_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewWindowInitialPixelWidth: %d\n",
        resources_.nAssemblyViewWindowInitialPixelWidth_ );
   }

   // consed.automaticallyScaleTraces
   if ( resources_.bAutomaticallyScaleTraces_ !=
        CONDEF->bAutomaticallyScaleTraces_ ) {

      fprintf( pFileToWrite,
               "consed.automaticallyScaleTraces: %s\n",
               ( resources_.bAutomaticallyScaleTraces_ ?
                     "true" : "false" ) );
   }

   // consed.automaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight
   if ( resources_.dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_ !=
        CONDEF->dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_ ) {
     fprintf( pFileToWrite, 
        "consed.automaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight: %f\n",
        resources_.dAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight_ );
   }

   // consed.automaticallyScaleTracesSamplePeakPercentile
   if ( resources_.nAutomaticallyScaleTracesSamplePeakPercentile_ !=
        CONDEF->nAutomaticallyScaleTracesSamplePeakPercentile_ ) {
     fprintf( pFileToWrite, 
        "consed.automaticallyScaleTracesSamplePeakPercentile: %d\n",
        resources_.nAutomaticallyScaleTracesSamplePeakPercentile_ );
   }

   // consed.verticalTraceMagnification
   if ( resources_.nVerticalTraceMagnification_ !=
        CONDEF->nVerticalTraceMagnification_ ) {
     fprintf( pFileToWrite, 
        "consed.verticalTraceMagnification: %d\n",
        resources_.nVerticalTraceMagnification_ );
   }

   // consed.userDefinedKeys
   if ( resources_.soUserDefinedKeys_ !=
        CONDEF->soUserDefinedKeys_ ) {

        fprintf( pFileToWrite,
              "consed.userDefinedKeys: %s\n",
              resources_.soUserDefinedKeys_.data() );
   }

   // consed.programsForUserDefinedKeys
   if ( resources_.soProgramsForUserDefinedKeys_ !=
        CONDEF->soProgramsForUserDefinedKeys_ ) {

        fprintf( pFileToWrite,
              "consed.programsForUserDefinedKeys: %s\n",
              resources_.soProgramsForUserDefinedKeys_.data() );
   }

   // consed.argumentsToPassToUserDefinedPrograms
   if ( resources_.soArgumentsToPassToUserDefinedPrograms_ !=
        CONDEF->soArgumentsToPassToUserDefinedPrograms_ ) {

        fprintf( pFileToWrite,
              "consed.argumentsToPassToUserDefinedPrograms: %s\n",
              resources_.soArgumentsToPassToUserDefinedPrograms_.data() );
   }

   // consed.tagsToApplyWithUserDefinedKeys
   if ( resources_.soTagsToApplyWithUserDefinedKeys_ !=
        CONDEF->soTagsToApplyWithUserDefinedKeys_ ) {

        fprintf( pFileToWrite,
              "consed.tagsToApplyWithUserDefinedKeys: %s\n",
              resources_.soTagsToApplyWithUserDefinedKeys_.data() );
   }

   // consed.snpGenomeUseInsertionPolymorphisms
   if ( resources_.bSnpGenomeUseInsertionPolymorphisms_ !=
        CONDEF->bSnpGenomeUseInsertionPolymorphisms_ ) {

      fprintf( pFileToWrite,
               "consed.snpGenomeUseInsertionPolymorphisms: %s\n",
               ( resources_.bSnpGenomeUseInsertionPolymorphisms_ ?
                     "true" : "false" ) );
   }

   // consed.listOfTagTypesToHide
   if ( resources_.soListOfTagTypesToHide_ !=
        CONDEF->soListOfTagTypesToHide_ ) {

        fprintf( pFileToWrite,
              "consed.listOfTagTypesToHide: %s\n",
              resources_.soListOfTagTypesToHide_.data() );
   }

   // consed.listOfOptionalWordsToSaveInListOfReadNames
   if ( resources_.soListOfOptionalWordsToSaveInListOfReadNames_ !=
        CONDEF->soListOfOptionalWordsToSaveInListOfReadNames_ ) {

        fprintf( pFileToWrite,
              "consed.listOfOptionalWordsToSaveInListOfReadNames: %s\n",
              resources_.soListOfOptionalWordsToSaveInListOfReadNames_.data() );
   }

   // consed.extendConsensusWithHighQuality
   if ( resources_.bExtendConsensusWithHighQuality_ !=
        CONDEF->bExtendConsensusWithHighQuality_ ) {

      fprintf( pFileToWrite,
               "consed.extendConsensusWithHighQuality: %s\n",
               ( resources_.bExtendConsensusWithHighQuality_ ?
                     "true" : "false" ) );
   }

   // consed.fastStartup
   if ( resources_.bFastStartup_ !=
        CONDEF->bFastStartup_ ) {

      fprintf( pFileToWrite,
               "consed.fastStartup: %s\n",
               ( resources_.bFastStartup_ ?
                     "true" : "false" ) );
   }

   // consed.fastStartupFile
   if ( resources_.filFastStartupFile_ !=
        CONDEF->filFastStartupFile_ ) {

        fprintf( pFileToWrite,
              "consed.fastStartupFile: %s\n",
              resources_.filFastStartupFile_.data() );
   }

   // consed.alwaysRunProgramToGetChromats
   if ( resources_.soAlwaysRunProgramToGetChromats_ !=
        CONDEF->soAlwaysRunProgramToGetChromats_ ) {

        fprintf( pFileToWrite,
              "consed.alwaysRunProgramToGetChromats: %s\n",
              resources_.soAlwaysRunProgramToGetChromats_.data() );
   }

   // consed.programToRunToGetChromats
   if ( resources_.filProgramToRunToGetChromats_ !=
        CONDEF->filProgramToRunToGetChromats_ ) {

        fprintf( pFileToWrite,
              "consed.programToRunToGetChromats: %s\n",
              resources_.filProgramToRunToGetChromats_.data() );
   }

   // consed.programToRunToGetChromatsOf454Reads
   if ( resources_.filProgramToRunToGetChromatsOf454Reads_ !=
        CONDEF->filProgramToRunToGetChromatsOf454Reads_ ) {

        fprintf( pFileToWrite,
              "consed.programToRunToGetChromatsOf454Reads: %s\n",
              resources_.filProgramToRunToGetChromatsOf454Reads_.data() );
   }

   // consed.createFakeChromatsForSolexaReads
   if ( resources_.bCreateFakeChromatsForSolexaReads_ !=
        CONDEF->bCreateFakeChromatsForSolexaReads_ ) {

      fprintf( pFileToWrite,
               "consed.createFakeChromatsForSolexaReads: %s\n",
               ( resources_.bCreateFakeChromatsForSolexaReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishUseLongModelReadRatherThanShort
   if ( resources_.bAutoFinishUseLongModelReadRatherThanShort_ !=
        CONDEF->bAutoFinishUseLongModelReadRatherThanShort_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishUseLongModelReadRatherThanShort: %s\n",
               ( resources_.bAutoFinishUseLongModelReadRatherThanShort_ ?
                     "true" : "false" ) );
   }

   // consed.askAgainIfWantToQuitConsedIfThisManyReads
   if ( resources_.nAskAgainIfWantToQuitConsedIfThisManyReads_ !=
        CONDEF->nAskAgainIfWantToQuitConsedIfThisManyReads_ ) {
     fprintf( pFileToWrite, 
        "consed.askAgainIfWantToQuitConsedIfThisManyReads: %d\n",
        resources_.nAskAgainIfWantToQuitConsedIfThisManyReads_ );
   }

   // consed.printWindowInstructions
   if ( resources_.soPrintWindowInstructions_ !=
        CONDEF->soPrintWindowInstructions_ ) {

        fprintf( pFileToWrite,
              "consed.printWindowInstructions: %s\n",
              resources_.soPrintWindowInstructions_.data() );
   }

   // consed.allowMultipleSearchForStringWindows
   if ( resources_.bAllowMultipleSearchForStringWindows_ !=
        CONDEF->bAllowMultipleSearchForStringWindows_ ) {

      fprintf( pFileToWrite,
               "consed.allowMultipleSearchForStringWindows: %s\n",
               ( resources_.bAllowMultipleSearchForStringWindows_ ?
                     "true" : "false" ) );
   }

   // consed.autoPCRAmplifyFalseProductsOKIfLargerThanThis
   if ( resources_.nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ !=
        CONDEF->nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ ) {
     fprintf( pFileToWrite, 
        "consed.autoPCRAmplifyFalseProductsOKIfLargerThanThis: %d\n",
        resources_.nAutoPCRAmplifyFalseProductsOKIfLargerThanThis_ );
   }

   // consed.autoPCRAmplifyMakePrimerOutOfFirstRegion
   if ( resources_.bAutoPCRAmplifyMakePrimerOutOfFirstRegion_ !=
        CONDEF->bAutoPCRAmplifyMakePrimerOutOfFirstRegion_ ) {

      fprintf( pFileToWrite,
               "consed.autoPCRAmplifyMakePrimerOutOfFirstRegion: %s\n",
               ( resources_.bAutoPCRAmplifyMakePrimerOutOfFirstRegion_ ?
                     "true" : "false" ) );
   }

   // consed.autoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct
   if ( resources_.nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ !=
        CONDEF->nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ ) {
     fprintf( pFileToWrite, 
        "consed.autoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct: %d\n",
        resources_.nAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct_ );
   }

   // consed.addNewReadsRecalculateConsensusQuality
   if ( resources_.bAddNewReadsRecalculateConsensusQuality_ !=
        CONDEF->bAddNewReadsRecalculateConsensusQuality_ ) {

      fprintf( pFileToWrite,
               "consed.addNewReadsRecalculateConsensusQuality: %s\n",
               ( resources_.bAddNewReadsRecalculateConsensusQuality_ ?
                     "true" : "false" ) );
   }

   // consed.addNewReadsPutReadIntoItsOwnContig
   if ( resources_.soAddNewReadsPutReadIntoItsOwnContig_ !=
        CONDEF->soAddNewReadsPutReadIntoItsOwnContig_ ) {

        fprintf( pFileToWrite,
              "consed.addNewReadsPutReadIntoItsOwnContig: %s\n",
              resources_.soAddNewReadsPutReadIntoItsOwnContig_.data() );
   }

   // consed.addNewReadsCheckThatCrossMatchRunCorrectly
   if ( resources_.bAddNewReadsCheckThatCrossMatchRunCorrectly_ !=
        CONDEF->bAddNewReadsCheckThatCrossMatchRunCorrectly_ ) {

      fprintf( pFileToWrite,
               "consed.addNewReadsCheckThatCrossMatchRunCorrectly: %s\n",
               ( resources_.bAddNewReadsCheckThatCrossMatchRunCorrectly_ ?
                     "true" : "false" ) );
   }

   // consed.assemblyViewNumberOfRowsOfTags
   if ( resources_.nAssemblyViewNumberOfRowsOfTags_ !=
        CONDEF->nAssemblyViewNumberOfRowsOfTags_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewNumberOfRowsOfTags: %d\n",
        resources_.nAssemblyViewNumberOfRowsOfTags_ );
   }

   // consed.warnUserWhenTryingToEditAllReads
   if ( resources_.bWarnUserWhenTryingToEditAllReads_ !=
        CONDEF->bWarnUserWhenTryingToEditAllReads_ ) {

      fprintf( pFileToWrite,
               "consed.warnUserWhenTryingToEditAllReads: %s\n",
               ( resources_.bWarnUserWhenTryingToEditAllReads_ ?
                     "true" : "false" ) );
   }

   // consed.maybeXKEYSYMDBPath
   if ( resources_.filMaybeXKEYSYMDBPath_ !=
        CONDEF->filMaybeXKEYSYMDBPath_ ) {

        fprintf( pFileToWrite,
              "consed.maybeXKEYSYMDBPath: %s\n",
              resources_.filMaybeXKEYSYMDBPath_.data() );
   }

   // consed.maybeXKEYSYMDBPath2
   if ( resources_.filMaybeXKEYSYMDBPath2_ !=
        CONDEF->filMaybeXKEYSYMDBPath2_ ) {

        fprintf( pFileToWrite,
              "consed.maybeXKEYSYMDBPath2: %s\n",
              resources_.filMaybeXKEYSYMDBPath2_.data() );
   }

   // consed.amountToMoveWithBigLeftAndRightArrows
   if ( resources_.nAmountToMoveWithBigLeftAndRightArrows_ !=
        CONDEF->nAmountToMoveWithBigLeftAndRightArrows_ ) {
     fprintf( pFileToWrite, 
        "consed.amountToMoveWithBigLeftAndRightArrows: %d\n",
        resources_.nAmountToMoveWithBigLeftAndRightArrows_ );
   }

   // consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads
   if ( resources_.nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_ !=
        CONDEF->nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_ ) {
     fprintf( pFileToWrite, 
        "consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads: %d\n",
        resources_.nNavigateByHighlyDiscrepantPositionsMinDiscrepantReads_ );
   }

   // consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage
   if ( resources_.nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_ !=
        CONDEF->nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_ ) {
     fprintf( pFileToWrite, 
        "consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage: %d\n",
        resources_.nNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage_ );
   }

   // consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality
   if ( resources_.nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_ !=
        CONDEF->nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_ ) {
     fprintf( pFileToWrite, 
        "consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality: %d\n",
        resources_.nNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality_ );
   }

   // consed.navigateByHighlyDiscrepantPositionsJustListIndels
   if ( resources_.bNavigateByHighlyDiscrepantPositionsJustListIndels_ !=
        CONDEF->bNavigateByHighlyDiscrepantPositionsJustListIndels_ ) {

      fprintf( pFileToWrite,
               "consed.navigateByHighlyDiscrepantPositionsJustListIndels: %s\n",
               ( resources_.bNavigateByHighlyDiscrepantPositionsJustListIndels_ ?
                     "true" : "false" ) );
   }

   // consed.navigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation
   if ( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_ !=
        CONDEF->bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_ ) {

      fprintf( pFileToWrite,
               "consed.navigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation: %s\n",
               ( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation_ ?
                     "true" : "false" ) );
   }

   // consed.navigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus
   if ( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_ !=
        CONDEF->bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_ ) {

      fprintf( pFileToWrite,
               "consed.navigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus: %s\n",
               ( resources_.bNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus_ ?
                     "true" : "false" ) );
   }

   // consed.navigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus
   if ( resources_.soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_ !=
        CONDEF->soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_ ) {

        fprintf( pFileToWrite,
              "consed.navigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus: %s\n",
              resources_.soNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus_.data() );
   }

   // consed.phdBallDirectory
   if ( resources_.filPhdBallDirectory_ !=
        CONDEF->filPhdBallDirectory_ ) {

        fprintf( pFileToWrite,
              "consed.phdBallDirectory: %s\n",
              resources_.filPhdBallDirectory_.data() );
   }

   // consed.newAceFileFOF
   if ( resources_.filNewAceFileFOF_ !=
        CONDEF->filNewAceFileFOF_ ) {

        fprintf( pFileToWrite,
              "consed.newAceFileFOF: %s\n",
              resources_.filNewAceFileFOF_.data() );
   }

   // consed.navigateByHighOrLowDepthCoalesceRegionsIfThisClose
   if ( resources_.nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_ !=
        CONDEF->nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_ ) {
     fprintf( pFileToWrite, 
        "consed.navigateByHighOrLowDepthCoalesceRegionsIfThisClose: %d\n",
        resources_.nNavigateByHighOrLowDepthCoalesceRegionsIfThisClose_ );
   }

   // consed.removeReadsDeleteNotJustPutInOwnContig
   if ( resources_.bRemoveReadsDeleteNotJustPutInOwnContig_ !=
        CONDEF->bRemoveReadsDeleteNotJustPutInOwnContig_ ) {

      fprintf( pFileToWrite,
               "consed.removeReadsDeleteNotJustPutInOwnContig: %s\n",
               ( resources_.bRemoveReadsDeleteNotJustPutInOwnContig_ ?
                     "true" : "false" ) );
   }

   // consed.paired454LeftReadExtension
   if ( resources_.soPaired454LeftReadExtension_ !=
        CONDEF->soPaired454LeftReadExtension_ ) {

        fprintf( pFileToWrite,
              "consed.paired454LeftReadExtension: %s\n",
              resources_.soPaired454LeftReadExtension_.data() );
   }

   // consed.paired454RightReadExtension
   if ( resources_.soPaired454RightReadExtension_ !=
        CONDEF->soPaired454RightReadExtension_ ) {

        fprintf( pFileToWrite,
              "consed.paired454RightReadExtension: %s\n",
              resources_.soPaired454RightReadExtension_.data() );
   }

   // consed.snpGenome1MSnps
   if ( resources_.filSnpGenome1MSnps_ !=
        CONDEF->filSnpGenome1MSnps_ ) {

        fprintf( pFileToWrite,
              "consed.snpGenome1MSnps: %s\n",
              resources_.filSnpGenome1MSnps_.data() );
   }

   // consed.diffChromosomesExcludeDeletions
   if ( resources_.bDiffChromosomesExcludeDeletions_ !=
        CONDEF->bDiffChromosomesExcludeDeletions_ ) {

      fprintf( pFileToWrite,
               "consed.diffChromosomesExcludeDeletions: %s\n",
               ( resources_.bDiffChromosomesExcludeDeletions_ ?
                     "true" : "false" ) );
   }

   // consed.snpGenomeFilterByWeight
   if ( resources_.bSnpGenomeFilterByWeight_ !=
        CONDEF->bSnpGenomeFilterByWeight_ ) {

      fprintf( pFileToWrite,
               "consed.snpGenomeFilterByWeight: %s\n",
               ( resources_.bSnpGenomeFilterByWeight_ ?
                     "true" : "false" ) );
   }

   // consed.wantReadsUpToThisFarFromSnps
   if ( resources_.nWantReadsUpToThisFarFromSnps_ !=
        CONDEF->nWantReadsUpToThisFarFromSnps_ ) {
     fprintf( pFileToWrite, 
        "consed.wantReadsUpToThisFarFromSnps: %d\n",
        resources_.nWantReadsUpToThisFarFromSnps_ );
   }

   // consed.phaster2PhdBallSaveWhichMate
   if ( resources_.soPhaster2PhdBallSaveWhichMate_ !=
        CONDEF->soPhaster2PhdBallSaveWhichMate_ ) {

        fprintf( pFileToWrite,
              "consed.phaster2PhdBallSaveWhichMate: %s\n",
              resources_.soPhaster2PhdBallSaveWhichMate_.data() );
   }

   // consed.phaster2PhdBallSaveInPhasterFormat
   if ( resources_.bPhaster2PhdBallSaveInPhasterFormat_ !=
        CONDEF->bPhaster2PhdBallSaveInPhasterFormat_ ) {

      fprintf( pFileToWrite,
               "consed.phaster2PhdBallSaveInPhasterFormat: %s\n",
               ( resources_.bPhaster2PhdBallSaveInPhasterFormat_ ?
                     "true" : "false" ) );
   }

   // consed.phaster2PhdBallCalculateNewLocationsFile
   if ( resources_.bPhaster2PhdBallCalculateNewLocationsFile_ !=
        CONDEF->bPhaster2PhdBallCalculateNewLocationsFile_ ) {

      fprintf( pFileToWrite,
               "consed.phaster2PhdBallCalculateNewLocationsFile: %s\n",
               ( resources_.bPhaster2PhdBallCalculateNewLocationsFile_ ?
                     "true" : "false" ) );
   }

   // consed.phdBall2FastaIgnoreLowQualityReads
   if ( resources_.bPhdBall2FastaIgnoreLowQualityReads_ !=
        CONDEF->bPhdBall2FastaIgnoreLowQualityReads_ ) {

      fprintf( pFileToWrite,
               "consed.phdBall2FastaIgnoreLowQualityReads: %s\n",
               ( resources_.bPhdBall2FastaIgnoreLowQualityReads_ ?
                     "true" : "false" ) );
   }

   // consed.phdBall2FastaLowestAverageQuality
   if ( resources_.nPhdBall2FastaLowestAverageQuality_ !=
        CONDEF->nPhdBall2FastaLowestAverageQuality_ ) {
     fprintf( pFileToWrite, 
        "consed.phdBall2FastaLowestAverageQuality: %d\n",
        resources_.nPhdBall2FastaLowestAverageQuality_ );
   }

   // consed.nextPhredPipelineControlFile
   if ( resources_.filNextPhredPipelineControlFile_ !=
        CONDEF->filNextPhredPipelineControlFile_ ) {

        fprintf( pFileToWrite,
              "consed.nextPhredPipelineControlFile: %s\n",
              resources_.filNextPhredPipelineControlFile_.data() );
   }

   // consed.nextPhredPipelineTiffPerlScript
   if ( resources_.filNextPhredPipelineTiffPerlScript_ !=
        CONDEF->filNextPhredPipelineTiffPerlScript_ ) {

        fprintf( pFileToWrite,
              "consed.nextPhredPipelineTiffPerlScript: %s\n",
              resources_.filNextPhredPipelineTiffPerlScript_.data() );
   }

   // consed.nextPhredPipelinePhasterPerlScript
   if ( resources_.filNextPhredPipelinePhasterPerlScript_ !=
        CONDEF->filNextPhredPipelinePhasterPerlScript_ ) {

        fprintf( pFileToWrite,
              "consed.nextPhredPipelinePhasterPerlScript: %s\n",
              resources_.filNextPhredPipelinePhasterPerlScript_.data() );
   }

   // consed.nextPhredPipelineVersion
   if ( resources_.soNextPhredPipelineVersion_ !=
        CONDEF->soNextPhredPipelineVersion_ ) {

        fprintf( pFileToWrite,
              "consed.nextPhredPipelineVersion: %s\n",
              resources_.soNextPhredPipelineVersion_.data() );
   }

   // consed.nextPhredPipelineMainDirectory
   if ( resources_.soNextPhredPipelineMainDirectory_ !=
        CONDEF->soNextPhredPipelineMainDirectory_ ) {

        fprintf( pFileToWrite,
              "consed.nextPhredPipelineMainDirectory: %s\n",
              resources_.soNextPhredPipelineMainDirectory_.data() );
   }

   // consed.maxNumberOfReadsPerPhdBall
   if ( resources_.nMaxNumberOfReadsPerPhdBall_ !=
        CONDEF->nMaxNumberOfReadsPerPhdBall_ ) {
     fprintf( pFileToWrite, 
        "consed.maxNumberOfReadsPerPhdBall: %d\n",
        resources_.nMaxNumberOfReadsPerPhdBall_ );
   }

   // consed.userWantsToSaveToThisAceFile
   if ( resources_.filUserWantsToSaveToThisAceFile_ !=
        CONDEF->filUserWantsToSaveToThisAceFile_ ) {

        fprintf( pFileToWrite,
              "consed.userWantsToSaveToThisAceFile: %s\n",
              resources_.filUserWantsToSaveToThisAceFile_.data() );
   }

   // consed.autoFinishEmulate9_66Behavior
   if ( resources_.bAutoFinishEmulate9_66Behavior_ !=
        CONDEF->bAutoFinishEmulate9_66Behavior_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishEmulate9_66Behavior: %s\n",
               ( resources_.bAutoFinishEmulate9_66Behavior_ ?
                     "true" : "false" ) );
   }

   // consed.primersPCRPrimersGroupedIntoWindowOfThisManyBases
   if ( resources_.nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ !=
        CONDEF->nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ ) {
     fprintf( pFileToWrite, 
        "consed.primersPCRPrimersGroupedIntoWindowOfThisManyBases: %d\n",
        resources_.nPrimersPCRPrimersGroupedIntoWindowOfThisManyBases_ );
   }

   // consed.primersLookForThisManyPCRPrimerPairsPerPairOfGroups
   if ( resources_.nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ !=
        CONDEF->nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ ) {
     fprintf( pFileToWrite, 
        "consed.primersLookForThisManyPCRPrimerPairsPerPairOfGroups: %d\n",
        resources_.nPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups_ );
   }

   // consed.autoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs
   if ( resources_.dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ !=
        CONDEF->dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs: %f\n",
        resources_.dAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs_ );
   }

   // consed.autoFinishCheckThatReadsFromTheSameTemplateAreConsistent
   if ( resources_.bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_ !=
        CONDEF->bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishCheckThatReadsFromTheSameTemplateAreConsistent: %s\n",
               ( resources_.bAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether
   if ( resources_.bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_ !=
        CONDEF->bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether: %s\n",
               ( resources_.bAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether
   if ( resources_.bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_ !=
        CONDEF->bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether: %s\n",
               ( resources_.bAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean
   if ( resources_.dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ !=
        CONDEF->dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean: %f\n",
        resources_.dAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean_ );
   }

   // consed.autoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize
   if ( resources_.nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ !=
        CONDEF->nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize: %d\n",
        resources_.nAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize_ );
   }

   // consed.autoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize
   if ( resources_.dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ !=
        CONDEF->dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize: %f\n",
        resources_.dAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize_ );
   }

   // consed.autoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead
   if ( resources_.nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ !=
        CONDEF->nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead: %d\n",
        resources_.nAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead_ );
   }

   // consed.autoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp
   if ( resources_.nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ !=
        CONDEF->nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp: %d\n",
        resources_.nAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp_ );
   }

   // consed.autoFinishNumberOfBasesBetweenContigsAssumed
   if ( resources_.nAutoFinishNumberOfBasesBetweenContigsAssumed_ !=
        CONDEF->nAutoFinishNumberOfBasesBetweenContigsAssumed_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishNumberOfBasesBetweenContigsAssumed: %d\n",
        resources_.nAutoFinishNumberOfBasesBetweenContigsAssumed_ );
   }

   // consed.autoFinishPotentialHighQualityPartOfReadStart
   if ( resources_.nAutoFinishPotentialHighQualityPartOfReadStart_ !=
        CONDEF->nAutoFinishPotentialHighQualityPartOfReadStart_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishPotentialHighQualityPartOfReadStart: %d\n",
        resources_.nAutoFinishPotentialHighQualityPartOfReadStart_ );
   }

   // consed.autoFinishPotentialHighQualityPartOfReadEnd
   if ( resources_.nAutoFinishPotentialHighQualityPartOfReadEnd_ !=
        CONDEF->nAutoFinishPotentialHighQualityPartOfReadEnd_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishPotentialHighQualityPartOfReadEnd: %d\n",
        resources_.nAutoFinishPotentialHighQualityPartOfReadEnd_ );
   }

   // consed.autoFinishPrintCustomNavigationFileForChosenReads
   if ( resources_.bAutoFinishPrintCustomNavigationFileForChosenReads_ !=
        CONDEF->bAutoFinishPrintCustomNavigationFileForChosenReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishPrintCustomNavigationFileForChosenReads: %s\n",
               ( resources_.bAutoFinishPrintCustomNavigationFileForChosenReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch
   if ( resources_.nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ !=
        CONDEF->nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch: %d\n",
        resources_.nAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch_ );
   }

   // consed.autoFinishTagOligosWhenDoExperiments
   if ( resources_.bAutoFinishTagOligosWhenDoExperiments_ !=
        CONDEF->bAutoFinishTagOligosWhenDoExperiments_ ) {

      fprintf( pFileToWrite,
               "consed.autoFinishTagOligosWhenDoExperiments: %s\n",
               ( resources_.bAutoFinishTagOligosWhenDoExperiments_ ?
                     "true" : "false" ) );
   }

   // consed.countPads
   if ( resources_.bCountPads_ !=
        CONDEF->bCountPads_ ) {

      fprintf( pFileToWrite,
               "consed.countPads: %s\n",
               ( resources_.bCountPads_ ?
                     "true" : "false" ) );
   }

   // consed.debugging
   if ( resources_.nDebugging_ !=
        CONDEF->nDebugging_ ) {
     fprintf( pFileToWrite, 
        "consed.debugging: %d\n",
        resources_.nDebugging_ );
   }

   // consed.debugging2
   if ( resources_.nDebugging2_ !=
        CONDEF->nDebugging2_ ) {
     fprintf( pFileToWrite, 
        "consed.debugging2: %d\n",
        resources_.nDebugging2_ );
   }

   // consed.debugging3
   if ( resources_.nDebugging3_ !=
        CONDEF->nDebugging3_ ) {
     fprintf( pFileToWrite, 
        "consed.debugging3: %d\n",
        resources_.nDebugging3_ );
   }

   // consed.debuggingString
   if ( resources_.soDebuggingString_ !=
        CONDEF->soDebuggingString_ ) {

        fprintf( pFileToWrite,
              "consed.debuggingString: %s\n",
              resources_.soDebuggingString_.data() );
   }

   // consed.ignoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion
   if ( resources_.nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_ !=
        CONDEF->nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_ ) {
     fprintf( pFileToWrite, 
        "consed.ignoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion: %d\n",
        resources_.nIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion_ );
   }

   // consed.ignoreUnalignedHighQualitySegmentsShorterThanThis
   if ( resources_.nIgnoreUnalignedHighQualitySegmentsShorterThanThis_ !=
        CONDEF->nIgnoreUnalignedHighQualitySegmentsShorterThanThis_ ) {
     fprintf( pFileToWrite, 
        "consed.ignoreUnalignedHighQualitySegmentsShorterThanThis: %d\n",
        resources_.nIgnoreUnalignedHighQualitySegmentsShorterThanThis_ );
   }

   // consed.primersLookThisFarForForwardVectorInsertJunction
   if ( resources_.nPrimersLookThisFarForForwardVectorInsertJunction_ !=
        CONDEF->nPrimersLookThisFarForForwardVectorInsertJunction_ ) {
     fprintf( pFileToWrite, 
        "consed.primersLookThisFarForForwardVectorInsertJunction: %d\n",
        resources_.nPrimersLookThisFarForForwardVectorInsertJunction_ );
   }

   // consed.primersDNAConcentrationNanomolar
   if ( resources_.dPrimersDNAConcentrationNanomolar_ !=
        CONDEF->dPrimersDNAConcentrationNanomolar_ ) {
     fprintf( pFileToWrite, 
        "consed.primersDNAConcentrationNanomolar: %f\n",
        resources_.dPrimersDNAConcentrationNanomolar_ );
   }

   // consed.primersMaxMatchElsewhereScore
   if ( resources_.nPrimersMaxMatchElsewhereScore_ !=
        CONDEF->nPrimersMaxMatchElsewhereScore_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxMatchElsewhereScore: %d\n",
        resources_.nPrimersMaxMatchElsewhereScore_ );
   }

   // consed.primersMaxMatchElsewhereScoreForPCR
   if ( resources_.nPrimersMaxMatchElsewhereScoreForPCR_ !=
        CONDEF->nPrimersMaxMatchElsewhereScoreForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxMatchElsewhereScoreForPCR: %d\n",
        resources_.nPrimersMaxMatchElsewhereScoreForPCR_ );
   }

   // consed.primersMaxSelfMatchScore
   if ( resources_.nPrimersMaxSelfMatchScore_ !=
        CONDEF->nPrimersMaxSelfMatchScore_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxSelfMatchScore: %d\n",
        resources_.nPrimersMaxSelfMatchScore_ );
   }

   // consed.primersMaxPrimerDimerScoreForPCR
   if ( resources_.nPrimersMaxPrimerDimerScoreForPCR_ !=
        CONDEF->nPrimersMaxPrimerDimerScoreForPCR_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMaxPrimerDimerScoreForPCR: %d\n",
        resources_.nPrimersMaxPrimerDimerScoreForPCR_ );
   }

   // consed.primersMinQuality
   if ( resources_.nPrimersMinQuality_ !=
        CONDEF->nPrimersMinQuality_ ) {
     fprintf( pFileToWrite, 
        "consed.primersMinQuality: %d\n",
        resources_.nPrimersMinQuality_ );
   }

   // consed.primersPrintInfoOnRejectedTemplates
   if ( resources_.bPrimersPrintInfoOnRejectedTemplates_ !=
        CONDEF->bPrimersPrintInfoOnRejectedTemplates_ ) {

      fprintf( pFileToWrite,
               "consed.primersPrintInfoOnRejectedTemplates: %s\n",
               ( resources_.bPrimersPrintInfoOnRejectedTemplates_ ?
                     "true" : "false" ) );
   }

   // consed.primersSaltConcentrationMillimolar
   if ( resources_.dPrimersSaltConcentrationMillimolar_ !=
        CONDEF->dPrimersSaltConcentrationMillimolar_ ) {
     fprintf( pFileToWrite, 
        "consed.primersSaltConcentrationMillimolar: %f\n",
        resources_.dPrimersSaltConcentrationMillimolar_ );
   }

   // consed.primersScreenForVector
   if ( resources_.bPrimersScreenForVector_ !=
        CONDEF->bPrimersScreenForVector_ ) {

      fprintf( pFileToWrite,
               "consed.primersScreenForVector: %s\n",
               ( resources_.bPrimersScreenForVector_ ?
                     "true" : "false" ) );
   }

   // consed.primersToleranceForDifferentBeginningLocationOfUniversalPrimerReads
   if ( resources_.nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ !=
        CONDEF->nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ ) {
     fprintf( pFileToWrite, 
        "consed.primersToleranceForDifferentBeginningLocationOfUniversalPrimerReads: %d\n",
        resources_.nPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads_ );
   }

   // consed.primersTooManyVectorBasesInWalkingRead
   if ( resources_.nPrimersTooManyVectorBasesInWalkingRead_ !=
        CONDEF->nPrimersTooManyVectorBasesInWalkingRead_ ) {
     fprintf( pFileToWrite, 
        "consed.primersTooManyVectorBasesInWalkingRead: %d\n",
        resources_.nPrimersTooManyVectorBasesInWalkingRead_ );
   }

   // consed.qualityThresholdForLowConsensusQuality
   if ( resources_.nQualityThresholdForLowConsensusQuality_ !=
        CONDEF->nQualityThresholdForLowConsensusQuality_ ) {
     fprintf( pFileToWrite, 
        "consed.qualityThresholdForLowConsensusQuality: %d\n",
        resources_.nQualityThresholdForLowConsensusQuality_ );
   }

   // consed.tagColorPerCentOfBase
   if ( resources_.nTagColorPerCentOfBase_ !=
        CONDEF->nTagColorPerCentOfBase_ ) {
     fprintf( pFileToWrite, 
        "consed.tagColorPerCentOfBase: %d\n",
        resources_.nTagColorPerCentOfBase_ );
   }

   // consed.uncompressedChromatDirectory
   if ( resources_.soUncompressedChromatDirectory_ !=
        CONDEF->soUncompressedChromatDirectory_ ) {

        fprintf( pFileToWrite,
              "consed.uncompressedChromatDirectory: %s\n",
              resources_.soUncompressedChromatDirectory_.data() );
   }

   // consed.454sff2scfDirectory
   if ( resources_.fil454sff2scfDirectory_ !=
        CONDEF->fil454sff2scfDirectory_ ) {

        fprintf( pFileToWrite,
              "consed.454sff2scfDirectory: %s\n",
              resources_.fil454sff2scfDirectory_.data() );
   }

   // consed.whenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion
   if ( resources_.nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_ !=
        CONDEF->nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_ ) {
     fprintf( pFileToWrite, 
        "consed.whenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion: %d\n",
        resources_.nWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion_ );
   }

   // consed.writeThisAceFormat
   if ( resources_.nWriteThisAceFormat_ !=
        CONDEF->nWriteThisAceFormat_ ) {
     fprintf( pFileToWrite, 
        "consed.writeThisAceFormat: %d\n",
        resources_.nWriteThisAceFormat_ );
   }

   // consed.dumpCoreIfBoundsError
   if ( resources_.bDumpCoreIfBoundsError_ !=
        CONDEF->bDumpCoreIfBoundsError_ ) {

      fprintf( pFileToWrite,
               "consed.dumpCoreIfBoundsError: %s\n",
               ( resources_.bDumpCoreIfBoundsError_ ?
                     "true" : "false" ) );
   }

   // consed.autoFinishMinSmithWatermanScoreOfARun
   if ( resources_.nAutoFinishMinSmithWatermanScoreOfARun_ !=
        CONDEF->nAutoFinishMinSmithWatermanScoreOfARun_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishMinSmithWatermanScoreOfARun: %d\n",
        resources_.nAutoFinishMinSmithWatermanScoreOfARun_ );
   }

   // consed.autoFinishDoNotComparePCRPrimersMoreThanThisManyTimes
   if ( resources_.dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ !=
        CONDEF->dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ ) {
     fprintf( pFileToWrite, 
        "consed.autoFinishDoNotComparePCRPrimersMoreThanThisManyTimes: %f\n",
        resources_.dAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes_ );
   }

   // consed.restrictionDigestMaximumBasesToCompareToVector
   if ( resources_.nRestrictionDigestMaximumBasesToCompareToVector_ !=
        CONDEF->nRestrictionDigestMaximumBasesToCompareToVector_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestMaximumBasesToCompareToVector: %d\n",
        resources_.nRestrictionDigestMaximumBasesToCompareToVector_ );
   }

   // consed.restrictionDigestZoomFactor
   if ( resources_.dRestrictionDigestZoomFactor_ !=
        CONDEF->dRestrictionDigestZoomFactor_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestZoomFactor: %f\n",
        resources_.dRestrictionDigestZoomFactor_ );
   }

   // consed.restrictionDigestZoomFactorForNavigate
   if ( resources_.dRestrictionDigestZoomFactorForNavigate_ !=
        CONDEF->dRestrictionDigestZoomFactorForNavigate_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestZoomFactorForNavigate: %f\n",
        resources_.dRestrictionDigestZoomFactorForNavigate_ );
   }

   // consed.restrictionDigestToleranceInPositionUnits
   if ( resources_.nRestrictionDigestToleranceInPositionUnits_ !=
        CONDEF->nRestrictionDigestToleranceInPositionUnits_ ) {
     fprintf( pFileToWrite, 
        "consed.restrictionDigestToleranceInPositionUnits: %d\n",
        resources_.nRestrictionDigestToleranceInPositionUnits_ );
   }

   // consed.autoPCRAmplifyTooManySeriousFalseMatches
   if ( resources_.nAutoPCRAmplifyTooManySeriousFalseMatches_ !=
        CONDEF->nAutoPCRAmplifyTooManySeriousFalseMatches_ ) {
     fprintf( pFileToWrite, 
        "consed.autoPCRAmplifyTooManySeriousFalseMatches: %d\n",
        resources_.nAutoPCRAmplifyTooManySeriousFalseMatches_ );
   }

   // consed.assemblyViewZoomFactor
   if ( resources_.dAssemblyViewZoomFactor_ !=
        CONDEF->dAssemblyViewZoomFactor_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewZoomFactor: %f\n",
        resources_.dAssemblyViewZoomFactor_ );
   }

   // consed.assemblyViewFilterInconsistentFwdRevPairsIfThisClose
   if ( resources_.nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_ !=
        CONDEF->nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewFilterInconsistentFwdRevPairsIfThisClose: %d\n",
        resources_.nAssemblyViewFilterInconsistentFwdRevPairsIfThisClose_ );
   }

   // consed.assemblyViewGridCellWidthInPixels
   if ( resources_.dAssemblyViewGridCellWidthInPixels_ !=
        CONDEF->dAssemblyViewGridCellWidthInPixels_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewGridCellWidthInPixels: %f\n",
        resources_.dAssemblyViewGridCellWidthInPixels_ );
   }

   // consed.assemblyViewCursorSensitivityInPixels
   if ( resources_.nAssemblyViewCursorSensitivityInPixels_ !=
        CONDEF->nAssemblyViewCursorSensitivityInPixels_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewCursorSensitivityInPixels: %d\n",
        resources_.nAssemblyViewCursorSensitivityInPixels_ );
   }

   // consed.assemblyViewReadDepthQuality
   if ( resources_.nAssemblyViewReadDepthQuality_ !=
        CONDEF->nAssemblyViewReadDepthQuality_ ) {
     fprintf( pFileToWrite, 
        "consed.assemblyViewReadDepthQuality: %d\n",
        resources_.nAssemblyViewReadDepthQuality_ );
   }

   // consed.showAllTracesMaxNumberOfTracesToShowAtOnce
   if ( resources_.nShowAllTracesMaxNumberOfTracesToShowAtOnce_ !=
        CONDEF->nShowAllTracesMaxNumberOfTracesToShowAtOnce_ ) {
     fprintf( pFileToWrite, 
        "consed.showAllTracesMaxNumberOfTracesToShowAtOnce: %d\n",
        resources_.nShowAllTracesMaxNumberOfTracesToShowAtOnce_ );
   }

   // consed.allowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess
   if ( resources_.nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_ !=
        CONDEF->nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_ ) {
     fprintf( pFileToWrite, 
        "consed.allowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess: %d\n",
        resources_.nAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess_ );
   }

   // consed.justForPrimateProject
   if ( resources_.bJustForPrimateProject_ !=
        CONDEF->bJustForPrimateProject_ ) {

      fprintf( pFileToWrite,
               "consed.justForPrimateProject: %s\n",
               ( resources_.bJustForPrimateProject_ ?
                     "true" : "false" ) );
   }

   // consed.solexaFilesAreAssumedToBeHere
   if ( resources_.filSolexaFilesAreAssumedToBeHere_ !=
        CONDEF->filSolexaFilesAreAssumedToBeHere_ ) {

        fprintf( pFileToWrite,
              "consed.solexaFilesAreAssumedToBeHere: %s\n",
              resources_.filSolexaFilesAreAssumedToBeHere_.data() );
   }

   // consed.solexaAlignmentFilesPerInsertingPadsCycle
   if ( resources_.nSolexaAlignmentFilesPerInsertingPadsCycle_ !=
        CONDEF->nSolexaAlignmentFilesPerInsertingPadsCycle_ ) {
     fprintf( pFileToWrite, 
        "consed.solexaAlignmentFilesPerInsertingPadsCycle: %d\n",
        resources_.nSolexaAlignmentFilesPerInsertingPadsCycle_ );
   }

   // consed.solexaAlignmentsPerAlignmentFile
   if ( resources_.nSolexaAlignmentsPerAlignmentFile_ !=
        CONDEF->nSolexaAlignmentsPerAlignmentFile_ ) {
     fprintf( pFileToWrite, 
        "consed.solexaAlignmentsPerAlignmentFile: %d\n",
        resources_.nSolexaAlignmentsPerAlignmentFile_ );
   }

   // consed.solexaFastqFilesArePhredQualityNotSolexaQuality
   if ( resources_.bSolexaFastqFilesArePhredQualityNotSolexaQuality_ !=
        CONDEF->bSolexaFastqFilesArePhredQualityNotSolexaQuality_ ) {

      fprintf( pFileToWrite,
               "consed.solexaFastqFilesArePhredQualityNotSolexaQuality: %s\n",
               ( resources_.bSolexaFastqFilesArePhredQualityNotSolexaQuality_ ?
                     "true" : "false" ) );
   }

   // consed.solexa64FastqOrSanger33Fastq
   if ( resources_.soSolexa64FastqOrSanger33Fastq_ !=
        CONDEF->soSolexa64FastqOrSanger33Fastq_ ) {

        fprintf( pFileToWrite,
              "consed.solexa64FastqOrSanger33Fastq: %s\n",
              resources_.soSolexa64FastqOrSanger33Fastq_.data() );
   }

   // consed.maximumReadsInReadList
   if ( resources_.nMaximumReadsInReadList_ !=
        CONDEF->nMaximumReadsInReadList_ ) {
     fprintf( pFileToWrite, 
        "consed.maximumReadsInReadList: %d\n",
        resources_.nMaximumReadsInReadList_ );
   }

   // consed.maxLengthOfReadsInapLocatedFragment2
   if ( resources_.nMaxLengthOfReadsInapLocatedFragment2_ !=
        CONDEF->nMaxLengthOfReadsInapLocatedFragment2_ ) {
     fprintf( pFileToWrite, 
        "consed.maxLengthOfReadsInapLocatedFragment2: %d\n",
        resources_.nMaxLengthOfReadsInapLocatedFragment2_ );
   }

   // consed.maximumStartupErrorsToReport
   if ( resources_.nMaximumStartupErrorsToReport_ !=
        CONDEF->nMaximumStartupErrorsToReport_ ) {
     fprintf( pFileToWrite, 
        "consed.maximumStartupErrorsToReport: %d\n",
        resources_.nMaximumStartupErrorsToReport_ );
   }

   // consed.454LinkerAlignmentMatchScore
   if ( resources_.n454LinkerAlignmentMatchScore_ !=
        CONDEF->n454LinkerAlignmentMatchScore_ ) {
     fprintf( pFileToWrite, 
        "consed.454LinkerAlignmentMatchScore: %d\n",
        resources_.n454LinkerAlignmentMatchScore_ );
   }

   // consed.454LinkerAlignmentMismatchScore
   if ( resources_.n454LinkerAlignmentMismatchScore_ !=
        CONDEF->n454LinkerAlignmentMismatchScore_ ) {
     fprintf( pFileToWrite, 
        "consed.454LinkerAlignmentMismatchScore: %d\n",
        resources_.n454LinkerAlignmentMismatchScore_ );
   }

   // consed.454LinkerAlignmentIndelScore
   if ( resources_.n454LinkerAlignmentIndelScore_ !=
        CONDEF->n454LinkerAlignmentIndelScore_ ) {
     fprintf( pFileToWrite, 
        "consed.454LinkerAlignmentIndelScore: %d\n",
        resources_.n454LinkerAlignmentIndelScore_ );
   }

   // consed.filter454ReadsDeleteCrossMatchOutput
   if ( resources_.bFilter454ReadsDeleteCrossMatchOutput_ !=
        CONDEF->bFilter454ReadsDeleteCrossMatchOutput_ ) {

      fprintf( pFileToWrite,
               "consed.filter454ReadsDeleteCrossMatchOutput: %s\n",
               ( resources_.bFilter454ReadsDeleteCrossMatchOutput_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportAllNeededSpeciesCode
   if ( resources_.nAutoReportAllNeededSpeciesCode_ !=
        CONDEF->nAutoReportAllNeededSpeciesCode_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportAllNeededSpeciesCode: %d\n",
        resources_.nAutoReportAllNeededSpeciesCode_ );
   }

   // consed.autoReportUseCommasInBigNumbers
   if ( resources_.bAutoReportUseCommasInBigNumbers_ !=
        CONDEF->bAutoReportUseCommasInBigNumbers_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportUseCommasInBigNumbers: %s\n",
               ( resources_.bAutoReportUseCommasInBigNumbers_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintToCompareToReich
   if ( resources_.bAutoReportPrintToCompareToReich_ !=
        CONDEF->bAutoReportPrintToCompareToReich_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintToCompareToReich: %s\n",
               ( resources_.bAutoReportPrintToCompareToReich_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportOnlyAllowSitesThatAreBetweenAcceptableSites
   if ( resources_.bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_ !=
        CONDEF->bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportOnlyAllowSitesThatAreBetweenAcceptableSites: %s\n",
               ( resources_.bAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDeaminationMutationsDeterminedByMoreAccurateMethod
   if ( resources_.bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_ !=
        CONDEF->bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDeaminationMutationsDeterminedByMoreAccurateMethod: %s\n",
               ( resources_.bAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportChooseTreesUsingBadData
   if ( resources_.bAutoReportChooseTreesUsingBadData_ !=
        CONDEF->bAutoReportChooseTreesUsingBadData_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportChooseTreesUsingBadData: %s\n",
               ( resources_.bAutoReportChooseTreesUsingBadData_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportChooseTreesByCountingDeaminationMutations
   if ( resources_.bAutoReportChooseTreesByCountingDeaminationMutations_ !=
        CONDEF->bAutoReportChooseTreesByCountingDeaminationMutations_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportChooseTreesByCountingDeaminationMutations: %s\n",
               ( resources_.bAutoReportChooseTreesByCountingDeaminationMutations_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportChooseTreesUsingKimura
   if ( resources_.bAutoReportChooseTreesUsingKimura_ !=
        CONDEF->bAutoReportChooseTreesUsingKimura_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportChooseTreesUsingKimura: %s\n",
               ( resources_.bAutoReportChooseTreesUsingKimura_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintCrudeChimpHumanMutations
   if ( resources_.bAutoReportPrintCrudeChimpHumanMutations_ !=
        CONDEF->bAutoReportPrintCrudeChimpHumanMutations_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintCrudeChimpHumanMutations: %s\n",
               ( resources_.bAutoReportPrintCrudeChimpHumanMutations_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintPositionsForGraham
   if ( resources_.bAutoReportPrintPositionsForGraham_ !=
        CONDEF->bAutoReportPrintPositionsForGraham_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintPositionsForGraham: %s\n",
               ( resources_.bAutoReportPrintPositionsForGraham_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintAncestralCpGs
   if ( resources_.bAutoReportPrintAncestralCpGs_ !=
        CONDEF->bAutoReportPrintAncestralCpGs_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintAncestralCpGs: %s\n",
               ( resources_.bAutoReportPrintAncestralCpGs_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintCpGMutations
   if ( resources_.bAutoReportPrintCpGMutations_ !=
        CONDEF->bAutoReportPrintCpGMutations_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintCpGMutations: %s\n",
               ( resources_.bAutoReportPrintCpGMutations_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintMutationsWithContext
   if ( resources_.bAutoReportPrintMutationsWithContext_ !=
        CONDEF->bAutoReportPrintMutationsWithContext_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintMutationsWithContext: %s\n",
               ( resources_.bAutoReportPrintMutationsWithContext_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCountAllMutationsML
   if ( resources_.bAutoReportCountAllMutationsML_ !=
        CONDEF->bAutoReportCountAllMutationsML_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCountAllMutationsML: %s\n",
               ( resources_.bAutoReportCountAllMutationsML_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCountAllMutations
   if ( resources_.bAutoReportCountAllMutations_ !=
        CONDEF->bAutoReportCountAllMutations_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCountAllMutations: %s\n",
               ( resources_.bAutoReportCountAllMutations_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportIgnoreMultipleTrees
   if ( resources_.bAutoReportIgnoreMultipleTrees_ !=
        CONDEF->bAutoReportIgnoreMultipleTrees_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportIgnoreMultipleTrees: %s\n",
               ( resources_.bAutoReportIgnoreMultipleTrees_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCountAcceptableColumnsWithNoneOnLeft
   if ( resources_.bAutoReportCountAcceptableColumnsWithNoneOnLeft_ !=
        CONDEF->bAutoReportCountAcceptableColumnsWithNoneOnLeft_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCountAcceptableColumnsWithNoneOnLeft: %s\n",
               ( resources_.bAutoReportCountAcceptableColumnsWithNoneOnLeft_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintFlankedColumns4
   if ( resources_.bAutoReportPrintFlankedColumns4_ !=
        CONDEF->bAutoReportPrintFlankedColumns4_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintFlankedColumns4: %s\n",
               ( resources_.bAutoReportPrintFlankedColumns4_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportUseAnnotationFormat
   if ( resources_.bAutoReportUseAnnotationFormat_ !=
        CONDEF->bAutoReportUseAnnotationFormat_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportUseAnnotationFormat: %s\n",
               ( resources_.bAutoReportUseAnnotationFormat_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintFlankedColumns3
   if ( resources_.bAutoReportPrintFlankedColumns3_ !=
        CONDEF->bAutoReportPrintFlankedColumns3_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintFlankedColumns3: %s\n",
               ( resources_.bAutoReportPrintFlankedColumns3_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintFlankedColumns2
   if ( resources_.bAutoReportPrintFlankedColumns2_ !=
        CONDEF->bAutoReportPrintFlankedColumns2_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintFlankedColumns2: %s\n",
               ( resources_.bAutoReportPrintFlankedColumns2_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintFlankedColumns
   if ( resources_.bAutoReportPrintFlankedColumns_ !=
        CONDEF->bAutoReportPrintFlankedColumns_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintFlankedColumns: %s\n",
               ( resources_.bAutoReportPrintFlankedColumns_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportHighQualitySegmentData
   if ( resources_.bAutoReportHighQualitySegmentData_ !=
        CONDEF->bAutoReportHighQualitySegmentData_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportHighQualitySegmentData: %s\n",
               ( resources_.bAutoReportHighQualitySegmentData_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportGoodReadsBug
   if ( resources_.bAutoReportGoodReadsBug_ !=
        CONDEF->bAutoReportGoodReadsBug_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportGoodReadsBug: %s\n",
               ( resources_.bAutoReportGoodReadsBug_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDiscrepancyRateInFlankedRegions
   if ( resources_.bAutoReportDiscrepancyRateInFlankedRegions_ !=
        CONDEF->bAutoReportDiscrepancyRateInFlankedRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDiscrepancyRateInFlankedRegions: %s\n",
               ( resources_.bAutoReportDiscrepancyRateInFlankedRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDiscrepancyRateInFlankedRegions2
   if ( resources_.bAutoReportDiscrepancyRateInFlankedRegions2_ !=
        CONDEF->bAutoReportDiscrepancyRateInFlankedRegions2_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDiscrepancyRateInFlankedRegions2: %s\n",
               ( resources_.bAutoReportDiscrepancyRateInFlankedRegions2_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDiscrepancyRateInFlankedRegions4
   if ( resources_.bAutoReportDiscrepancyRateInFlankedRegions4_ !=
        CONDEF->bAutoReportDiscrepancyRateInFlankedRegions4_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDiscrepancyRateInFlankedRegions4: %s\n",
               ( resources_.bAutoReportDiscrepancyRateInFlankedRegions4_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDiscrepancyRateInFlankedRegions5
   if ( resources_.bAutoReportDiscrepancyRateInFlankedRegions5_ !=
        CONDEF->bAutoReportDiscrepancyRateInFlankedRegions5_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDiscrepancyRateInFlankedRegions5: %s\n",
               ( resources_.bAutoReportDiscrepancyRateInFlankedRegions5_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportSingleSignalOrQuality
   if ( resources_.bAutoReportSingleSignalOrQuality_ !=
        CONDEF->bAutoReportSingleSignalOrQuality_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportSingleSignalOrQuality: %s\n",
               ( resources_.bAutoReportSingleSignalOrQuality_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportLowQualityBasesInHQS
   if ( resources_.bAutoReportLowQualityBasesInHQS_ !=
        CONDEF->bAutoReportLowQualityBasesInHQS_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportLowQualityBasesInHQS: %s\n",
               ( resources_.bAutoReportLowQualityBasesInHQS_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareHQSWithLQS
   if ( resources_.bAutoReportCompareHQSWithLQS_ !=
        CONDEF->bAutoReportCompareHQSWithLQS_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareHQSWithLQS: %s\n",
               ( resources_.bAutoReportCompareHQSWithLQS_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCountColumnsForGroupsOfSpecies
   if ( resources_.bAutoReportCountColumnsForGroupsOfSpecies_ !=
        CONDEF->bAutoReportCountColumnsForGroupsOfSpecies_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCountColumnsForGroupsOfSpecies: %s\n",
               ( resources_.bAutoReportCountColumnsForGroupsOfSpecies_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportSingleSignalInfo
   if ( resources_.bAutoReportSingleSignalInfo_ !=
        CONDEF->bAutoReportSingleSignalInfo_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportSingleSignalInfo: %s\n",
               ( resources_.bAutoReportSingleSignalInfo_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportSingleSignalInfo2
   if ( resources_.bAutoReportSingleSignalInfo2_ !=
        CONDEF->bAutoReportSingleSignalInfo2_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportSingleSignalInfo2: %s\n",
               ( resources_.bAutoReportSingleSignalInfo2_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareTopAndBottomStrands
   if ( resources_.bAutoReportCompareTopAndBottomStrands_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrands_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrands: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrands_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareTopAndBottomStrandsNoHuman
   if ( resources_.bAutoReportCompareTopAndBottomStrandsNoHuman_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrandsNoHuman_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrandsNoHuman: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrandsNoHuman_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareTopAndBottomStrands2
   if ( resources_.bAutoReportCompareTopAndBottomStrands2_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrands2_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrands2: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrands2_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareTopAndBottomStrands3
   if ( resources_.bAutoReportCompareTopAndBottomStrands3_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrands3_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrands3: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrands3_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCompareTopAndBottomStrands4
   if ( resources_.bAutoReportCompareTopAndBottomStrands4_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrands4_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrands4: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrands4_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportTopStrandPinnedPosition
   if ( resources_.nAutoReportTopStrandPinnedPosition_ !=
        CONDEF->nAutoReportTopStrandPinnedPosition_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportTopStrandPinnedPosition: %d\n",
        resources_.nAutoReportTopStrandPinnedPosition_ );
   }

   // consed.autoReportBottomStrandPinnedPosition
   if ( resources_.nAutoReportBottomStrandPinnedPosition_ !=
        CONDEF->nAutoReportBottomStrandPinnedPosition_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportBottomStrandPinnedPosition: %d\n",
        resources_.nAutoReportBottomStrandPinnedPosition_ );
   }

   // consed.autoReportCompareTopAndBottomStrandsWithHuman
   if ( resources_.bAutoReportCompareTopAndBottomStrandsWithHuman_ !=
        CONDEF->bAutoReportCompareTopAndBottomStrandsWithHuman_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCompareTopAndBottomStrandsWithHuman: %s\n",
               ( resources_.bAutoReportCompareTopAndBottomStrandsWithHuman_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintLengthsOfAlignedSegmentsOfReads
   if ( resources_.bAutoReportPrintLengthsOfAlignedSegmentsOfReads_ !=
        CONDEF->bAutoReportPrintLengthsOfAlignedSegmentsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintLengthsOfAlignedSegmentsOfReads: %s\n",
               ( resources_.bAutoReportPrintLengthsOfAlignedSegmentsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads
   if ( resources_.bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_ !=
        CONDEF->bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads: %s\n",
               ( resources_.bAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintIfReadsAreCorrectlyAligned
   if ( resources_.bAutoReportPrintIfReadsAreCorrectlyAligned_ !=
        CONDEF->bAutoReportPrintIfReadsAreCorrectlyAligned_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintIfReadsAreCorrectlyAligned: %s\n",
               ( resources_.bAutoReportPrintIfReadsAreCorrectlyAligned_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportCalculateErrorProbabilitiesByComparingPTroPPan
   if ( resources_.bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_ !=
        CONDEF->bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportCalculateErrorProbabilitiesByComparingPTroPPan: %s\n",
               ( resources_.bAutoReportCalculateErrorProbabilitiesByComparingPTroPPan_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies
   if ( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_ !=
        CONDEF->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies: %s\n",
               ( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies2
   if ( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_ !=
        CONDEF->bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies2: %s\n",
               ( resources_.bAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportFilterSingleSignal
   if ( resources_.bAutoReportFilterSingleSignal_ !=
        CONDEF->bAutoReportFilterSingleSignal_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportFilterSingleSignal: %s\n",
               ( resources_.bAutoReportFilterSingleSignal_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportGoodHitReads
   if ( resources_.filAutoReportGoodHitReads_ !=
        CONDEF->filAutoReportGoodHitReads_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportGoodHitReads: %s\n",
              resources_.filAutoReportGoodHitReads_.data() );
   }

   // consed.autoReportQualityWindowLow
   if ( resources_.nAutoReportQualityWindowLow_ !=
        CONDEF->nAutoReportQualityWindowLow_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportQualityWindowLow: %d\n",
        resources_.nAutoReportQualityWindowLow_ );
   }

   // consed.autoReportQualityWindowHigh
   if ( resources_.nAutoReportQualityWindowHigh_ !=
        CONDEF->nAutoReportQualityWindowHigh_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportQualityWindowHigh: %d\n",
        resources_.nAutoReportQualityWindowHigh_ );
   }

   // consed.autoReportPrintNumberOfIsolatedPadsForEachSpecies
   if ( resources_.bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_ !=
        CONDEF->bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintNumberOfIsolatedPadsForEachSpecies: %s\n",
               ( resources_.bAutoReportPrintNumberOfIsolatedPadsForEachSpecies_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintNumberOfIsolatedPads
   if ( resources_.bAutoReportPrintNumberOfIsolatedPads_ !=
        CONDEF->bAutoReportPrintNumberOfIsolatedPads_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintNumberOfIsolatedPads: %s\n",
               ( resources_.bAutoReportPrintNumberOfIsolatedPads_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportIsolatedPadsOfReadsWithThisPattern
   if ( resources_.soAutoReportIsolatedPadsOfReadsWithThisPattern_ !=
        CONDEF->soAutoReportIsolatedPadsOfReadsWithThisPattern_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportIsolatedPadsOfReadsWithThisPattern: %s\n",
              resources_.soAutoReportIsolatedPadsOfReadsWithThisPattern_.data() );
   }

   // consed.autoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy
   if ( resources_.nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ !=
        CONDEF->nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy: %d\n",
        resources_.nAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy_ );
   }

   // consed.autoReportMaxSizeOfDiscrepantRegion
   if ( resources_.nAutoReportMaxSizeOfDiscrepantRegion_ !=
        CONDEF->nAutoReportMaxSizeOfDiscrepantRegion_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportMaxSizeOfDiscrepantRegion: %d\n",
        resources_.nAutoReportMaxSizeOfDiscrepantRegion_ );
   }

   // consed.autoReportSizeOfDiscrepantRegion
   if ( resources_.nAutoReportSizeOfDiscrepantRegion_ !=
        CONDEF->nAutoReportSizeOfDiscrepantRegion_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportSizeOfDiscrepantRegion: %d\n",
        resources_.nAutoReportSizeOfDiscrepantRegion_ );
   }

   // consed.autoReportPrintMinimumQualityHistogram
   if ( resources_.bAutoReportPrintMinimumQualityHistogram_ !=
        CONDEF->bAutoReportPrintMinimumQualityHistogram_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintMinimumQualityHistogram: %s\n",
               ( resources_.bAutoReportPrintMinimumQualityHistogram_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintDiscrepantRegions
   if ( resources_.bAutoReportPrintDiscrepantRegions_ !=
        CONDEF->bAutoReportPrintDiscrepantRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintDiscrepantRegions: %s\n",
               ( resources_.bAutoReportPrintDiscrepantRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintBasesInDiscrepantRegions
   if ( resources_.bAutoReportPrintBasesInDiscrepantRegions_ !=
        CONDEF->bAutoReportPrintBasesInDiscrepantRegions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintBasesInDiscrepantRegions: %s\n",
               ( resources_.bAutoReportPrintBasesInDiscrepantRegions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis
   if ( resources_.soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_ !=
        CONDEF->soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis: %s\n",
              resources_.soAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis_.data() );
   }

   // consed.autoReportBackboneReadHasThisStringInIt
   if ( resources_.soAutoReportBackboneReadHasThisStringInIt_ !=
        CONDEF->soAutoReportBackboneReadHasThisStringInIt_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportBackboneReadHasThisStringInIt: %s\n",
              resources_.soAutoReportBackboneReadHasThisStringInIt_.data() );
   }

   // consed.autoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold
   if ( resources_.bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_ !=
        CONDEF->bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold: %s\n",
               ( resources_.bAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintSpeciesAlignment
   if ( resources_.bAutoReportPrintSpeciesAlignment_ !=
        CONDEF->bAutoReportPrintSpeciesAlignment_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintSpeciesAlignment: %s\n",
               ( resources_.bAutoReportPrintSpeciesAlignment_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintReadAlignment
   if ( resources_.bAutoReportPrintReadAlignment_ !=
        CONDEF->bAutoReportPrintReadAlignment_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintReadAlignment: %s\n",
               ( resources_.bAutoReportPrintReadAlignment_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintTheseReads
   if ( resources_.filAutoReportPrintTheseReads_ !=
        CONDEF->filAutoReportPrintTheseReads_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportPrintTheseReads: %s\n",
              resources_.filAutoReportPrintTheseReads_.data() );
   }

   // consed.autoReportPrintReadPositions
   if ( resources_.bAutoReportPrintReadPositions_ !=
        CONDEF->bAutoReportPrintReadPositions_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintReadPositions: %s\n",
               ( resources_.bAutoReportPrintReadPositions_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportPrintChosenReadName
   if ( resources_.bAutoReportPrintChosenReadName_ !=
        CONDEF->bAutoReportPrintChosenReadName_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportPrintChosenReadName: %s\n",
               ( resources_.bAutoReportPrintChosenReadName_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportNumbersOfCharactersOfChosenReadNameToBePrinted
   if ( resources_.nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ !=
        CONDEF->nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportNumbersOfCharactersOfChosenReadNameToBePrinted: %d\n",
        resources_.nAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted_ );
   }

   // consed.autoReportPrefix
   if ( resources_.soAutoReportPrefix_ !=
        CONDEF->soAutoReportPrefix_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportPrefix: %s\n",
              resources_.soAutoReportPrefix_.data() );
   }

   // consed.autoReportUseOldCriteriaForDeletingColumnsOfPads
   if ( resources_.bAutoReportUseOldCriteriaForDeletingColumnsOfPads_ !=
        CONDEF->bAutoReportUseOldCriteriaForDeletingColumnsOfPads_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportUseOldCriteriaForDeletingColumnsOfPads: %s\n",
               ( resources_.bAutoReportUseOldCriteriaForDeletingColumnsOfPads_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues
   if ( resources_.bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_ !=
        CONDEF->bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues: %s\n",
               ( resources_.bAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportFlankingBasesMustBeSingleSignal
   if ( resources_.bAutoReportFlankingBasesMustBeSingleSignal_ !=
        CONDEF->bAutoReportFlankingBasesMustBeSingleSignal_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportFlankingBasesMustBeSingleSignal: %s\n",
               ( resources_.bAutoReportFlankingBasesMustBeSingleSignal_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportMinimumQualityOfFlankingBases
   if ( resources_.nAutoReportMinimumQualityOfFlankingBases_ !=
        CONDEF->nAutoReportMinimumQualityOfFlankingBases_ ) {
     fprintf( pFileToWrite, 
        "consed.autoReportMinimumQualityOfFlankingBases: %d\n",
        resources_.nAutoReportMinimumQualityOfFlankingBases_ );
   }

   // consed.autoReportFlankingBasesMustBeInHighQualitySegment
   if ( resources_.bAutoReportFlankingBasesMustBeInHighQualitySegment_ !=
        CONDEF->bAutoReportFlankingBasesMustBeInHighQualitySegment_ ) {

      fprintf( pFileToWrite,
               "consed.autoReportFlankingBasesMustBeInHighQualitySegment: %s\n",
               ( resources_.bAutoReportFlankingBasesMustBeInHighQualitySegment_ ?
                     "true" : "false" ) );
   }

   // consed.autoReportSpecies
   if ( resources_.soAutoReportSpecies_ !=
        CONDEF->soAutoReportSpecies_ ) {

        fprintf( pFileToWrite,
              "consed.autoReportSpecies: %s\n",
              resources_.soAutoReportSpecies_.data() );
   }

    // guiEditResources.cpp.part7


    fclose( pFileToWrite );


    popupInfoMessage( widPopupShell_, 
       "Note that these new parameters will take effect only after restarting Consed/Autofinish" );


}


void guiEditResources :: checkEverything() {


   checkPrintPS();
   checkDefaultTagType();
   checkDefaultTagOnConsensusNotReads();
   checkAutoFinishMinNumberOfErrorsFixedByAnExp();
   checkAutoFinishRedundancy();
   checkAutoFinishAverageInsertSize();
   checkPrimersMaxInsertSizeOfASubclone();
   checkPrimersMaxMeltingTemp();
   checkPrimersMaxMeltingTempForPCR();
   checkPrimersPickTemplatesForPrimers();
   checkPrimersSubcloneFullPathnameOfFileOfSequencesForScreening();
   checkPrimersCloneFullPathnameOfFileOfSequencesForScreening();
   checkPrimersMinMeltingTemp();
   checkPrimersMinMeltingTempForPCR();
   checkSearchFunctionsUseUnalignedEndsOfReads();
   checkSearchFunctionsUseLowQualityEndsOfReads();
   checkInexactSearchForStringMaxPerCentMismatch();
   checkOnlyAllowOneReadWriteConsedAtATime();
   checkAutoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair();
   checkPrintWindowCommand();
   checkFileOfTagTypes();
   checkAssemblyViewShowConsistentFwdRevPairs();
   checkAssemblyViewShowConsistentFwdRevPairDepth();
   checkAssemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds();
   checkAssemblyViewShowLegsOnSquaresForConsistentFwdRevPairs();
   checkAssemblyViewShowGapSpanningFwdRevPairs();
   checkAssemblyViewShowWhichInconsistentFwdRevPairs();
   checkAssemblyViewShowReadDepth();
   checkAssemblyViewShowMultipleHighQualityDiscrepancies();
   checkAssemblyViewShowRestrictionDigestCutSites();
   checkAssemblyViewFilterSequenceMatchesBySize();
   checkAssemblyViewSequenceMatchesMinSize();
   checkAssemblyViewSequenceMatchesMaxSize();
   checkAssemblyViewAutomaticallyStartWithConsed();
   checkAssemblyViewDisplayTheseTagTypesOnTheseLines();
   checkAssemblyViewShowTags();
   checkAutoEditRecalculateHighQualitySegmentsOfReads();
   checkAutoEditConvertCloneEndBasesToXs();
   checkAutoEditTellPhrapNotToOverlapMultiplyDiscrepantReads();
   checkAutoEditTagEditableLowConsensusQualityRegions();
   checkAutoEditMakeFakeRead();
   checkAutoEditMakeFakeReadFromRead1();
   checkAutoEditMakeFakeReadFromRead2();
   checkAutoEditMakeFakeReadName();
   checkAutoEditMakeFakeReadFastaFilename();
   checkAutoEditMergeAssembly();
   checkAutoEditSecondaryAceFile();
   checkAutoEditFixRunsInConsensus();
   checkShowAllTracesJustShowGoodTraces();
   checkAddAlignedSequenceQualityOfBases();
   checkMakeLightBackgroundInAlignedReadsWindowAndTracesWindow();
   checkPutVerticalLineAtCursor();
   checkPutHorizontalLineAtCursor();
   checkHighlightedReadsFile();
   checkAutoReportPrintReadNamesInRegion();
   checkAutoReportPrintReadNamesInRegionContig();
   checkAutoReportPrintReadNamesInRegionLeftPos();
   checkAutoReportPrintReadNamesInRegionRightPos();
   checkAutoReportPrintHighlyDiscrepantRegions();
   checkAutoReportPrintScaffolds();
   checkNumberUnpaddedConsensusAtUserDefined();
   checkAutoReportPrintHighQualityDiscrepancies();
   checkAutoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags();
   checkAutoReportHighQualityDiscrepanciesExcludeMostPads();
   checkAutoReportPrintLowConsensusQualityRegions();
   checkAutoReportPrintSingleSubcloneRegions();
   checkAutoReportPrintSingleStrandedRegions();
   checkAutoReportPrintLinkingForwardReversePairs();
   checkAutoReportPrintFilteredInconsistentForwardReversePairs();
   checkAutoReportPrintAssemblySummary();
   checkShowAllTracesDoNotShowTraceIfTheseTagsPresent();
   checkNameOfFakeJoiningReadsIncludesAceFileName();
   checkWhenUserScrollsOffWindowMillisecondsBetweenScrolling();
   checkWhenUserScrollsOffWindowBasesToScrollEachTime();
   checkCompareContigsUseBandedRatherThanFullSmithWaterman();
   checkCompareContigsBandSize();
   checkAssemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany();
   checkAssemblyViewShowSequenceMatches();
   checkAssemblyViewOKToShowSequenceMatchesBetweenContigs();
   checkAssemblyViewOKToShowSequenceMatchesWithinContigs();
   checkAssemblyViewOKToShowDirectSequenceMatches();
   checkAssemblyViewOKToShowInvertedSequenceMatches();
   checkAssemblyViewOnlyShowSequenceMatchesToAParticularRegion();
   checkAssemblyViewOnlyShowSequenceMatchesToThisContig();
   checkAssemblyViewOnlyShowSequenceMatchesToThisRegionLeft();
   checkAssemblyViewOnlyShowSequenceMatchesToThisRegionRight();
   checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigs();
   checkAssemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar();
   checkDefaultReadPrefix();
   checkReadPrefixesFile();
   checkMaxCharsDisplayedForReadPrefix();
   checkAutoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates();
   checkAutoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions();
   checkAutoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis();
   checkAutoFinishDoNotDoPCRIfEndIsExtendedByReads();
   checkAutoFinishMaxAcceptableErrorsPerMegabase();
   checkAutoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize();
   checkPrimersNumberOfBasesToBackUpToStartLooking();
   checkPrimersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment();
   checkPrimersOKToChoosePrimersInSingleSubcloneRegion();
   checkPrimersOKToChoosePrimersWhereHighQualityDiscrepancies();
   checkPrimersOKToChoosePrimersWhereUnalignedHighQualityRegion();
   checkAutoFinishCallReversesToFlankGaps();
   checkAutoFinishAllowWholeCloneReads();
   checkAutoFinishAllowCustomPrimerSubcloneReads();
   checkAutoFinishAllowResequencingReads();
   checkAutoFinishAllowResequencingReadsOnlyForRunsAndStops();
   checkAutoFinishAllowDeNovoUniversalPrimerSubcloneReads();
   checkAutoFinishAllowMinilibraries();
   checkAutoFinishAllowPCR();
   checkAutoFinishAllowUnorientedPCRReactions();
   checkAutoFinishAllowResequencingAUniversalPrimerAutofinishRead();
   checkAutoFinishAlwaysCloseGapsUsingMinilibraries();
   checkAutoFinishMaximumFinishingReadLength();
   checkAutoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger();
   checkAutoFinishSuggestSpecialChemistryForRunsAndStops();
   checkAutoFinishSuggestThisManyMinilibrariesPerGap();
   checkPrimersWindowSizeInLooking();
   checkPrimersAssumeTemplatesAreDoubleStrandedUnlessSpecified();
   checkAlignedReadsWindowInitialCharsWide();
   checkAlignedReadsWindowInitialCharsHigh();
   checkAlignedReadsWindowMaxCharsForReadNames();
   checkAlignedReadsWindowAutomaticallyExpandRoomForReadNames();
   checkAutoFinishAllowResequencingReadsToExtendContigs();
   checkAutoFinishCallHowManyReversesToFlankGaps();
   checkAutoFinishCloseGaps();
   checkAutoFinishContinueEvenThoughReadInfoDoesNotMakeSense();
   checkAutoFinishCostOfResequencingUniversalPrimerSubcloneReaction();
   checkAutoFinishCostOfCustomPrimerSubcloneReaction();
   checkAutoFinishCostOfCustomPrimerCloneReaction();
   checkAutoFinishCostOfDeNovoUniversalPrimerSubcloneReaction();
   checkAutoFinishCostOfMinilibrary();
   checkAutoFinishCoverSingleSubcloneRegions();
   checkAutoFinishCoverLowConsensusQualityRegions();
   checkAutoFinishDebugUniversalPrimerReadsFile();
   checkAutoFinishDebugCustomPrimerReadsFile();
   checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases();
   checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases();
   checkAutoFinishDoNotFinishWhereTheseTagsAre();
   checkAutoFinishDoNotExtendContigsWhereTheseTagsAre();
   checkAutoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd();
   checkDumpContigOrderAndOrientationInfoToThisFile();
   checkAutoFinishDumpTemplates();
   checkAutoFinishExcludeContigIfOnlyThisManyReadsOrLess();
   checkAutoFinishExcludeContigIfDepthOfCoverageGreaterThanThis();
   checkAutoFinishExcludeContigIfThisManyBasesOrLess();
   checkAutoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions();
   checkPrimersMinNumberOfTemplatesForPrimers();
   checkAutoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus();
   checkAutoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead();
   checkAutoFinishCDNANotGenomic();
   checkAutoFinishConfidenceThatReadWillCoverSingleSubcloneRegion();
   checkAutoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads();
   checkAutoFinishPrintMinilibrariesSummaryFile();
   checkAutoFinishNearGapsSuggestEachMissingReadOfReadPairs();
   checkAutoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger();
   checkCheckIfTooManyWalks();
   checkNumberOfColumnsBeforeReadNameInAlignedReadsWindow();
   checkCompareContigsAlignsThisManyBasesMax();
   checkCompressedChromatExtension();
   checkDimLowQualityEndsOfReads();
   checkDimUnalignedEndsOfReads();
   checkFakeReadsSpecifiedByFilenameExtension();
   checkFullPathnameOfAddReads2ConsedScript();
   checkFullPathnameOfFixContigEndScript();
   checkFixContigEndsCleanUpTemporaryFiles();
   checkFixContigEndsMinSmithWatermanScoreToMakeJoin();
   checkFixContigEndsMinNumberOfReadsInContig();
   checkFullPathnameOfCrossMatch();
   checkFullPathnameOfPhred();
   checkFullPathnameOfMiniassemblyScript();
   checkGunzipFullPath();
   checkFullPathnameOfFilter454ReadsScript();
   checkFilter454ReadsAgainstThis();
   check454LinkerSequences();
   checkHideSomeTagTypesAtStartup();
   checkMaximumNumberOfTracesShown();
   checkNavigateAutomaticTracePopup();
   checkNavigateAutomaticAllTracesPopup();
   checkPrimersMinimumLengthOfAPrimer();
   checkPrimersMaximumLengthOfAPrimer();
   checkPrimersMinimumLengthOfAPrimerForPCR();
   checkPrimersMaximumLengthOfAPrimerForPCR();
   checkPrimersMaxMeltingTempDifferenceForPCR();
   checkPrimersMaxPCRPrimerPairsToDisplay();
   checkPrimersCheckJustSomePCRPrimerPairsRatherThanAll();
   checkPrimersNumberOfTemplatesToDisplayInFront();
   checkPrimersMaxLengthOfMononucleotideRepeat();
   checkPrimersBadLibrariesFile();
   checkPrimersLibrariesInfoFile();
   checkPrimersBadTemplatesFile();
   checkPrimersChooseTemplatesByPositionInsteadOfQuality();
   checkPrimersWhenChoosingATemplateMinPotentialReadLength();
   checkPrimersWindowSizeInLookingForPCR();
   checkQualityThresholdForFindingHighQualityDiscrepancies();
   checkQualityThresholdForNavigateByDepthOfCoverage();
   checkNavigateByHighDepthOfCoverageNotLow();
   checkMinDepthForNavigateByDepthOfCoverage();
   checkDefaultVectorPathnameForRestrictionFragments();
   checkFileOfAdditionalRestrictionEnzymes();
   checkCommonRestrictionEnzymes();
   checkDefaultSelectedRestrictionEnzymes();
   checkRestrictionEnzymesActualFragmentsFile();
   checkRestrictionDigestInitialWindowSizeInTextRows();
   checkRestrictionDigestDoNoShowAreaOfFragmentsOverThisSize();
   checkShowReadsAlphabetically();
   checkShowReadsInAlignedReadsWindowOrderedByFile();
   checkShowReadsInAlignedReadsWindowOrderedByThisFile();
   checkShowReadsAtCursorSortedHow();
   checkShowABIBasesInTraceWindow();
   checkTracesWindowInitialPixelHeight();
   checkAssemblyViewWindowInitialPixelHeight();
   checkAssemblyViewFileOfTemplatesToNotShow();
   checkAssemblyViewCrossMatchMinmatch();
   checkAssemblyViewCrossMatchMinscore();
   checkAssemblyViewFindSequenceMatchesForConsedScript();
   checkAssemblyViewCrossmatchMinmatch();
   checkAssemblyViewCrossmatchMinscore();
   checkAssemblyViewSequenceMatchesMinimumSimilarity();
   checkTracesWindowInitialPixelWidth();
   checkAssemblyViewWindowInitialPixelWidth();
   checkAutomaticallyScaleTraces();
   checkAutomaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight();
   checkAutomaticallyScaleTracesSamplePeakPercentile();
   checkVerticalTraceMagnification();
   checkUserDefinedKeys();
   checkProgramsForUserDefinedKeys();
   checkArgumentsToPassToUserDefinedPrograms();
   checkTagsToApplyWithUserDefinedKeys();
   checkSnpGenomeUseInsertionPolymorphisms();
   checkListOfTagTypesToHide();
   checkListOfOptionalWordsToSaveInListOfReadNames();
   checkExtendConsensusWithHighQuality();
   checkFastStartup();
   checkFastStartupFile();
   checkAlwaysRunProgramToGetChromats();
   checkProgramToRunToGetChromats();
   checkProgramToRunToGetChromatsOf454Reads();
   checkCreateFakeChromatsForSolexaReads();
   checkAutoFinishUseLongModelReadRatherThanShort();
   checkAskAgainIfWantToQuitConsedIfThisManyReads();
   checkPrintWindowInstructions();
   checkAllowMultipleSearchForStringWindows();
   checkAutoPCRAmplifyFalseProductsOKIfLargerThanThis();
   checkAutoPCRAmplifyMakePrimerOutOfFirstRegion();
   checkAutoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct();
   checkAddNewReadsRecalculateConsensusQuality();
   checkAddNewReadsPutReadIntoItsOwnContig();
   checkAddNewReadsCheckThatCrossMatchRunCorrectly();
   checkAssemblyViewNumberOfRowsOfTags();
   checkWarnUserWhenTryingToEditAllReads();
   checkMaybeXKEYSYMDBPath();
   checkMaybeXKEYSYMDBPath2();
   checkAmountToMoveWithBigLeftAndRightArrows();
   checkNavigateByHighlyDiscrepantPositionsMinDiscrepantReads();
   checkNavigateByHighlyDiscrepantPositionsMaxDepthOfCoverage();
   checkNavigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality();
   checkNavigateByHighlyDiscrepantPositionsJustListIndels();
   checkNavigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation();
   checkNavigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus();
   checkNavigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus();
   checkPhdBallDirectory();
   checkNewAceFileFOF();
   checkNavigateByHighOrLowDepthCoalesceRegionsIfThisClose();
   checkRemoveReadsDeleteNotJustPutInOwnContig();
   checkPaired454LeftReadExtension();
   checkPaired454RightReadExtension();
   checkSnpGenome1MSnps();
   checkDiffChromosomesExcludeDeletions();
   checkSnpGenomeFilterByWeight();
   checkWantReadsUpToThisFarFromSnps();
   checkPhaster2PhdBallSaveWhichMate();
   checkPhaster2PhdBallSaveInPhasterFormat();
   checkPhaster2PhdBallCalculateNewLocationsFile();
   checkPhdBall2FastaIgnoreLowQualityReads();
   checkPhdBall2FastaLowestAverageQuality();
   checkNextPhredPipelineControlFile();
   checkNextPhredPipelineTiffPerlScript();
   checkNextPhredPipelinePhasterPerlScript();
   checkNextPhredPipelineVersion();
   checkNextPhredPipelineMainDirectory();
   checkMaxNumberOfReadsPerPhdBall();
   checkUserWantsToSaveToThisAceFile();
   checkAutoFinishEmulate9_66Behavior();
   checkPrimersPCRPrimersGroupedIntoWindowOfThisManyBases();
   checkPrimersLookForThisManyPCRPrimerPairsPerPairOfGroups();
   checkAutoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs();
   checkAutoFinishCheckThatReadsFromTheSameTemplateAreConsistent();
   checkAutoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether();
   checkAutoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether();
   checkAutoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean();
   checkAutoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize();
   checkAutoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize();
   checkAutoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead();
   checkAutoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp();
   checkAutoFinishNumberOfBasesBetweenContigsAssumed();
   checkAutoFinishPotentialHighQualityPartOfReadStart();
   checkAutoFinishPotentialHighQualityPartOfReadEnd();
   checkAutoFinishPrintCustomNavigationFileForChosenReads();
   checkAutoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch();
   checkAutoFinishTagOligosWhenDoExperiments();
   checkCountPads();
   checkDebugging();
   checkDebugging2();
   checkDebugging3();
   checkDebuggingString();
   checkIgnoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion();
   checkIgnoreUnalignedHighQualitySegmentsShorterThanThis();
   checkPrimersLookThisFarForForwardVectorInsertJunction();
   checkPrimersDNAConcentrationNanomolar();
   checkPrimersMaxMatchElsewhereScore();
   checkPrimersMaxMatchElsewhereScoreForPCR();
   checkPrimersMaxSelfMatchScore();
   checkPrimersMaxPrimerDimerScoreForPCR();
   checkPrimersMinQuality();
   checkPrimersPrintInfoOnRejectedTemplates();
   checkPrimersSaltConcentrationMillimolar();
   checkPrimersScreenForVector();
   checkPrimersToleranceForDifferentBeginningLocationOfUniversalPrimerReads();
   checkPrimersTooManyVectorBasesInWalkingRead();
   checkQualityThresholdForLowConsensusQuality();
   checkTagColorPerCentOfBase();
   checkUncompressedChromatDirectory();
   check454sff2scfDirectory();
   checkWhenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion();
   checkWriteThisAceFormat();
   checkDumpCoreIfBoundsError();
   checkAutoFinishMinSmithWatermanScoreOfARun();
   checkAutoFinishDoNotComparePCRPrimersMoreThanThisManyTimes();
   checkRestrictionDigestMaximumBasesToCompareToVector();
   checkRestrictionDigestZoomFactor();
   checkRestrictionDigestZoomFactorForNavigate();
   checkRestrictionDigestToleranceInPositionUnits();
   checkAutoPCRAmplifyTooManySeriousFalseMatches();
   checkAssemblyViewZoomFactor();
   checkAssemblyViewFilterInconsistentFwdRevPairsIfThisClose();
   checkAssemblyViewGridCellWidthInPixels();
   checkAssemblyViewCursorSensitivityInPixels();
   checkAssemblyViewReadDepthQuality();
   checkShowAllTracesMaxNumberOfTracesToShowAtOnce();
   checkAllowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess();
   checkJustForPrimateProject();
   checkSolexaFilesAreAssumedToBeHere();
   checkSolexaAlignmentFilesPerInsertingPadsCycle();
   checkSolexaAlignmentsPerAlignmentFile();
   checkSolexaFastqFilesArePhredQualityNotSolexaQuality();
   checkSolexa64FastqOrSanger33Fastq();
   checkMaximumReadsInReadList();
   checkMaxLengthOfReadsInapLocatedFragment2();
   checkMaximumStartupErrorsToReport();
   check454LinkerAlignmentMatchScore();
   check454LinkerAlignmentMismatchScore();
   check454LinkerAlignmentIndelScore();
   checkFilter454ReadsDeleteCrossMatchOutput();
   checkAutoReportAllNeededSpeciesCode();
   checkAutoReportUseCommasInBigNumbers();
   checkAutoReportPrintToCompareToReich();
   checkAutoReportOnlyAllowSitesThatAreBetweenAcceptableSites();
   checkAutoReportDeaminationMutationsDeterminedByMoreAccurateMethod();
   checkAutoReportChooseTreesUsingBadData();
   checkAutoReportChooseTreesByCountingDeaminationMutations();
   checkAutoReportChooseTreesUsingKimura();
   checkAutoReportPrintCrudeChimpHumanMutations();
   checkAutoReportPrintPositionsForGraham();
   checkAutoReportPrintAncestralCpGs();
   checkAutoReportPrintCpGMutations();
   checkAutoReportPrintMutationsWithContext();
   checkAutoReportCountAllMutationsML();
   checkAutoReportCountAllMutations();
   checkAutoReportIgnoreMultipleTrees();
   checkAutoReportCountAcceptableColumnsWithNoneOnLeft();
   checkAutoReportPrintFlankedColumns4();
   checkAutoReportUseAnnotationFormat();
   checkAutoReportPrintFlankedColumns3();
   checkAutoReportPrintFlankedColumns2();
   checkAutoReportPrintFlankedColumns();
   checkAutoReportHighQualitySegmentData();
   checkAutoReportGoodReadsBug();
   checkAutoReportDiscrepancyRateInFlankedRegions();
   checkAutoReportDiscrepancyRateInFlankedRegions2();
   checkAutoReportDiscrepancyRateInFlankedRegions4();
   checkAutoReportDiscrepancyRateInFlankedRegions5();
   checkAutoReportSingleSignalOrQuality();
   checkAutoReportLowQualityBasesInHQS();
   checkAutoReportCompareHQSWithLQS();
   checkAutoReportCountColumnsForGroupsOfSpecies();
   checkAutoReportSingleSignalInfo();
   checkAutoReportSingleSignalInfo2();
   checkAutoReportCompareTopAndBottomStrands();
   checkAutoReportCompareTopAndBottomStrandsNoHuman();
   checkAutoReportCompareTopAndBottomStrands2();
   checkAutoReportCompareTopAndBottomStrands3();
   checkAutoReportCompareTopAndBottomStrands4();
   checkAutoReportTopStrandPinnedPosition();
   checkAutoReportBottomStrandPinnedPosition();
   checkAutoReportCompareTopAndBottomStrandsWithHuman();
   checkAutoReportPrintLengthsOfAlignedSegmentsOfReads();
   checkAutoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads();
   checkAutoReportPrintIfReadsAreCorrectlyAligned();
   checkAutoReportCalculateErrorProbabilitiesByComparingPTroPPan();
   checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies();
   checkAutoReportPrintAgreeDisagreeBetweenPairsOfSpecies2();
   checkAutoReportFilterSingleSignal();
   checkAutoReportGoodHitReads();
   checkAutoReportQualityWindowLow();
   checkAutoReportQualityWindowHigh();
   checkAutoReportPrintNumberOfIsolatedPadsForEachSpecies();
   checkAutoReportPrintNumberOfIsolatedPads();
   checkAutoReportIsolatedPadsOfReadsWithThisPattern();
   checkAutoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy();
   checkAutoReportMaxSizeOfDiscrepantRegion();
   checkAutoReportSizeOfDiscrepantRegion();
   checkAutoReportPrintMinimumQualityHistogram();
   checkAutoReportPrintDiscrepantRegions();
   checkAutoReportPrintBasesInDiscrepantRegions();
   checkAutoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis();
   checkAutoReportBackboneReadHasThisStringInIt();
   checkAutoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold();
   checkAutoReportPrintSpeciesAlignment();
   checkAutoReportPrintReadAlignment();
   checkAutoReportPrintTheseReads();
   checkAutoReportPrintReadPositions();
   checkAutoReportPrintChosenReadName();
   checkAutoReportNumbersOfCharactersOfChosenReadNameToBePrinted();
   checkAutoReportPrefix();
   checkAutoReportUseOldCriteriaForDeletingColumnsOfPads();
   checkAutoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues();
   checkAutoReportFlankingBasesMustBeSingleSignal();
   checkAutoReportMinimumQualityOfFlankingBases();
   checkAutoReportFlankingBasesMustBeInHighQualitySegment();
   checkAutoReportSpecies();
    // guiEditResources.cpp.part9



}



void guiEditResources :: userResizedWindow() {

   if ( !bAllTheWayUp_ ) return;

   Dimension dimClipWindowWidth;

   XtVaGetValues( widClipWindow_, XmNwidth, &dimClipWindowWidth, NULL );

   // it is only necessary to set one form in the row-col widget 
   // to get the entire row-col widget to increase in size and, apparently,
   // this causes all the form widgets within it to increase in size as well
   // This makes all the textfield widgets that are connected to the right end
   // to resize as well.

   XtVaSetValues( widPrimersSubcloneFullPathnameForm_, XmNwidth, dimClipWindowWidth, NULL );


   // for some reason, Motif changes the increment when the window is resized.
   XtVaSetValues( widVerticalScrollBar_,
                  XmNincrement, 20,
                  NULL );


}



void guiEditResources :: userPushedHelp( const RWCString& soResource ) {


   int n;
   bool bFound = false;
   int nStartIndex;
   for( n = 0; aszDefaultResources[n] && !bFound; ++n ) {
      char* pFound = strstr( aszDefaultResources[n], soResource.data() );
      if ( pFound == aszDefaultResources[n] ) {
         bFound = true;
         nStartIndex = n;
      }
   }

   if ( !bFound ) {
      RWCString soError = "Internal program error finding ";
      soError += soResource;
      popupErrorMessage( soError );
      return;
   }

   // now find the end

   int nEndIndex;
   bool bFoundEnd = false;
   for( n = nStartIndex + 1; !bFoundEnd; ++n ) {
      if ( !aszDefaultResources[n] ) {
         bFoundEnd = true;
         nEndIndex = n - 1;
      }
      else if ( memcmp( "consed.", aszDefaultResources[n], 7 ) == 0 ) {
         // found next resources
         bFoundEnd = true;
         nEndIndex = n - 1;
      }
   }

   if ( !bFoundEnd ) {
      RWCString soError = "Internal program error b finding ";
      soError += soResource;
      popupErrorMessage( soError );
      return;
   }

   RWCString soToDisplay;

   for( n = nStartIndex; n <= nEndIndex; ++n ) {
      soToDisplay += RWCString( aszDefaultResources[n] );
   }

   soToDisplay += "\n";
   soToDisplay += "(YES) = freely customize to your own site\n";
   soToDisplay += "(OK)  = don't change unless you have a specific need and know what you\n";
   soToDisplay += "         are doing\n";
   soToDisplay += "(NO)  = don't change this!\n";

   TextBox* pDocumentationWindow = new TextBox( soResource,
                                        15, // rows visible
                                        soToDisplay );


   pDocumentationWindow->makeVisible();


}



void guiEditResources :: windowCameUp() {

   XtVaGetValues( widScrolledWindow_, 
                  XmNverticalScrollBar,
                  &widVerticalScrollBar_,
                  NULL );

   XtVaSetValues( widVerticalScrollBar_,
                  XmNincrement, 20,
                  NULL );



}




void guiEditResources :: userPushedFindButton( 
                            const bool bFindFirstNotFindNext ) {

   char* szValue =
   XmTextFieldGetString( widEnterParameter_ );
   RWCString soValue = szValue;
   XtFree( szValue );
   
   RWCString soOriginalCase = soValue;

   soValue.toLower();


   int nStartIndex = ( bFindFirstNotFindNext ? 0 :
                       nIndexOfLastFoundResource_ + 1 );
   bool bFound = false;

   for( int nParameter = nStartIndex; 
        nParameter < aConsedResources_.length() && ! bFound; ++nParameter ) {
       
     if ( aConsedResources_[ nParameter ].index( soValue ) != RW_NPOS ) {
         nIndexOfLastFoundResource_ = nParameter;
         bFound = true;
     }
   }


   if ( !bFound ) {
      popupErrorMessage( "could not find %s", soOriginalCase.data() );
      return;
   }


   int nScrollBarMax;
   int nScrollBarMin;
   int nSliderSize;

   XtVaGetValues( widVerticalScrollBar_,
                  XmNmaximum, &nScrollBarMax,
                  XmNminimum, &nScrollBarMin,
                  XmNsliderSize, &nSliderSize,
                  NULL );

   const int nMarginAtTop = 20;

   int nNewValue = nIndexOfLastFoundResource_ * 
      (double) ( nScrollBarMax - nScrollBarMin + 1 ) /
      (double) aConsedResources_.length() - nMarginAtTop;

   if ( nNewValue < 0 )
      nNewValue = 0;
   else if ( nNewValue > ( nScrollBarMax - nSliderSize - nScrollBarMin + 1 ) )
      nNewValue = nScrollBarMax - nSliderSize - nScrollBarMin + 1;

   XtVaSetValues( widVerticalScrollBar_,
                  XmNvalue, nNewValue,
                  NULL );

   
   XmScrollBarCallbackStruct xmMyScrollBarCallbackStruct;
   xmMyScrollBarCallbackStruct.reason = 0;
   xmMyScrollBarCallbackStruct.event = 0;
   xmMyScrollBarCallbackStruct.value = nNewValue;
   xmMyScrollBarCallbackStruct.pixel = 0;
    

   XtCallCallbacks( widVerticalScrollBar_,
                    XmNvalueChangedCallback,
                    &xmMyScrollBarCallbackStruct );


}


void guiEditResources :: createResourceArray() {

   aConsedResources_.resize( (size_t) 200 );

   // guiEditResources.cpp.part10
   aConsedResources_.insert("consed.printPS" );
   aConsedResources_.insert("consed.defaultTagType" );
   aConsedResources_.insert("consed.defaultTagOnConsensusNotReads" );
   aConsedResources_.insert("consed.autoFinishMinNumberOfErrorsFixedByAnExp" );
   aConsedResources_.insert("consed.autoFinishRedundancy" );
   aConsedResources_.insert("consed.autoFinishAverageInsertSize" );
   aConsedResources_.insert("consed.primersMaxInsertSizeOfASubclone" );
   aConsedResources_.insert("consed.primersMaxMeltingTemp" );
   aConsedResources_.insert("consed.primersMaxMeltingTempForPCR" );
   aConsedResources_.insert("consed.primersPickTemplatesForPrimers" );
   aConsedResources_.insert("consed.primersSubcloneFullPathnameOfFileOfSequencesForScreening" );
   aConsedResources_.insert("consed.primersCloneFullPathnameOfFileOfSequencesForScreening" );
   aConsedResources_.insert("consed.primersMinMeltingTemp" );
   aConsedResources_.insert("consed.primersMinMeltingTempForPCR" );
   aConsedResources_.insert("consed.searchFunctionsUseUnalignedEndsOfReads" );
   aConsedResources_.insert("consed.searchFunctionsUseLowQualityEndsOfReads" );
   aConsedResources_.insert("consed.inexactSearchForStringMaxPerCentMismatch" );
   aConsedResources_.insert("consed.onlyAllowOneReadWriteConsedAtATime" );
   aConsedResources_.insert("consed.autoFinishAllowHighQualityDiscrepanciesInTemplateIfConsistentForwardReversePair" );
   aConsedResources_.insert("consed.printWindowCommand" );
   aConsedResources_.insert("consed.fileOfTagTypes" );
   aConsedResources_.insert("consed.assemblyViewShowConsistentFwdRevPairs" );
   aConsedResources_.insert("consed.assemblyViewShowConsistentFwdRevPairDepth" );
   aConsedResources_.insert("consed.assemblyViewShowConsistentFwdRevPairsBetweenDifferentScaffolds" );
   aConsedResources_.insert("consed.assemblyViewShowLegsOnSquaresForConsistentFwdRevPairs" );
   aConsedResources_.insert("consed.assemblyViewShowGapSpanningFwdRevPairs" );
   aConsedResources_.insert("consed.assemblyViewShowWhichInconsistentFwdRevPairs" );
   aConsedResources_.insert("consed.assemblyViewShowReadDepth" );
   aConsedResources_.insert("consed.assemblyViewShowMultipleHighQualityDiscrepancies" );
   aConsedResources_.insert("consed.assemblyViewShowRestrictionDigestCutSites" );
   aConsedResources_.insert("consed.assemblyViewFilterSequenceMatchesBySize" );
   aConsedResources_.insert("consed.assemblyViewSequenceMatchesMinSize" );
   aConsedResources_.insert("consed.assemblyViewSequenceMatchesMaxSize" );
   aConsedResources_.insert("consed.assemblyViewAutomaticallyStartWithConsed" );
   aConsedResources_.insert("consed.assemblyViewDisplayTheseTagTypesOnTheseLines" );
   aConsedResources_.insert("consed.assemblyViewShowTags" );
   aConsedResources_.insert("consed.autoEditRecalculateHighQualitySegmentsOfReads" );
   aConsedResources_.insert("consed.autoEditConvertCloneEndBasesToXs" );
   aConsedResources_.insert("consed.autoEditTellPhrapNotToOverlapMultiplyDiscrepantReads" );
   aConsedResources_.insert("consed.autoEditTagEditableLowConsensusQualityRegions" );
   aConsedResources_.insert("consed.autoEditMakeFakeRead" );
   aConsedResources_.insert("consed.autoEditMakeFakeReadFromRead1" );
   aConsedResources_.insert("consed.autoEditMakeFakeReadFromRead2" );
   aConsedResources_.insert("consed.autoEditMakeFakeReadName" );
   aConsedResources_.insert("consed.autoEditMakeFakeReadFastaFilename" );
   aConsedResources_.insert("consed.autoEditMergeAssembly" );
   aConsedResources_.insert("consed.autoEditSecondaryAceFile" );
   aConsedResources_.insert("consed.autoEditFixRunsInConsensus" );
   aConsedResources_.insert("consed.showAllTracesJustShowGoodTraces" );
   aConsedResources_.insert("consed.addAlignedSequenceQualityOfBases" );
   aConsedResources_.insert("consed.makeLightBackgroundInAlignedReadsWindowAndTracesWindow" );
   aConsedResources_.insert("consed.putVerticalLineAtCursor" );
   aConsedResources_.insert("consed.putHorizontalLineAtCursor" );
   aConsedResources_.insert("consed.highlightedReadsFile" );
   aConsedResources_.insert("consed.autoReportPrintReadNamesInRegion" );
   aConsedResources_.insert("consed.autoReportPrintReadNamesInRegionContig" );
   aConsedResources_.insert("consed.autoReportPrintReadNamesInRegionLeftPos" );
   aConsedResources_.insert("consed.autoReportPrintReadNamesInRegionRightPos" );
   aConsedResources_.insert("consed.autoReportPrintHighlyDiscrepantRegions" );
   aConsedResources_.insert("consed.autoReportPrintScaffolds" );
   aConsedResources_.insert("consed.numberUnpaddedConsensusAtUserDefined" );
   aConsedResources_.insert("consed.autoReportPrintHighQualityDiscrepancies" );
   aConsedResources_.insert("consed.autoReportHighQualityDiscrepanciesExcludeCompressionOrG_dropoutTags" );
   aConsedResources_.insert("consed.autoReportHighQualityDiscrepanciesExcludeMostPads" );
   aConsedResources_.insert("consed.autoReportPrintLowConsensusQualityRegions" );
   aConsedResources_.insert("consed.autoReportPrintSingleSubcloneRegions" );
   aConsedResources_.insert("consed.autoReportPrintSingleStrandedRegions" );
   aConsedResources_.insert("consed.autoReportPrintLinkingForwardReversePairs" );
   aConsedResources_.insert("consed.autoReportPrintFilteredInconsistentForwardReversePairs" );
   aConsedResources_.insert("consed.autoReportPrintAssemblySummary" );
   aConsedResources_.insert("consed.showAllTracesDoNotShowTraceIfTheseTagsPresent" );
   aConsedResources_.insert("consed.nameOfFakeJoiningReadsIncludesAceFileName" );
   aConsedResources_.insert("consed.whenUserScrollsOffWindowMillisecondsBetweenScrolling" );
   aConsedResources_.insert("consed.whenUserScrollsOffWindowBasesToScrollEachTime" );
   aConsedResources_.insert("consed.compareContigsUseBandedRatherThanFullSmithWaterman" );
   aConsedResources_.insert("consed.compareContigsBandSize" );
   aConsedResources_.insert("consed.assemblyViewShowFwdRevPairDepthsInRedIfOnlyThisMany" );
   aConsedResources_.insert("consed.assemblyViewShowSequenceMatches" );
   aConsedResources_.insert("consed.assemblyViewOKToShowSequenceMatchesBetweenContigs" );
   aConsedResources_.insert("consed.assemblyViewOKToShowSequenceMatchesWithinContigs" );
   aConsedResources_.insert("consed.assemblyViewOKToShowDirectSequenceMatches" );
   aConsedResources_.insert("consed.assemblyViewOKToShowInvertedSequenceMatches" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToAParticularRegion" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToThisContig" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToThisRegionLeft" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToThisRegionRight" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigs" );
   aConsedResources_.insert("consed.assemblyViewOnlyShowSequenceMatchesToEndsOfContigsThisFar" );
   aConsedResources_.insert("consed.defaultReadPrefix" );
   aConsedResources_.insert("consed.readPrefixesFile" );
   aConsedResources_.insert("consed.maxCharsDisplayedForReadPrefix" );
   aConsedResources_.insert("consed.autoFinishDoNotDoPCRIfThisManyAvailableGapSpanningTemplates" );
   aConsedResources_.insert("consed.autoFinishDoNotDoUnorientedPCRIfThisManyOrMoreUnorientedPCRReactions" );
   aConsedResources_.insert("consed.autoFinishDoNotDoOrientedPCRIfGapSizeLargerThanThis" );
   aConsedResources_.insert("consed.autoFinishDoNotDoPCRIfEndIsExtendedByReads" );
   aConsedResources_.insert("consed.autoFinishMaxAcceptableErrorsPerMegabase" );
   aConsedResources_.insert("consed.autoFinishIfNotEnoughFwdRevPairsUseThisPerCentOfInsertSize" );
   aConsedResources_.insert("consed.primersNumberOfBasesToBackUpToStartLooking" );
   aConsedResources_.insert("consed.primersMakePCRPrimersThisManyBasesBackFromEndOfHighQualitySegment" );
   aConsedResources_.insert("consed.primersOKToChoosePrimersInSingleSubcloneRegion" );
   aConsedResources_.insert("consed.primersOKToChoosePrimersWhereHighQualityDiscrepancies" );
   aConsedResources_.insert("consed.primersOKToChoosePrimersWhereUnalignedHighQualityRegion" );
   aConsedResources_.insert("consed.autoFinishCallReversesToFlankGaps" );
   aConsedResources_.insert("consed.autoFinishAllowWholeCloneReads" );
   aConsedResources_.insert("consed.autoFinishAllowCustomPrimerSubcloneReads" );
   aConsedResources_.insert("consed.autoFinishAllowResequencingReads" );
   aConsedResources_.insert("consed.autoFinishAllowResequencingReadsOnlyForRunsAndStops" );
   aConsedResources_.insert("consed.autoFinishAllowDeNovoUniversalPrimerSubcloneReads" );
   aConsedResources_.insert("consed.autoFinishAllowMinilibraries" );
   aConsedResources_.insert("consed.autoFinishAllowPCR" );
   aConsedResources_.insert("consed.autoFinishAllowUnorientedPCRReactions" );
   aConsedResources_.insert("consed.autoFinishAllowResequencingAUniversalPrimerAutofinishRead" );
   aConsedResources_.insert("consed.autoFinishAlwaysCloseGapsUsingMinilibraries" );
   aConsedResources_.insert("consed.autoFinishMaximumFinishingReadLength" );
   aConsedResources_.insert("consed.autoFinishSuggestMinilibraryIfGapThisManyBasesOrLarger" );
   aConsedResources_.insert("consed.autoFinishSuggestSpecialChemistryForRunsAndStops" );
   aConsedResources_.insert("consed.autoFinishSuggestThisManyMinilibrariesPerGap" );
   aConsedResources_.insert("consed.primersWindowSizeInLooking" );
   aConsedResources_.insert("consed.primersAssumeTemplatesAreDoubleStrandedUnlessSpecified" );
   aConsedResources_.insert("consed.alignedReadsWindowInitialCharsWide" );
   aConsedResources_.insert("consed.alignedReadsWindowInitialCharsHigh" );
   aConsedResources_.insert("consed.alignedReadsWindowMaxCharsForReadNames" );
   aConsedResources_.insert("consed.alignedReadsWindowAutomaticallyExpandRoomForReadNames" );
   aConsedResources_.insert("consed.autoFinishAllowResequencingReadsToExtendContigs" );
   aConsedResources_.insert("consed.autoFinishCallHowManyReversesToFlankGaps" );
   aConsedResources_.insert("consed.autoFinishCloseGaps" );
   aConsedResources_.insert("consed.autoFinishContinueEvenThoughReadInfoDoesNotMakeSense" );
   aConsedResources_.insert("consed.autoFinishCostOfResequencingUniversalPrimerSubcloneReaction" );
   aConsedResources_.insert("consed.autoFinishCostOfCustomPrimerSubcloneReaction" );
   aConsedResources_.insert("consed.autoFinishCostOfCustomPrimerCloneReaction" );
   aConsedResources_.insert("consed.autoFinishCostOfDeNovoUniversalPrimerSubcloneReaction" );
   aConsedResources_.insert("consed.autoFinishCostOfMinilibrary" );
   aConsedResources_.insert("consed.autoFinishCoverSingleSubcloneRegions" );
   aConsedResources_.insert("consed.autoFinishCoverLowConsensusQualityRegions" );
   aConsedResources_.insert("consed.autoFinishDebugUniversalPrimerReadsFile" );
   aConsedResources_.insert("consed.autoFinishDebugCustomPrimerReadsFile" );
   aConsedResources_.insert("consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloserThanThisManyBases" );
   aConsedResources_.insert("consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloserThanThisManyBases" );
   aConsedResources_.insert("consed.autoFinishDoNotFinishWhereTheseTagsAre" );
   aConsedResources_.insert("consed.autoFinishDoNotExtendContigsWhereTheseTagsAre" );
   aConsedResources_.insert("consed.autoFinishDoNotExtendContigsIfTagsAreThisCloseToContigEnd" );
   aConsedResources_.insert("consed.dumpContigOrderAndOrientationInfoToThisFile" );
   aConsedResources_.insert("consed.autoFinishDumpTemplates" );
   aConsedResources_.insert("consed.autoFinishExcludeContigIfOnlyThisManyReadsOrLess" );
   aConsedResources_.insert("consed.autoFinishExcludeContigIfDepthOfCoverageGreaterThanThis" );
   aConsedResources_.insert("consed.autoFinishExcludeContigIfThisManyBasesOrLess" );
   aConsedResources_.insert("consed.autoFinishHowManyTemplatesYouIntendToUseForCustomPrimerSubcloneReactions" );
   aConsedResources_.insert("consed.primersMinNumberOfTemplatesForPrimers" );
   aConsedResources_.insert("consed.autoFinishMinBaseOverlapBetweenAReadAndHighQualitySegmentOfConsensus" );
   aConsedResources_.insert("consed.autoFinishNumberOfVectorBasesAtBeginningOfAUniveralPrimerRead" );
   aConsedResources_.insert("consed.autoFinishCDNANotGenomic" );
   aConsedResources_.insert("consed.autoFinishConfidenceThatReadWillCoverSingleSubcloneRegion" );
   aConsedResources_.insert("consed.autoFinishPrintForwardOrReverseStrandWhenPrintingSubcloneTemplatesForCustomPrimerReads" );
   aConsedResources_.insert("consed.autoFinishPrintMinilibrariesSummaryFile" );
   aConsedResources_.insert("consed.autoFinishNearGapsSuggestEachMissingReadOfReadPairs" );
   aConsedResources_.insert("consed.autoFinishDoNotIgnoreLCQIfThisManyBasesFromEndOfContigForLCQTagger" );
   aConsedResources_.insert("consed.checkIfTooManyWalks" );
   aConsedResources_.insert("consed.numberOfColumnsBeforeReadNameInAlignedReadsWindow" );
   aConsedResources_.insert("consed.compareContigsAlignsThisManyBasesMax" );
   aConsedResources_.insert("consed.compressedChromatExtension" );
   aConsedResources_.insert("consed.dimLowQualityEndsOfReads" );
   aConsedResources_.insert("consed.dimUnalignedEndsOfReads" );
   aConsedResources_.insert("consed.fakeReadsSpecifiedByFilenameExtension" );
   aConsedResources_.insert("consed.fullPathnameOfAddReads2ConsedScript" );
   aConsedResources_.insert("consed.fullPathnameOfFixContigEndScript" );
   aConsedResources_.insert("consed.fixContigEndsCleanUpTemporaryFiles" );
   aConsedResources_.insert("consed.fixContigEndsMinSmithWatermanScoreToMakeJoin" );
   aConsedResources_.insert("consed.fixContigEndsMinNumberOfReadsInContig" );
   aConsedResources_.insert("consed.fullPathnameOfCrossMatch" );
   aConsedResources_.insert("consed.fullPathnameOfPhred" );
   aConsedResources_.insert("consed.fullPathnameOfMiniassemblyScript" );
   aConsedResources_.insert("consed.gunzipFullPath" );
   aConsedResources_.insert("consed.fullPathnameOfFilter454ReadsScript" );
   aConsedResources_.insert("consed.filter454ReadsAgainstThis" );
   aConsedResources_.insert("consed.454LinkerSequences" );
   aConsedResources_.insert("consed.hideSomeTagTypesAtStartup" );
   aConsedResources_.insert("consed.maximumNumberOfTracesShown" );
   aConsedResources_.insert("consed.navigateAutomaticTracePopup" );
   aConsedResources_.insert("consed.navigateAutomaticAllTracesPopup" );
   aConsedResources_.insert("consed.primersMinimumLengthOfAPrimer" );
   aConsedResources_.insert("consed.primersMaximumLengthOfAPrimer" );
   aConsedResources_.insert("consed.primersMinimumLengthOfAPrimerForPCR" );
   aConsedResources_.insert("consed.primersMaximumLengthOfAPrimerForPCR" );
   aConsedResources_.insert("consed.primersMaxMeltingTempDifferenceForPCR" );
   aConsedResources_.insert("consed.primersMaxPCRPrimerPairsToDisplay" );
   aConsedResources_.insert("consed.primersCheckJustSomePCRPrimerPairsRatherThanAll" );
   aConsedResources_.insert("consed.primersNumberOfTemplatesToDisplayInFront" );
   aConsedResources_.insert("consed.primersMaxLengthOfMononucleotideRepeat" );
   aConsedResources_.insert("consed.primersBadLibrariesFile" );
   aConsedResources_.insert("consed.primersLibrariesInfoFile" );
   aConsedResources_.insert("consed.primersBadTemplatesFile" );
   aConsedResources_.insert("consed.primersChooseTemplatesByPositionInsteadOfQuality" );
   aConsedResources_.insert("consed.primersWhenChoosingATemplateMinPotentialReadLength" );
   aConsedResources_.insert("consed.primersWindowSizeInLookingForPCR" );
   aConsedResources_.insert("consed.qualityThresholdForFindingHighQualityDiscrepancies" );
   aConsedResources_.insert("consed.qualityThresholdForNavigateByDepthOfCoverage" );
   aConsedResources_.insert("consed.navigateByHighDepthOfCoverageNotLow" );
   aConsedResources_.insert("consed.MinDepthForNavigateByDepthOfCoverage" );
   aConsedResources_.insert("consed.defaultVectorPathnameForRestrictionFragments" );
   aConsedResources_.insert("consed.fileOfAdditionalRestrictionEnzymes" );
   aConsedResources_.insert("consed.commonRestrictionEnzymes" );
   aConsedResources_.insert("consed.defaultSelectedRestrictionEnzymes" );
   aConsedResources_.insert("consed.restrictionEnzymesActualFragmentsFile" );
   aConsedResources_.insert("consed.restrictionDigestInitialWindowSizeInTextRows" );
   aConsedResources_.insert("consed.restrictionDigestDoNoShowAreaOfFragmentsOverThisSize" );
   aConsedResources_.insert("consed.showReadsAlphabetically" );
   aConsedResources_.insert("consed.showReadsInAlignedReadsWindowOrderedByFile" );
   aConsedResources_.insert("consed.showReadsInAlignedReadsWindowOrderedByThisFile" );
   aConsedResources_.insert("consed.showReadsAtCursorSortedHow" );
   aConsedResources_.insert("consed.showABIBasesInTraceWindow" );
   aConsedResources_.insert("consed.tracesWindowInitialPixelHeight" );
   aConsedResources_.insert("consed.assemblyViewWindowInitialPixelHeight" );
   aConsedResources_.insert("consed.assemblyViewFileOfTemplatesToNotShow" );
   aConsedResources_.insert("consed.assemblyViewCrossMatchMinmatch" );
   aConsedResources_.insert("consed.assemblyViewCrossMatchMinscore" );
   aConsedResources_.insert("consed.assemblyViewFindSequenceMatchesForConsedScript" );
   aConsedResources_.insert("consed.assemblyViewCrossmatchMinmatch" );
   aConsedResources_.insert("consed.assemblyViewCrossmatchMinscore" );
   aConsedResources_.insert("consed.assemblyViewSequenceMatchesMinimumSimilarity" );
   aConsedResources_.insert("consed.tracesWindowInitialPixelWidth" );
   aConsedResources_.insert("consed.assemblyViewWindowInitialPixelWidth" );
   aConsedResources_.insert("consed.automaticallyScaleTraces" );
   aConsedResources_.insert("consed.automaticallyScaleTracesSamplePeakHeightFractionOfWindowHeight" );
   aConsedResources_.insert("consed.automaticallyScaleTracesSamplePeakPercentile" );
   aConsedResources_.insert("consed.verticalTraceMagnification" );
   aConsedResources_.insert("consed.userDefinedKeys" );
   aConsedResources_.insert("consed.programsForUserDefinedKeys" );
   aConsedResources_.insert("consed.argumentsToPassToUserDefinedPrograms" );
   aConsedResources_.insert("consed.tagsToApplyWithUserDefinedKeys" );
   aConsedResources_.insert("consed.snpGenomeUseInsertionPolymorphisms" );
   aConsedResources_.insert("consed.listOfTagTypesToHide" );
   aConsedResources_.insert("consed.listOfOptionalWordsToSaveInListOfReadNames" );
   aConsedResources_.insert("consed.extendConsensusWithHighQuality" );
   aConsedResources_.insert("consed.fastStartup" );
   aConsedResources_.insert("consed.fastStartupFile" );
   aConsedResources_.insert("consed.alwaysRunProgramToGetChromats" );
   aConsedResources_.insert("consed.programToRunToGetChromats" );
   aConsedResources_.insert("consed.programToRunToGetChromatsOf454Reads" );
   aConsedResources_.insert("consed.createFakeChromatsForSolexaReads" );
   aConsedResources_.insert("consed.autoFinishUseLongModelReadRatherThanShort" );
   aConsedResources_.insert("consed.askAgainIfWantToQuitConsedIfThisManyReads" );
   aConsedResources_.insert("consed.printWindowInstructions" );
   aConsedResources_.insert("consed.allowMultipleSearchForStringWindows" );
   aConsedResources_.insert("consed.autoPCRAmplifyFalseProductsOKIfLargerThanThis" );
   aConsedResources_.insert("consed.autoPCRAmplifyMakePrimerOutOfFirstRegion" );
   aConsedResources_.insert("consed.autoPCRAmplifyMaybeRejectPrimerIfThisCloseToDesiredProduct" );
   aConsedResources_.insert("consed.addNewReadsRecalculateConsensusQuality" );
   aConsedResources_.insert("consed.addNewReadsPutReadIntoItsOwnContig" );
   aConsedResources_.insert("consed.addNewReadsCheckThatCrossMatchRunCorrectly" );
   aConsedResources_.insert("consed.assemblyViewNumberOfRowsOfTags" );
   aConsedResources_.insert("consed.warnUserWhenTryingToEditAllReads" );
   aConsedResources_.insert("consed.maybeXKEYSYMDBPath" );
   aConsedResources_.insert("consed.maybeXKEYSYMDBPath2" );
   aConsedResources_.insert("consed.amountToMoveWithBigLeftAndRightArrows" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsMinDiscrepantReads" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsMaxDepthOfCoverage" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsIgnoreBasesBelowThisQuality" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsJustListIndels" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsIgnoreOtherReadsStartingAtSameLocation" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsIgnoreIfListedBasesInConsensus" );
   aConsedResources_.insert("consed.navigateByHighlyDiscrepantPositionsIgnoreIfTheseBasesInConsensus" );
   aConsedResources_.insert("consed.phdBallDirectory" );
   aConsedResources_.insert("consed.newAceFileFOF" );
   aConsedResources_.insert("consed.navigateByHighOrLowDepthCoalesceRegionsIfThisClose" );
   aConsedResources_.insert("consed.removeReadsDeleteNotJustPutInOwnContig" );
   aConsedResources_.insert("consed.paired454LeftReadExtension" );
   aConsedResources_.insert("consed.paired454RightReadExtension" );
   aConsedResources_.insert("consed.snpGenome1MSnps" );
   aConsedResources_.insert("consed.diffChromosomesExcludeDeletions" );
   aConsedResources_.insert("consed.snpGenomeFilterByWeight" );
   aConsedResources_.insert("consed.wantReadsUpToThisFarFromSnps" );
   aConsedResources_.insert("consed.phaster2PhdBallSaveWhichMate" );
   aConsedResources_.insert("consed.phaster2PhdBallSaveInPhasterFormat" );
   aConsedResources_.insert("consed.phaster2PhdBallCalculateNewLocationsFile" );
   aConsedResources_.insert("consed.phdBall2FastaIgnoreLowQualityReads" );
   aConsedResources_.insert("consed.phdBall2FastaLowestAverageQuality" );
   aConsedResources_.insert("consed.nextPhredPipelineControlFile" );
   aConsedResources_.insert("consed.nextPhredPipelineTiffPerlScript" );
   aConsedResources_.insert("consed.nextPhredPipelinePhasterPerlScript" );
   aConsedResources_.insert("consed.nextPhredPipelineVersion" );
   aConsedResources_.insert("consed.nextPhredPipelineMainDirectory" );
   aConsedResources_.insert("consed.maxNumberOfReadsPerPhdBall" );
   aConsedResources_.insert("consed.userWantsToSaveToThisAceFile" );
   aConsedResources_.insert("consed.autoFinishEmulate9_66Behavior" );
   aConsedResources_.insert("consed.primersPCRPrimersGroupedIntoWindowOfThisManyBases" );
   aConsedResources_.insert("consed.primersLookForThisManyPCRPrimerPairsPerPairOfGroups" );
   aConsedResources_.insert("consed.autoFinishStandardDeviationsFromMeanFromGapToLookForTemplatesForSuggestingEachMissingReadOfReadPairs" );
   aConsedResources_.insert("consed.autoFinishCheckThatReadsFromTheSameTemplateAreConsistent" );
   aConsedResources_.insert("consed.autoFinishDoNotAllowSubcloneCustomPrimerReadsCloseTogether" );
   aConsedResources_.insert("consed.autoFinishDoNotAllowWholeCloneCustomPrimerReadsCloseTogether" );
   aConsedResources_.insert("consed.autoFinishMinilibrariesPreferTemplateIfSizeThisManyStdDevsFromMean" );
   aConsedResources_.insert("consed.autoFinishMinNumberOfForwardReversePairsInLibraryToCalculateAverageInsertSize" );
   aConsedResources_.insert("consed.autoFinishIfEnoughFwdRevPairsUseThisManyStdDevBelowMeanForInsertSize" );
   aConsedResources_.insert("consed.autoFinishNewCustomPrimerReadThisFarFromOldCustomPrimerRead" );
   aConsedResources_.insert("consed.autoFinishMinNumberOfSingleSubcloneBasesFixedByAnExp" );
   aConsedResources_.insert("consed.autoFinishNumberOfBasesBetweenContigsAssumed" );
   aConsedResources_.insert("consed.autoFinishPotentialHighQualityPartOfReadStart" );
   aConsedResources_.insert("consed.autoFinishPotentialHighQualityPartOfReadEnd" );
   aConsedResources_.insert("consed.autoFinishPrintCustomNavigationFileForChosenReads" );
   aConsedResources_.insert("consed.autoFinishReversesForFlankingGapsTemplateMustProtrudeFromContigThisMuch" );
   aConsedResources_.insert("consed.autoFinishTagOligosWhenDoExperiments" );
   aConsedResources_.insert("consed.countPads" );
   aConsedResources_.insert("consed.debugging" );
   aConsedResources_.insert("consed.debugging2" );
   aConsedResources_.insert("consed.debugging3" );
   aConsedResources_.insert("consed.debuggingString" );
   aConsedResources_.insert("consed.ignoreHighQualityDiscrepanciesThisManyBasesFromEndOfAlignedRegion" );
   aConsedResources_.insert("consed.ignoreUnalignedHighQualitySegmentsShorterThanThis" );
   aConsedResources_.insert("consed.primersLookThisFarForForwardVectorInsertJunction" );
   aConsedResources_.insert("consed.primersDNAConcentrationNanomolar" );
   aConsedResources_.insert("consed.primersMaxMatchElsewhereScore" );
   aConsedResources_.insert("consed.primersMaxMatchElsewhereScoreForPCR" );
   aConsedResources_.insert("consed.primersMaxSelfMatchScore" );
   aConsedResources_.insert("consed.primersMaxPrimerDimerScoreForPCR" );
   aConsedResources_.insert("consed.primersMinQuality" );
   aConsedResources_.insert("consed.primersPrintInfoOnRejectedTemplates" );
   aConsedResources_.insert("consed.primersSaltConcentrationMillimolar" );
   aConsedResources_.insert("consed.primersScreenForVector" );
   aConsedResources_.insert("consed.primersToleranceForDifferentBeginningLocationOfUniversalPrimerReads" );
   aConsedResources_.insert("consed.primersTooManyVectorBasesInWalkingRead" );
   aConsedResources_.insert("consed.qualityThresholdForLowConsensusQuality" );
   aConsedResources_.insert("consed.tagColorPerCentOfBase" );
   aConsedResources_.insert("consed.uncompressedChromatDirectory" );
   aConsedResources_.insert("consed.454sff2scfDirectory" );
   aConsedResources_.insert("consed.whenMakingFakeReadToJoinContigsAddThisManyBasesOnEitherSideOfAlignedRegion" );
   aConsedResources_.insert("consed.writeThisAceFormat" );
   aConsedResources_.insert("consed.dumpCoreIfBoundsError" );
   aConsedResources_.insert("consed.autoFinishMinSmithWatermanScoreOfARun" );
   aConsedResources_.insert("consed.autoFinishDoNotComparePCRPrimersMoreThanThisManyTimes" );
   aConsedResources_.insert("consed.restrictionDigestMaximumBasesToCompareToVector" );
   aConsedResources_.insert("consed.restrictionDigestZoomFactor" );
   aConsedResources_.insert("consed.restrictionDigestZoomFactorForNavigate" );
   aConsedResources_.insert("consed.restrictionDigestToleranceInPositionUnits" );
   aConsedResources_.insert("consed.autoPCRAmplifyTooManySeriousFalseMatches" );
   aConsedResources_.insert("consed.assemblyViewZoomFactor" );
   aConsedResources_.insert("consed.assemblyViewFilterInconsistentFwdRevPairsIfThisClose" );
   aConsedResources_.insert("consed.assemblyViewGridCellWidthInPixels" );
   aConsedResources_.insert("consed.assemblyViewCursorSensitivityInPixels" );
   aConsedResources_.insert("consed.assemblyViewReadDepthQuality" );
   aConsedResources_.insert("consed.showAllTracesMaxNumberOfTracesToShowAtOnce" );
   aConsedResources_.insert("consed.allowFwdRevPairScaffoldsToBeMergedIfThisManyBasesIntersectionOrLess" );
   aConsedResources_.insert("consed.justForPrimateProject" );
   aConsedResources_.insert("consed.solexaFilesAreAssumedToBeHere" );
   aConsedResources_.insert("consed.solexaAlignmentFilesPerInsertingPadsCycle" );
   aConsedResources_.insert("consed.solexaAlignmentsPerAlignmentFile" );
   aConsedResources_.insert("consed.solexaFastqFilesArePhredQualityNotSolexaQuality" );
   aConsedResources_.insert("consed.solexa64FastqOrSanger33Fastq" );
   aConsedResources_.insert("consed.maximumReadsInReadList" );
   aConsedResources_.insert("consed.maxLengthOfReadsInapLocatedFragment2" );
   aConsedResources_.insert("consed.maximumStartupErrorsToReport" );
   aConsedResources_.insert("consed.454LinkerAlignmentMatchScore" );
   aConsedResources_.insert("consed.454LinkerAlignmentMismatchScore" );
   aConsedResources_.insert("consed.454LinkerAlignmentIndelScore" );
   aConsedResources_.insert("consed.filter454ReadsDeleteCrossMatchOutput" );
   aConsedResources_.insert("consed.autoReportAllNeededSpeciesCode" );
   aConsedResources_.insert("consed.autoReportUseCommasInBigNumbers" );
   aConsedResources_.insert("consed.autoReportPrintToCompareToReich" );
   aConsedResources_.insert("consed.autoReportOnlyAllowSitesThatAreBetweenAcceptableSites" );
   aConsedResources_.insert("consed.autoReportDeaminationMutationsDeterminedByMoreAccurateMethod" );
   aConsedResources_.insert("consed.autoReportChooseTreesUsingBadData" );
   aConsedResources_.insert("consed.autoReportChooseTreesByCountingDeaminationMutations" );
   aConsedResources_.insert("consed.autoReportChooseTreesUsingKimura" );
   aConsedResources_.insert("consed.autoReportPrintCrudeChimpHumanMutations" );
   aConsedResources_.insert("consed.autoReportPrintPositionsForGraham" );
   aConsedResources_.insert("consed.autoReportPrintAncestralCpGs" );
   aConsedResources_.insert("consed.autoReportPrintCpGMutations" );
   aConsedResources_.insert("consed.autoReportPrintMutationsWithContext" );
   aConsedResources_.insert("consed.autoReportCountAllMutationsML" );
   aConsedResources_.insert("consed.autoReportCountAllMutations" );
   aConsedResources_.insert("consed.autoReportIgnoreMultipleTrees" );
   aConsedResources_.insert("consed.autoReportCountAcceptableColumnsWithNoneOnLeft" );
   aConsedResources_.insert("consed.autoReportPrintFlankedColumns4" );
   aConsedResources_.insert("consed.autoReportUseAnnotationFormat" );
   aConsedResources_.insert("consed.autoReportPrintFlankedColumns3" );
   aConsedResources_.insert("consed.autoReportPrintFlankedColumns2" );
   aConsedResources_.insert("consed.autoReportPrintFlankedColumns" );
   aConsedResources_.insert("consed.autoReportHighQualitySegmentData" );
   aConsedResources_.insert("consed.autoReportGoodReadsBug" );
   aConsedResources_.insert("consed.autoReportDiscrepancyRateInFlankedRegions" );
   aConsedResources_.insert("consed.autoReportDiscrepancyRateInFlankedRegions2" );
   aConsedResources_.insert("consed.autoReportDiscrepancyRateInFlankedRegions4" );
   aConsedResources_.insert("consed.autoReportDiscrepancyRateInFlankedRegions5" );
   aConsedResources_.insert("consed.autoReportSingleSignalOrQuality" );
   aConsedResources_.insert("consed.autoReportLowQualityBasesInHQS" );
   aConsedResources_.insert("consed.autoReportCompareHQSWithLQS" );
   aConsedResources_.insert("consed.autoReportCountColumnsForGroupsOfSpecies" );
   aConsedResources_.insert("consed.autoReportSingleSignalInfo" );
   aConsedResources_.insert("consed.autoReportSingleSignalInfo2" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrands" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrandsNoHuman" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrands2" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrands3" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrands4" );
   aConsedResources_.insert("consed.autoReportTopStrandPinnedPosition" );
   aConsedResources_.insert("consed.autoReportBottomStrandPinnedPosition" );
   aConsedResources_.insert("consed.autoReportCompareTopAndBottomStrandsWithHuman" );
   aConsedResources_.insert("consed.autoReportPrintLengthsOfAlignedSegmentsOfReads" );
   aConsedResources_.insert("consed.autoReportPrintLengthsOfUnalignedHighQualitySegmentsOfReads" );
   aConsedResources_.insert("consed.autoReportPrintIfReadsAreCorrectlyAligned" );
   aConsedResources_.insert("consed.autoReportCalculateErrorProbabilitiesByComparingPTroPPan" );
   aConsedResources_.insert("consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies" );
   aConsedResources_.insert("consed.autoReportPrintAgreeDisagreeBetweenPairsOfSpecies2" );
   aConsedResources_.insert("consed.autoReportFilterSingleSignal" );
   aConsedResources_.insert("consed.autoReportGoodHitReads" );
   aConsedResources_.insert("consed.autoReportQualityWindowLow" );
   aConsedResources_.insert("consed.autoReportQualityWindowHigh" );
   aConsedResources_.insert("consed.autoReportPrintNumberOfIsolatedPadsForEachSpecies" );
   aConsedResources_.insert("consed.autoReportPrintNumberOfIsolatedPads" );
   aConsedResources_.insert("consed.autoReportIsolatedPadsOfReadsWithThisPattern" );
   aConsedResources_.insert("consed.autoReportMinNumberOfPerfectlyAlignedBasesBeforeDiscrepancy" );
   aConsedResources_.insert("consed.autoReportMaxSizeOfDiscrepantRegion" );
   aConsedResources_.insert("consed.autoReportSizeOfDiscrepantRegion" );
   aConsedResources_.insert("consed.autoReportPrintMinimumQualityHistogram" );
   aConsedResources_.insert("consed.autoReportPrintDiscrepantRegions" );
   aConsedResources_.insert("consed.autoReportPrintBasesInDiscrepantRegions" );
   aConsedResources_.insert("consed.autoReportPrintDiscrepantRegionsButIgnoreReadsContainingThis" );
   aConsedResources_.insert("consed.autoReportBackboneReadHasThisStringInIt" );
   aConsedResources_.insert("consed.autoReportPrintDiscrepantRegionsButOnlyIfAboveQualityThreshold" );
   aConsedResources_.insert("consed.autoReportPrintSpeciesAlignment" );
   aConsedResources_.insert("consed.autoReportPrintReadAlignment" );
   aConsedResources_.insert("consed.autoReportPrintTheseReads" );
   aConsedResources_.insert("consed.autoReportPrintReadPositions" );
   aConsedResources_.insert("consed.autoReportPrintChosenReadName" );
   aConsedResources_.insert("consed.autoReportNumbersOfCharactersOfChosenReadNameToBePrinted" );
   aConsedResources_.insert("consed.autoReportPrefix" );
   aConsedResources_.insert("consed.autoReportUseOldCriteriaForDeletingColumnsOfPads" );
   aConsedResources_.insert("consed.autoReportDeleteColumnsOfPadsBeforeAdjustingReadQualityValues" );
   aConsedResources_.insert("consed.autoReportFlankingBasesMustBeSingleSignal" );
   aConsedResources_.insert("consed.autoReportMinimumQualityOfFlankingBases" );
   aConsedResources_.insert("consed.autoReportFlankingBasesMustBeInHighQualitySegment" );
   aConsedResources_.insert("consed.autoReportSpecies" );
   for( int nResource = 0; nResource < aConsedResources_.length(); ++nResource ) {
      aConsedResources_[ nResource ].toLower();
   }



}