Example #1
0
class LinksView(View):
    def __init__(self, parent):
        super().__init__(parent)
        self['text'] = 'Links'
        self.update_idletasks()
        h = self.parent.winfo_reqheight()
        w = self.parent.winfo_reqwidth()

        self._flow = None
        self._grid_rows_descr: List[Dict] = []
        self._possible_input: List[str] = []
        self._active_wd_idx = -1

        self.grid()
        self.rowconfigure(0, weight=1)
        self.rowconfigure(1, weight=1)

        self._infovar = StringVar()
        self._info_entry = Entry(self,
                                 name='flow_info',
                                 textvariable=self._infovar,
                                 width=35)
        self._info_entry.grid(row=0,
                              column=0,
                              padx=PADX,
                              pady=PADY,
                              sticky=N + W + E)
        self._info_desr = {
            'getter': self._infovar.get,
            'setter': self._infovar.set,
            'wd': self._info_entry
        }
        # Content will be scrolable
        self._content = ScrolledFrame(self,
                                      use_ttk=True,
                                      height=int(h / 5),
                                      width=int((w / 2)))
        self._content.grid(row=1,
                           column=0,
                           padx=PADX,
                           pady=PADY_S,
                           sticky=W + E)
        # Create the params frame within the ScrolledFrame
        self._links_view = self._content.display_widget(Frame)
        return

    @property
    def descriptors(self) -> List[Dict]:
        return self._grid_rows_descr

    @property
    def info_descr(self) -> str:
        return self._info_desr

    def get_active_item_link_descriptors(self) -> List[List[Widget]]:
        if self._active_wd_idx < 0:
            return None
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        return descriptors

    def clear(self) -> None:
        self._infovar.set('')
        for child in self._links_view.winfo_children():
            child.grid_remove()
        self._grid_rows_descr.clear()
        self._content.scroll_to_top()
        self._possible_input.clear()
        self._active_wd_idx = -1
        return

    def build(self, flow: FlowModel) -> None:
        self._flow = flow
        self._infovar.set(flow.info)
        items = copy.deepcopy(flow.items)
        for i, item in enumerate(items):
            item_links_frame = self._create_item_links_container(i + 1, item)
            item_links_frame.grid(row=i + 1, column=0, padx=PADX, sticky=W + E)
            item_links_frame.columnconfigure(0, weight=1)
            item_links_frame.columnconfigure(1, weight=1)
            item_links_descr = self._create_item_links_widgets(
                item_links_frame, i, item)
            self._grid_rows_descr.append(item_links_descr)
        self._disable_all()
        self._active_wd_idx = 0
        self._hightlighte_active_wd(True)
        self._set_active_wd_state(True)
        return

    def _create_item_links_container(self, idx: int,
                                     item: FlowItemModel) -> Widget:
        i_n = item.name.replace('.', '-')
        name = f'--{idx}-{i_n}--'
        item_links_frame = LabelFrame(self._links_view, name=name)
        return item_links_frame

    def _create_item_links_widgets(self, container: LabelFrame, idx: int,
                                   item: FlowItemModel) -> Dict:
        item_links_descr = []
        title = f'{idx}-{item.name}'
        i_n = item.name.replace('.', '-')
        name = f'--{idx}-{i_n}--'
        item_label = Label(container, name=name, text=title)
        item_label.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W)
        item_links_descr.append({
            'name': item_label.winfo_name(),
            'getter': None,
            'setter': None,
            'wd': item_label
        })
        infovar = StringVar()
        infovar.set(item.title)
        info_entry = Entry(container, textvariable=infovar, width=38)
        info_entry.grid(row=0, column=1, padx=PADX_S, pady=PADY_S, sticky=E)
        item_links_descr.append({
            'name': info_entry.winfo_name(),
            'getter': infovar.get,
            'setter': None,
            'wd': info_entry
        })

        inrefs_def = item.inrefs_def
        outrefs_def = item.outrefs_def

        for i, outref_def in enumerate(outrefs_def):
            outref_name = outref_def.get('name')
            self._possible_input.append(f'{title}-{outref_name}')

        links = item.links
        if len(inrefs_def) > 0:
            for i, inref_def in enumerate(inrefs_def):
                inref_name = inref_def.get('name')
                getter, inref_lbl, inref_combo = self._create_link_widget(
                    container, inref_name, links)
                inref_lbl.grid(row=i + 1,
                               column=0,
                               padx=PADX_S,
                               pady=PADY_S,
                               sticky=W)
                inref_combo.grid(row=i + 1,
                                 column=1,
                                 columnspan=2,
                                 padx=PADX_S,
                                 pady=PADY_S,
                                 sticky=E)
                item_links_descr.append({
                    'name': inref_name,
                    'getter': getter,
                    'setter': None,
                    'wd': inref_combo
                })
        return item_links_descr

    def _create_link_widget(
            self, container: LabelFrame, inref_name: str,
            links: Dict[str, str]) -> Tuple[Callable, Widget, Widget]:
        def get():
            return inref_combo.get()

        text = f'{inref_name}:'
        inref_lbl = Label(container,
                          text=text,
                          anchor=W,
                          justify=LEFT,
                          width=10)
        var = StringVar()
        inref_combo = Combobox(container,
                               name=inref_name,
                               justify=LEFT,
                               width=35)
        inref_combo['values'] = copy.deepcopy(
            self._possible_input[:len(self._possible_input) - 2])
        # Assign current value
        if len(links) > 0:
            link = links.get(inref_name)
            if link is not None:
                inref_combo.set(link)
                inref_combo.textvariable = var
        return get, inref_lbl, inref_combo

    def set_active_wd(self, idx: int) -> None:
        self._hightlighte_active_wd()
        self._set_active_wd_state()
        self._active_wd_idx = idx
        self._hightlighte_active_wd(True)
        self._set_active_wd_state(True)
        return

    def _set_active_wd_state(self, active: bool = False) -> None:
        state = DISABLED
        if active:
            state = NORMAL
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        for descr in descriptors:
            widget = descr.get('wd')
            widget['state'] = state
        return

    def _disable_all(self) -> None:
        for descriptors in self._grid_rows_descr:
            for descr in descriptors:
                widget = descr.get('wd')
                widget['state'] = DISABLED
        return

    # UI methods

    def _hightlighte_active_wd(self, active: bool = False) -> None:
        fg_color = 'black'
        bg_color = 'SystemButtonFace'
        if active:
            fg_color = 'white'
            bg_color = 'RoyalBlue'
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        for descr in descriptors:
            widget = descr.get('wd')
            name = widget.winfo_name()
            if name.startswith('--'):
                widget['fg'] = fg_color
                widget['bg'] = bg_color
                break
        return
