mg-pso-gui 0.0.1__py3-none-any.whl

mg-pso-gui/BoundsEditorWindow.py

@@ -0,0 +1,74 @@
+from typing import Union, Tuple, Optional
+
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkInputDialog
+from ListParametersView import ListParametersView
+
+class BoundsEditorWindow(CTkInputDialog):
+    """
+    Dialog with extra window, message, entry widget, cancel and ok button.
+    For detailed information check out the documentation.
+    """
+
+    def __init__(self, *args,
+                 step_index: 0,
+                 bound_index: 0,
+                 option_manager: None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.geometry("400x800")
+        
+        self.step_index = step_index
+        self.bound_index = bound_index  
+        self.option_manager = option_manager
+        self.bounds = None
+
+    def _create_widgets(self):
+
+        self.grid_columnconfigure((0, 1), weight=1)
+        self.rowconfigure(0, weight=1)
+
+        self.bounds = ListParametersView(
+                self, step_index=self.step_index, bound_index=self.bound_index, option_manager=self.option_manager)
+        self.bounds.grid(row=0, column=0, columnspan=2, padx=(10, 10),
+                    pady=(10, 10), sticky="nsew")
+        self.bounds.grid_columnconfigure(0, weight=1)
+
+        self._ok_button = CTkButton(master=self,
+                                    width=100,
+                                    border_width=0,
+                                    fg_color=self._button_fg_color,
+                                    hover_color=self._button_hover_color,
+                                    text_color=self._button_text_color,
+                                    text='Save',
+                                    command=self._ok_event)
+        self._ok_button.grid(row=2, column=0, columnspan=1, padx=(20, 10), pady=(0, 20), sticky="ew")
+
+        self._cancel_button = CTkButton(master=self,
+                                        width=100,
+                                        border_width=0,
+                                        fg_color=self._button_fg_color,
+                                        hover_color=self._button_hover_color,
+                                        text_color=self._button_text_color,
+                                        text='Cancel',
+                                        command=self._ok_event)
+        self._cancel_button.grid(row=2, column=1, columnspan=1, padx=(10, 20), pady=(0, 20), sticky="ew")
+        
+    def _ok_event(self, event=None):
+        # Save values in bounds editor...
+        
+        self.bounds.push_to_option_manager()
+        
+        self.grab_release()
+        self.destroy()
+
+    def _on_closing(self):
+        self.grab_release()
+        self.destroy()
+
+    def _cancel_event(self):
+        self.grab_release()
+        self.destroy()

mg-pso-gui/BoundsList.py

@@ -0,0 +1,263 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkOptionMenu
+from customtkinter import CTkTextbox
+from customtkinter import CTkImage
+from BoundsEditorWindow import BoundsEditorWindow
+from CTkToolTip import *
+import tkinter as tk
+import json
+import PIL
+from PIL import Image
+import os
+
+
+optParams = []
+
+details = json.load(open("bounds.json", "r"))
+paramMap = {}
+for param in details["parameter"]:
+    paramMap[param["name"]] = param
+    if "min" in param:
+        optParams.append(param["name"])
+        
+optParams.sort()
+
+class BoundsList(CTkFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 step_index: 0,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.edit_mode = False
+        self.tooltip_list = []
+        
+        self.option_manager = option_manager
+        self.step_index = step_index 
+        self.render()
+    
+    def clear(self):
+        for list in self.tooltip_list:
+            for tooltip in list:
+                tooltip.destroy()
+        self.containerFrame.destroy()
+        self.tooltip_list = []
+        
+    def toggle_edit_mode(self):
+        self.clear()
+        self.edit_mode = not self.edit_mode
+        self.render()
+        
+    def refresh(self, *args):
+        self.clear()
+        self.render()
+        
+    def render(self):
+        row = 0
+        index = 0
+        
+        self.tooltip_list = []
+        
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        self.containerFrame.grid_columnconfigure(0, weight=1, minsize=20)
+        self.containerFrame.grid_columnconfigure(5, weight=1, minsize=20)
+        self.containerFrame.grid_columnconfigure((1, 2, 3, 4), weight=5)
+        
+        CTkLabel(self.containerFrame, text="Type:").grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        CTkLabel(self.containerFrame, text="Name:").grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        CTkLabel(self.containerFrame, text="Bounds:").grid(row=row, column=2, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        CTkLabel(self.containerFrame, text="Default:").grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        CTkLabel(self.containerFrame, text="Strategy:").grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        row += 1
+        
+        bounds = self.option_manager.get_steps()[self.step_index]["param"]
+        
+        for bound in bounds:
+            tt1 = None
+            tt2 = None
+            tt3 = None
+                        
+            tt = CTkOptionMenu(self.containerFrame, dynamic_resizing=False, values=['float', 'int', 'list', 'string', 'custom'], variable=bound["type"], command=self.refresh)
+            #command = lambda _, index=index, option=tt: (self.update_type(index, option)) 
+            #tt.configure(command=command)
+            #tt.set(bound["type"].get())
+            tt.grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="new")
+            
+            cc = None
+            
+            bound_type = bound["type"].get()
+            
+            if bound_type == "float":
+                cc = CTkOptionMenu(self.containerFrame, dynamic_resizing=False, values=optParams, variable=bound["name"])
+                cc.grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="new")
+                
+                command = lambda _, index=index: (self.update_values(index), self.update_tooltips(index))  
+                cc.configure(command=command)
+            else:
+                
+                cc = CTkEntry(self.containerFrame)
+                cc.configure(textvariable=bound["name"])
+                cc.grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="new")
+                
+                        
+            if self.edit_mode:
+                remove_func = lambda index=index: (self.clear(), self.option_manager.remove_bound(self.step_index, index), self.render())
+                bb = CTkButton(self.containerFrame, text="Remove", command=remove_func)
+                bb.grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
+                CTkToolTip(bb, delay=0.1, alpha=0.95, message="Delete this bound...")
+            else:
+                bounds_min = CTkEntry(self.containerFrame)
+                vcmd = (self.register(self.validate_number), '%P', cc, bounds_min)
+                bounds_min.grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
+                bounds_min.configure(textvariable=bound["bounds"][0], validate='all', validatecommand=vcmd)
+                self.validate_number(bounds_min.get(), cc, bounds_min)
+                            
+                bounds_max = CTkEntry(self.containerFrame)
+                vcmd = (self.register(self.validate_number), '%P', cc, bounds_max)
+                bounds_max.grid(row=row, column=3, padx=(5, 5), pady=(5, 5), sticky="new")
+                bounds_max.configure(textvariable=bound["bounds"][1], validate='all', validatecommand=vcmd)
+                self.validate_number(bounds_max.get(), cc, bounds_max)
+                tt2 = CTkToolTip(bounds_max, delay=0.1, alpha=0.95, message="...")
+                
+                default_value = CTkEntry(self.containerFrame)
+                default_value.grid(row=row, column=4, padx=(5, 5), pady=(5, 5), sticky="new")
+                default_value.configure(textvariable=bound["default_value"])
+            
+                
+                if (bound_type == "list"):
+                    def button_click_event(bound_index):
+                        dialog = BoundsEditorWindow(title="Edit List Bound", step_index=self.step_index, bound_index=bound_index, option_manager=self.option_manager)
+                        print("Number:", dialog.get_input())
+
+                    open_window = lambda event=None, bound_index=index: (button_click_event(bound_index))
+                    expand_image = CTkImage(Image.open(os.path.join("./images", "expand.png")), size=(20, 20))
+                    button = CTkButton(self.containerFrame, width=30, text=None, image=expand_image, command=open_window)
+                    button.grid(row=row, column=6, padx=(5, 5), pady=(5, 5), sticky="new")
+                
+                calibration_strat = CTkOptionMenu(self.containerFrame, dynamic_resizing=False, values=['none', 'mean', 'single'], variable=bound["calibration_strategy"])
+                calibration_strat.grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="new")
+                
+                tt1 = CTkToolTip(bounds_min, delay=0.1, alpha=0.95, message="...")
+                tt2 = CTkToolTip(bounds_max, delay=0.1, alpha=0.95, message="...")
+                if cc is not None:
+                    tt3 = CTkToolTip(cc, delay=0.1, alpha=0.95, message="...")
+                        
+                self.tooltip_list.append([tt3, tt1, tt2])
+                        
+                self.update_tooltips(index)
+            
+            row += 1
+            index += 1
+            
+        add_func = lambda: (self.clear(), self.option_manager.add_bound(self.step_index), self.render())
+        if len(bounds) > 0:
+            if self.edit_mode:
+                CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="new")
+            else:
+                CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="new")
+            CTkButton(self.containerFrame, text="Add Parameter", command=add_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="new")
+        else:
+            CTkButton(self.containerFrame, text="Add Parameter", command=add_func).grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="new")
+            
+    def update_type(self, index, option):
+        value = option.get()
+        self.option_manager.get_steps()[self.step_index]["param"][index]["type"].set(value)
+        self.refresh()
+            
+    def update_values(self, index):
+        name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
+        if name in paramMap:
+            obj = paramMap[name]
+            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][0].set(obj["softmin"])
+            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][1].set(obj["softmax"])
+            
+    def update_tooltips(self, index):
+        try:
+            name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
+            bound_type = self.option_manager.get_steps()[self.step_index]["param"][index]["type"].get()
+            
+            tooltips = self.tooltip_list[index]
+            t3 = tooltips[0]
+            t1 = tooltips[1]
+            t2 = tooltips[2]
+            
+            if (t1 == None or t2 == None or t3 == None):
+                if (t1 is not None):
+                    t1.configure(message="")
+                if (t2 is not None):
+                    t2.configure(message="")
+                if (t3 is not None):
+                    t3.configure(message="")
+                print("update skipped")
+                return
+            
+            if bound_type == "list":
+                t1.configure(message="")
+                t2.configure(message="")
+                t3.configure(message="")
+            
+            if name in paramMap:
+                obj = paramMap[name]
+                description = obj["description"]
+                default = str(obj["value"])
+                min = str(obj["min"])
+                max = str(obj["max"])
+                softmin = str(obj["softmin"])
+                softmax = str(obj["softmax"])
+                unit = str(obj["unit"])
+                t1.configure(message=description + "\nMin: " + min + "\nSoft Min: " + softmin + "\nUnit: " + unit)
+                t2.configure(message=description + "\nMax: " + max + "\nSoft Max: " + softmax + "\nUnit: " + unit)
+                t3.configure(message=description + "\nDefault: " + default + "\nUnit: " + unit)
+        except:
+            pass
+        
+    def validate_number(self, P, name, entry):
+        
+        # Get the root window
+        root = self.winfo_toplevel()
+        
+        # Get the entry widget using its internal Tkinter name
+        entry_widget = root.nametowidget(entry)
+        name_widget = root.nametowidget(name)
+        
+        if isinstance(name_widget, CTkTextbox):
+            return True
+        
+        # Call the get method on the entry widget
+        bound_name = name_widget.get()
+        value = entry_widget.get()
+        
+        # Print the value of the entry widget
+        #print(bound_name)
+        
+        if P == "" or P == "." or P == "-":
+            entry_widget.configure(border_color="red")
+            return True
+        
+        try:
+            float(P)
+            entry_widget.configure(border_color=["#979DA2", "#565B5E"])
+            
+            if bound_name in paramMap:
+                obj = paramMap[bound_name]
+                if "min" in obj and float(P) < float(obj["min"]):
+                    entry_widget.configure(border_color="red")
+                elif "max" in obj and float(P) > float(obj["max"]):
+                    entry_widget.configure(border_color="red")
+                elif "softmin" in obj and float(P) < float(obj["softmin"]):
+                    entry_widget.configure(border_color="yellow")
+                elif "softmax" in obj and float(P) > float(obj["softmax"]):
+                    entry_widget.configure(border_color="yellow")
+            
+            return True
+        except ValueError as e:
+            print(e)
+            return False
+        except Exception as e:
+            print(e)
+            return False

