Besides of that I support the idea of having constant values like window's height, width and input_row settings as class constants (uppercase names) and referencing negative kcell flag as not kcell instead of kcell == False here's some list of advises in terms of better code organizing, restructuring conditionals and eliminating duplicates:

• window's half of width int(self.winwidth / 2) is calculated 13 times across 3 methods.
  Instead, we'll apply Extract variable technique, extracting precalculated expression into the instance field self.win_width_half = int(self.winwidth / 2) and referencing it in all places it's needed
  (like self.inputcol = [[36, 50], [self.win_width_half + 36, self.win_width_half + 50]])

• setting "windows entry points" in initScreen method (should be renamed to init_screen): involves consecutive 20 calls of self.measurewin.addstr(...) function.
  Instead, we can define entry points attributes beforehand and then pass them in simple iteration:

  win_entry_points_attrs = [
      (2, self.inputcol[0][0] - 3, "1", self.white),
      (2, self.inputcol[0][1] - 3, "2", self.white),
      (2, self.inputcol[1][0] - 3, "1", self.white),
      (2, self.inputcol[1][1] - 3, "2", self.white),
  
      (5, 5, "A"),
      (9, 5, "B"),
      (13, 5, "C"),
      (17, 5, "D"),
      (16, 20, "D.I"),
      (18, 20, "D.II"),
      (22, 5, "E"),
      (21, 20, "E.I"),
      (23, 20, "E.II"),
  
      (5, self.win_width_half + 5, "F"),
      (9, self.win_width_half + 5, "G"),
      (13, self.win_width_half + 5, "H"),
      (12, self.win_width_half + 20, "H.I"),
      (14, self.win_width_half + 20, "H.II"),
      (18, self.win_width_half + 5, "J"),
      (17, self.win_width_half + 20, "J.I"),
      (19, self.win_width_half + 20, "J.II"),
  ]
  # print the windows entry points
  for attrs in win_entry_points_attrs:
      self.measurewin.addstr(*attrs) 
  

Optimizations within inputMeasures method (should be renamed to input_measures):

• the condition:

  if ((ch == curses.KEY_UP and j > 0)
          or (ch == curses.KEY_DOWN and kcell == False)
          or (ch == curses.KEY_LEFT and (i != 0 or k != 0) and kcell == False)
          or (ch == curses.KEY_RIGHT and (i != 1 or k != 1) and kcell == False)
          or (ch in [ord("s"), ord("S")])
          or (ch in [ord("q"), ord("Q")])):
      break
  

  has a common check kcell == False (should be not kcell) in 3 branches (in the middle) and that's a sign of Consolidate conditional refactoring technique:

  if ((ch == curses.KEY_UP and j > 0)
          or (not kcell and (ch == curses.KEY_DOWN
                              or (ch == curses.KEY_LEFT and (i != 0 or k != 0))
                              or (ch == curses.KEY_RIGHT and (i != 1 or k != 1))))
          or (chr(ch).lower() in ("s", "q"))):
      break
  

• the variable cursorcntr (cursor counter) deserves for a more meaningful variable name (Rename variable technique) - I would suggest cursor_cnt

• the last complex if .. elif .. elif conditional of 6 branches at the end of method input_measures seems to be a good candidate for Replace Conditional with Polymorphism technique (OOP approach) but that would require more knowledge and vision about your program conception/settings.
  For now, the first 4 branches of that conditional perform the same action cursor_cnt *= 2 - we can eliminate duplication with additional check.
  It's good to move "save/quit" branches up, as they call self.exit() which will throw raise SystemExit to exit the program.
  Thus the reorganized conditional would look as:

  # set of key codes defined in the parent scope (at least before the loop or as instance variable)
  key_set = set((curses.KEY_UP, curses.KEY_DOWN, curses.KEY_LEFT, curses.KEY_RIGHT))
  ...
  # check If the user wants to save/quit
  inp_char = chr(ch).lower()
  if inp_char == 's':
      self.exit("save")
  elif inp_char == 'q':
      self.exit("quit")
  
  if ch in key_set:
      cursor_cnt *= 2
  
  if ch == curses.KEY_UP:
      if kcell:
          kcell = False
      else:
          self.cirow -= 1
      # If I pressed an arrow key the value of the cursor counter is always set to a
      # multiple of two (which means that when an arrow key is entered I will always
      # get a blinking cursos in the destination cell)
  
  elif ch == curses.KEY_DOWN:
      if (i == 0 and j == 6) or (i == 1 and j == 5):
          kcell = True
      else:
          self.cirow += 1
  
  elif ch == curses.KEY_LEFT:
      self.cicol -= 1
      if i == 1 and k == 0:
          self.ciside -= 1
          self.cicol += 2
  
  elif ch == curses.KEY_RIGHT:
      self.cicol += 1
      if i == 0 and k == 1:
          self.ciside += 1
          self.cicol -= 2
          if self.cirow == 6:
              self.cirow -= 1
  

I really recommend you look into using panels. Anytime you will have widgets that could possibly overlap, it makes life alot easier. This is a simple example that should get you started. (Neither curses.beep() or curses.flash() seem to work on my terminal, but that is beside the point)

#!/usr/bin/env python

import curses
from curses import panel


class Menu(object):
    def __init__(self, items, stdscreen):
        self.window = stdscreen.subwin(0, 0)
        self.window.keypad(1)
        self.panel = panel.new_panel(self.window)
        self.panel.hide()
        panel.update_panels()

        self.position = 0
        self.items = items
        self.items.append(("exit", "exit"))

    def navigate(self, n):
        self.position += n
        if self.position < 0:
            self.position = 0
        elif self.position >= len(self.items):
            self.position = len(self.items) - 1

    def display(self):
        self.panel.top()
        self.panel.show()
        self.window.clear()

        while True:
            self.window.refresh()
            curses.doupdate()
            for index, item in enumerate(self.items):
                if index == self.position:
                    mode = curses.A_REVERSE
                else:
                    mode = curses.A_NORMAL

                msg = "%d. %s" % (index, item[0])
                self.window.addstr(1 + index, 1, msg, mode)

            key = self.window.getch()

            if key in [curses.KEY_ENTER, ord("\n")]:
                if self.position == len(self.items) - 1:
                    break
                else:
                    self.items[self.position][1]()

            elif key == curses.KEY_UP:
                self.navigate(-1)

            elif key == curses.KEY_DOWN:
                self.navigate(1)

        self.window.clear()
        self.panel.hide()
        panel.update_panels()
        curses.doupdate()


class MyApp(object):
    def __init__(self, stdscreen):
        self.screen = stdscreen
        curses.curs_set(0)

        submenu_items = [("beep", curses.beep), ("flash", curses.flash)]
        submenu = Menu(submenu_items, self.screen)

        main_menu_items = [
            ("beep", curses.beep),
            ("flash", curses.flash),
            ("submenu", submenu.display),
        ]
        main_menu = Menu(main_menu_items, self.screen)
        main_menu.display()


if __name__ == "__main__":
    curses.wrapper(MyApp)

Some things to note when looking over your code.

Using curses.wrapper(callable) to launch your application is cleaner than doing your own try/except with cleanup.

Your class calls initscr twice which will probably generate two screens (havent tested if it returns the same screen if its setup), and then when you have multiple menus there is no proper handling of (what should be) different windows/screens. I think its clearer and better bookkeeping to pass the menu the screen to use and let the menu make a subwindow to display in as in my example.

Naming a list 'list' isn't a great idea, because it shadows the list() function.

If you want to launch another terminal app like 'top', it is probably better to let python exit curses cleanly first then launch in order to prevent any futzing with terminal settings.