Example #2
0
class DataView(View):
  def __init__(self, parent):
    super().__init__(parent)
    self['text'] = 'Data'
    # self['bg'] = 'green'

    h = self.parent.winfo_reqheight()
    w = self.parent.winfo_reqwidth()
    self.grid()
    # self.grid_propagate(False)

    self.rowconfigure(0, weight=1)
    self.rowconfigure(1, weight=1)
    # self.rowconfigure(2, weight=1)
    # self.columnconfigure(0, pad=15)
    self.columnconfigure(0, weight=1)

    # Last existing output
    self._data_last = Frame(self, height=int(h*0.3), highlightbackground='gray', highlightthickness=1)
    self._data_last.grid(row=0, column=0, padx=PADX, pady=PADY_S, sticky=W + E + N + S)
    self._data_last.columnconfigure(0, weight=1)
    self._data_last.rowconfigure(0, weight=1)
    self._data_last.grid_propagate(False)
    # self._last_view = Label(self._data_last, name='last image')

    # Setup canvas inside the frame
    # self._canvas_data_last = Canvas(self._data_last, bg='green')
    # self._canvas_data_last.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W + E + N + S)

    #Add PIL image to the Canvas
    # canvas.create_image(10,10,anchor=NW,image=img)

    # Preview content will be scrolable
    self.content = ScrolledFrame(self, height=int(h*0.3), use_ttk=True)
    # Bind the arrow keys and scroll wheel
    # self.content.bind_arrow_keys(self)
    # self.content.bind_scroll_wheel(self)
    self.content.grid(row=1, column=0, padx=PADX, pady=PADY_S, sticky=W + E + N + S)
    # Create the preview frame within the ScrolledFrame
    self.preview_view = self.content.display_widget(Frame)
    
    # self.data_actions = Frame(self, height=int(h*0.2), highlightbackground='gray', highlightthickness=1)
    # self.data_actions.grid(row=2, column=0, padx=PADX, pady=PADY_S, sticky=W + E + S)
    # self.data_actions.columnconfigure(0, weight=1)
    # self.data_actions.columnconfigure(1, weight=1)
    # self.data_actions.columnconfigure(2, weight=1)
    # self.data_actions.columnconfigure(3, weight=1)
    # self.data_actions.columnconfigure(4, weight=1)
    
    # self._preview_height = DEFAULT_VIEW_SIZE
    # self._preview_width = DEFAULT_VIEW_SIZE

    # self.scale_frame = LabelFrame(self.data_actions, text='Preview size:')
    # self.scale_frame.grid(row=0, column=0, columnspan=4, padx=PADX_S, pady=PADY_S, sticky=W+E)
    # self.scale_frame.columnconfigure(0, weight=1)
    # self.scale_frame.columnconfigure(1, weight=1)
    # self.scale_frame.columnconfigure(2, weight=1)
    # self.scale_frame.columnconfigure(3, weight=1)

    # self.var_h = IntVar()
    # self.var_h.set(self._preview_height)
    # self.scale_h = Scale(self.scale_frame, from_=50, to=500, resolution=50, variable=self.var_h, orient=HORIZONTAL, length=400)
    # self.scale_h.grid(row=0, column=0, columnspan=3, padx=PADX_S, pady=PADY_S, sticky=W+E)
    # self.scale_h.bind("<ButtonRelease-1>", self._set_h)

    # self.var_fixed_size = BooleanVar()
    # self.fixed_size = Checkbutton(self.scale_frame, variable=self.var_fixed_size, text='Fixed size', onvalue=True, offvalue=False, command=self._fix_size)
    # self.fixed_size.grid(row=0, column=3, padx=PADX_S, pady=PADY_S, sticky=W+E)

    # self.btn_save = Button(self.data_actions, text='Save', width=BTNW_S, command=self._save)
    # self.btn_save.grid(row=0, column=4, padx=PADX, pady=PADY)
    
    self._out = None
    self._idx_map :Dict = {}
    self._grid_rows: List[Widget] = []
    self._storage: FlowStorage = None
    self._last_view = None
    return

  @property
  def storage(self) -> FlowStorage:
    return self._storage
  
  @storage.setter
  def storage(self, storage) -> None:
    self._storage = storage
    return

  def clear_view(self) -> None:
    self._out = None
    self._idx_map = {}
    for row in self._grid_rows:
      row.grid_remove()  
    self._grid_rows.clear()
    self.content.scroll_to_top()
    if self._last_view is not None:
      self._last_view.grid_remove()
    return

  def default(self) -> None:
    # if self.var_fixed_size.get():
    #   return
    self._preview_height = DEFAULT_VIEW_SIZE
    self._preview_width = DEFAULT_VIEW_SIZE
    # self.var_h.set(self._preview_height)
    self._preview() 
    return

  def _preview_size(self, image) -> Tuple[int,int]:
    (h, w) = image.shape[:2]
    ratio = w/h
    if h > self._preview_height:
      h = self._preview_height
      w = int(h*ratio)
    elif w > self._preview_width:    
      w = self._preview_width
      h = int(w/ratio)
    elif h < self._preview_height and w < self._preview_width:
      h = self._preview_height
      w = int(h*ratio)
    else:
      pass
    return (w, h)

  def _fit_image(self, image):  
    dim = self._preview_size(image)
    image = cv2.resize(image, dim, interpolation=cv2.INTER_NEAREST)
    return image

  def _preview_image_list(self, parent, image: List[np.ndarray], name: str) -> Widget:
    image = cv2.hconcat(image)
    return self._preview_image(parent, image, name)

  def _preview_image(self, parent, image: np.ndarray, name: str) -> Widget:
    preview = self._fit_image(image)
    pil_image = Image.fromarray(preview)
    photo = ImageTk.PhotoImage(pil_image)
    view = Label(parent, name=name, image=photo)
    view.image = photo
    return view

  def _preview_object(self, parent, data: any, name: str) -> Widget:
    view = Label(parent, name=name, border=1)
    # text = json.dumps(data, indent = 3)
    # df = pd.DataFrame(data)
    view.config(text = data)
    return view

  def _get_preview(self, ref_type: FlowDataType) -> Callable:
    views = {
      FlowDataType.NP_ARRAY: self._preview_image,
      FlowDataType.LIST_NP_ARRAYS: self._preview_image_list
    }
    return views.get(ref_type, self._preview_object)

  def _clear_preview(self, idx: int) -> None:
    if len(self._grid_rows) > 0:
      self._out = None
      # map idx to preview idx
      row_idx = self._get_row_idx(f'{idx}')
      if row_idx == WITHOUT_PREVIEW_DATA:
        return
      row_idx = max(len(self._idx_map)-1, self._get_row_idx(f'{idx}'))
      try:
        # remove idx mapping for the idx
        self._idx_map.pop(f'{row_idx}')
        # remove existing preview item with the idx
        res = self._grid_rows.pop(row_idx)
        res.grid_remove()
      except IndexError:
        pass
    return
  
  def update_result(self, idx: int, state_id: str) -> None:
    self._show_last(state_id)
    self. _clear_preview(idx)
    return
 
  def _create_row_output_container(self, row_idx: int, title: str) -> Widget:
    state_frame = LabelFrame(self.preview_view, name=f'--{row_idx}--', text=title)
    state_frame.grid(row=row_idx, column=0, sticky=W)
    state_frame.rowconfigure(0, pad=15)
    state_frame.columnconfigure(0, weight=1)
    state_frame.columnconfigure(0, pad=15)
    # state_frame.columnconfigure(1, weight=1)
    # state_frame.columnconfigure(1, pad=15)
    return state_frame

  def _create_preview(self, row_idx, title, out_data, out_refs) -> None:
    preview_frame = self._create_row_output_container(row_idx, title)
    # previews for a state outputs 
    for i, ref in enumerate(out_refs):
      (ref_extr, ref_intr, ref_type) = ref
      data = out_data.get(ref_intr)
      if data is None:
        continue
      preview = self._get_preview(ref_type)
      # convert to a conventional format (without '.')
      name = ref_extr.replace('.', '-')
      widget = preview(preview_frame, data, name)
      widget.grid(row=i, column=0, sticky=W)
      widget.bind('<Button-1>', self._on_click)
    try:
      # remove existing item with the row_idx
      self._grid_rows.pop(row_idx)
    except IndexError:
      pass
    # set new one
    self._grid_rows.insert(row_idx, preview_frame)

    # Scroll view if need
    self.update_idletasks()
    h = preview_frame.winfo_height()
    self.content.focus_set()
    self.content.yview(SCROLL, h, UNITS)
    return

  def _get_row_idx(self, state_id: str) -> int:
    row_idx = self._idx_map.get(state_id, WITHOUT_PREVIEW_DATA)
    return row_idx

  @staticmethod
  def _parse_out_refs(refs) -> Tuple[str, str]:
    parts =refs[0][0].split('-')
    state_id = parts[0]
    title = '-'.join(parts[0:len(parts)-1])
    return state_id, title

  def _show_last(self, state_id: str) -> None:
    out_data = self._storage.get_state_output_data(state_id)
    refs = self._storage.get_state_output_refs(state_id)
    if out_data is None or refs is None:
      return
    out_refs = [(ref.ext_ref, ref.int_ref, ref.data_type) for ref in refs]  
    if len(out_refs) > 0:
      ref = out_refs[0]
      (ref_extr, ref_intr, ref_type) = ref
      data = out_data.get(ref_intr)
      if data.dtype == np.dtype('uint8'):
        pil_image = Image.fromarray(data)
        photo = ImageTk.PhotoImage(pil_image)
        self._last_view = Label(self._data_last, name='last image', image=photo)
        self._last_view.image = photo 
        self._last_view.grid(row=0, column=0, padx=PADX_S, pady=PADY_S, sticky=W + E + N + S)
      else:
        self._last_view.grid_remove()
      # self._canvas_data_last.create_image(x1=10, y1=10, anchor=NW, image=photo)
    return

  def _preview(self) -> None:   
    if self._out is None:
      return
    (out_refs, out_data) = self._out
    if len(out_refs) > 0:
      state_id, title = self._parse_out_refs(out_refs)
      row_idx = self._get_row_idx(state_id)
      self._create_preview(row_idx, title, out_data, out_refs)
    return

  def _map_idx_to_row_idx(self, idx: int) -> None:
    preview_row = len(self._idx_map)
    (out_refs, out_data) = self._out
    if len(out_refs) == 0 and len(out_data) == 0:
      # No data for preview
      self._idx_map[f'{idx}'] = WITHOUT_PREVIEW_DATA
      return
    # map idx to row_idx
    self._idx_map[f'{idx}'] = min(idx, preview_row)
    return

  def _show_preview(self, idx: int, state_id: str) -> None:
    out_data = self._storage.get_state_output_data(state_id)
    refs = self._storage.get_state_output_refs(state_id)
    if out_data is None or refs is None:
      return
    out_refs = [(ref.ext_ref, ref.int_ref, ref.data_type) for ref in refs]  
    self._out = (out_refs, out_data)
    self._map_idx_to_row_idx(idx)
    self._preview()
    return

  def show_result(self, idx: int, state_id: str) -> None:
    self._show_preview(idx, state_id)
    self._show_last(state_id)
    return
    
  def _on_click(self, event) -> None:
    event.widget.focus_set()
    active_widget_name = event.widget._name
    print(active_widget_name)
    for row in self._grid_rows:
      for child in row.children:
        if child == active_widget_name:
          self._plot(child)
    return

  def _plot(self, name: str) -> None:
    parts = name.split('-')
    state_id = parts[0] + '-' + parts[2]
    key = parts[3]
    data_dict = self._storage.get_state_output_data(state_id)
    data = data_dict.get(key)
    plot_dlg = PlotDialog(self, name, data)
    return

  def _set_h(self, event) -> None:
    self._preview_height = self.scale_h.get()
    self._preview()
    return

  def _fix_size(self) -> None:
    # self.scale_h['state'] = NORMAL
    # if self.var_fixed_size.get() == True:
    #   self.scale_h['state'] = DISABLED
    return

  def _save(self) -> None:
    print('save')
    return

  # TODO:
  # https://stackoverflow.com/questions/28005591/how-to-create-a-scrollable-canvas-that-scrolls-without-a-scroll-bar-in-python
  def _move(self, preview_frame):
    deltay = self._preview_height
    deltax = self._preview_width
    # make sure we don't move beyond our scrollable region
    (x0,y0,x1,y1) = self.content._canvas.coords()
    deltay = 0 if (deltay > 0 and y1 >= 400) else deltay
    deltay = 0 if (deltay < 0 and y0 <= -400) else deltay
    deltax = 0 if (deltax > 0 and x1 >= 400) else deltax
    deltax = 0 if (deltax < 0 and x0 <= -400) else deltax

    # move the item, then scroll it into view
    self.content._canvas.move(preview_frame, deltax, deltay)
    self._make_visible(preview_frame)    

  def _make_visible(self, preview_frame) -> None:
    # determine the bounding box of the visible area of the screen
    (cx0,cy0) = (self.content._canvas.canvasx(0), self.content._canvas.canvasy(0))
    (cx1,cy1) = (self.content._canvas.canvasx(self.content._canvas.cget("width")), 
                  self.content._canvas.canvasy(self.content._canvas.cget("height")))

    # determine the bounding box of the thing to be made visible
    (x0,y0,x1,y1) = self.content._canvas.coords(preview_frame)

    # determine how far off the screen the object is
    deltax = x0-cx0 if x0 <= cx0 else x1-cx1 if x1 >= cx1 else 0
    deltay = y0-cy0 if y0 <= cy0 else y1-cy1 if y1 >= cy1 else 0

    # scroll the canvas to make the item visible
    self.canvas.xview("scroll", int(deltax), "units")
    self.canvas.yview("scroll", int(deltay), "units")
    return