mg-pso-gui/CTkToolTip/__init__.py

@@ -0,0 +1,11 @@
+"""
+CustomTkinter ToolTip
+Author: Akash Bora
+This is a tooltip/pop-up widget made with customtkinter.
+Homepage: https://github.com/Akascape/CTkToolTip
+"""
+
+__version__ = '0.4'
+
+from .ctk_tooltip import CTkToolTip
+

mg-pso-gui/CTkToolTip/ctk_tooltip.py

@@ -0,0 +1,187 @@
+"""
+CTkToolTip Widget
+version: 0.4
+"""
+
+import time
+import sys
+import customtkinter
+from tkinter import Toplevel, Frame
+
+class CTkToolTip(Toplevel):
+    """
+    Creates a ToolTip (pop-up) widget for customtkinter.
+    """
+
+    def __init__(
+        self,
+        widget: any = None,
+        message: str = None,
+        delay: float = 0.2,
+        follow: bool = True,
+        x_offset: int = +20,
+        y_offset: int = +10,
+        bg_color: str = None,
+        corner_radius: int = 10,
+        border_width: int = 0,
+        border_color: str = None,
+        alpha: float = 0.8,
+        padding: tuple = (10,2),
+        **message_kwargs):
+        
+        super().__init__()
+
+        self.widget = widget
+        
+        self.withdraw()
+        # Disable ToolTip's title bar
+        self.overrideredirect(True)
+                
+        if sys.platform.startswith("win"):
+            self.transparent_color = self.widget._apply_appearance_mode(customtkinter.ThemeManager.theme["CTkToplevel"]["fg_color"])
+            self.attributes("-transparentcolor", self.transparent_color)
+            self.transient()
+        elif sys.platform.startswith("darwin"):
+            self.transparent_color = 'systemTransparent'
+            self.attributes("-transparent", True)
+            self.transient(self.master)
+        else:
+            self.transparent_color = '#000001'
+            corner_radius = 0
+            self.transient()
+            
+        self.resizable(width=True, height=True)
+        self.transient()
+        
+        # Make the background transparent
+        self.config(background=self.transparent_color)
+        
+        # StringVar instance for msg string
+        self.messageVar = customtkinter.StringVar()
+        self.message = message
+        self.messageVar.set(self.message)
+      
+        self.delay = delay
+        self.follow = follow
+        self.x_offset = x_offset
+        self.y_offset = y_offset
+        self.corner_radius = corner_radius
+        self.alpha = alpha
+        self.border_width = border_width
+        self.padding = padding
+        self.bg_color = bg_color
+        self.border_color = border_color
+        self.disable = False
+        
+        # visibility status of the ToolTip inside|outside|visible
+        self.status = "outside"
+        self.last_moved = 0
+        self.attributes('-alpha', self.alpha)
+        
+        # Add the message widget inside the tooltip
+        self.transparent_frame = Frame(self, bg=self.transparent_color)
+        self.transparent_frame.pack(padx=0, pady=0, fill="both", expand=True)
+        
+        self.frame = customtkinter.CTkFrame(self.transparent_frame, bg_color=self.transparent_color, corner_radius=self.corner_radius,
+                                            border_width=self.border_width, fg_color=self.bg_color, border_color=self.border_color)
+        self.frame.pack(padx=0, pady=0, fill="both", expand=True)
+        
+        self.message_label = customtkinter.CTkLabel(self.frame, textvariable=self.messageVar, **message_kwargs)
+        self.message_label.pack(fill="both", padx=self.padding[0]+self.border_width,
+                                pady=self.padding[1]+self.border_width, expand=True)
+
+        if self.widget != None:
+            if self.widget.winfo_name()!="tk":
+                if self.frame.cget("fg_color")==self.widget.cget("bg_color"):
+                    if not bg_color:             
+                        self._top_fg_color = self.frame._apply_appearance_mode(customtkinter.ThemeManager.theme["CTkFrame"]["top_fg_color"])
+                        self.frame.configure(fg_color=self._top_fg_color)
+
+            # Add bindings to the widget without overriding the existing ones
+            self.widget.bind("<Enter>", self.on_enter, add="+")
+            self.widget.bind("<Leave>", self.on_leave, add="+")
+            self.widget.bind("<Motion>", self.on_enter, add="+")
+            self.widget.bind("<B1-Motion>", self.on_enter, add="+")
+            self.widget.bind("<Destroy>", lambda _: self.hide(), add="+")
+
+    def show(self) -> None:
+        """
+        Enable the widget.
+        """
+        self.disable = False
+        
+    def on_enter(self, event) -> None:
+        """
+        Processes motion within the widget including entering and moving.
+        """
+
+        if self.disable: return
+        self.last_moved = time.time()
+
+        # Set the status as inside for the very first time
+        if self.status == "outside":
+            self.status = "inside"
+
+        # If the follow flag is not set, motion within the widget will make the ToolTip dissapear
+        if not self.follow:
+            self.status = "inside"
+            self.withdraw()
+
+        # Offsets the ToolTip using the coordinates od an event as an origin
+        self.geometry(f"+{event.x_root + self.x_offset}+{event.y_root + self.y_offset}")
+
+        # Time is in integer: milliseconds
+        self.after(int(self.delay * 1000), self._show)
+
+    def on_leave(self, event=None) -> None:
+        """
+        Hides the ToolTip temporarily.
+        """
+
+        if self.disable: return
+        self.status = "outside"
+        self.withdraw()
+
+    def _show(self) -> None:
+        """
+        Displays the ToolTip.
+        """
+
+        if not self.widget.winfo_exists():
+            self.hide()
+            self.destroy()
+            
+        if self.status == "inside" and time.time() - self.last_moved >= self.delay:
+            self.status = "visible"
+            self.deiconify()
+        
+    def hide(self) -> None:
+        """
+        Disable the widget from appearing.
+        """
+        if not self.winfo_exists():
+            return
+        self.withdraw()
+        self.disable = True
+
+    def is_disabled(self) -> None:
+        """
+        Return the window state
+        """
+        return self.disable
+    
+    def get(self) -> None:
+        """
+        Returns the text on the tooltip.
+        """  
+        return self.messageVar.get()
+    
+    def configure(self, message: str = None, delay: float = None, bg_color: str = None, **kwargs):
+        """
+        Set new message or configure the label parameters.
+        """
+        if delay: self.delay = delay
+        if bg_color: self.frame.configure(fg_color=bg_color)
+        
+        self.messageVar.set(message)
+        self.message_label.configure(**kwargs)

