Index: src/sans/perspectives/fitting/basepage.py
===================================================================
--- src/sans/perspectives/fitting/basepage.py	(revision 27b7accfe21e1b3456e646ee01adff844993eae3)
+++ src/sans/perspectives/fitting/basepage.py	(revision 116e1a745c824ae90452a0a866bede4b161d79f5)
@@ -172,6 +172,10 @@
         self.orientation_params = []
         self.orientation_params_disp = []
-        if self.model != None:
-            self.disp_list = self.model.getDispParamList()
+#       Self.model should ALWAYS be None here.  It was set to none above in 
+#       this long init setting.  no obvious function call in between setting
+#       and this - commenting out on 4/8/2014 by PDB.  Remove once clear 
+#       it is pointless.
+#        if self.model != None:
+#            self.disp_list = self.model.getDispParamList()
         self.temp_multi_functional = False
         ##enable model 2D draw
@@ -481,4 +485,12 @@
         set some page important information at once
         """
+#       THIS METHOD/FUNCTION NO LONGE APPEARS TO BE CALLED.  Started up program 
+#       and started new fit window and PR and Invariant and a fit in fitting
+#       but never entered this routine which should be an initialization
+#       routine.  Leave for a while but probably something to clean up at 
+#       some point?
+#
+#       PDB April 13 2014
+#
         ##window_name
         self.window_name = page_info.window_name
@@ -626,8 +638,22 @@
             return
         if len(self.model_list_box) > 0:
-            self._populate_box(self.formfactorbox,
-                               self.model_list_box["Shapes"])
-       
-        if len(self.model_list_box) > 0:
+        ## This is obsolete code since form factor box is no longer static.
+        ## It is now set dynamically through _show_combox and _show_combos_helper
+        ## These are called for first time by formfactor_combo_init
+        ## itself called from fitpanel only.  If we find that I'm wrong and
+        ## we DO need to initialize somehow here - do it by a call to 
+        ## formfactor_combo_init 
+        ## self.formfator_combo_init()
+        ## BUT NOT HERE -- make it last line of this 
+        ## method so that structure box is populated before _show_comboox_helper
+        ## is called.  Otherwise wx will complain mightily:-)
+        ##
+        ## Also change the name to initiatlize_structurebox along with changes
+        ## to other combobox methods (_populate_listbox --> _populate_categorybox
+        ## etc )
+        ##
+        ##     PDB 4/26/2014
+#            self._populate_box(self.formfactorbox,
+#                               self.model_list_box["Shapes"])
             self._populate_box(self.structurebox,
                                 self.model_list_box["Structure Factors"])
@@ -644,4 +670,5 @@
                 self.structurebox.Enable()
                 self.text2.Enable()
+
                 
     def set_dispers_sizer(self):
@@ -1836,122 +1863,129 @@
                               [max_state, max_value], unit])
            
-    def _set_model_sizer_selection(self, model):
-        """
-        Display the sizer according to the type of the current model
-        """
-        if model == None:
-            return
-        if hasattr(model, "s_model"):
-            
-            class_name = model.s_model.__class__
-            name = model.s_model.name
-            flag = (name != "NoStructure")
-            if flag and \
-                (class_name in self.model_list_box["Structure Factors"]):
-                self.structurebox.Show()
-                self.text2.Show()
-                self.structurebox.Enable()
-                self.text2.Enable()
-                items = self.structurebox.GetItems()
-                self.sizer1.Layout()
-                
-                for i in range(len(items)):
-                    if items[i] == str(name):
-                        self.structurebox.SetSelection(i)
-                        break
-                    
-        if hasattr(model, "p_model"):
-            class_name = model.p_model.__class__
-            name = model.p_model.name
-            self.formfactorbox.Clear()
-            
-            for k, list in self.model_list_box.iteritems():
-                if k in["P(Q)*S(Q)", "Shapes"] and \
-                    class_name in self.model_list_box["Shapes"]:
-                    self.shape_rbutton.SetValue(True)
+#    The following funcion seems to be superseded with fillsizer and 
+#    init combo box.  certainly it seems not to know about categories and uses 
+#    only shapes and shape independent -- tested after commenting out and does
+#    not seem to cause problem.  Leave commented out for now but delete in
+#    a code cleanup once clear it really is no longer used.
+#    PDB  8 April 2014
+
+#    def _set_model_sizer_selection(self, model):
+#        """
+#        Display the sizer according to the type of the current model
+#        """
+#        if model == None:
+#            return
+#        if hasattr(model, "s_model"):
+#            
+#            class_name = model.s_model.__class__
+#            name = model.s_model.name
+#            flag = (name != "NoStructure")
+#            if flag and \
+#                (class_name in self.model_list_box["Structure Factors"]):
+#                self.structurebox.Show()
+#                self.text2.Show()
+#                self.structurebox.Enable()
+#               self.text2.Enable()
+ #               items = self.structurebox.GetItems()
+ #               self.sizer1.Layout()
+ #               
+ #               for i in range(len(items)):
+ #                   if items[i] == str(name):
+ #                       self.structurebox.SetSelection(i)
+ #                       break
+ #                   
+ #       if hasattr(model, "p_model"):
+ #           class_name = model.p_model.__class__
+ #           name = model.p_model.name
+ #           self.formfactorbox.Clear()
+ #           
+ #           for k, list in self.model_list_box.iteritems():
+ #               if k in["P(Q)*S(Q)", "Shapes"] and \
+ #                   class_name in self.model_list_box["Shapes"]:
+ #                   self.shape_rbutton.SetValue(True)
+ #                   ## fill the form factor list with new model
+ #                   self._populate_box(self.formfactorbox,
+ #                                      self.model_list_box["Shapes"])
+ #                   items = self.formfactorbox.GetItems()
+ #                   ## set comboxbox to the selected item
+ #                   for i in range(len(items)):
+ #                       if items[i] == str(name):
+ #                           self.formfactorbox.SetSelection(i)
+ #                           break
+ #                   return
+ #               elif k == "Shape-Independent":
+ #                   self.shape_indep_rbutton.SetValue(True)
+ #               elif k == "Structure Factors":
+ #                   self.struct_rbutton.SetValue(True)
+ #               elif k == "Multi-Functions":
+ #                   continue
+ #               else:
+ #                   self.plugin_rbutton.SetValue(True)
+ #              
+ #               if class_name in list:
+ #                   ## fill the form factor list with new model
+ #                   self._populate_box(self.formfactorbox, list)
+ #                   items = self.formfactorbox.GetItems()
+ #                   ## set comboxbox to the selected item
+ #                   for i in range(len(items)):
+ #                       if items[i] == str(name):
+ #                           self.formfactorbox.SetSelection(i)
+ #                           break
+ #                   break
+ #       else:
+            ## Select the model from the menu
+#            class_name = model.__class__
+#            name = model.name
+#            self.formfactorbox.Clear()
+#            items = self.formfactorbox.GetItems()
+#    
+#            for k, list in self.model_list_box.iteritems():
+#                if k in["P(Q)*S(Q)", "Shapes"] and \
+#                    class_name in self.model_list_box["Shapes"]:
+#                    if class_name in self.model_list_box["P(Q)*S(Q)"]:
+#                        self.structurebox.Show()
+#                        self.text2.Show()
+#                       self.structurebox.Enable()
+#                       self.structurebox.SetSelection(0)
+#                       self.text2.Enable()
+#                   else:
+#                        self.structurebox.Hide()
+#                        self.text2.Hide()
+#                        self.structurebox.Disable()
+#                        self.structurebox.SetSelection(0)
+#                        self.text2.Disable()
+#                        
+#                    self.shape_rbutton.SetValue(True)
                     ## fill the form factor list with new model
