def set_budget_max(self, n: int):
    """
    When the user selects or deselects a region the budget widgets need
    to know the new total cost for all the selected regions.  This method
    passes that information to each of the budget widgets.

    Arguments:
      n: the new maximum budget amount
    """
    for t in self.tabs:
        t.set_budget_max(n)

def values(self):
    """
    Return the budget settings for the currently selected budget type.

    Returns:
      bmax:  the maximum budget to pass to OptiPass
      binc:  the increment between budget values
    """
    return self.tabs[self.tabs.active].values()

def set_budget_max(self, n):
    """
    Choose a maximum budget by scanning a table of budget levels to
    find the first one less than the total cost.

    Arguments:
      n: the total cost of all barriers in the current selection.
    """
    for i in range(len(self.levels)-1, -1, -1):
        if n >= self.levels[i][1]:
            self.slider.options = self.labels[:i+1]
            break

def values(self):
    """
    Return the selected budget level (based on the slider position) and
    the number of budgets.  For basic budgets the interval between budgets
    is computed by dividing the select budget value by the number of increments
    (a constant defined in the class, currently equal to 10).

    Returns:
      bmax:  the highest budget to pass to OptiPass
      binc:  the increment between budgets
    """
    x = self.map[self.slider.value]
    return x, (x // self.increments)

def count_updated(self, e):
    """
    Callback function invoked when the user changes the number of budget
    levels.  Computes a new budget increment.
    """
    self.inc_slider.value = self.max_slider.value // self.count_input.value

def inc_updated(self, e):
    """
    Callback function invoked when the user changes the budget increment.
    Computes a new number of budgets.
    """
    c = max(self.COUNT_MIN, self.max_slider.value // self.inc_slider.value)
    c = min(self.COUNT_MAX, c)
    self.count_input.value = c

def max_updated(self, e):
    """
    Callback function invoked when the user moves the maximum budget
    slider.  Computes a new budget increment.
    """
    self.inc_slider.value = self.max_slider.value // self.count_input.value

def set_budget_max(self, n):
    """
    Called when the user selects or deselects a region.  Save the new
    maximum, and update the value of the increment based on the new maximum.

    Arguments:
      n:  the total cost of all barriers in the selected regions.
    """
    self.max_slider.end = max(1, n)
    self.max_slider.start = self.MAX_STEP
    self.inc_slider.end = max(1, n // 2)
    self.inc_slider.start = max(self.INC_STEP, n / self.COUNT_MAX)
    lim = 'N/A' if n == 0 else f'${n/1000000:.2f}M'
    self[0][1] = pn.pane.HTML(f'<b>Limit: {lim}</b>')

def values(self):
    """
    In this widget the maximum budget and budget increment are determined
    by the values in the corresponding widgets.
    """
    return self.max_slider.value, self.inc_slider.value

def parse_dollar_amount(self, s: str):
    """
    Make sure the string entered by the user has an acceptable format.
    It can be all digits (e.g. "1500000"), or digits separated by commas
    (e.g. "1,500,000"), or a number followed by a K or M (e.g. "1.5M").
    There can be a dollar sign at the front of the string.

    Arguments:
      s:  the string entered into the text box

    Returns:
      the value of the string converted into an integer

    """
    try:
        if s.startswith('$'):
            s = s[1:]
        if s.endswith(('K','M')):
            multiplier = 1000 if s.endswith('K') else 1000000
            res = int(float(s[:-1]) * multiplier)
        elif ',' in s:
            parts = s.split(',')
            assert len(parts[0]) <= 3 and (len(parts) == 1 or all(len(p) == 3 for p in parts[1:]))
            res = int(''.join(parts))
        else:
            res = int(s)
        return res
    except Exception:
        raise ValueError('unexpected format in dollar amount')

def values(self):
    """
    Return the specified budget amount as both the maximum budget and the
    budget interval.
    """
    s = self.input.value
    if s.startswith('$'):
        s = s[1:]
    n = self.parse_dollar_amount(self.input.value)
    return n, n