wolfhece 2.0.55__py3-none-any.whl → 2.1.1__py3-none-any.whl

wolfhece/PyPalette.py

@@ -322,6 +322,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
         On copie les valeurs, on ne pointe pas l'objet
         """
+
         for k in range(len(srcpal.values)):
             self.values[k]=srcpal.values[k]
 
@@ -374,6 +375,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
     def default16(self):
         """Palette 16 coulrurs par défaut dans WOLF"""
+
         self.nb=16
         self.values = np.linspace(0.,1.,16)
         self.colors = np.zeros((self.nb,4) , dtype=int)
@@ -398,6 +400,51 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def set_values_colors(self,
+                          values:typing.Union[list[float], np.ndarray],
+                          colors:typing.Union[list[tuple[int]], np.ndarray]):
+        """ Mise à jour des valeurs et couleurs de la palette """
+
+        assert len(values) == len(colors), "Length of values and colors must be the same"
+        assert len(values) > 1, "At least 2 values are required"
+        assert len(colors[0]) in [3,4], "Colors must be in RGB or RGBA format"
+
+        self.nb = len(values)
+        self.values = np.asarray(values)
+
+        self.colors = np.zeros((self.nb,4) , dtype=int)
+        self.colorsflt = np.zeros((self.nb,4) , dtype=float)
+
+        if isinstance(colors, list):
+            if len(colors[0]) == 3:
+                for curcol in range(self.nb):
+                    self.colors[curcol,0] = colors[curcol][0]
+                    self.colors[curcol,1] = colors[curcol][1]
+                    self.colors[curcol,2] = colors[curcol][2]
+                    self.colors[curcol,3] = 255
+            elif len(colors[0]) == 4:
+                for curcol in range(self.nb):
+                    self.colors[curcol,0] = colors[curcol][0]
+                    self.colors[curcol,1] = colors[curcol][1]
+                    self.colors[curcol,2] = colors[curcol][2]
+                    self.colors[curcol,3] = colors[curcol][3]
+        elif isinstance(colors, np.ndarray):
+            if colors.shape[1] == 3:
+                for curcol in range(self.nb):
+                    self.colors[curcol,0] = colors[curcol,0]
+                    self.colors[curcol,1] = colors[curcol,1]
+                    self.colors[curcol,2] = colors[curcol,2]
+                    self.colors[curcol,3] = 255
+            elif colors.shape[1] == 4:
+                for curcol in range(self.nb):
+                    self.colors[curcol,0] = colors[curcol,0]
+                    self.colors[curcol,1] = colors[curcol,1]
+                    self.colors[curcol,2] = colors[curcol,2]
+                    self.colors[curcol,3] = colors[curcol,3]
+
+
+        self.fill_segmentdata()
+
     def defaultgray(self):
         """Palette grise par défaut dans WOLF"""
         self.nb=2

wolfhece/PyParams.py

@@ -62,7 +62,7 @@ class Buttons(Enum):
     Apply = 'Apply'
     Reload = 'Reload'
 
-def new_json(values:dict, fullcomment:str='') -> dict:
+def new_json(values:dict=None, fullcomment:str='') -> dict:
     """
     Create a new JSON string from values and fullcomment
 
@@ -311,10 +311,141 @@ class Wolf_Param(wx.Frame):
         if to_read:
             self.ReadFile(filename)
 
+        self.prop = None
+        self.sizer = None
+
         if self.wx_exists and init_GUI:
             self._set_gui(parent,title,w,h,ontop,to_read,withbuttons,DestroyAtClosing,toShow)
