Pasted

###################################################################################################
# SHINY Explorer - XXX (xxx) - ui.R
###################################################################################################
 
tabPanel('XXX', icon = icon(''),
 
# SIDEBAR PANEL -----------------------------------------------------------------------------------------------------------------
    sidebarPanel(
 
        # GEOGRAPHY -------------------------------------------------------------------------------------------------------------------
        a(id = 'tgl_hsp_geo', 'Show/Hide GEOGRAPHY', class = 'toggle-choices'),  
        div(id = "hdn_hsp_geo",
            p(),
            selectInput('cbo_hsp_geo', 'GEOGRAPHY:', choices = locations, selected = 'LAT'),
            conditionalPanel("input.tabs_hsp !== 'funnelplot' && input.tabs_hsp !== 'maps'",
                checkboxInput('chk_hsp_geo_cdn', 'Use Code instead of Label', value = TRUE )
            )
        ),
        hr(),
 
        # TIMESPAN -------------------------------------------------------------------------------------------------------------------
        a(id = 'tgl_hsp_tmp', 'Show/Hide TIMESPAN', class = 'toggle-choices'),  
        div(id = 'hdn_hsp_tmp',
            p(),
            selectInput('cbo_hsp_tmp', 'TIMESPAN:',  choices = c( 'select year(s)' = 1, 'select month(s)' = 2,'choose date range' = 3) ),
            conditionalPanel("input.cbo_hsp_tmp == '1'",
                sliderInput('sld_hsp_tmp', label = NULL, 
                    min = min(dataset$date.year), max = max(dataset$date.year),
                    value = c(max(dataset$date.year) - 2, max(dataset$date.year) ),
                    step = 1, ticks = FALSE, sep = ''
                )
            ),
            conditionalPanel("input.cbo_hsp_tmp != '1'",
                uiOutput('ui_hsp_tmp')
            )
        ), hr(),
 
        # METRICS ---------------------------------------------------------------------------------------------------------------------
        a(id = 'tgl_hsp_mtc', 'Show/Hide METRICS', class = 'toggle-choices'),  
        div(id = 'hdn_hsp_mtc',
            p(),
 
            # Metric Controls for TABLE -------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'table'",
                # Choose Reference metric
                selectInput('cbo_hsp_tblY', 'REFERENCE', choices = build_uiY('hsp') ), 
                # Choose a filter
                selectInput('cbo_hsp_tblF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                # Choose which value of previous variable dta should be filtered on
                conditionalPanel("input.cbo_hsp_tblF !== 'NONE'",
                    uiOutput('ui_hsp_tbl_flt')
                ),
                # Control the variable to order upon
                uiOutput('ui_hsp_tbl_ord'),
                # Control if the order is ASCending or DESCending
                uiOutput('ui_hsp_tbl_ort'), br(),
                # Choose if group above metric
                selectInput('cbo_hsp_tblG', 'GROUPED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                conditionalPanel("input.cbo_hsp_tblG !== 'NONE'",
                    # Choose how group above metric: 
                    uiOutput('ui_hsp_tbl_grp'),
                    # Choose, if applicable, the reference (Total, Rows, Columns) for the above: 
                    uiOutput('ui_hsp_tbl_gpr')
                )
            ),
            
            # Metric Controls for BARPLOT -------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'barplot'",
                # Choose Reference metric
                selectInput('cbo_hsp_brpY', 'REFERENCE', choices = build_uiY('hsp') ), 
                # Show Percentage. Only if chosen reference is type 2 (measure)
                uiOutput('ui_hsp_brp_pct'),
                # Show Average. Only if type = 2 and pct, or 3 and 4 always. IF GROUPED, only when faceting
                uiOutput('ui_hsp_brp_avg'),
                # Choose a filter
                selectInput('cbo_hsp_brpF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                # Choose which value of previous variable dta should be filtered on
                conditionalPanel("input.cbo_hsp_brpF !== 'NONE'",
                    uiOutput('ui_hsp_brp_flt')
                ),
                # Choose if and how group above metric
                selectInput('cbo_hsp_brpG', 'GROUPED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                # Choose how grouping should be displayed
                conditionalPanel("input.cbo_hsp_brpG !== 'NONE'",
                    uiOutput('ui_hsp_brp_grp'),
                    # Show/Hide zero/missing values when dodging
                    conditionalPanel("input.cbo_hsp_brp_grp == 'dodge'",
                        checkboxInput('chk_hsp_brp_sna', 'SHOW MISSING', value = FALSE )
                    ),
                    # Faceting options
                    conditionalPanel("input.cbo_hsp_brp_grp == 'facet'",
                        checkboxInput('chk_hsp_brp_scl', 'ALIGN SCALES', value = TRUE ),
                        selectInput('cbo_hsp_brpG2', 'ADD VARIABLE:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                        # Choose numbers of columns if faceting only once
                        conditionalPanel("input.cbo_hsp_brpG2 == 'NONE'",
                            sliderInput('sld_hsp_brp_fct', 'COLUMNS:', min = 1, max = 6, value = 2, ticks = FALSE)
                        )
                    )
                )
            ),
 
            # Metric Controls for BOXPLOT -------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'boxplot'",
                # Choose Reference metric
                selectInput('cbo_hsp_bxpY', 'REFERENCE:', choices = build_uiV('NUM') ),
                # Delete outliers
                checkboxInput('chk_hsp_bxp_out', 'Remove Outliers', value = FALSE ),
                conditionalPanel("input.chk_hsp_bxp_out === false",
                    # Force y-axis to show origin
                    checkboxInput('chk_hsp_bxp_yzr', 'SHOW ORIGIN', FALSE)
                ),
                # Choose a filter
                selectInput('cbo_hsp_bxpF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                # Choose which value of previous variable dta should be filtered on
                conditionalPanel("input.cbo_hsp_bxpF !== 'NONE'",
                    uiOutput('ui_hsp_bxp_flt')
                ),
                # Add mean placeholder in boxes
                checkboxInput('chk_hsp_bxp_avg', 'ADD MEAN POINT', FALSE),
                # # Add st.dev line in boxes
                # conditionalPanel("input.chk_hsp_bxp_avg",
                #   checkboxInput('chk_hsp_bxp_sdv', 'ADD SD LINE', value = FALSE)
                # ),
                # Choose if and how group above metric
                selectInput('cbo_hsp_bxpG', 'GROUPED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                # Choose how grouping should be displayed
                conditionalPanel("input.cbo_hsp_bxpG !== 'NONE'",
                    radioButtons('rdb_hsp_bxp_grp', 'GROUPING TYPE:', choices = c('dodge', 'facet'), inline = TRUE ),
                    # Faceting options
                    conditionalPanel("input.rdb_hsp_bxp_grp == 'facet'",
                        selectInput('cbo_hsp_bxpG2', 'ADD VARIABLE:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                        # Choose numbers of columns if faceting only once
                        conditionalPanel("input.cbo_hsp_bxpG2 == 'NONE'",
                            sliderInput('sld_hsp_bxp_fct', 'COLUMNS:', min = 1, max = 6, value = 2, ticks = FALSE)
                        )
                    )
                )
            ),
 
            # Metric Controls for HEATMAP -------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'heatmap'",
                # Choose the prefixed timespans to use as Y-coord
                selectInput('cbo_hsp_hmpX2', 'TIMEPART:', choices = timeref, selected = 'month_st'),
                # Choose Reference metric
                selectInput('cbo_hsp_hmpY', 'REFERENCE:', choices = build_uiY('hsp') ), 
                # If Y is a measure, ask for value or percentage
                uiOutput('ui_hsp_hmp_pct'),
                # Rescale the values along the x.axis or y.axis
                checkboxInput('chk_hsp_hmp_rvv', 'RESCALE VALUES', value = FALSE),
                conditionalPanel("input.chk_hsp_hmp_rvv", 
                    uiOutput('ui_hsp_hmp_rvc')
                ),
                # Choose a filter
                selectInput('cbo_hsp_hmpF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                # Choose which value of previous variable dta should be filtered on
                conditionalPanel("input.cbo_hsp_hmpF !== 'NONE'",
                    uiOutput('ui_hsp_hmp_flt')
                ),
                # Choose if group above metric (only faceting in this case)
                selectInput('cbo_hsp_hmpG', 'GROUPED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                conditionalPanel("input.cbo_hsp_hmpG !== 'NONE'",
                    selectInput('cbo_hsp_hmpG2', 'ADD VARIABLE:', choices = c('NONE', build_uiV(c('CAT', 'LGC', 'TMS')) ) ),
                    # Choose numbers of columns if faceting only once
                    conditionalPanel("input.cbo_hsp_hmpG2 == 'NONE'",
                        sliderInput('sld_hsp_hmp_fct', 'COLUMNS:', min = 1, max = 6, value = 2, ticks = FALSE)
                    )
                )
            ),
 
            # Metric Controls for FUNNELPLOT -------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'funnelplot'",
                # Choose effect size (X)
                selectInput('cbo_hsp_fnlX', 'EFFECT SIZE (X):', choices = c(build_uiY('fnl')) ),
                # show reduced effect size
                checkboxInput('chk_hsp_fnl_pcY', 'SHOW REDUCED EFFECT SIZE', FALSE),
                # trimming effect sizes
                uiOutput('ui_hsp_fnl_tmz'),
                # Choose reference measure / metric
                selectInput('cbo_hsp_fnlY', 'REFERENCE (Y)', choices = build_uiY('hsp', 2:3) ), 
                # Show Percentage. Only if chosen reference is type 2 (measure)
                uiOutput('ui_hsp_fnl_pct'),
                # trimming metric values
                uiOutput('ui_hsp_fnl_tmt'),
                # Choose a filter
                selectInput('cbo_hsp_fnlF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                # Choose which value of previous variable dta should be filtered on
                conditionalPanel("input.cbo_hsp_fnlF !== 'NONE'",
                    uiOutput('ui_hsp_fnl_flt')
                ),
                # overall average
                checkboxInput('chk_hsp_fnl_avg', 'ADD AVERAGE LINE', TRUE),
                # add funnel plot
                uiOutput('ui_hsp_fnl_fnl'),
                # funnel p-limits
                conditionalPanel("input.chk_hsp_fnl_fnl",
                    selectInput('cbo_hsp_fnl_flm', 'CONTROL LIMITS:', 
                        choices = funnel.defaults[['prob.tot']],
                        multiple = TRUE,
                        selected = funnel.defaults[['prob.sel']]
                    )
                )
            ),
 
            # Metric Controls for MAPS --------------------------------------------------------------------------------------------------------------
            conditionalPanel("input.tabs_hsp == 'maps'",
                             
                # Choose Area Metric
                selectInput('cbo_hsp_mapY', 'AREA METRIC:', choices = c('NONE', build_uiY('map')) ),
                conditionalPanel("input.cbo_hsp_mapY !== 'NONE'",
                    # Choose how to classify metric
                    selectInput('cbo_hsp_map_Ycl', 'CLASS METHOD:', choices = class.methods),
                    # Choose number of classes
                    sliderInput('sld_hsp_map_Ycn', 'NUMBER OF CLASSES:', min = 3, max = 9, value = 5, step = 1, ticks = FALSE),
                    # Choose a filter
                    selectInput('cbo_hsp_mapF', 'FILTERED BY:', choices = c('NONE', build_uiV(c('CAT', 'LGC')) ) ),
                    # Choose which value of previous variable dta should be filtered on
                    conditionalPanel("input.cbo_hsp_mapF !== 'NONE'",
                        uiOutput('ui_hsp_map_flt')
                    )
                ),
                # Add Points
                checkboxInput('chk_hsp_map_hsp', 'ADD POINTS', FALSE),
                # Choose between icons or dots for plotting points
                conditionalPanel("input.chk_hsp_map_hsp",
                    radioButtons('rdb_hsp_map_hsp', 'TYPE:', choices = c('Icons', 'Points'), inline = TRUE ),
                    # Choosing attributes/measures/metrics when Points are plotted
                    conditionalPanel("input.rdb_hsp_map_hsp == 'Points'",
                        selectInput('cbo_hsp_mapZ1', 'FILL MEASURE:', choices = c('NONE', build_uiV(c('NUM')) ) ),
                        conditionalPanel("input.cbo_hsp_mapZ1 !== 'NONE'",
                            selectInput('cbo_hsp_map_Z1c', 'CLASS METHOD:', choices = class.methods)
                        ),
                        selectInput('cbo_hsp_mapZ2', 'SIZE MEASURE:', choices = c('NONE', build_uiV(c('NUM')) ) ),
                        conditionalPanel("input.cbo_hsp_mapZ2 !== 'NONE'",
                            selectInput('cbo_hsp_map_Z2c', 'CLASS METHOD:', choices = class.methods)
                        )
                    )
                )               
            )
 
            # END OF Metrics Controls -------------------------------------------------------------------------------------------
            
        ), hr(),
 
        # OPTIONS ---------------------------------------------------------------------------------------------------------------
        a(id = 'tgl_hsp_opt', 'Show/Hide OPTIONS', class = 'toggle-choices'),  
        hidden(
            div(id = 'hdn_hsp_opt',
                p(),
                  
                # Option Controls for TABLE ----------------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'table'",
                    # Control the color for the background in the cells with the bars
                    colourpicker::colourInput('col_hsp_tbb', 'FILL COLOUR:', '#63B8FF', showColour = 'background'),
                    # Control the color for the font when cells are formatted
                    colourpicker::colourInput('col_hsp_tbf', 'FONT COLOUR:', 'black', showColour = 'background', palette = 'limited'),
                    # Control the divergent palette for the background in the INDEX column
                    selectInput('pal_hsp_tbl', 'PALETTE:', choices = lst.palette[['DIVERGING']], selected = 'Spectral' ),
                    checkboxInput('chk_hsp_tbl_rvc', 'REVERSE COLOURS', value = FALSE),
                    # Control the number of colours for the above divergent palette
                    sliderInput('sld_hsp_tbl_col', 'NUMBER OF QUANTILES:', min = 2, max = 10, value = 5, step = 1, ticks = FALSE)
                    
                    # END OF TABLE Option Controls ---------------------------------------------------------------------------------------
                ),
                
                # Option Controls for BARPLOT  -------------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'barplot'",
 
                    # GENERAL --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_brp_gen', 'Show/Hide GENERAL', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_brp_gen',
                            p(),
                            # Plot Zoom
                            sliderInput('sld_hsp_brp_ggw', 'ZOOM:', min = 4, max = 10, value = 6.5, step = 0.5, ticks = FALSE),
                            # User decides how many units wants to see
                            uiOutput('ui_hsp_brp_cnt'),
                            # Force y-axis to show origin
                            checkboxInput('chk_hsp_brp_yzr', 'SHOW ORIGIN', TRUE),
                            # Text Size and Font family
                            sliderInput('sld_hsp_brp_xlz', 'TEXT SIZE:', min = 1, max = 15, value = 7, step = 0.5, ticks = FALSE),
                            selectInput('cbo_hsp_brp_ffm', 'FONT FAMILY:', choices = font.table, selected = 'Arial')
                        ), hr()
                    ), br(),
 
                    # AXIS --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_brp_axs', 'Show/Hide AXIS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_brp_axs',
                            p(),
                            # Control the rotation of the axis labels
                            uiOutput('ui_hsp_brp_lbr'),
                            # Control the appearance of Axis Lines and Ticks, plus Plot Border
                            checkboxInput('chk_hsp_brp_xlx', 'ADD x-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_brp_xly', 'ADD y-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_brp_xtk', 'ADD AXIS TICKS', TRUE),
                            checkboxInput('chk_hsp_brp_plb', 'ADD PLOT BORDER', FALSE),
                            conditionalPanel("input.chk_hsp_brp_xlx || input.chk_hsp_brp_xly || input.chk_hsp_brp_xtk || input.chk_hsp_brp_plb",
                                sliderInput('sld_hsp_brp_xsz', 'SIZE:', min = 1, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_brp_xsc', 'COLOUR:', 'grey50', showColour = 'background')
                            ),
                            # Add and Control the appearance of Axis Titles
                            checkboxInput('chk_hsp_brp_xlt', 'ADD AXIS TITLES', FALSE),
                            conditionalPanel("input.chk_hsp_brp_xlt",
                                sliderInput('sld_hsp_brp_xlt', 'FONT SIZE MULTIPLE:', min = 0, max = 100, value = 20, step = 5, ticks = FALSE, post = '%'),
                                selectInput('cbo_hsp_brp_xlt', 'FONT FACE:', choices = face.types, selected = 'bold')
                            )
                        ), hr()
                    ), br(),
 
                    # BACKGROUND --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_brp_bkg', 'Show/Hide BACKGROUND', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_brp_bkg',
                            p(),
                            # Background color
                            colourpicker::colourInput('col_hsp_brp_bkg', 'BACKGROUND COLOUR:', 'white', showColour = 'background'),
                            # Grids
                            checkboxGroupInput('chg_hsp_brp_grd', 'ADD GRIDS', choices = c('Horizontal', 'Vertical'), inline = TRUE ),
                            conditionalPanel("input.chg_hsp_brp_grd.length > 0",
                                sliderInput('sld_hsp_brp_gdz', 'SIZE:', min = 0.5, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_brp_gdc', 'COLOUR:', 'grey50', showColour = 'background'),
                                selectInput('cbo_hsp_brp_gdt', 'TYPE:', choices = line.types, selected = 'dotted')
                            )
                        ), hr()
                    ), br(),
 
                    # BARS ------------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_brp_brs', 'Show/Hide BARS', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_brp_brs',
                            p(),
                            # Control how bars are ordered
                            selectInput('cbo_hsp_brp_ord', 'ORDERING:', choices = c('Alpha (ASC)' = 1, 'Alpha (DESC)' = 2, 'Values (ASC)' = 3, 'Values (DESC)' = 4) ),
                            # Control if barplot is horizontal or vertical
                            radioButtons('rdb_hsp_brp_orn', 'ORIENTATION:', choices = c('Vertical', 'Horizontal'), inline = TRUE ),
                            # Choose colour / palette
                            uiOutput('ui_hsp_brp_col'),
                            conditionalPanel("typeof input.pal_hsp_brp !== 'undefined'",
                                checkboxInput('chk_hsp_brp_rvc', 'REVERSE COLOURS', value = FALSE)
                            ),
                            # Control width of bars
                            sliderInput('sld_hsp_brp_baw', 'WIDTH:', min = 1, max = 10, value = 8, step = 0.5, ticks = FALSE),
                            # Add and customize bars' borders
                            checkboxInput('chk_hsp_brp_bdr', 'ADD BARS BORDER', FALSE),
                            conditionalPanel("input.chk_hsp_brp_bdr",
                                sliderInput('sld_hsp_brp_bow', 'SIZE:', min = 1, max = 15, value = 6, step = 1, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_brp_boc', 'COLOUR:', 'black', showColour = 'background'),
                                selectInput('cbo_hsp_brp_bot', 'TYPE:', choices = line.types, selected = 'solid')
                            )
                        ), hr()
                    ), br(),
 
                    # LABELS IN BARS --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_brp_lbl', 'Show/Hide LABELS', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_brp_lbl',
                            p(),
                            # Add (if not grouped stack/fill), and customize value labels in bars (depends on labels IN/OUT and orientation H/V)
                            checkboxInput('chk_hsp_brp_lbl', 'ADD VALUE LABELS IN BARS', FALSE),
                            conditionalPanel("input.chk_hsp_brp_lbl",
                                sliderInput('sld_hsp_brp_lbz', 'LABELS FONT SIZE', min = 1, max = 4, value = 1.6, step = 0.2, ticks = TRUE),
                                radioButtons('rdb_hsp_brp_lbp', 'LABELS POSITION', choices = c('Inside', 'Outside'), inline = TRUE ),
                                # uiOutput('ui_hsp_brp_lbp'),
                                uiOutput('ui_hsp_brp_lbc')
                            )
                        ), hr()
                    ), br(),
 
                    # AVERAGE LINE ----------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_hsp_brp_avg", 
                        a(id = 'tgl_hsp_brp_avg', 'Show/Hide AVERAGE LINE', class = 'toggle-choices-sub'),  
                        hidden(
                            div(id = 'hdn_hsp_brp_avg',
                                p(),
                                checkboxInput('chk_hsp_brp_avl', 'ADD VALUE', value = FALSE),
                                colourpicker::colourInput('col_hsp_brp_avc', 'COLOUR:', 'black', showColour = 'background'),
                                sliderInput('sld_hsp_brp_avz', 'SIZE:', min = 1, max = 8, value = 4, step = 0.5, ticks = FALSE),
                                selectInput('cbo_hsp_brp_avt', 'TYPE:', choices = line.types, selected = 'dotdash'),
                                sliderInput('sld_hsp_brp_avt', 'TRANSPARENCY:', min = 0, max = 10, value = 4, step = 1, ticks = FALSE)
                            )
                        ), br()
                    )
 
                    # END OF BARS Option Controls ----------------------------------------------------------------------------------------
                ),
                
                # Option Controls for BOXPLOT  -------------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'boxplot'",
 
                    # GENERAL --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_bxp_gen', 'Show/Hide GENERAL', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_bxp_gen',
                            p(),
                            # Plot Zoom
                            sliderInput('sld_hsp_bxp_ggw', 'ZOOM:', min = 4, max = 10, value = 6.5, step = 0.5, ticks = FALSE),
                            # User decides how many units wants to see
                            uiOutput('ui_hsp_bxp_cnt'),
                            # Text Size and Font family
                            sliderInput('sld_hsp_bxp_xlz', 'TEXT SIZE:', min = 1, max = 15, value = 7, step = 0.5, ticks = FALSE),
                            selectInput('cbo_hsp_bxp_ffm', 'FONT FAMILY:', choices = font.table, selected = 'Arial')
                        ), hr()
                    ), br(),
 
                    # AXIS --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_bxp_axs', 'Show/Hide AXIS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_bxp_axs',
                            p(),
                            # Control the rotation of the axis labels
                            uiOutput('ui_hsp_bxp_lbr'),
                            # Control the appearance of Axis Lines and Ticks, plus Plot Border
                            checkboxInput('chk_hsp_bxp_xlx', 'ADD x-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_bxp_xly', 'ADD y-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_bxp_xtk', 'ADD AXIS TICKS', TRUE),
                            checkboxInput('chk_hsp_bxp_plb', 'ADD PLOT BORDER', FALSE),
                            conditionalPanel("input.chk_hsp_bxp_xlx || input.chk_hsp_bxp_xly || input.chk_hsp_bxp_xtk || input.chk_hsp_bxp_plb",
                                sliderInput('sld_hsp_bxp_xsz', 'SIZE:', min = 1, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_bxp_xsc', 'COLOUR:', 'grey50', showColour = 'background')
                            ),
                            # Add and Control the appearance of Axis Titles
                            checkboxInput('chk_hsp_bxp_xlt', 'ADD AXIS TITLES', FALSE),
                            conditionalPanel("input.chk_hsp_bxp_xlt",
                                sliderInput('sld_hsp_bxp_xlt', 'FONT SIZE MULTIPLE:', min = 0, max = 100, value = 20, step = 5, ticks = FALSE, post = '%'),
                                selectInput('cbo_hsp_bxp_xlt', 'FONT FACE:', choices = face.types, selected = 'bold')
                            )
                        ), hr()
                    ), br(),
 
                    # BACKGROUND --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_bxp_bkg', 'Show/Hide BACKGROUND', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_bxp_bkg',
                            p(),
                            # Background color
                            colourpicker::colourInput('col_hsp_bxp_bkg', 'BACKGROUND COLOUR:', 'white', showColour = 'background'),
                            # Grids
                            checkboxGroupInput('chg_hsp_bxp_grd', 'ADD GRIDS', choices = c('Horizontal', 'Vertical'), inline = TRUE ),
                            conditionalPanel("input.chg_hsp_bxp_grd.length > 0",
                                sliderInput('sld_hsp_bxp_gdz', 'SIZE:', min = 0.5, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_bxp_gdc', 'COLOUR:', 'grey50', showColour = 'background'),
                                selectInput('cbo_hsp_bxp_gdt', 'TYPE:', choices = line.types, selected = 'dotted')
                            )
                        ), hr()
                    ), br(),
 
                    # BOXES ------------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_bxp_bxs', 'Show/Hide BOXES', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_bxp_bxs',
                            p(),
                            # Control how boxes are ordered
                            selectInput('cbo_hsp_bxp_ord', 'ORDERING:', choices = c('Alpha (ASC)' = 1, 'Alpha (DESC)' = 2, 'Median (ASC)' = 3, 'Median (DESC)' = 4) ),
                            # Control if boxplot is horizontal or vertical
                            radioButtons('rdb_hsp_bxp_orn', 'ORIENTATION:', choices = c('Vertical', 'Horizontal'), inline = TRUE ),
                            # Choose colour / palette
                            uiOutput('ui_hsp_bxp_col'),
                            conditionalPanel("typeof input.pal_hsp_bxp !== 'undefined'",
                                checkboxInput('chk_hsp_bxp_rvc', 'REVERSE COLOURS', value = FALSE)
                            ),
                            # Control width of boxes
                            sliderInput('sld_hsp_bxp_bxw', 'WIDTH:', min = 1, max = 10, value = 8, step = 0.5, ticks = FALSE),
                            # Distance between boxes when grouped dodged
                            conditionalPanel("input.rdb_hsp_bxp_grp === 'dodge'",
                                sliderInput('sld_hsp_bxp_gdd', 'DISTANCE:', min = 1, max = 10, value = 8, step = 1, ticks = FALSE)
                            )
                        ), hr()
                    ), br(),
                    
                    # LINES ------------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_bxp_lns', 'Show/Hide LINES', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_bxp_lns',
                            p(),
                            # Customize boxes' borders
                            sliderInput('sld_hsp_bxp_bbw', 'SIZE:', min = 1, max = 15, value = 6, step = 1, ticks = FALSE),
                            colourpicker::colourInput('col_hsp_bxp_boc', 'COLOUR:', 'black', showColour = 'background'),
                            selectInput('cbo_hsp_bxp_bbt', 'TYPE:', choices = line.types, selected = 'solid')
                        ), hr()
                    ), br(),
 
                    # OUTLIERS ----------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_tms_bxp_out === false", 
                        a(id = 'tgl_hsp_bxp_out', 'Show/Hide OUTLIERS', class = 'toggle-choices-sub'),
                        hidden(
                            div(id = 'hdn_hsp_bxp_out',
                                p(),
                                conditionalPanel("input.rdb_hsp_bxp_grp !== 'dodge'", 
                                    colourpicker::colourInput('col_hsp_bxp_otf', 'FILL COLOUR:', 'black', showColour = 'background')
                                ),
                                colourpicker::colourInput('col_hsp_bxp_otb', 'BORDER COLOUR:', 'black', showColour = 'background'),
                                sliderInput('sld_hsp_bxp_otz', 'SIZE:', min = 1, max = 10, value = 5, step = 1, ticks = FALSE),
                                sliderInput('sld_hsp_bxp_ott', 'TRANSPARENCY:', min = 0, max = 10, value = 4, step = 1, ticks = FALSE),
                                selectInput('cbo_hsp_bxp_out', 'SHAPE:', choices = point.shapes, selected = 21 )
                            )
                        ), br()
                    ), 
 
                    # AVERAGE INBOX ----------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_hsp_bxp_avg", 
                        a(id = 'tgl_hsp_bxp_avg', 'Show/Hide AVERAGE', class = 'toggle-choices-sub'),
                        hidden(
                            div(id = 'hdn_hsp_bxp_avg',
                                p(),
                                colourpicker::colourInput('col_hsp_bxp_avc', 'COLOUR:', 'darkred', showColour = 'background'),
                                sliderInput('sld_hsp_bxp_avz', 'SIZE:', min = 1, max = 10, value = 5, step = 1, ticks = FALSE),
                                selectInput('cbo_hsp_bxp_avs', 'SHAPE:', choices = point.shapes, selected = 21 ),
#                               selectInput('cbo_hsp_bxp_avl', 'LINETYPE:', choices = line.types, selected = 'dotdash'),
                                sliderInput('sld_hsp_bxp_avt', 'TRANSPARENCY:', min = 0, max = 10, value = 4, step = 1, ticks = FALSE)
                            )
                        ), br()
                    )
 
                    # END OF BOXES Option Controls ---------------------------------------------------------------------------------------
                ),
                
                # Option Controls for HEATMAP  -------------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'heatmap'",
 
                    # GENERAL ---------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_hmp_gen', 'Show/Hide GENERAL', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_hmp_gen',
                            p(),
                            # Plot Zoom
                            sliderInput('sld_hsp_hmp_ggw', 'ZOOM:', min = 4, max = 10, value = 6.5, step = 0.5, ticks = FALSE),
                            # User decides how many units wants to see
                            uiOutput('ui_hsp_hmp_cnt'),
                            # Text Size and Font family
                            sliderInput('sld_hsp_hmp_xlz', 'TEXT SIZE:', min = 1, max = 15, value = 7, step = 0.5, ticks = FALSE),
                            selectInput('cbo_hsp_hmp_ffm', 'FONT FAMILY:', choices = font.table, selected = 'Arial')
                        ), hr()
                    ), br(),
 
                    # AXIS ------------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_hmp_axs', 'Show/Hide AXIS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_hmp_axs',
                            p(),
                            # Control the rotation of the axis labels
                            uiOutput('ui_hsp_hmp_lbr'),
                            # Axis Ticks, see boxes border for size and color
                            checkboxInput('chk_hsp_hmp_xtk', 'ADD AXIS TICKS', TRUE),
                             # Add and Control the appearance of Axis Titles
                            checkboxInput('chk_hsp_hmp_xlt', 'ADD AXIS TITLES', FALSE),
                            conditionalPanel("input.chk_hsp_hmp_xlt",
                                sliderInput('sld_hsp_hmp_xlt', 'FONT SIZE MULTIPLE:', min = 0, max = 100, value = 20, step = 5, ticks = FALSE, post = '%'),
                                selectInput('cbo_hsp_hmp_xlt', 'FONT FACE:', choices = face.types, selected = 'bold')
                            )
                        ), hr()
                    ), br(),
 
                    # BOXES -----------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_hmp_bxs', 'Show/Hide BOXES', class = 'toggle-choices-sub'),
                    hidden(
                        div(id = 'hdn_hsp_hmp_bxs',
                            p(),
                            # Choose palette
                            selectInput('pal_hsp_hmp', 'FILL PALETTE:', choices = lst.palette, selected = 'YlGnBu'),
                            # Reverse the colours in palette
                            checkboxInput('chk_hsp_hmp_rvc', 'REVERSE COLOURS', value = FALSE),
                            # Transparency
                            sliderInput('sld_hsp_hmp_trp', 'TRANSPARENCY:', min = 0, max = 7, value = 3, step = 0.5, ticks = FALSE),
                            # Show/Hide zero/missing values when dodging
                            checkboxInput('chk_hsp_hmp_sna', 'SHOW MISSING', value = FALSE ),
                            # NAs boxes' colour
                            conditionalPanel("input.chk_hsp_hmp_sna",
                                colourpicker::colourInput('col_hsp_hmp_nas', 'EMPTY BOXES COLOUR:', 'grey62', showColour = 'background')
                            ),
                            # Control how centres (X-geo) are ordered
                            selectInput('cbo_hsp_hmp_ord', 'ORDERING:', choices = c('Alpha (ASC)' = 1, 'Alpha (DESC)' = 2, 'Metric (ASC)' = 3, 'Metric (DESC)' = 4) ),
                            # Put Centres on vertical Axis
                            checkboxInput('chk_hsp_hmp_orn', 'CENTRES ON Y-AXIS', value = FALSE ),
                            # Option to make boxes squared (NOTE: coord_flip DOES NOT WORK WITH coord_equal)
                            conditionalPanel("input.chk_hsp_hmp_orn === false", 
                                checkboxInput('chk_hsp_hmp_sqb', 'MAKE BOXES SQUARED', value = FALSE)
                            ),
                            # Customize boxes' borders
                            sliderInput('sld_hsp_hmp_bbz', 'BORDER SIZE:', min = 1, max = 15, value = 6, step = 1, ticks = FALSE),
                            colourpicker::colourInput('col_hsp_hmp_bbc', 'BORDER COLOUR:', 'black', showColour = 'background'),
                            selectInput('cbo_hsp_hmp_bbt', 'BORDER TYPE:', choices = line.types, selected = 'solid')
                        )
                    )
 
                    # END OF TILES Option Controls ---------------------------------------------------------------------------------------
                ),
                            
                # Option Controls for FUNNELPLOT ----------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'funnelplot'",
                                 
                    # GENERAL --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_fnl_gen', 'Show/Hide GENERAL', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_fnl_gen',
                            p(),
                            # Plot Zoom
                            sliderInput('sld_hsp_fnl_ggw', 'ZOOM:', min = 4, max = 10, value = 6.5, step = 0.5, ticks = FALSE),
                            # Text Size and Font family
                            sliderInput('sld_hsp_fnl_xlz', 'TEXT SIZE:', min = 1, max = 15, value = 7, step = 0.5, ticks = FALSE),
                            selectInput('cbo_hsp_fnl_ffm', 'FONT FAMILY:', choices = font.table, selected = 'Arial')
                        ), hr()
                    ), br(),
 
                    # AXIS --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_fnl_axs', 'Show/Hide AXIS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_fnl_axs',
                            p(),
                            # Control the appearance of Axis Lines and Ticks, plus Plot Border
                            checkboxInput('chk_hsp_fnl_xlx', 'ADD x-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_fnl_xly', 'ADD y-AXIS LINE', TRUE),
                            checkboxInput('chk_hsp_fnl_xtk', 'ADD AXIS TICKS', TRUE),
                            checkboxInput('chk_hsp_fnl_plb', 'ADD PLOT BORDER', FALSE),
                            conditionalPanel("input.chk_hsp_fnl_xlx || input.chk_hsp_fnl_xly || input.chk_hsp_fnl_xtk || input.chk_hsp_fnl_plb",
                                sliderInput('sld_hsp_fnl_xsz', 'SIZE:', min = 1, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_fnl_xsc', 'COLOUR:', 'grey50', showColour = 'background')
                            ),
                            # Add and Control the appearance of Axis Titles
                            checkboxInput('chk_hsp_fnl_xlt', 'ADD AXIS TITLES', FALSE),
                            conditionalPanel("input.chk_hsp_fnl_xlt",
                                sliderInput('sld_hsp_fnl_xlt', 'FONT SIZE MULTIPLE:', min = 0, max = 100, value = 20, step = 5, ticks = FALSE, post = '%'),
                                selectInput('cbo_hsp_fnl_xlt', 'FONT FACE:', choices = face.types, selected = 'bold')
                            )
                        ), hr()
                    ), br(),
 
                    # BACKGROUND --------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_fnl_bkg', 'Show/Hide BACKGROUND', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_fnl_bkg',
                            p(),
                            # Background color
                            colourpicker::colourInput('col_hsp_fnl_bkg', 'BACKGROUND COLOUR:', 'white', showColour = 'background'),
                            # Grids
                            checkboxGroupInput('chg_hsp_fnl_grd', 'ADD GRIDS', choices = c('Horizontal', 'Vertical'), inline = TRUE ),
                            conditionalPanel("input.chg_hsp_fnl_grd.length > 0",
                                sliderInput('sld_hsp_fnl_gdz', 'SIZE:', min = 0.5, max = 5, value = 2, step = 0.5, ticks = FALSE),
                                colourpicker::colourInput('col_hsp_fnl_gdc', 'COLOUR:', 'grey50', showColour = 'background'),
                                selectInput('cbo_hsp_fnl_gdt', 'TYPE:', choices = line.types, selected = 'dotted')
                            )
                        ), hr()
                    ), br(),
                    
                    # POINTS -------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_fnl_pnt', 'Show/Hide POINTS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_fnl_pnt',
                            p(),
                            sliderInput('sld_hsp_fnl_pnz', 'SIZE:', min = 1, max = 10, value = 3, step = 1, ticks = FALSE),
                            colourpicker::colourInput('col_hsp_fnl_pnf', 'FILL COLOUR:', 'black', showColour = 'background'),
                            colourpicker::colourInput('col_hsp_fnl_pnc', 'BORDER COLOUR:', 'black', showColour = 'background'),
                            sliderInput('sld_hsp_fnl_pno', 'OPACITY:', min = 1, max = 10, value = 7, step = 1, ticks = FALSE),
                            selectInput('cbo_hsp_fnl_pnh', 'SHAPE:', choices = point.shapes, selected = 21 )
                        ), hr()
                    ), br(),
                    
                    # LABELS -------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_fnl_lbl', 'Show/Hide LABELS', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_fnl_lbl',
                            p(),
                            sliderInput('sld_hsp_fnl_lbz', 'TEXT SIZE:', min = 1, max = 10, value = 4, step = 0.5, ticks = FALSE),
                            colourpicker::colourInput('col_hsp_fnl_lbc', 'TEXT COLOUR:', 'black', showColour = 'background'),
                            sliderInput('sld_hsp_fnl_lbo', 'TEXT OPACITY:', min = 1, max = 10, value = 6, step = 1, ticks = FALSE),
                            colourpicker::colourInput('col_hsp_fnl_sgc', 'SEGMENT COLOUR:', 'black', showColour = 'background'),
                            sliderInput('sld_hsp_fnl_sgz', 'SEGMENT SIZE:', min = 1, max = 10, value = 4, step = 0.5, ticks = FALSE),
                            sliderInput('sld_hsp_fnl_sgt', 'SEGMENT OPACITY:', min = 0, max = 10, value = 6, step = 1, ticks = FALSE),
                            sliderInput('sld_hsp_fnl_sgm', 'MIN LENGTH:', min = 0, max = 5, value = 0.5, step = 0.1, ticks = FALSE),
                            checkboxInput('chk_hsp_fnl_sgr', 'ADD ARROW', value = FALSE)
                        ), hr()
                    ), br(),
                    
                    # AVERAGE LINE ----------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_hsp_fnl_avg", 
                        a(id = 'tgl_hsp_fnl_avg', 'Show/Hide AVERAGE LINE', class = 'toggle-choices-sub'),  
                        hidden(
                            div(id = 'hdn_hsp_fnl_avg',
                                p(),
                                checkboxInput('chk_hsp_fnl_avl', 'ADD VALUE', value = FALSE),
                                colourpicker::colourInput('col_hsp_fnl_avc', 'COLOUR:', 'red', showColour = 'background'),
                                sliderInput('sld_hsp_fnl_avz', 'SIZE:', min = 1, max = 8, value = 4, step = 0.5, ticks = FALSE),
                                selectInput('cbo_hsp_fnl_avt', 'TYPE:', choices = line.types, selected = 'dotdash')
                            )
                        ), br()
                    ),
                    
                    # FUNNEL LIMITS ----------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_hsp_fnl_fnl", 
                        a(id = 'tgl_hsp_fnl_fnl', 'Show/Hide FUNNEL LIMITS', class = 'toggle-choices-sub'),  
                        hidden(
                            div(id = 'hdn_hsp_fnl_fnl',
                                p(),
                                sliderInput('sld_hsp_fnl_fnz', 'SIZE:', min = 1, max = 8, value = 4, step = 0.5, ticks = FALSE),
                                selectInput('cbo_hsp_fnl_fnc', 'COLOUR(S):', 
                                    choice = funnel.defaults[['col.tot']], multiple = TRUE, 
                                    selected = funnel.defaults[['col.sel']] 
                                ),
                                selectInput('cbo_hsp_fnl_fnt', 'TYPE(S):', 
                                    choices = funnel.defaults[['type.tot']], multiple = TRUE, 
                                    selected = funnel.defaults[['type.sel']]
                                ),
                                checkboxInput('chk_hsp_fnl_fnv', 'ADD VALUE(S)', value = FALSE)
                            )
                        ), br()
                    )
 
                    # END OF POINTS Option Controls -------------------------------------------------------------------------------------------------
                ),
                
                # Option Controls for MAP ------------------------------------------------------------------------------------------------
                conditionalPanel("input.tabs_hsp == 'maps'",
                    # GENERAL  --------------------------------------------------------------------------------------------------
                    a(id = 'tgl_hsp_map_gen', 'Show/Hide GENERAL', class = 'toggle-choices-sub'),  
                    hidden(
                        div(id = 'hdn_hsp_map_gen',
                            p(),
                            # Choose background tile
                            selectInput('cbo_hsp_map_tls', 'TILES:', choices = c(tiles.list), selected = tile.ini),
                            conditionalPanel("input.cbo_hsp_mapY !== 'NONE'",
                                # Add Legend
                                checkboxInput('chk_hsp_map_lgn', 'ADD LEGEND', TRUE),
                                conditionalPanel("input.chk_hsp_map_lgn",
                                    # Legend Position
                                    selectInput('cbo_hsp_map_lgn', 'POSITION:', choices = c('bottomright', 'bottomleft', 'topleft', 'topright') )
                                )
                            )
                        ), hr()
                    ), br(),
                    
                    # POLYGONS  -------------------------------------------------------------------------------------------------
                    conditionalPanel("input.cbo_hsp_mapY !== 'NONE'",
                        a(id = 'tgl_hsp_map_pol', 'Show/Hide AREAS', class = 'toggle-choices-sub'),  
                        hidden(
                            div(id = 'hdn_hsp_map_pol',
                                p(),
                                # Palette IF any metric is chosen, otherwise colour
                                selectInput('pal_hsp_mapY', 'FILL PALETTE:', choices = lst.palette, selected = 'Blues'),
                                conditionalPanel("typeof input.pal_hsp_mapY !== 'undefined'",
                                    checkboxInput('chk_hsp_mapY_rvc', 'REVERSE COLOURS', value = FALSE)
                                ),
                                # Transparency
                                sliderInput('sld_hsp_mapY_trp', 'TRANSPARENCY:', min = 0, max = 10, value = 3, step = 0.5, ticks = FALSE),
                                # Borders Size and colour
                                colourpicker::colourInput('col_hsp_mapY_bcl', 'BORDER COLOUR:', 'black', showColour = 'background'),
                                sliderInput('sld_hsp_mapY_bsz', 'BORDER SIZE:', min = 1, max = 20, value = 4, step = 1, ticks = FALSE)
                            ), hr()
                        ), br()
                    ),
                    # POINTS  ---------------------------------------------------------------------------------------------------
                    conditionalPanel("input.chk_hsp_map_hsp",
                        a(id = 'tgl_hsp_map_pnt', 'Show/Hide POINTS', class = 'toggle-choices-sub'),  
                        hidden(
                            div(id = 'hdn_hsp_map_pnt',
                                p(),
                                # Palette IF any metric is chosen, otherwise colour
                                uiOutput('ui_hsp_mapZ_col'),
                                conditionalPanel("typeof input.pal_hsp_mapZ !== 'undefined'",
                                    checkboxInput('chk_hsp_mapZ_rvc', 'REVERSE COLOURS', value = FALSE)
                                ),
                                # Transparency
                                sliderInput('sld_hsp_mapZ_trp', 'TRANSPARENCY:', min = 0, max = 10, value = 3, ticks = FALSE),
                                # Shape
                                selectInput('cbo_hsp_mapZ_shp', 'SHAPE:', choices = point.shapes, selected = 21 )
                            ), hr()
                        ), br()
                    )
                    
                    # END OF MAPS Option Controls ----------------------------------------------------------------------------------------
                )
                
                # END OF Option Controls -------------------------------------------------------------------------------------------------
        )), hr(),
        
        # DOWNLOAD --------------------------------------------------------------------------------------------------------------------
        a(id = 'tgl_hsp_dwn', 'Show/Hide DOWNLOAD', class = 'toggle-choices'),  
        hidden(
            div(id = 'hdn_hsp_dwn',
                p(),
                # Common input for filename, needs a UI to change default
                uiOutput('ui_hsp_dwn'),
                # Download dataset for TABLE
                conditionalPanel("input.tabs_hsp == 'table'",
                    textOutput('out_hsp_dwn'), br(),
                    downloadButton('dwn_hsp_dta', label = btndwn.text[1], class = 'btndwn')
                ),
                # Download dataset behind charts and map
                conditionalPanel("input.tabs_hsp !== 'table'",
                    downloadButton('dwn_hsp_tbl', label = btndwn.text[5], class = 'btndwn')
                ),
                # Download static JPG / interactive HTML for MAP
                conditionalPanel("input.tabs_hsp == 'maps'",
                    downloadButton('dwn_hsp_mpp', label = btndwn.text[3], class = 'btndwn'),
                    downloadButton('dwn_hsp_mph', label = btndwn.text[4], class = 'btndwn')
                ),
                # Download chart for remaining substabs
                conditionalPanel("input.tabs_hsp !== 'table' && input.tabs_hsp !== 'maps'",
                    # Optional Caption
                    checkboxInput('chk_hsp_cpt', 'ADD CAPTION', value = FALSE ),
                    conditionalPanel("input.chk_hsp_cpt",
                        textInput('txt_hsp_cpt', '', value = plt.caption)
                    ),
                    # Download Chart
                    downloadButton('dwn_hsp_plt', label = btndwn.text[2], class = 'btndwn')
                )
        )), hr(),
 
        width = 2
 
    ),
 
