docs: def display(self, stats, cs_status=None):
          """Display the servers list.
  
          Return:
              True if the stats have been displayed
              False if the stats have not been displayed (no server available)
          """
          # Init the internal line/column for Glances Curses
          self.init_line_column()
  
          # Get the current screen size
          screen_x = self.screen.getmaxyx()[1]
          screen_y = self.screen.getmaxyx()[0]
          stats_max = screen_y - 3
          stats_len = len(stats)
  
          self._page_max_lines = stats_max
          self._page_max = int(math.ceil(stats_len / stats_max))
          # Init position
          x = 0
          y = 0
  
          # Display top header
          if stats_len == 0:
              if self.first_scan and not self.args.disable_autodiscover:
                  msg = 'Glances is scanning your network. Please wait...'
                  self.first_scan = False
              else:
                  msg = 'No Glances server available'
          elif len(stats) == 1:
              msg = 'One Glances server available'
          else:
              msg = '{} Glances servers available'.format(stats_len)
          if self.args.disable_autodiscover:
              msg += ' (auto discover is disabled)'
          if screen_y > 1:
              self.term_window.addnstr(y, x,
                                       msg,
                                       screen_x - x,
                                       self.colors_list['TITLE'])
  
              msg = '{}'.format(self._get_status_count(stats))
              self.term_window.addnstr(y + 1, x,
                                       msg,
                                       screen_x - x)
  
          if stats_len > stats_max and screen_y > 2:
              msg = '{} servers displayed.({}/{}) {}'.format(self.get_pagelines(stats),
                                                              self._current_page + 1, 
                                                              self._page_max, 
                                                              self._get_status_count(stats))
              self.term_window.addnstr(y + 1, x,
                                       msg,
                                       screen_x - x)
          
          if stats_len == 0:
              return False
  
          # Display the Glances server list
          # ================================
  
          # Table of table
          # Item description: [stats_id, column name, column size]
          column_def = [
              ['name', 'Name', 16],
              ['alias', None, None],
              ['load_min5', 'LOAD', 6],
              ['cpu_percent', 'CPU%', 5],
              ['mem_percent', 'MEM%', 5],
              ['status', 'STATUS', 9],
              ['ip', 'IP', 15],
              # ['port', 'PORT', 5],
              ['hr_name', 'OS', 16],
          ]
          y = 2
  
          # Display table header
          xc = x + 2
          for cpt, c in enumerate(column_def):
              if xc < screen_x and y < screen_y and c[1] is not None:
                  self.term_window.addnstr(y, xc,
                                           c[1],
                                           screen_x - x,
                                           self.colors_list['BOLD'])
                  xc += c[2] + self.space_between_column
          y += 1
  
          # If a servers has been deleted from the list...
          # ... and if the cursor is in the latest position
          if self.cursor > len(stats) - 1:
              # Set the cursor position to the latest item
              self.cursor = len(stats) - 1
  
          stats_list = self._get_stats(stats)
          start_line = self._page_max_lines * self._current_page 
          end_line = start_line + self.get_pagelines(stats_list)
          current_page = stats_list[start_line:end_line]
          
          # Display table
          line = 0
          for v in current_page:
              # Limit the number of displayed server (see issue #1256)
              if line >= stats_max:
                  continue
              # Get server stats
              server_stat = {}
              for c in column_def:
                  try:
                      server_stat[c[0]] = v[c[0]]
                  except KeyError as e:
                      logger.debug(
                          "Cannot grab stats {} from server (KeyError: {})".format(c[0], e))
                      server_stat[c[0]] = '?'
                  # Display alias instead of name
                  try:
                      if c[0] == 'alias' and v[c[0]] is not None:
                          server_stat['name'] = v[c[0]]
                  except KeyError:
                      pass
  
              # Display line for server stats
              cpt = 0
              xc = x
  
              # Is the line selected ?
              if line == self.cursor:
                  # Display cursor
                  self.term_window.addnstr(
                      y, xc, ">", screen_x - xc, self.colors_list['BOLD'])
  
              # Display the line
              xc += 2
              for c in column_def:
                  if xc < screen_x and y < screen_y and c[1] is not None:
                      # Display server stats
                      self.term_window.addnstr(
                          y, xc, format(server_stat[c[0]]), c[2], self.colors_list[v['status']])
                      xc += c[2] + self.space_between_column
                  cpt += 1
              # Next line, next server...
              y += 1
              line += 1
  
          return True