-                    self._populate_box(self.formfactorbox,
-                                       self.model_list_box["Shapes"])
-                    items = self.formfactorbox.GetItems()
+#                    self._populate_box(self.formfactorbox,
+#                                       self.model_list_box["Shapes"])
+#                    items = self.formfactorbox.GetItems()
+#                    ## set comboxbox to the selected item
+#                    for i in range(len(items)):
+#                        if items[i] == str(name):
+#                            self.formfactorbox.SetSelection(i)
+#                            break
+#                    return
+#                elif k == "Shape-Independent":
+#                    self.shape_indep_rbutton.SetValue(True)
+#                elif k == "Structure Factors":
+#                    self.struct_rbutton.SetValue(True)
+#                elif k == "Multi-Functions":
+#                    continue
+#                else:
+#                    self.plugin_rbutton.SetValue(True)
+#                if class_name in list:
+#                    self.structurebox.SetSelection(0)
+#                    self.structurebox.Disable()
+#                    self.text2.Disable()
+                    ## fill the form factor list with new model
+#                    self._populate_box(self.formfactorbox, list)
+#                    items = self.formfactorbox.GetItems()
                     ## set comboxbox to the selected item
-                    for i in range(len(items)):
-                        if items[i] == str(name):
-                            self.formfactorbox.SetSelection(i)
-                            break
-                    return
-                elif k == "Shape-Independent":
-                    self.shape_indep_rbutton.SetValue(True)
-                elif k == "Structure Factors":
-                    self.struct_rbutton.SetValue(True)
-                elif k == "Multi-Functions":
-                    continue
-                else:
-                    self.plugin_rbutton.SetValue(True)
-               
-                if class_name in list:
-                    ## fill the form factor list with new model
-                    self._populate_box(self.formfactorbox, list)
-                    items = self.formfactorbox.GetItems()
-                    ## set comboxbox to the selected item
-                    for i in range(len(items)):
-                        if items[i] == str(name):
-                            self.formfactorbox.SetSelection(i)
-                            break
-                    break
-        else:
-            ## Select the model from the menu
-            class_name = model.__class__
-            name = model.name
-            self.formfactorbox.Clear()
-            items = self.formfactorbox.GetItems()
-    
-            for k, list in self.model_list_box.iteritems():
-                if k in["P(Q)*S(Q)", "Shapes"] and \
-                    class_name in self.model_list_box["Shapes"]:
-                    if class_name in self.model_list_box["P(Q)*S(Q)"]:
-                        self.structurebox.Show()
-                        self.text2.Show()
-                        self.structurebox.Enable()
-                        self.structurebox.SetSelection(0)
-                        self.text2.Enable()
-                    else:
-                        self.structurebox.Hide()
-                        self.text2.Hide()
-                        self.structurebox.Disable()
-                        self.structurebox.SetSelection(0)
-                        self.text2.Disable()
-                        
-                    self.shape_rbutton.SetValue(True)
-                    ## fill the form factor list with new model
-                    self._populate_box(self.formfactorbox,
-                                       self.model_list_box["Shapes"])
-                    items = self.formfactorbox.GetItems()
-                    ## set comboxbox to the selected item
-                    for i in range(len(items)):
-                        if items[i] == str(name):
-                            self.formfactorbox.SetSelection(i)
-                            break
-                    return
-                elif k == "Shape-Independent":
-                    self.shape_indep_rbutton.SetValue(True)
-                elif k == "Structure Factors":
-                    self.struct_rbutton.SetValue(True)
-                elif k == "Multi-Functions":
-                    continue
-                else:
-                    self.plugin_rbutton.SetValue(True)
-                if class_name in list:
-                    self.structurebox.SetSelection(0)
-                    self.structurebox.Disable()
-                    self.text2.Disable()
-                    ## fill the form factor list with new model
-                    self._populate_box(self.formfactorbox, list)
-                    items = self.formfactorbox.GetItems()
-                    ## set comboxbox to the selected item
-                    for i in range(len(items)):
-                        if items[i] == str(name):
-                            self.formfactorbox.SetSelection(i)
-                            break
-                    break
+#                    for i in range(len(items)):
+#                        if items[i] == str(name):
+#                            self.formfactorbox.SetSelection(i)
+#                            break
+#                    break
                 
     def _draw_model(self, update_chisqr=True, source='model'):
Index: src/sans/perspectives/fitting/models.py
===================================================================
--- src/sans/perspectives/fitting/models.py	(revision 201af9f481a69dc31baac2847a064fb4036d1223)
+++ src/sans/perspectives/fitting/models.py	(revision 116e1a745c824ae90452a0a866bede4b161d79f5)
@@ -47,5 +47,5 @@
     
     """
-    #Check is the plugin is of type Model1DPlugin
+    #Check if the plugin is of type Model1DPlugin
     if not issubclass(model, Model1DPlugin):
         msg = "Plugin %s must be of type Model1DPlugin \n" % str(name)
@@ -243,19 +243,19 @@
     ## external dict for models
     model_combobox = ModelList()
-    ## Dictionary of form models
+    ## Dictionary of form factor models
     form_factor_dict = {}
-    ## dictionary of other
+    ## dictionary of structure factor models
     struct_factor_dict = {}
-    ##list of form factors
-    shape_list = []
-    ## independent shape model list
-    shape_indep_list = []
+    ##list of shape models -- this is superseded by categories 
+#    shape_list = []
+    ## shape independent model list-- this is superseded by categories
+#    shape_indep_list = []
     ##list of structure factors
     struct_list = []
-    ##list of model allowing multiplication
+    ##list of model allowing multiplication by a structure factor
     multiplication_factor = []
-    ##list of multifunctional shapes
+    ##list of multifunctional shapes (i.e. that have user defined number of levels
     multi_func_list = []
-    ## list of added models
+    ## list of added models -- currently python models found in the plugin dir.
     plugins = []
     ## Event owner (guiframe)
@@ -290,4 +290,22 @@
         """
 
