docs: def display_slitlet_arrangement(fileobj,
                                  grism=None,
                                  spfilter=None,
                                  bbox=None,
                                  adjust=None,
                                  geometry=None,
                                  debugplot=0):
      """Display slitlet arrangment from CSUP keywords in FITS header.
  
      Parameters
      ----------
      fileobj : file object
          FITS or TXT file object.
      grism : str
          Grism.
      grism : str
          Filter.
      bbox : tuple of 4 floats
          If not None, values for xmin, xmax, ymin and ymax.
      adjust : bool
          Adjust X range according to minimum and maximum csu_bar_left
          and csu_bar_right (note that this option is overriden by 'bbox')
      geometry : tuple (4 integers) or None
          x, y, dx, dy values employed to set the Qt backend geometry.
      debugplot : int
          Determines whether intermediate computations and/or plots
          are displayed. The valid codes are defined in
          numina.array.display.pause_debugplot
  
      Returns
      -------
      csu_bar_left : list of floats
          Location (mm) of the left bar for each slitlet.
      csu_bar_right : list of floats
          Location (mm) of the right bar for each slitlet, using the
          same origin employed for csu_bar_left (which is not the
          value stored in the FITS keywords.
      csu_bar_slit_center : list of floats
          Middle point (mm) in between the two bars defining a slitlet.
      csu_bar_slit_width : list of floats
          Slitlet width (mm), computed as the distance between the two
          bars defining the slitlet.
  
      """
  
      if fileobj.name[-4:] == ".txt":
          if grism is None:
              raise ValueError("Undefined grism!")
          if spfilter is None:
              raise ValueError("Undefined filter!")
          # define CsuConfiguration object
          csu_config = CsuConfiguration()
          csu_config._csu_bar_left = []
          csu_config._csu_bar_right = []
          csu_config._csu_bar_slit_center = []
          csu_config._csu_bar_slit_width = []
  
          # since the input filename has been opened with argparse in binary
          # mode, it is necessary to close it and open it in text mode
          fileobj.close()
          # read TXT file
          with open(fileobj.name, mode='rt') as f:
              file_content = f.read().splitlines()
          next_id_bar = 1
          for line in file_content:
              if len(line) > 0:
                  if line[0] not in ['#']:
                      line_contents = line.split()
                      id_bar = int(line_contents[0])
                      position = float(line_contents[1])
                      if id_bar == next_id_bar:
                          if id_bar <= EMIR_NBARS:
                              csu_config._csu_bar_left.append(position)
                              next_id_bar = id_bar + EMIR_NBARS
                          else:
                              csu_config._csu_bar_right.append(341.5 - position)
                              next_id_bar = id_bar - EMIR_NBARS + 1
                      else:
                          raise ValueError("Unexpected id_bar:" + str(id_bar))
  
          # compute slit width and center
          for i in range(EMIR_NBARS):
              csu_config._csu_bar_slit_center.append(
                  (csu_config._csu_bar_left[i] + csu_config._csu_bar_right[i])/2
              )
              csu_config._csu_bar_slit_width.append(
                  csu_config._csu_bar_right[i] - csu_config._csu_bar_left[i]
              )
  
      else:
          # read input FITS file
          hdulist = fits.open(fileobj.name)
          image_header = hdulist[0].header
          hdulist.close()
  
          # additional info from header
          grism = image_header['grism']
          spfilter = image_header['filter']
  
          # define slitlet arrangement
          csu_config = CsuConfiguration.define_from_fits(fileobj)
  
      # determine calibration
      if grism in ["J", "OPEN"] and spfilter == "J":
          wv_parameters = set_wv_parameters("J", "J")
      elif grism in ["H", "OPEN"] and spfilter == "H":
          wv_parameters = set_wv_parameters("H", "H")
      elif grism in ["K", "OPEN"] and spfilter == "Ksp":
          wv_parameters = set_wv_parameters("Ksp", "K")
      elif grism in ["LR", "OPEN"] and spfilter == "YJ":
          wv_parameters = set_wv_parameters("YJ", "LR")
      elif grism in ["LR", "OPEN"] and spfilter == "HK":
          wv_parameters = set_wv_parameters("HK", "LR")
      else:
          raise ValueError("Invalid grism + filter configuration")
  
      crval1 = wv_parameters['poly_crval1_linear']
      cdelt1 = wv_parameters['poly_cdelt1_linear']
  
      wvmin_useful = wv_parameters['wvmin_useful']
      wvmax_useful = wv_parameters['wvmax_useful']
  
      # display arrangement
      if abs(debugplot) >= 10:
          print("slit     left    right   center   width   min.wave   max.wave")
          print("====  =======  =======  =======   =====   ========   ========")
          for i in range(EMIR_NBARS):
              ibar = i + 1
              csu_crval1 = crval1(csu_config.csu_bar_slit_center(ibar))
              csu_cdelt1 = cdelt1(csu_config.csu_bar_slit_center(ibar))
              csu_crvaln = csu_crval1 + (EMIR_NAXIS1 - 1) * csu_cdelt1
              if wvmin_useful is not None:
                  csu_crval1 = np.amax([csu_crval1, wvmin_useful])
              if wvmax_useful is not None:
                  csu_crvaln = np.amin([csu_crvaln, wvmax_useful])
              print("{0:4d} {1:8.3f} {2:8.3f} {3:8.3f} {4:7.3f}   "
                    "{5:8.2f}   {6:8.2f}".format(
                  ibar, csu_config.csu_bar_left(ibar),
                  csu_config.csu_bar_right(ibar),
                  csu_config.csu_bar_slit_center(ibar),
                  csu_config.csu_bar_slit_width(ibar),
                  csu_crval1, csu_crvaln)
              )
          print(
              "---> {0:8.3f} {1:8.3f} {2:8.3f} {3:7.3f} <- mean (all)".format(
                  np.mean(csu_config._csu_bar_left),
                  np.mean(csu_config._csu_bar_right),
                  np.mean(csu_config._csu_bar_slit_center),
                  np.mean(csu_config._csu_bar_slit_width)
              )
          )
          print(
              "---> {0:8.3f} {1:8.3f} {2:8.3f} {3:7.3f} <- mean (odd)".format(
                  np.mean(csu_config._csu_bar_left[::2]),
                  np.mean(csu_config._csu_bar_right[::2]),
                  np.mean(csu_config._csu_bar_slit_center[::2]),
                  np.mean(csu_config._csu_bar_slit_width[::2])
              )
          )
          print(
              "---> {0:8.3f} {1:8.3f} {2:8.3f} {3:7.3f} <- mean (even)".format(
                  np.mean(csu_config._csu_bar_left[1::2]),
                  np.mean(csu_config._csu_bar_right[1::2]),
                  np.mean(csu_config._csu_bar_slit_center[1::2]),
                  np.mean(csu_config._csu_bar_slit_width[1::2])
              )
          )
  
      # display slit arrangement
      if abs(debugplot) % 10 != 0:
          fig = plt.figure()
          set_window_geometry(geometry)
          ax = fig.add_subplot(111)
          if bbox is None:
              if adjust:
                  xmin = min(csu_config._csu_bar_left)
                  xmax = max(csu_config._csu_bar_right)
                  dx = xmax - xmin
                  if dx == 0:
                      dx = 1
                  xmin -= dx/20
                  xmax += dx/20
                  ax.set_xlim(xmin, xmax)
              else:
                  ax.set_xlim(0., 341.5)
              ax.set_ylim(0, 56)
          else:
              ax.set_xlim(bbox[0], bbox[1])
              ax.set_ylim(bbox[2], bbox[3])
          ax.set_xlabel('csu_bar_position (mm)')
          ax.set_ylabel('slit number')
          for i in range(EMIR_NBARS):
              ibar = i + 1
              ax.add_patch(patches.Rectangle(
                  (csu_config.csu_bar_left(ibar), ibar-0.5),
                  csu_config.csu_bar_slit_width(ibar), 1.0))
              ax.plot([0., csu_config.csu_bar_left(ibar)], [ibar, ibar],
                      '-', color='gray')
              ax.plot([csu_config.csu_bar_right(ibar), 341.5],
                      [ibar, ibar], '-', color='gray')
          plt.title("File: " + fileobj.name + "\ngrism=" + grism +
                    ", filter=" + spfilter)
          pause_debugplot(debugplot, pltshow=True)
  
      # return results
      return csu_config._csu_bar_left, csu_config._csu_bar_right, \
             csu_config._csu_bar_slit_center, csu_config._csu_bar_slit_width