Example #3
0
class ParamsView(View):
    def __init__(self, parent):
        super().__init__(parent)
        self['text'] = 'Parameters'
        self._factory = ParamWidgetFactory()

        self.update_idletasks()
        h = self.parent.winfo_reqheight()

        self._flow = None
        self._grid_rows_descr: List[Dict] = []
        self._active_wd_idx = -1

        self.grid()
        self.rowconfigure(0, weight=1)
        self.rowconfigure(1, weight=1)

        # Content will be scrolable
        self._content = ScrolledFrame(self, use_ttk=True, height=int(h * 0.65))
        self._content.grid(row=0,
                           column=0,
                           padx=PADX,
                           pady=PADY_S,
                           sticky=N + S + W + E)
        # Create the params frame within the ScrolledFrame
        self._params_view = self._content.display_widget(Frame)

        # Setup param actions view
        self._params_actions_frame = Frame(self,
                                           highlightbackground='gray',
                                           highlightthickness=1)
        self.btn_params_reset = Button(self._params_actions_frame,
                                       text='Reset',
                                       width=BTNW_S)
        self.btn_params_default = Button(self._params_actions_frame,
                                         text='Default',
                                         width=BTNW_S)
        self.btn_params_io = Button(self._params_actions_frame,
                                    text='I/O',
                                    width=BTNW_S)
        self.btn_params_reset.grid(row=0,
                                   column=0,
                                   padx=PADX,
                                   pady=PADY_S,
                                   sticky=W + N)
        self.btn_params_default.grid(row=0,
                                     column=1,
                                     padx=PADX,
                                     pady=PADY_S,
                                     sticky=W + N)
        self.btn_params_io.grid(row=0,
                                column=2,
                                padx=PADX,
                                pady=PADY_S,
                                sticky=W + N)
        self._params_actions_frame.grid(row=1,
                                        column=0,
                                        padx=PADX,
                                        pady=PADY_S,
                                        sticky=W + E + S)

        self._activate_params_buttons()
        return