+        ## NOTE: as of April 26, 2014, as part of first pass on fixing categories,
+        ## all the appends to shape_list or shape_independent_list are 
+        ## commented out.  They should be possible to remove.  They are in 
+        ## fact a "category" of model whereas the other list are actually 
+        ## "attributes" of a model.  In other words is it a structure factor
+        ## that can be used against a form factor, is it a form factor that is
+        ## knows how to be multiplied by a structure factor, does it have user
+        ## defined number of parameters, etc.
+        ##
+        ## We hope this whole list will be superseded by the new C models
+        ## structure where each model will provide a method to interrogate it
+        ## about its "attributes" -- then this long list becomes a loop reading
+        ## each model in the category list to populate the "attribute"lists.  
+        ## We should also refactor the whole category vs attribute list 
+        ## structure when doing this as now the attribute lists think they are
+        ## also category lists.
+        ##
+        ##   -PDB  April 26, 2014
 
         # regular model names only
@@ -295,5 +313,5 @@
         from sans.models.SphereModel import SphereModel
         self.model_dictionary[SphereModel.__name__] = SphereModel
-        self.shape_list.append(SphereModel)
+#        self.shape_list.append(SphereModel)
         self.multiplication_factor.append(SphereModel)
         self.model_name_list.append(SphereModel.__name__)
@@ -301,10 +319,10 @@
         from sans.models.BinaryHSModel import BinaryHSModel
         self.model_dictionary[BinaryHSModel.__name__] = BinaryHSModel
-        self.shape_list.append(BinaryHSModel)
+#        self.shape_list.append(BinaryHSModel)
         self.model_name_list.append(BinaryHSModel.__name__)
                         
         from sans.models.FuzzySphereModel import FuzzySphereModel
         self.model_dictionary[FuzzySphereModel.__name__] = FuzzySphereModel
-        self.shape_list.append(FuzzySphereModel)
+#        self.shape_list.append(FuzzySphereModel)
         self.multiplication_factor.append(FuzzySphereModel)
         self.model_name_list.append(FuzzySphereModel.__name__)
@@ -312,10 +330,10 @@
         from sans.models.RaspBerryModel import RaspBerryModel
         self.model_dictionary[RaspBerryModel.__name__] = RaspBerryModel
-        self.shape_list.append(RaspBerryModel)
+#        self.shape_list.append(RaspBerryModel)
         self.model_name_list.append(RaspBerryModel.__name__)
                 
         from sans.models.CoreShellModel import CoreShellModel
         self.model_dictionary[CoreShellModel.__name__] = CoreShellModel
-        self.shape_list.append(CoreShellModel)
+#        self.shape_list.append(CoreShellModel)
         self.multiplication_factor.append(CoreShellModel)
         self.model_name_list.append(CoreShellModel.__name__)
@@ -323,10 +341,10 @@
         from sans.models.Core2ndMomentModel import Core2ndMomentModel
         self.model_dictionary[Core2ndMomentModel.__name__] = Core2ndMomentModel
-        self.shape_list.append(Core2ndMomentModel)
+#        self.shape_list.append(Core2ndMomentModel)
         self.model_name_list.append(Core2ndMomentModel.__name__)
         
         from sans.models.CoreMultiShellModel import CoreMultiShellModel
         self.model_dictionary[CoreMultiShellModel.__name__] = CoreMultiShellModel
-        self.shape_list.append(CoreMultiShellModel)
+#        self.shape_list.append(CoreMultiShellModel)
         self.multiplication_factor.append(CoreMultiShellModel)
         self.multi_func_list.append(CoreMultiShellModel)
@@ -334,5 +352,5 @@
         from sans.models.VesicleModel import VesicleModel
         self.model_dictionary[VesicleModel.__name__] = VesicleModel
-        self.shape_list.append(VesicleModel)
+#        self.shape_list.append(VesicleModel)
         self.multiplication_factor.append(VesicleModel)
         self.model_name_list.append(VesicleModel.__name__)
@@ -340,5 +358,5 @@
         from sans.models.MultiShellModel import MultiShellModel
         self.model_dictionary[MultiShellModel.__name__] = MultiShellModel
-        self.shape_list.append(MultiShellModel)
+#        self.shape_list.append(MultiShellModel)
         self.multiplication_factor.append(MultiShellModel)
         self.model_name_list.append(MultiShellModel.__name__)
@@ -346,5 +364,5 @@
         from sans.models.OnionExpShellModel import OnionExpShellModel
         self.model_dictionary[OnionExpShellModel.__name__] = OnionExpShellModel
-        self.shape_list.append(OnionExpShellModel)
+#        self.shape_list.append(OnionExpShellModel)
         self.multiplication_factor.append(OnionExpShellModel)
         self.multi_func_list.append(OnionExpShellModel)
@@ -352,5 +370,5 @@
         from sans.models.SphericalSLDModel import SphericalSLDModel
         self.model_dictionary[SphericalSLDModel.__name__] = SphericalSLDModel
-        self.shape_list.append(SphericalSLDModel)
+#        self.shape_list.append(SphericalSLDModel)
         self.multiplication_factor.append(SphericalSLDModel)
         self.multi_func_list.append(SphericalSLDModel)
@@ -359,10 +377,10 @@
         from sans.models.LinearPearlsModel import LinearPearlsModel
         self.model_dictionary[LinearPearlsModel.__name__] = LinearPearlsModel
-        self.shape_list.append(LinearPearlsModel)
+#        self.shape_list.append(LinearPearlsModel)
         self.model_name_list.append(LinearPearlsModel.__name__)
           
         from sans.models.PearlNecklaceModel import PearlNecklaceModel
         self.model_dictionary[PearlNecklaceModel.__name__] = PearlNecklaceModel