# MAIN PANEL --------------------------------------------------------------------------------------------------------------------
    mainPanel(
        tabsetPanel(id = 'tabs_hsp',
                    
            tabPanel('table', icon = icon('table'), 
                htmlOutput('out_hsp_tbx'), withSpinner( dataTableOutput('out_hsp_tbl') )
            ), 
            
            tabPanel('barplot', icon = icon('bar-chart'), 
                htmlOutput('out_hsp_brx'), withSpinner( ggiraphOutput('out_hsp_brp') )
            ), 
            
            tabPanel('boxplot', icon = icon('object-align-vertical', lib = 'glyphicon'), 
                htmlOutput('out_hsp_bxx'), withSpinner( ggiraphOutput('out_hsp_bxp') )
            ),
            
            tabPanel('heatmap', icon = icon('equalizer', lib = 'glyphicon'), 
                htmlOutput('out_hsp_hmx'), withSpinner( ggiraphOutput('out_hsp_hmp') )
            ),
            
            tabPanel('funnelplot', icon = icon('space-shuttle'), 
                htmlOutput('out_hsp_scx'), withSpinner( ggiraphOutput('out_hsp_fnl') ), hr(),
                fluidRow(
                    column(6, 
                        # Display the centre code(s) of the selected dot(s) 
                        textOutput('out_hsp_sel'), 
                        # Button to reset the complete selection (dots could be unselected one by one)
                        actionButton('btn_hsp_fnl_rst', 'Reset selection') 
                    ),
                    # Everything below should be displayed ONLY IF at least one dot is selected
                        # Time period 
                        column(3, uiOutput('ui_hsp_scl_flt') ),
                        column(3, 
                            # If  checked, display an additional line being the TOTAL UK
                            uiOutput('ui_hsp_scl_tuk'),
                            # If checked the metric is calculated on all records as a single entity, only if selection multiple dots
                            uiOutput('ui_hsp_scl_agg')
                        )
                    ),
                    br(), br(),
                    # Display the time series 
                    withSpinner( dygraphOutput('out_hsp_scl') ), hr(),
                    # Should display also the table with all the individual records related to the selected dot(s) ?
                    uiOutput('ui_hsp_fnl_tbl'), 
                    # IF the previous has been checked:
                        # Choose which fields to display, code and day of procedure are always displayed
                        uiOutput('ui_hsp_sct_flt'), 
                        # Display the table 
                        dataTableOutput('out_hsp_sct'), hr()
            ),
            
            tabPanel('maps', icon = icon('globe', lib = 'glyphicon'), 
                htmlOutput('out_hsp_mpx'), withSpinner( leafletOutput('out_hsp_map', width = '100%', height = 800) )
            )
            
        )
    )
    
)