mg-pso-gui/CalibrationParametersView.py

@@ -0,0 +1,61 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+import tkinter as tk
+
+global option_manager
+
+class CalibrationParametersView(CTkScrollableFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.option_manager = option_manager
+        self.key_values = option_manager.get_arguments()['calibration_parameters']
+        self.edit_mode = False
+        
+        self.render()
+
+    def clear(self):
+        self.containerFrame.destroy()
+        
+    def toggle_edit_mode(self):
+        self.clear()
+        self.edit_mode = not self.edit_mode
+        self.render()
+        
+    def render(self):
+        row = 0
+        index = 0
+        
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        self.containerFrame.grid_columnconfigure((0, 1), weight=1)
+        
+        CTkLabel(self.containerFrame, text="Name:").grid(row=row, column=0, columnspan=1, padx=5, pady=5, sticky="")
+        CTkLabel(self.containerFrame, text="Value:").grid(row=row, column=1, columnspan=1, padx=5, pady=5, sticky="")
+        row += 1
+        
+        for key_value_pair in self.key_values:
+            CTkEntry(self.containerFrame, textvariable=self.key_values[index]["name"]).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+            if self.edit_mode:
+                return_func = lambda index=index: (self.clear(), self.option_manager.remove_calibration_parameter(index), self.render())
+                CTkButton(self.containerFrame, text="Remove", command=return_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+            else:
+                bb = CTkEntry(self.containerFrame)
+                bb.grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+                bb.configure(textvariable=self.key_values[index]["value"])
+            row += 1
+            index += 1
+            
+        if self.edit_mode:
+            CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+        else:
+            CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+        add_key_func = lambda: (self.clear(), self.option_manager.add_calibration_param("name", "value"), self.render())
+        CTkButton(self.containerFrame, text="Add Parameter", command=add_key_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")

mg-pso-gui/FunctionsList.py

@@ -0,0 +1,83 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkOptionMenu
+import tkinter as tk
+
+# TODO: Add weights to interface for each function
+
+class FunctionsList(CTkFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 step_index: 0,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+
+        self.option_manager = option_manager
+        self.step_index = step_index
+
+        self.edit_mode = False
+        self.render()
+    
+    def clear(self):
+        self.containerFrame.destroy()
+        
+    def toggle_edit_mode(self):
+        self.clear()
+        self.edit_mode = not self.edit_mode
+        self.render()
+        
+    def render(self):
+        
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        self.containerFrame.grid_columnconfigure((0, 1), weight=1)
+        
+        row = 1
+        
+        funcs = self.option_manager.get_steps()[self.step_index]["objfunc"]
+        
+        index = 0
+        for func in funcs:
+            
+            CTkLabel(self.containerFrame, text="Name:").grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+            CTkLabel(self.containerFrame, text="Objective:").grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="nsew")
+            CTkLabel(self.containerFrame, text="Weight:").grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
+            
+            row += 1
+            
+            CTkEntry(self.containerFrame, textvariable=func["name"]).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            CTkEntry(self.containerFrame, textvariable=func["of"]).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+            CTkEntry(self.containerFrame, textvariable=func["weight"]).grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+            row += 1
+            
+            CTkLabel(self.containerFrame, text="Data:").grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+            
+            row += 1
+            for obj in func["data"]:
+                CTkEntry(self.containerFrame, textvariable=obj).grid(row=row, column=0, columnspan=3, padx=(5, 5), pady=(5, 5), sticky="nsew")
+                row += 1
+            
+            if self.edit_mode:
+                remove_func = lambda index=index: (self.clear(), self.option_manager.remove_function(self.step_index, index), self.render())
+                CTkButton(self.containerFrame, text="Remove", command=remove_func).grid(row=row, column=0, columnspan=3, padx=(5, 5), pady=(5, 5), sticky="ew")
+                row += 1
+                pass
+            else:
+                pass
+            index += 1
+            row += 1
+            
+        add_function = lambda: (self.clear(), self.option_manager.add_function(self.step_index), self.render())
+        if len(funcs) > 0:
+            if self.edit_mode:
+                CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            else:
+                CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            CTkButton(self.containerFrame, text="Add Objective Function", command=add_function).grid(row=row, column=1, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="ew")
+        else:
+            CTkButton(self.containerFrame, text="Add Objective Function", command=add_function).grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="ew")