-        self.shape_list.append(PearlNecklaceModel)
+#        self.shape_list.append(PearlNecklaceModel)
         self.model_name_list.append(PearlNecklaceModel.__name__)
         #self.multiplication_factor.append(PearlNecklaceModel)
@@ -370,5 +388,5 @@
         from sans.models.CylinderModel import CylinderModel
         self.model_dictionary[CylinderModel.__name__] = CylinderModel
-        self.shape_list.append(CylinderModel)
+#        self.shape_list.append(CylinderModel)
         self.multiplication_factor.append(CylinderModel)
         self.model_name_list.append(CylinderModel.__name__)
@@ -376,5 +394,5 @@
         from sans.models.CoreShellCylinderModel import CoreShellCylinderModel
         self.model_dictionary[CoreShellCylinderModel.__name__] = CoreShellCylinderModel
-        self.shape_list.append(CoreShellCylinderModel)
+#        self.shape_list.append(CoreShellCylinderModel)
         self.multiplication_factor.append(CoreShellCylinderModel)
         self.model_name_list.append(CoreShellCylinderModel.__name__)
@@ -382,5 +400,5 @@
         from sans.models.CoreShellBicelleModel import CoreShellBicelleModel
         self.model_dictionary[CoreShellBicelleModel.__name__] = CoreShellBicelleModel
-        self.shape_list.append(CoreShellBicelleModel)
+#        self.shape_list.append(CoreShellBicelleModel)
         self.multiplication_factor.append(CoreShellBicelleModel)
         self.model_name_list.append(CoreShellBicelleModel.__name__)
@@ -388,5 +406,5 @@
         from sans.models.HollowCylinderModel import HollowCylinderModel
         self.model_dictionary[HollowCylinderModel.__name__] = HollowCylinderModel
-        self.shape_list.append(HollowCylinderModel)
+#        self.shape_list.append(HollowCylinderModel)
         self.multiplication_factor.append(HollowCylinderModel)
         self.model_name_list.append(HollowCylinderModel.__name__)
@@ -394,15 +412,15 @@
         from sans.models.FlexibleCylinderModel import FlexibleCylinderModel
         self.model_dictionary[FlexibleCylinderModel.__name__] = FlexibleCylinderModel
-        self.shape_list.append(FlexibleCylinderModel)
+#        self.shape_list.append(FlexibleCylinderModel)
         self.model_name_list.append(FlexibleCylinderModel.__name__)
 
         from sans.models.FlexCylEllipXModel import FlexCylEllipXModel
         self.model_dictionary[FlexCylEllipXModel.__name__] = FlexCylEllipXModel
-        self.shape_list.append(FlexCylEllipXModel)
+#        self.shape_list.append(FlexCylEllipXModel)
         self.model_name_list.append(FlexCylEllipXModel.__name__)
         
         from sans.models.StackedDisksModel import StackedDisksModel
         self.model_dictionary[StackedDisksModel.__name__] = StackedDisksModel
-        self.shape_list.append(StackedDisksModel)
+#        self.shape_list.append(StackedDisksModel)
         self.multiplication_factor.append(StackedDisksModel)
         self.model_name_list.append(StackedDisksModel.__name__)
@@ -410,5 +428,5 @@
         from sans.models.ParallelepipedModel import ParallelepipedModel
         self.model_dictionary[ParallelepipedModel.__name__] = ParallelepipedModel
-        self.shape_list.append(ParallelepipedModel)
+#        self.shape_list.append(ParallelepipedModel)
         self.multiplication_factor.append(ParallelepipedModel)
         self.model_name_list.append(ParallelepipedModel.__name__)
@@ -416,5 +434,5 @@
         from sans.models.CSParallelepipedModel import CSParallelepipedModel
         self.model_dictionary[CSParallelepipedModel.__name__] = CSParallelepipedModel
-        self.shape_list.append(CSParallelepipedModel)
+#        self.shape_list.append(CSParallelepipedModel)
         self.multiplication_factor.append(CSParallelepipedModel)
         self.model_name_list.append(CSParallelepipedModel.__name__)
@@ -422,5 +440,5 @@
         from sans.models.EllipticalCylinderModel import EllipticalCylinderModel
         self.model_dictionary[EllipticalCylinderModel.__name__] = EllipticalCylinderModel
-        self.shape_list.append(EllipticalCylinderModel)
+#        self.shape_list.append(EllipticalCylinderModel)
         self.multiplication_factor.append(EllipticalCylinderModel)
         self.model_name_list.append(EllipticalCylinderModel.__name__)
@@ -428,5 +446,5 @@
         from sans.models.BarBellModel import BarBellModel
         self.model_dictionary[BarBellModel.__name__] = BarBellModel
-        self.shape_list.append(BarBellModel)
+#        self.shape_list.append(BarBellModel)
         self.model_name_list.append(BarBellModel.__name__)
         # not implemeted yet!
@@ -435,5 +453,5 @@
         from sans.models.CappedCylinderModel import CappedCylinderModel
         self.model_dictionary[CappedCylinderModel.__name__] = CappedCylinderModel
-        self.shape_list.append(CappedCylinderModel)
+ #       self.shape_list.append(CappedCylinderModel)
         self.model_name_list.append(CappedCylinderModel.__name__)
         # not implemeted yet!
@@ -442,5 +460,5 @@
         from sans.models.EllipsoidModel import EllipsoidModel
         self.model_dictionary[EllipsoidModel.__name__] = EllipsoidModel
-        self.shape_list.append(EllipsoidModel)
+#        self.shape_list.append(EllipsoidModel)
         self.multiplication_factor.append(EllipsoidModel)
         self.model_name_list.append(EllipsoidModel.__name__)
@@ -448,5 +466,5 @@
         from sans.models.CoreShellEllipsoidModel import CoreShellEllipsoidModel
         self.model_dictionary[CoreShellEllipsoidModel.__name__] = CoreShellEllipsoidModel
-        self.shape_list.append(CoreShellEllipsoidModel)
+#        self.shape_list.append(CoreShellEllipsoidModel)
         self.multiplication_factor.append(CoreShellEllipsoidModel)
         self.model_name_list.append(CoreShellEllipsoidModel.__name__)
@@ -454,5 +472,5 @@
         from sans.models.TriaxialEllipsoidModel import TriaxialEllipsoidModel
         self.model_dictionary[TriaxialEllipsoidModel.__name__] = TriaxialEllipsoidModel
-        self.shape_list.append(TriaxialEllipsoidModel)
+#        self.shape_list.append(TriaxialEllipsoidModel)
         self.multiplication_factor.append(TriaxialEllipsoidModel)
         self.model_name_list.append(TriaxialEllipsoidModel.__name__)
