def _make_budget_table(self):
    """
    Display a table that has one column for each budget level, showing
    which barriers were included in the solution for that level.  Attach
    a callback function that is called when the user clicks on a row
    in the table (the callback updates the map to show gates used in a
    solution).
    """
    df = self.op.summary[['budget','habitat', 'gates']]
    colnames = ['Budget', 'Net Gain', 'gates']
    formatters = { 
        'Budget': {'type': 'money', 'symbol': '$', 'precision': 0},
        'Net Gain': NumberFormatter(format='0.0', text_align='center'),
    }
    alignment = { 
        'Budget': 'right',
        'Net Gain': 'center',
    }
    df = pd.concat([
        df,
        pd.Series(self.op.summary.gates.apply(len))
    ], axis=1)
    colnames.append('# Barriers')
    alignment['# Barriers'] = 'center'
    for i, t in enumerate(self.op.targets):
        if t.abbrev in self.op.summary.columns:
            df = pd.concat([df, self.op.summary[t.abbrev]], axis=1)
            col = t.short
            if self.op.weighted:
                col += f'⨉{self.op.weights[i]}'
            colnames.append(col)
            formatters[col] = NumberFormatter(format='0.0', text_align='center')
    df.columns = colnames
    table = pn.widgets.Tabulator(
        df,
        show_index = False,
        hidden_columns = ['gates'],
        editors = { c: None for c in colnames },
        text_align = alignment,
        header_align = {c: 'center' for c in colnames},
        formatters = formatters,
        selectable = True,
        configuration = {'columnDefaults': {'headerSort': False}},
    )
    table.on_click(self.budget_table_cb)
    self.budget_table = df
    return table

def _make_figures_tab(self):
    """
    Create a Tabs object with one tab for each ROI curve.
    """
    tabs = pn.Tabs(
        tabs_location='left',
        stylesheets = [tab_style_sheet],
    )
    self.op.make_roi_curves()
    for p in self.op.display_figures:
        tabs.append(p)
    return tabs

def _make_gate_table(self):
    """
    Make a table showing details about gates used in solutions.
    """
    formatters = { }
    alignment = { }
    df = self.op.table_view()
    hidden = ['Count']
    for col in df.columns:
        if col.startswith('$') or col in ['Primary','Dominant']:
            formatters[col] = {'type': 'tickCross', 'crossElement': ''}
            alignment[col] = 'center'
        elif col.endswith('hab'):
            c = col.replace('_hab','')
            formatters[c] = NumberFormatter(format='0.0', text_align='center')
            # alignment[c] = 'center'
        elif col.endswith('tude'):
            formatters[col] = NumberFormatter(format='0.00', text_align='center')
            # alignment[col] = 'right'
        elif col.endswith('gain'):
            hidden.append(col)
        elif col == 'Cost':
            formatters[col] = {'type': 'money', 'symbol': '$', 'precision': 0}
            alignment[col] = 'right'
    colnames = [c.replace('_hab','') for c in df.columns]
    if self.op.weighted:
        for i, t in enumerate(self.op.targets):
            if t.short not in colnames:             # shouldn't happen, but just in case...
                continue
            j = colnames.index(t.short)
            colnames[j] += f'⨉{self.op.weights[i]}'
            formatters[colnames[j]] = NumberFormatter(format='0.0', text_align='center')
    df.columns = colnames

    table = pn.widgets.Tabulator(
        df, 
        show_index=False, 
        frozen_columns=['ID'],
        hidden_columns=hidden,
        formatters=formatters,
        text_align=alignment,
        configuration={'columnDefaults': {'headerSort': False}},
        header_align={c: 'center' for c in df.columns},
        selectable = False,
    )
    table.disabled = True
    self.gate_table = df
    return table

def _make_title(self):
    """
    The top section of the output pane is a title showing the optimization parameters.
    """
    regions = self.op.regions
    targets = [t.short for t in self.op.targets]
    if self.op.weighted:
        targets = [f'{targets[i]} ⨉ {self.op.weights[i]}' for i in range(len(targets))]
    bmax = self.op.budget_max
    binc = self.op.budget_delta
    if bmax > binc:
        title_template = '<p><b>Regions:</b> {r}; <b>Targets:</b> {t}; <b>Climate:</b> {c}; <b>Budgets:</b> {min} to {max}</p>'
        return pn.pane.HTML(title_template.format(
            r = ', '.join(regions),
            t = ', '.join(targets),
            c = self.op.climate,
            min = OP.format_budget_amount(binc),
            max = OP.format_budget_amount(bmax),
        ))
    else:
        title_template = '<p><b>Regions:</b> {r}; <b>Targets:</b> {t}; <b>Climate:</b> {c}; <b>Budget:</b> {b}'
        return pn.pane.HTML(title_template.format(
            r = ', '.join(regions),
            t = ', '.join(targets),
            c = self.op.climate,
            b = OP.format_budget_amount(bmax),
        ))

def budget_table_cb(self, e):
    """
    The callback function invoked when the user clicks a row in the budget table.
    Use the event to figure out which row was clicked.  Hide any dots that were displayed
    previously, then make the dots for the selected row visible.
    """
    if n := self.selected_row:
        self.dots[n].visible = False
    self.selected_row = e.row
    self.dots[self.selected_row].visible = True

def hide_dots(self):
    """
    Callback function invoked when users click on a region name in the start panel to hide
    any dots that might be on the map.
    """
    if self.selected_row:
        self.dots[self.selected_row].visible = False
    self.selected_row = None

def make_dots(self, plot):
    """
    Called after the output panel is initialized, make a set of glyphs to display
    for each budget level.
    """
    if hasattr(self, 'budget_table'):
        self.selected_row = None
        self.dots = []
        for row in self.budget_table.itertuples():
            df = self.bf.map_info[self.bf.data.BARID.isin(row.gates)]
            c = plot.circle_dot('x', 'y', size=12, line_color='blue', fill_color='white', source=df)
            # c = plot.star_dot('x', 'y', size=20, line_color='blue', fill_color='white', source=df)
            # c = plot.star('x', 'y', size=12, color='blue', source=df)
            # c = plot.hex('x', 'y', size=12, color='green', source=df)
            c.visible = False
            self.dots.append(c)