# API

    @property
    def descriptors(self) -> List[Dict]:
        return self._grid_rows_descr

    def get_active_item_params_widgets(self) -> List[Widget]:
        if self._active_wd_idx < 0:
            return None
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        widgets = []
        for descr in descriptors:
            widget = descr.get('wd')
            widgets.append(widget)
        return widgets

    def get_item_name(self, idx: int) -> str:
        descriptors = self._grid_rows_descr[idx]
        widget_0 = descriptors[0].get('wd')
        parent_name = widget_0.winfo_parent()
        idx_s = parent_name.index('--')
        p_n: str = parent_name[idx_s + 2:len(parent_name) - 2]
        idx_point = p_n.find('-', 3)
        p_n = p_n[:idx_point] + '.' + p_n[idx_point + 1:]
        return p_n

    def get_item_params(self, idx: int) -> Dict:
        params = {}
        descriptors = self._grid_rows_descr[idx]
        for descr in descriptors:
            widget = descr.get('wd')
            name = widget.winfo_name()
            if name.startswith('--'):
                continue
            getter = descr.get('getter')
            value = getter()
            params[name] = value
        return params

    def set_item_params(self, idx: int, params) -> None:
        if self._active_wd_idx < 0:
            return None
        descriptors = self._grid_rows_descr[idx]
        for descr in descriptors:
            widget = descr.get('wd')
            name = widget.winfo_name()
            if name.startswith('--'):
                continue
            setter = descr.get('setter')
            setter(params.get(name))
        return

    def clear(self) -> None:
        for child in self._params_view.winfo_children():
            child.grid_remove()
        self._grid_rows_descr.clear()
        self._content.scroll_to_top()
        self._active_wd_idx = -1
        self._activate_params_buttons()
        return