@@ -460,40 +478,40 @@
         from sans.models.LamellarModel import LamellarModel
         self.model_dictionary[LamellarModel.__name__] = LamellarModel
-        self.shape_list.append(LamellarModel)
+#        self.shape_list.append(LamellarModel)
         self.model_name_list.append(LamellarModel.__name__)
         
         from sans.models.LamellarFFHGModel import LamellarFFHGModel
         self.model_dictionary[LamellarFFHGModel.__name__] = LamellarFFHGModel
-        self.shape_list.append(LamellarFFHGModel)
+#        self.shape_list.append(LamellarFFHGModel)
         self.model_name_list.append(LamellarFFHGModel.__name__)
         
         from sans.models.LamellarPSModel import LamellarPSModel
         self.model_dictionary[LamellarPSModel.__name__] = LamellarPSModel
-        self.shape_list.append(LamellarPSModel)
+#        self.shape_list.append(LamellarPSModel)
         self.model_name_list.append(LamellarPSModel.__name__)
      
         from sans.models.LamellarPSHGModel import LamellarPSHGModel
         self.model_dictionary[LamellarPSHGModel.__name__] = LamellarPSHGModel
-        self.shape_list.append(LamellarPSHGModel)
+#        self.shape_list.append(LamellarPSHGModel)
         self.model_name_list.append(LamellarPSHGModel.__name__)
         
         from sans.models.LamellarPCrystalModel import LamellarPCrystalModel
         self.model_dictionary[LamellarPCrystalModel.__name__] = LamellarPCrystalModel
-        self.shape_list.append(LamellarPCrystalModel)
+#        self.shape_list.append(LamellarPCrystalModel)
         self.model_name_list.append(LamellarPCrystalModel.__name__)
         
         from sans.models.SCCrystalModel import SCCrystalModel
         self.model_dictionary[SCCrystalModel.__name__] = SCCrystalModel
-        self.shape_list.append(SCCrystalModel)
+#        self.shape_list.append(SCCrystalModel)
         self.model_name_list.append(SCCrystalModel.__name__)
         
         from sans.models.FCCrystalModel import FCCrystalModel
         self.model_dictionary[FCCrystalModel.__name__] = FCCrystalModel
-        self.shape_list.append(FCCrystalModel)
+#        self.shape_list.append(FCCrystalModel)
         self.model_name_list.append(FCCrystalModel.__name__)
         
         from sans.models.BCCrystalModel import BCCrystalModel
         self.model_dictionary[BCCrystalModel.__name__] = BCCrystalModel
-        self.shape_list.append(BCCrystalModel)
+#        self.shape_list.append(BCCrystalModel)
         self.model_name_list.append(BCCrystalModel.__name__)
       
@@ -523,10 +541,10 @@
         from sans.models.PowerLawAbsModel import PowerLawAbsModel
         self.model_dictionary[PowerLawAbsModel.__name__] = PowerLawAbsModel
-        self.shape_indep_list.append(PowerLawAbsModel)
+#        self.shape_indep_list.append(PowerLawAbsModel)
         self.model_name_list.append(PowerLawAbsModel.__name__)
         
         from sans.models.BEPolyelectrolyte import BEPolyelectrolyte
         self.model_dictionary[BEPolyelectrolyte.__name__] = BEPolyelectrolyte
-        self.shape_indep_list.append(BEPolyelectrolyte)
+#        self.shape_indep_list.append(BEPolyelectrolyte)
         self.model_name_list.append(BEPolyelectrolyte.__name__)
         self.form_factor_dict[str(wx.NewId())] =  [SphereModel]
@@ -534,150 +552,150 @@
         from sans.models.BroadPeakModel import BroadPeakModel
         self.model_dictionary[BroadPeakModel.__name__] = BroadPeakModel
-        self.shape_indep_list.append(BroadPeakModel)
+#        self.shape_indep_list.append(BroadPeakModel)
         self.model_name_list.append(BroadPeakModel.__name__)
         
         from sans.models.CorrLengthModel import CorrLengthModel
         self.model_dictionary[CorrLengthModel.__name__] = CorrLengthModel
-        self.shape_indep_list.append(CorrLengthModel)
+#        self.shape_indep_list.append(CorrLengthModel)
         self.model_name_list.append(CorrLengthModel.__name__)
         
         from sans.models.DABModel import DABModel
         self.model_dictionary[DABModel.__name__] = DABModel
-        self.shape_indep_list.append(DABModel)
+#        self.shape_indep_list.append(DABModel)
         self.model_name_list.append(DABModel.__name__)
         
         from sans.models.DebyeModel import DebyeModel
         self.model_dictionary[DebyeModel.__name__] = DebyeModel
-        self.shape_indep_list.append(DebyeModel)
+#        self.shape_indep_list.append(DebyeModel)
         self.model_name_list.append(DebyeModel.__name__)
         
         from sans.models.FractalModel import FractalModel
         self.model_dictionary[FractalModel.__name__] = FractalModel
-        self.shape_indep_list.append(FractalModel)
+#        self.shape_indep_list.append(FractalModel)
         self.model_name_list.append(FractalModel.__name__)
         
         from sans.models.FractalCoreShellModel import FractalCoreShellModel
         self.model_dictionary[FractalCoreShellModel.__name__] = FractalCoreShellModel
-        self.shape_indep_list.append(FractalCoreShellModel)
+#        self.shape_indep_list.append(FractalCoreShellModel)
         self.model_name_list.append(FractalCoreShellModel.__name__)
         
         from sans.models.GaussLorentzGelModel import GaussLorentzGelModel
         self.model_dictionary[GaussLorentzGelModel.__name__] = GaussLorentzGelModel
-        self.shape_indep_list.append(GaussLorentzGelModel)
+#        self.shape_indep_list.append(GaussLorentzGelModel)
         self.model_name_list.append(GaussLorentzGelModel.__name__)
                 
         from sans.models.GuinierModel import GuinierModel
         self.model_dictionary[GuinierModel.__name__] = GuinierModel
-        self.shape_indep_list.append(GuinierModel)
+#        self.shape_indep_list.append(GuinierModel)
         self.model_name_list.append(GuinierModel.__name__)
         
         from sans.models.GuinierPorodModel import GuinierPorodModel
         self.model_dictionary[GuinierPorodModel.__name__] = GuinierPorodModel