-        else:
-            self.prop = None
+
+    @property
+    def has_prop(self) -> bool:
+        """ Return True if the property grid is available """
+        return self.prop is not None
+
+    @property
+    def has_gui(self) -> bool:
+        """ Return True if the own GUI is available"""
+
+        return self.sizer is not None
+
+    def ensure_prop(self, wxparent = None, show_in_active_if_default:bool = False):
+        """ Ensure that the property grid is available """
+
+        if self.wx_exists:
+            if not self.has_prop:
+                self._set_only_prop(wxparent)
+                self.show_in_active_if_default = show_in_active_if_default
+                self.prop.SetSizeHints(0,600)
+
+            self.Populate()
+
+
+    def ensure_gui(self,
+                   title:str = "Default Title",
+                   w:int = 500, h:int = 800,
+                   ontop:bool = False,
+                   to_read:bool = True,
+                   withbuttons:bool = True,
+                   DestroyAtClosing:bool = True,
+                   toShow:bool = True,
+                   full_style:bool = False):
+        """ Ensure that the GUI is available """
+
+        if not self.has_gui and self.wx_exists:
+            self._set_gui(title=title,
+                          w=w, h=h,
+                          ontop=ontop,
+                          to_read=to_read,
+                          withbuttons=withbuttons,
+                          DestroyAtClosing=DestroyAtClosing,
+                          toShow=toShow,
+                          full_style=full_style,
+                          )
+
+    def copy(self):
+        """ Return a deep copy of the object """
+
+        newparams = Wolf_Param()
+
+        for group, params in self.myparams.items():
+            newparams.myparams[group] = deepcopy(params)
+
+        for group, params in self.myparams_default.items():
+            newparams.myparams_default[group] = deepcopy(params)
+
+        newparams.myIncGroup = deepcopy(self.myIncGroup)
+
+        newparams.myIncParam = deepcopy(self.myIncParam)
+
+        return newparams
+
+    def is_like(self, other:"Wolf_Param") -> bool:
+        """ Test if the object is like another object """
+
+        # if self.filename != other.filename:
+        #     return False
+
+        if self.myparams != other.myparams:
+            return False
+
+        if self.myparams_default != other.myparams_default:
+            return False
+
+        if self.myIncGroup != other.myIncGroup:
+            return False
+
+        if self.myIncParam != other.myIncParam:
+            return False
+
+        return True
+
+    def diff(self, other:"Wolf_Param", exclude_incremental:bool = False) -> dict:
+        """ Return the differences between two objects """
+
+        diff = {}
+
+        # if self.filename != other.filename:
+        #     diff["filename"] = (self.filename, other.filename)
+
+        if self.myparams != other.myparams:
+            for group in self.myparams.keys():
+                for param in self.myparams[group].keys():
+                    try:
+                        if self.myparams[group][param] != other.myparams[group][param]:
+                            diff[(group, param)] = (self.myparams[group][param], other.myparams[group][param])
+                    except:
+                        diff[(group, param)] = (self.myparams[group][param], None)
+
+        if self.myparams_default != other.myparams_default:
+            for group in self.myparams_default.keys():
+                for param in self.myparams_default[group].keys():
+                    try:
+                        if self.myparams_default[group][param] != other.myparams_default[group][param]:
+                            diff[(group, param)] = (self.myparams_default[group][param], other.myparams_default[group][param])
+                    except:
+                        diff[(group, param)] = (self.myparams_default[group][param], None)
+
+        if exclude_incremental:
+            return diff
+
+        if self.myIncGroup != other.myIncGroup:
+            for group in self.myIncGroup.keys():
+                try:
+                    if self.myIncGroup[group] != other.myIncGroup[group]:
+                        diff["myIncGroup"] = (self.myIncGroup[group], other.myIncGroup[group])
+                except:
+                    diff["myIncGroup"] = (self.myIncGroup[group], None)
+
+        if self.myIncParam != other.myIncParam:
+            for group in self.myIncParam.keys():
+                try:
+                    for param in self.myIncParam[group].keys():
+                        if self.myIncParam[group][param] != other.myIncParam[group][param]:
+                            diff["myIncParam"] = (self.myIncParam[group][param], other.myIncParam[group][param])
+                except:
+                    diff["myIncParam"] = (self.myIncParam[group][param], None)
+
+        return diff
 
     def set_callbacks(self, callback_update, callback_destroy):
         """ Set the callbacks for the update and destroy events """
@@ -370,7 +501,8 @@ class Wolf_Param(wx.Frame):
                 to_read:bool = True,
                 withbuttons:bool = True,
                 DestroyAtClosing:bool = True,
-                toShow:bool = True):
+                toShow:bool = True,
+                full_style = False):
         """
         Set the GUI if wxPython is running
 
@@ -390,9 +522,15 @@ class Wolf_Param(wx.Frame):
         :param withbuttons : if True, buttons will be displayed
         :param DestroyAtClosing : if True, the frame will be destroyed when closed
         :param toShow : if True, the frame will be displayed
-
+        :param full_style : if True, the full style of the PropertyGridManager will be displayed even if ontop is True
         """
 