# Build

    def build(self, flow: FlowModel) -> None:
        self._flow = flow
        items = copy.deepcopy(flow.items)
        for i, item in enumerate(items):
            item_params_frame = self._create_item_params_container(i, item)
            item_params_frame.grid(row=i, column=0, padx=PADX, sticky=W + E)
            self._factory.container = item_params_frame
            item_params_descr = self._create_item_params_widgets(i, item)
            self._grid_rows_descr.append(item_params_descr)
        self._disable_all()
        self._active_wd_idx = 0
        self._hightlighte_active_wd(True)
        self._set_active_wd_state(True)
        self._activate_params_buttons(True)
        return

    def _create_item_params_container(self, idx: int,
                                      item: FlowItemModel) -> Widget:
        i_n = item.name.replace('.', '-')
        name = f'--{idx}-{i_n}--'
        item_params_frame = LabelFrame(self._params_view, name=name)
        return item_params_frame

    def _create_item_params_widgets(self, idx: int,
                                    item: FlowItemModel) -> Dict:
        item_params_descr = []
        title = f'{idx}-{item.name}'
        i_n = item.name.replace('.', '-')
        name = f'--{idx}-{i_n}--'
        item_label = Label(self._factory.container, name=name, text=title)
        item_label.grid(row=0,
                        column=0,
                        columnspan=3,
                        padx=PADX_S,
                        pady=PADY_S,
                        sticky=W)
        item_params_descr.append({
            'name': item_label.winfo_name(),
            'getter': None,
            'setter': None,
            'wd': item_label
        })
        params, params_def = self._merge_curent_params_with_params_ws(item)
        for i, param_def in enumerate(params_def):
            name = param_def.get('name')
            comment = param_def.get('comment')
            pvalue = params.get(name, None)
            if pvalue is not None:
                param_def['default'] = pvalue
            getter, setter, param_widget = self._factory.create(param_def)
            param_widget.grid(row=i + 1,
                              column=1,
                              padx=PADX_S,
                              pady=PADY_S,
                              sticky=W)
            param_label = Label(self._factory.container, text=f'{name}')
            param_label.grid(row=i + 1,
                             column=0,
                             padx=PADX_S,
                             pady=PADY_S,
                             sticky=W)
            param_descr = Label(self._factory.container, text=f'{comment}')
            param_descr.grid(row=i + 1,
                             column=2,
                             padx=PADX_S,
                             pady=PADY_S,
                             sticky=W)
            item_params_descr.append({
                'name': param_widget.winfo_name(),
                'getter': getter,
                'setter': setter,
                'wd': param_widget
            })
        return item_params_descr

    @staticmethod
    def _merge_curent_params_with_params_ws(
            item: FlowItemModel) -> Tuple[Dict, Dict]:
        # merge curent params with params_ws
        params = item.params  # Dict
        params_ws = item.params_ws  # Dict
        params_def = item.params_def  # List[Dict]
        for k in params_ws.keys():
            if k in params:
                continue
            params[k] = params_ws.ket(k)
        return params, params_def

    def set_active_wd(self, idx: int) -> None:
        self._hightlighte_active_wd()
        if self._active_wd_idx > idx:
            # disable, when move backward
            self._set_active_wd_state()
        self._active_wd_idx = idx
        self._hightlighte_active_wd(True)
        self._set_active_wd_state(True)
        self._set_button_io_state(idx)
        return

    def _set_active_wd_state(self, active: bool = False) -> None:
        state = DISABLED
        if active:
            state = NORMAL
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        for descr in descriptors:
            widget = descr.get('wd')
            widget['state'] = state
        return

    def _disable_all(self) -> None:
        for descriptors in self._grid_rows_descr:
            for descr in descriptors:
                widget = descr.get('wd')
                widget['state'] = DISABLED
        return

    # UI methods
    def _hightlighte_active_wd(self, active: bool = False) -> None:
        fg_color = 'black'
        bg_color = 'SystemButtonFace'
        if active:
            fg_color = 'white'
            bg_color = 'RoyalBlue'
        descriptors = self._grid_rows_descr[self._active_wd_idx]
        for descr in descriptors:
            widget = descr.get('wd')
            name = widget.winfo_name()
            if name.startswith('--'):
                widget['fg'] = fg_color
                widget['bg'] = bg_color
                break
        return

    def _activate_params_buttons(self, activate=False) -> None:
        state = DISABLED
        if activate:
            state = NORMAL
        self.btn_params_reset['state'] = state
        self.btn_params_default['state'] = state
        self.btn_params_io['state'] = state
        return

    def _set_button_io_state(self, idx: int) -> None:
        flow_item = self._flow.get_item(idx)
        params_def = flow_item.params_def
        self.btn_params_io['state'] = DISABLED
        for param_def in params_def:
            if param_def.get('name') == 'path':
                self.btn_params_io['state'] = NORMAL
                break
        return