-        self.shape_indep_list.append(GuinierPorodModel)
+#        self.shape_indep_list.append(GuinierPorodModel)
         self.model_name_list.append(GuinierPorodModel.__name__)
 
         from sans.models.LorentzModel import LorentzModel
         self.model_dictionary[LorentzModel.__name__] = LorentzModel
-        self.shape_indep_list.append(LorentzModel)
+#        self.shape_indep_list.append(LorentzModel)
         self.model_name_list.append(LorentzModel.__name__)
 
         from sans.models.MassFractalModel import MassFractalModel
         self.model_dictionary[MassFractalModel.__name__] = MassFractalModel
-        self.shape_indep_list.append(MassFractalModel)
+#        self.shape_indep_list.append(MassFractalModel)
         self.model_name_list.append(MassFractalModel.__name__)
         
         from sans.models.MassSurfaceFractal import MassSurfaceFractal
         self.model_dictionary[MassSurfaceFractal.__name__] = MassSurfaceFractal
-        self.shape_indep_list.append(MassSurfaceFractal)
+#        self.shape_indep_list.append(MassSurfaceFractal)
         self.model_name_list.append(MassSurfaceFractal.__name__)
         
         from sans.models.PeakGaussModel import PeakGaussModel
         self.model_dictionary[PeakGaussModel.__name__] = PeakGaussModel
-        self.shape_indep_list.append(PeakGaussModel)
+#        self.shape_indep_list.append(PeakGaussModel)
         self.model_name_list.append(PeakGaussModel.__name__)
         
         from sans.models.PeakLorentzModel import PeakLorentzModel
         self.model_dictionary[PeakLorentzModel.__name__] = PeakLorentzModel
-        self.shape_indep_list.append(PeakLorentzModel)
+#        self.shape_indep_list.append(PeakLorentzModel)
         self.model_name_list.append(PeakLorentzModel.__name__)
         
         from sans.models.Poly_GaussCoil import Poly_GaussCoil
         self.model_dictionary[Poly_GaussCoil.__name__] = Poly_GaussCoil
-        self.shape_indep_list.append(Poly_GaussCoil)
+#        self.shape_indep_list.append(Poly_GaussCoil)
         self.model_name_list.append(Poly_GaussCoil.__name__)
         
         from sans.models.PolymerExclVolume import PolymerExclVolume
         self.model_dictionary[PolymerExclVolume.__name__] = PolymerExclVolume
-        self.shape_indep_list.append(PolymerExclVolume)
+#        self.shape_indep_list.append(PolymerExclVolume)
         self.model_name_list.append(PolymerExclVolume.__name__)
         
         from sans.models.PorodModel import PorodModel
         self.model_dictionary[PorodModel.__name__] = PorodModel
-        self.shape_indep_list.append(PorodModel)
+#        self.shape_indep_list.append(PorodModel)
         self.model_name_list.append(PorodModel.__name__)
         
         from sans.models.RPA10Model import RPA10Model
         self.model_dictionary[RPA10Model.__name__] = RPA10Model
-        self.shape_indep_list.append(RPA10Model)
+#        self.shape_indep_list.append(RPA10Model)
         self.multi_func_list.append(RPA10Model)
 
         from sans.models.StarPolymer import StarPolymer
         self.model_dictionary[StarPolymer.__name__] = StarPolymer
-        self.shape_indep_list.append(StarPolymer)
+#        self.shape_indep_list.append(StarPolymer)
         self.model_name_list.append(StarPolymer.__name__)
 
         from sans.models.SurfaceFractalModel import SurfaceFractalModel
         self.model_dictionary[SurfaceFractalModel.__name__] = SurfaceFractalModel
-        self.shape_indep_list.append(SurfaceFractalModel)
+#        self.shape_indep_list.append(SurfaceFractalModel)
         self.model_name_list.append(SurfaceFractalModel.__name__)
         
         from sans.models.TeubnerStreyModel import TeubnerStreyModel
         self.model_dictionary[TeubnerStreyModel.__name__] = TeubnerStreyModel
-        self.shape_indep_list.append(TeubnerStreyModel)
+#        self.shape_indep_list.append(TeubnerStreyModel)
         self.model_name_list.append(TeubnerStreyModel.__name__)
 
         from sans.models.TwoLorentzianModel import TwoLorentzianModel
         self.model_dictionary[TwoLorentzianModel.__name__] = TwoLorentzianModel
-        self.shape_indep_list.append(TwoLorentzianModel)
+#        self.shape_indep_list.append(TwoLorentzianModel)
         self.model_name_list.append(TwoLorentzianModel.__name__)
         
         from sans.models.TwoPowerLawModel import TwoPowerLawModel
         self.model_dictionary[TwoPowerLawModel.__name__] = TwoPowerLawModel
-        self.shape_indep_list.append(TwoPowerLawModel)
+#        self.shape_indep_list.append(TwoPowerLawModel)
         self.model_name_list.append(TwoPowerLawModel.__name__)
         
         from sans.models.UnifiedPowerRgModel import UnifiedPowerRgModel
         self.model_dictionary[UnifiedPowerRgModel.__name__] = UnifiedPowerRgModel
-        self.shape_indep_list.append(UnifiedPowerRgModel)
+#        self.shape_indep_list.append(UnifiedPowerRgModel)
         self.multi_func_list.append(UnifiedPowerRgModel)
 
         from sans.models.LineModel import LineModel
         self.model_dictionary[LineModel.__name__] = LineModel
-        self.shape_indep_list.append(LineModel)
+#        self.shape_indep_list.append(LineModel)
         self.model_name_list.append(LineModel.__name__)
         
         from sans.models.ReflectivityModel import ReflectivityModel
         self.model_dictionary[ReflectivityModel.__name__] = ReflectivityModel
-        self.shape_indep_list.append(ReflectivityModel)
+#        self.shape_indep_list.append(ReflectivityModel)
         self.multi_func_list.append(ReflectivityModel)
         
         from sans.models.ReflectivityIIModel import ReflectivityIIModel
         self.model_dictionary[ReflectivityIIModel.__name__] = ReflectivityIIModel
-        self.shape_indep_list.append(ReflectivityIIModel)
+#        self.shape_indep_list.append(ReflectivityIIModel)
         self.multi_func_list.append(ReflectivityIIModel)
         
         from sans.models.GelFitModel import GelFitModel
         self.model_dictionary[GelFitModel.__name__] = GelFitModel
-        self.shape_indep_list.append(GelFitModel)
+#        self.shape_indep_list.append(GelFitModel)
         self.model_name_list.append(GelFitModel.__name__)
 
         from sans.models.PringlesModel import PringlesModel
         self.model_dictionary[PringlesModel.__name__] = PringlesModel