+        self.wx_exists = wx.App.Get() is not None # test if wx App is running
+
+        if not self.wx_exists:
+            logging.error("wxPython is not running - Impossible to set the GUI")
+            return
+
         #Appel à l'initialisation d'un frame général
         if ontop:
             wx.Frame.__init__(self, parent, title=title, size=(w,h),style=wx.DEFAULT_FRAME_STYLE| wx.STAY_ON_TOP)
@@ -421,11 +559,24 @@ class Wolf_Param(wx.Frame):
 
         #ajout d'un widget de gestion de propriétés
         if ontop:
-            self.prop = pg.PropertyGridManager(self,
-                style = pg.PG_BOLD_MODIFIED|pg.PG_SPLITTER_AUTO_CENTER|
-                # Plus defaults.
-                pg.PGMAN_DEFAULT_STYLE
-            )
+            if full_style:
+                self.prop = pg.PropertyGridManager(self,
+                    style = pg.PG_BOLD_MODIFIED|pg.PG_SPLITTER_AUTO_CENTER|
+                    # Include toolbar.
+                    pg.PG_TOOLBAR |
+                    # Include description box.
+                    pg.PG_DESCRIPTION |
+                    pg.PG_TOOLTIPS |
+                    # Plus defaults.
+                    pg.PGMAN_DEFAULT_STYLE
+                )
+            else:
+                self.prop = pg.PropertyGridManager(self,
+                    style = pg.PG_BOLD_MODIFIED|pg.PG_SPLITTER_AUTO_CENTER|
+                    pg.PG_TOOLTIPS |
+                    # Plus defaults.
+                    pg.PGMAN_DEFAULT_STYLE
+                )
         else:
             self.prop = pg.PropertyGridManager(self,
                 style = pg.PG_BOLD_MODIFIED|pg.PG_SPLITTER_AUTO_CENTER|
@@ -463,6 +614,22 @@ class Wolf_Param(wx.Frame):
         #affichage de la page
         self.Show(toShow)
 
+    def _set_only_prop(self, wxparent):
+        """ Set only the property grid """
+
+        self.prop = pg.PropertyGridManager(wxparent,
+            style = pg.PG_BOLD_MODIFIED|pg.PG_SPLITTER_AUTO_CENTER|
+            # Include toolbar.
+            pg.PG_TOOLBAR |
+            # Include description box.
+            pg.PG_DESCRIPTION |
+            pg.PG_TOOLTIPS |
+            # Plus defaults.
+            pg.PGMAN_DEFAULT_STYLE
+        )
+
+        self.prop.Bind(pg.EVT_PG_DOUBLE_CLICK,self.OnDblClick)
+
     def hide_selected_buttons(self, to_hide:list[Buttons] = [Buttons.Load, Buttons.Save, Buttons.Reload]):
         """ Mask selected buttons - Default conserve only 'Apply change' """
 
@@ -476,6 +643,8 @@ class Wolf_Param(wx.Frame):
             elif locbutton == Buttons.Apply:
                 self.sizerbut.Hide(self.applychange)
 
+        self.Layout()
+
     def OnDblClick(self, event:wx.MouseEvent):
         """
         Double-click event handler to add a parameter to the active tab or reset to default value.
@@ -599,11 +768,11 @@ class Wolf_Param(wx.Frame):
             self._update_IncGroup(withGUI=True)
             self._update_IncParam(withGUI=True)
 
-            if not self._callback is None:
+            if self._callback is not None:
                 self._callback()
         else:
-            if self.wx_exists:
-                dlg = wx.MessageDialog(self,'Nothing to do!')
+            if self.has_gui:
+                dlg = wx.MessageDialog(None,'Nothing to do!')
                 dlg.ShowModal()
 
     @property
@@ -633,6 +802,9 @@ class Wolf_Param(wx.Frame):
 
         """
 
+        if not self.wx_exists:
+            logging.error("wxPython is not running - Impossible to apply changes to memory")
+
         assert self.wx_exists, "wxPython is not running"
 
         if isIncrementable:
@@ -686,7 +858,7 @@ class Wolf_Param(wx.Frame):
         """ Position the frame """
         self.SetPosition(wx.Point(position[0],position[1]+50))
 
-    def Populate(self):
+    def Populate(self, sorted_groups:bool = False):
         """
         Filling the property management object based on dictionaries
 
@@ -696,7 +868,7 @@ class Wolf_Param(wx.Frame):
         """
 
         if self.prop is None:
-            logging.error("ERROR : wxPython is not running - Impossible to populate the property grid")
+            logging.debug("ERROR : wxPython is not running - Impossible to populate the property grid")
             return
 
         self.prop.Clear()
@@ -734,6 +906,10 @@ class Wolf_Param(wx.Frame):
 
         # Display a header above the grid
         self.prop.ShowHeader()
+
+        if sorted_groups:
+            self.prop.Sort()
+
         self.prop.Refresh()
 
     def _insert_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
@@ -754,44 +930,102 @@ class Wolf_Param(wx.Frame):
             param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
             param[key_Param.TYPE] = param_def[key_Param.TYPE]
 
-        if key_Param.ADDED_JSON in param.keys() and param[key_Param.ADDED_JSON] is not None:
+        if key_Param.ADDED_JSON in param.keys()  and param[key_Param.ADDED_JSON] is not None:
             # Ajout des choix via chaîne JSON
-            list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
-            list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
+            if param[key_Param.ADDED_JSON]['Values'] is not None:
 
-            page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(param[key_Param.VALUE])))
+                list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
+                list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
 
-            self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]['Full_Comment'])
+                value_param = self.value_as_type(param[key_Param.VALUE], param[key_Param.TYPE], )
+                if type(value_param) == str:
+                    try:
+                        value_param = int(value_param)
+                    except:
+                        logging.debug("String type will be conserved! -- {}".format(value_param))
+
+                page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
+            else:
+                self._insert_with_type_based_on_value(page, group, param, prefix)
+
+            self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]['Full_Comment']  + '\n\n' + param[key_Param.COMMENT])
         else:
 
-            locvalue = self[(group, param_name)]
+            self._insert_with_type_based_on_value(page, group, param, prefix)
 
-            if isinstance(locvalue, float):
-                page.AppendIn(parent, pg.FloatProperty(label = param_name, name = locname, value = locvalue))
+            self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
 
-            elif isinstance(locvalue, int):
-                # bool is also an int
-                if isinstance(locvalue, bool):
-                    page.AppendIn(parent, pg.BoolProperty(label=param_name, name = locname, value = locvalue))
-                else:
-                    page.AppendIn(parent, pg.IntProperty(label = param_name, name = locname, value = locvalue))
+    def _insert_with_type_based_on_value(self, page:pg.PropertyGridPage, group:str, param:dict, prefix:str=''):
 
-            elif param[key_Param.TYPE]==Type_Param.File:
-                page.AppendIn(parent, pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+        param_name = param[key_Param.NAME]
+        locname = prefix + group + param_name
+        locvalue = self[(group, param_name)]
 
-            elif param[key_Param.TYPE]==Type_Param.Directory:
-                page.AppendIn(parent, pg.DirProperty(label = param_name, name = locname, value = locvalue))
+        # Get parent item based on group name
+        parent = page.GetPropertyByName(group)
+        assert parent is not None, "Group {} not found in page".format(group)
+        assert isinstance(parent, pg.PropertyCategory), "Parent is not a PropertyCategory"
 
-            elif param[key_Param.TYPE]==Type_Param.Color:
-                page.AppendIn(parent, pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+        if isinstance(locvalue, float):
+            page.AppendIn(parent,pg.FloatProperty(label = param_name, name = locname, value = locvalue))
 
-            elif param[key_Param.TYPE]==Type_Param.Fontname:
-                page.AppendIn(parent, pg.FontProperty(label = param_name, name = locname, value = locvalue))
+        elif isinstance(locvalue, int):
+            # bool is also an int
+            if isinstance(locvalue, bool):
+                page.AppendIn(parent,pg.BoolProperty(label=param_name, name = locname, value = locvalue))
+            else:
+                page.AppendIn(parent,pg.IntProperty(label = param_name, name = locname, value = locvalue))
+
+        elif param[key_Param.TYPE]==Type_Param.File:
+            page.AppendIn(parent,pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+
+        elif param[key_Param.TYPE]==Type_Param.Directory:
+            page.AppendIn(parent,pg.DirProperty(label = param_name, name = locname, value = locvalue))
+            # newobj.SetLabel(param_name)
+            # page.Append(newobj)
+
+        elif param[key_Param.TYPE]==Type_Param.Color:
+            page.AppendIn(parent,pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+
+        elif param[key_Param.TYPE]==Type_Param.Fontname:
+            page.AppendIn(parent,pg.FontProperty(label = param_name, name = locname, value = locvalue))
+
+        else:
+            page.AppendIn(parent,pg.StringProperty(label = param_name, name = locname, value = locvalue))
+
+    def _add_with_type_based_on_value(self, page:pg.PropertyGridPage, group:str, param:dict, prefix:str=''):
+
+        param_name = param[key_Param.NAME]
+        locname = prefix + group + param_name
+
+        locvalue = self._get_param_def(group, param_name) if prefix == PREFIX_DEFAULT else self[(group, param_name)]
+
+        if isinstance(locvalue, float):
+            page.Append(pg.FloatProperty(label = param_name, name = locname, value = locvalue))
 
+        elif isinstance(locvalue, int):
+            # bool is also an int
+            if isinstance(locvalue, bool):
+                page.Append(pg.BoolProperty(label=param_name, name = locname, value = locvalue))
             else:
-                page.AppendIn(parent, pg.StringProperty(label = param_name, name = locname, value = locvalue))
+                page.Append(pg.IntProperty(label = param_name, name = locname, value = locvalue))
 
-            self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
+        elif param[key_Param.TYPE]==Type_Param.File:
+            page.Append(pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+
+        elif param[key_Param.TYPE]==Type_Param.Directory:
+            page.Append(pg.DirProperty(label = param_name, name = locname, value = locvalue))
+            # newobj.SetLabel(param_name)
+            # page.Append(newobj)
+
+        elif param[key_Param.TYPE]==Type_Param.Color:
+            page.Append(pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+
+        elif param[key_Param.TYPE]==Type_Param.Fontname:
+            page.Append(pg.FontProperty(label = param_name, name = locname, value = locvalue))
+
+        else:
+            page.Append(pg.StringProperty(label = param_name, name = locname, value = locvalue))
 
     def _add_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
         """ Add an element to a page """
@@ -807,51 +1041,36 @@ class Wolf_Param(wx.Frame):
             param[key_Param.TYPE] = param_def[key_Param.TYPE]
 
         if key_Param.ADDED_JSON in param.keys() and param[key_Param.ADDED_JSON] is not None:
-            # Ajout des choix via chaîne JSON
-            list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
-            list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
-            # FIXME : TO GENERALIZE!!!
-            value_param = self.value_as_type(param[key_Param.VALUE], param[key_Param.TYPE], )
-            if type(value_param) == str:
-                try:
-                    value_param = int(value_param)
-                except:
-                    logging.debug("String type will be conserved! -- {}".format(value_param))
-            # print(value_param)
-            page.Append(pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
-            if "Full_Comment" in param[key_Param.ADDED_JSON]:
-                self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]["Full_Comment"])
-
-        else:
 
-            locvalue = self[(group, param_name)]
+            # Ajout des choix via chaîne JSON
+            if param[key_Param.ADDED_JSON]['Values'] is not None:
 
-            if isinstance(locvalue, float):
-                page.Append(pg.FloatProperty(label = param_name, name = locname, value = locvalue))
+                list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
+                list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
 
-            elif isinstance(locvalue, int):
-                # bool is also an int
-                if isinstance(locvalue, bool):
-                    page.Append(pg.BoolProperty(label=param_name, name = locname, value = locvalue))
-                else:
-                    page.Append(pg.IntProperty(label = param_name, name = locname, value = locvalue))
+                # FIXME : TO GENERALIZE!!!
+                value_param = self.value_as_type(param[key_Param.VALUE], param[key_Param.TYPE], )
+                if type(value_param) == str:
+                    try:
+                        value_param = int(value_param)
+                    except:
+                        logging.debug("String type will be conserved! -- {}".format(value_param))
+                # print(value_param)
+                page.Append(pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=value_param))
 
-            elif param[key_Param.TYPE]==Type_Param.File:
-                page.Append(pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+            else:
+                # Pas de chaîne JSON mais un commentaire complet
+                self._add_with_type_based_on_value(page, group, param, prefix)
 
-            elif param[key_Param.TYPE]==Type_Param.Directory:
-                page.Append(pg.DirProperty(label = param_name, name = locname, value = locvalue))
-                # newobj.SetLabel(param_name)
-                # page.Append(newobj)
 
-            elif param[key_Param.TYPE]==Type_Param.Color:
-                page.Append(pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+            if "Full_Comment" in param[key_Param.ADDED_JSON]:
+                self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]["Full_Comment"] + '\n\n' + param[key_Param.COMMENT])
+            else:
+                self.prop.SetPropertyHelpString(locname , param[key_Param.COMMENT])
 
-            elif param[key_Param.TYPE]==Type_Param.Fontname:
-                page.Append(pg.FontProperty(label = param_name, name = locname, value = locvalue))
+        else:
 
-            else:
-                page.Append(pg.StringProperty(label = param_name, name = locname, value = locvalue))
+            self._add_with_type_based_on_value(page, group, param, prefix)
 
             self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
 
@@ -1234,6 +1453,8 @@ class Wolf_Param(wx.Frame):
 
             if not paramloc[0] in self.myIncParam[groupname]:
                 curdict = self.myIncParam[groupname][paramloc[0]] = self._new_IncParam_dict(groupname, groupname if len(iterInfo)==3 else iterInfo[0], iterInfo[-3], iterInfo[-2], iterInfo[-1])
+            else:
+                curdict = self.myIncParam[groupname][paramloc[0]]
 
             if not "Saved" in curdict:
                 curdict["Saved"] = {}
@@ -1392,6 +1613,7 @@ class Wolf_Param(wx.Frame):
                  jsonstr:str = None,
                  whichdict:Literal['All', 'Default', 'Active', 'IncGroup', '']=''):
         """alias of addparam"""
+
         return self.addparam(groupname, name, value, type, comment, jsonstr, whichdict)
 
     def __getitem__(self, key:tuple[str, str]):
@@ -1549,6 +1771,22 @@ class Wolf_Param(wx.Frame):
         curType = self.get_type(group, name)
         return self.value_as_type(element, curType)
 
+    def _get_param_def(self, group:str, name:str, default_value=None):
+        """
+        Returns the default value of the parameter if found, otherwise None obj
+
+        """
+
+        if self.is_in_default(group, name):
+            element = self.myparams_default[group][name][key_Param.VALUE]
+        else:
+            element  = default_value
+            return element
+
+        # String conversion according to its type
+        curType = self.get_type(group, name)
+        return self.value_as_type(element, curType)
+
     def get_group(self, group:str) -> dict:
         """
         Return the group dictionnary if found, otherwise None obj
@@ -1564,6 +1802,69 @@ class Wolf_Param(wx.Frame):
         else:
             return None
 
+    def get_help(self, group:str, name:str) -> list[str, str]:
+        """
+        Return the help string if found, otherwise None obj
+
+        :return: [comment, full_comment]
+        """
+
+        if self.is_in_default(group, name):
+            curdict = self.myparams_default[group][name]
+            ret = [curdict[key_Param.COMMENT]]
+
+            if key_Param.ADDED_JSON in curdict.keys():
+                if curdict[key_Param.ADDED_JSON] is not None:
+                    if 'Full_Comment' in curdict[key_Param.ADDED_JSON].keys():
+                        ret += [curdict[key_Param.ADDED_JSON]['Full_Comment']]
+                    else:
+                        ret += ['']
+                else:
+                    ret += ['']
+            else:
+                ret += ['']
+
+            return ret
+
+        elif self.is_in_active(group, name):
+            curdict = self.myparams[group][name]
+            ret = [curdict[key_Param.COMMENT]]
+            if key_Param.ADDED_JSON in curdict.keys():
+                if curdict[key_Param.ADDED_JSON] is not None:
+                    if 'Full Comment' in curdict[key_Param.ADDED_JSON].keys():
+                        ret += [curdict[key_Param.ADDED_JSON]['Full_Comment']]
+                    else:
+                        ret += ['']
+                else:
+                    ret += ['']
+            else:
+                ret += ['']
+
+            return ret
+
+        else:
+            return None
+
+    def get_json_values(self, group:str, name:str) -> dict:
+        """
+        Return the 'values' in json string if found, otherwise None obj
+        """
+
+        if self.is_in_default(group, name):
+            curdict = self.myparams_default[group][name]
+            if key_Param.ADDED_JSON in curdict.keys():
+                if 'Values' in curdict[key_Param.ADDED_JSON].keys():
+                    return curdict[key_Param.ADDED_JSON]['Values']
+
+        elif self.is_in_active(group, name):
+            curdict = self.myparams[group][name]
+            if key_Param.ADDED_JSON in curdict.keys():
+                if 'Values' in curdict[key_Param.ADDED_JSON].keys():
+                    return curdict[key_Param.ADDED_JSON]['Values']
+
+        else:
+            return {}
+
     def _detect_type_from_value(self, value:Union[float, int, str, bool, tuple[int, int, int]]) -> Type_Param:
         """ Detect the type from the value """