-        self.shape_indep_list.append(PringlesModel)
+#        self.shape_indep_list.append(PringlesModel)
         self.model_name_list.append(PringlesModel.__name__)
 
         from sans.models.RectangularPrismModel import RectangularPrismModel
         self.model_dictionary[RectangularPrismModel.__name__] = RectangularPrismModel
-        self.shape_list.append(RectangularPrismModel)
+#        self.shape_list.append(RectangularPrismModel)
         self.multiplication_factor.append(RectangularPrismModel)
         self.model_name_list.append(RectangularPrismModel.__name__)
@@ -685,5 +703,5 @@
         from sans.models.RectangularHollowPrismInfThinWallsModel import RectangularHollowPrismInfThinWallsModel
         self.model_dictionary[RectangularHollowPrismInfThinWallsModel.__name__] = RectangularHollowPrismInfThinWallsModel
-        self.shape_list.append(RectangularHollowPrismInfThinWallsModel)
+#        self.shape_list.append(RectangularHollowPrismInfThinWallsModel)
         self.multiplication_factor.append(RectangularHollowPrismInfThinWallsModel)
         self.model_name_list.append(RectangularHollowPrismInfThinWallsModel.__name__)
@@ -691,5 +709,5 @@
         from sans.models.RectangularHollowPrismModel import RectangularHollowPrismModel
         self.model_dictionary[RectangularHollowPrismModel.__name__] = RectangularHollowPrismModel
-        self.shape_list.append(RectangularHollowPrismModel)
+#        self.shape_list.append(RectangularHollowPrismModel)
         self.multiplication_factor.append(RectangularHollowPrismModel)
         self.model_name_list.append(RectangularHollowPrismModel.__name__)
@@ -761,136 +779,146 @@
         return self.model_combobox.get_list()
        
-    def populate_menu(self, modelmenu, event_owner):
-        """
-        Populate a menu with our models
-        
-        :param id: first menu event ID to use when binding the menu events
-        :param modelmenu: wx.Menu object to populate
-        :param event_owner: wx object to bind the menu events to
-        
-        :return: the next free event ID following the new menu events
-        
-        """
+##   I believe the next four methods are for the old form factor GUI
+##   where the dropdown showed a list of categories which then rolled out
+##   in a second dropdown to the side. Some testing shows they indeed no longer
+##   seem to be called.  If no problems are found during testing of release we
+##   can remove this huge chunck of stuff.
+##
+##   -PDB  April 26, 2014
+
+#   def populate_menu(self, modelmenu, event_owner):
+#       """
+#       Populate a menu with our models
+#       
+#       :param id: first menu event ID to use when binding the menu events
+#       :param modelmenu: wx.Menu object to populate
+#       :param event_owner: wx object to bind the menu events to
+#       
+#       :return: the next free event ID following the new menu events
+#       
+#       """
+# 
         ## Fill model lists
-        self._getModelList()
+#        self._getModelList()
         ## store reference to model menu of guiframe
-        self.modelmenu = modelmenu
+#        self.modelmenu = modelmenu
         ## guiframe reference
-        self.event_owner = event_owner
-        
-        shape_submenu = wx.Menu()
-        shape_indep_submenu = wx.Menu()
-        structure_factor = wx.Menu()
-        added_models = wx.Menu()
-        multip_models = wx.Menu()
+#        self.event_owner = event_owner
+        
+#        shape_submenu = wx.Menu()
+#        shape_indep_submenu = wx.Menu()
+#        structure_factor = wx.Menu()
+#        added_models = wx.Menu()
+#        multip_models = wx.Menu()
         ## create menu with shape
-        self._fill_simple_menu(menuinfo=["Shapes",
-                                         shape_submenu,
-                                         " simple shape"],
-                         list1=self.shape_list)
-        
-        self._fill_simple_menu(menuinfo=["Shape-Independent",
-                                         shape_indep_submenu,
-                                         "List of shape-independent models"],
-                         list1=self.shape_indep_list)
-        
-        self._fill_simple_menu(menuinfo=["Structure Factors",
-                                         structure_factor,
-                                         "List of Structure factors models"],
-                                list1=self.struct_list)
-        
-        self._fill_plugin_menu(menuinfo=["Customized Models", added_models,
-                                            "List of additional models"],
-                                 list1=self.plugins)
-        
-        self._fill_menu(menuinfo=["P(Q)*S(Q)", multip_models,
-                                  "mulplication of 2 models"],
-                                   list1=self.multiplication_factor,
-                                   list2=self.struct_list)
-        return 0
-    
-    def _fill_plugin_menu(self, menuinfo, list1):
-        """
-        fill the plugin menu with costumized models
-        """
-        if len(list1) == 0:
-            id = wx.NewId()
-            msg = "No model available check plugins.log for errors to fix problem"
-            menuinfo[1].Append(int(id), "Empty", msg)
-        self._fill_simple_menu(menuinfo, list1)
-        
-    def _fill_simple_menu(self, menuinfo, list1):
-        """
-        Fill the menu with list item
-        
-        :param modelmenu: the menu to fill
-        :param menuinfo: submenu item for the first column of this modelmenu
-                         with info.Should be a list :
-                         [name(string) , menu(wx.menu), help(string)]
-        :param list1: contains item (form factor )to fill modelmenu second column
-        
-        """
-        if len(list1) > 0:
-            self.model_combobox.set_list(menuinfo[0], list1)
+#        self._fill_simple_menu(menuinfo=["Shapes",
+#                                         shape_submenu,
+#                                         " simple shape"],
+#                         list1=self.shape_list)
+        
+#        self._fill_simple_menu(menuinfo=["Shape-Independent",
+#                                         shape_indep_submenu,
+#                                         "List of shape-independent models"],
+#                         list1=self.shape_indep_list)
+        
+#        self._fill_simple_menu(menuinfo=["Structure Factors",
+#                                         structure_factor,
+#                                         "List of Structure factors models"],
+#                                list1=self.struct_list)
+        
+#        self._fill_plugin_menu(menuinfo=["Customized Models", added_models,
+#                                            "List of additional models"],
+#                                 list1=self.plugins)
+        
+#        self._fill_menu(menuinfo=["P(Q)*S(Q)", multip_models,
+#                                  "mulplication of 2 models"],
+#                                   list1=self.multiplication_factor,
+#                                   list2=self.struct_list)
+#        return 0
+    
+#    def _fill_plugin_menu(self, menuinfo, list1):
+#        """
+#        fill the plugin menu with costumized models
+#        """
+#        print ("got to fill plugin menu")
+#        if len(list1) == 0:
+#            id = wx.NewId()
+#            msg = "No model available check plugins.log for errors to fix problem"
+#            menuinfo[1].Append(int(id), "Empty", msg)
+#        self._fill_simple_menu(menuinfo, list1)
+        
+#   def _fill_simple_menu(self, menuinfo, list1):
+#       """
+#       Fill the menu with list item
+#       
+#       :param modelmenu: the menu to fill
+#       :param menuinfo: submenu item for the first column of this modelmenu
+#                        with info.Should be a list :
+#                        [name(string) , menu(wx.menu), help(string)]
+#       :param list1: contains item (form factor )to fill modelmenu second column
+#       
+#       """
+#       if len(list1) > 0:
+#           self.model_combobox.set_list(menuinfo[0], list1)
             
-            for item in list1:
-                try:
-                    id = wx.NewId()
-                    struct_factor = item()
-                    struct_name = struct_factor.__class__.__name__
-                    if hasattr(struct_factor, "name"):
-                        struct_name = struct_factor.name
-                        
-                    menuinfo[1].Append(int(id), struct_name, struct_name)
-                    if not  item in self.struct_factor_dict.itervalues():
-                        self.struct_factor_dict[str(id)] = item
-                    wx.EVT_MENU(self.event_owner, int(id), self._on_model)
-                except:
-                    msg = "Error Occured: %s" % sys.exc_value
-                    wx.PostEvent(self.event_owner, StatusEvent(status=msg))
-                
-        id = wx.NewId()
-        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
-        
-    def _fill_menu(self, menuinfo, list1, list2):
-        """
-        Fill the menu with list item
-        
-        :param menuinfo: submenu item for the first column of this modelmenu
-                         with info.Should be a list :
-                         [name(string) , menu(wx.menu), help(string)]
-        :param list1: contains item (form factor )to fill modelmenu second column
-        :param list2: contains item (Structure factor )to fill modelmenu
-                third column
-                
-        """
-        if len(list1) > 0:
-            self.model_combobox.set_list(menuinfo[0], list1)
-            
-            for item in list1:
-                form_factor = item()
-                form_name = form_factor.__class__.__name__
-                if hasattr(form_factor, "name"):
-                    form_name = form_factor.name
-                ### store form factor to return to other users
-                newmenu = wx.Menu()
-                if len(list2) > 0:
-                    for model  in list2:
-                        id = wx.NewId()
-                        struct_factor = model()
-                        name = struct_factor.__class__.__name__
-                        if hasattr(struct_factor, "name"):
-                            name = struct_factor.name
-                        newmenu.Append(id, name, name)
-                        wx.EVT_MENU(self.event_owner, int(id), self._on_model)
-                        ## save form_fact and struct_fact
-                        self.form_factor_dict[int(id)] = [form_factor,
-                                                          struct_factor]
-                        
-                form_id = wx.NewId()
-                menuinfo[1].AppendMenu(int(form_id), form_name,
-                                       newmenu, menuinfo[2])
-        id = wx.NewId()
-        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
+#            for item in list1:
+#                try:
+#                    id = wx.NewId()
+#                    struct_factor = item()
+#                    struct_name = struct_factor.__class__.__name__
+#                    if hasattr(struct_factor, "name"):
+#                        struct_name = struct_factor.name
+#                        
+#                    menuinfo[1].Append(int(id), struct_name, struct_name)
+#                    if not  item in self.struct_factor_dict.itervalues():
+#                        self.struct_factor_dict[str(id)] = item
+#                    wx.EVT_MENU(self.event_owner, int(id), self._on_model)
+#                except:
+#                    msg = "Error Occured: %s" % sys.exc_value
+#                    wx.PostEvent(self.event_owner, StatusEvent(status=msg))
+#                
+#        id = wx.NewId()
+#        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
+#        
+#    def _fill_menu(self, menuinfo, list1, list2):
+#        """
+#        Fill the menu with list item
+#        
+#        :param menuinfo: submenu item for the first column of this modelmenu
+#                         with info.Should be a list :
+#                         [name(string) , menu(wx.menu), help(string)]
+#        :param list1: contains item (form factor )to fill modelmenu second column
+#        :param list2: contains item (Structure factor )to fill modelmenu
+#                third column
+#                
+#        """
+#        if len(list1) > 0:
+#            self.model_combobox.set_list(menuinfo[0], list1)
+#            
+#            for item in list1:
+#                form_factor = item()
+#                form_name = form_factor.__class__.__name__
+#                if hasattr(form_factor, "name"):
+#                    form_name = form_factor.name
+#                ### store form factor to return to other users
+#                newmenu = wx.Menu()
+#                if len(list2) > 0:
+#                    for model  in list2:
+#                        id = wx.NewId()
+#                        struct_factor = model()
+#                        name = struct_factor.__class__.__name__
+#                        if hasattr(struct_factor, "name"):
+#                            name = struct_factor.name
+#                        newmenu.Append(id, name, name)
+#                        wx.EVT_MENU(self.event_owner, int(id), self._on_model)
+#                        ## save form_fact and struct_fact
+#                        self.form_factor_dict[int(id)] = [form_factor,
+#                                                          struct_factor]
+#                        
+#                form_id = wx.NewId()
+#                menuinfo[1].AppendMenu(int(form_id), form_name,
+#                                       newmenu, menuinfo[2])
+#        id = wx.NewId()
+#        self.modelmenu.AppendMenu(id, menuinfo[0], menuinfo[1], menuinfo[2])
         
     def _on_model(self, evt):
@@ -932,7 +960,15 @@
         
         """
-        self.model_combobox.set_list("Shapes", self.shape_list)
-        self.model_combobox.set_list("Shape-Independent",
-                                     self.shape_indep_list)
+        ## Model_list now only contains attribute lists not category list.
+        ## Eventually this should be in one master list -- read in category
+        ## list then pull those models that exist and get attributes then add
+        ## to list ..and if model does not exist remove from list as now
+        ## and update json file.
+        ##
+        ## -PDB   April 26, 2014
+        
+#        self.model_combobox.set_list("Shapes", self.shape_list)
+#        self.model_combobox.set_list("Shape-Independent",
+#                                     self.shape_indep_list)
         self.model_combobox.set_list("Structure Factors", self.struct_list)
         self.model_combobox.set_list("Customized Models", self.plugins)
