Shiny Dashboard

https://rstudio.github.io/shinydashboard/
Admin
Shiny Dashboard is an R package that makes it easy to create professional dashboards using Shiny...
Tokens:8,674
Snippets:51
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install shinydashboard Package

Source: https://rstudio.github.io/shinydashboard/get_started

Installs the shinydashboard package. Requires Shiny version 0.11 or above. This is a prerequisite for using any shinydashboard features.

```r
install.packages("shinydashboard")
```

--------------------------------

### Create Value Boxes with valueBox - R

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates the creation of value boxes using the valueBox function in shinydashboard, which are similar to info boxes but with a distinct appearance. The example shows both static and dynamic value boxes, with dynamic content rendered using renderValueBox.

```r
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(title = "Value boxes"),
  dashboardSidebar(),
  dashboardBody(
    fluidRow(
      # A static valueBox
      valueBox(10 * 2, "New Orders", icon = icon("credit-card")),

      # Dynamic valueBoxes
      valueBoxOutput("progressBox"),

      valueBoxOutput("approvalBox")
    ),
    fluidRow(
      # Clicking this will increment the progress amount
      box(width = 4, actionButton("count", "Increment progress"))
    )
  )
)

server <- function(input, output) {
  output$progressBox <- renderValueBox({
    valueBox(
      paste0(25 + input$count, "%"), "Progress", icon = icon("list"),
      color = "purple"
    )
  })

  output$approvalBox <- renderValueBox({
    valueBox(
      "80%", "Approval", icon = icon("thumbs-up", lib = "glyphicon"),
      color = "yellow"
    )
  })
}

shinyApp(ui, server)
```

--------------------------------

### Dynamically Generate Sidebar Menu in R

Source: https://rstudio.github.io/shinydashboard/structure

Example of creating a dynamic sidebar menu using `renderMenu` and `sidebarMenuOutput`. The `server` function defines the menu structure, which is then rendered in the `ui`.

```r
ui <- dashboardPage(
  dashboardHeader(title = "Dynamic sidebar"),
  dashboardSidebar(
    sidebarMenuOutput("menu")
  ),
  dashboardBody()
)

server <- function(input, output) {
  output$menu <- renderMenu({
    sidebarMenu(
      menuItem("Menu item", icon = icon("calendar"))
    )
  })
}

shinyApp(ui, server)
```

--------------------------------

### Create Icons with Different Libraries (Font-Awesome and Glyphicons)

Source: https://rstudio.github.io/shinydashboard/appearance

This example showcases how to create icons using both the default Font-Awesome library and the Glyphicons library by specifying the 'lib' argument in the icon() function. It illustrates creating a calendar icon (Font-Awesome) and a cog icon (Glyphicons).

```R
icon("calendar")
icon("cog", lib = "glyphicon")
```

--------------------------------

### shinydashboard with Interactive Box and Plot

Source: https://rstudio.github.io/shinydashboard/get_started

An example shinydashboard application demonstrating how to add interactive elements. It includes a plot output within a box and a slider input to control the data displayed in the plot.

```r
## app.R ##
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(title = "Basic dashboard"),
  dashboardSidebar(),
  dashboardBody(
    # Boxes need to be put in a row (or column)
    fluidRow(
      box(plotOutput("plot1", height = 250)),

      box(
        title = "Controls",
        sliderInput("slider", "Number of observations:", 1, 100, 50)
      )
    )
  )
)

server <- function(input, output) {
  set.seed(122)
  histdata <- rnorm(500)

  output$plot1 <- renderPlot({
    data <- histdata[seq_len(input$slider)]
    hist(data)
  })
}
```

--------------------------------

### Adjust shinydashboard Sidebar Width

Source: https://rstudio.github.io/shinydashboard/appearance

Illustrates how to change the width of the sidebar in a shinydashboard application using the `width` option in `dashboardSidebar`. This example also sets a wider title.

```R
shinyApp(
  ui = dashboardPage(
    dashboardHeader(
      title = "Title and sidebar 350 pixels wide",
      titleWidth = 350
    ),
    dashboardSidebar(
      width = 350,
      sidebarMenu(
        menuItem("Menu Item")
      )
    ),
    dashboardBody()
  ),
  server = function(input, output) { }
)
```

--------------------------------

### Complete Basic shinydashboard App

Source: https://rstudio.github.io/shinydashboard/get_started

A minimal, self-contained R application using shinydashboard. It includes the UI definition (dashboardPage with header, sidebar, body) and a basic server function, runnable with shinyApp().

```r
## app.R ##
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(),
  dashboardSidebar(),
  dashboardBody()
)

server <- function(input, output) { }

shinyApp(ui, server)
```

--------------------------------

### Minimal shinydashboard UI Structure

Source: https://rstudio.github.io/shinydashboard/get_started

Defines the most basic structure of a shinydashboard page, consisting of a header, sidebar, and body. This serves as a template for building more complex dashboards.

```r
## ui.R ##
library(shinydashboard)

dashboardPage(
  dashboardHeader(),
  dashboardSidebar(),
  dashboardBody()
)
```

--------------------------------

### Create Message Menu Items

Source: https://rstudio.github.io/shinydashboard/structure

Illustrates the creation of message menu items within a `dropdownMenu`. Each `messageItem` requires `from` and `message` arguments, and can optionally include an icon and time string.

```r
dropdownMenu(type = "messages",
  messageItem(
    from = "Sales Dept",
    message = "Sales are steady this month."
  ),
  messageItem(
    from = "New User",
    message = "How do I register?",
    icon = icon("question"),
    time = "13:45"
  ),
  messageItem(
    from = "Support",
    message = "The new server is ready.",
    icon = icon("life-ring"),
    time = "2014-12-01"
  )
)
```

--------------------------------

### Organize Dashboard Page Components

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to break down the `dashboardPage` into separate variables for header, sidebar, and body for improved readability and maintainability in larger applications.

```r
header <- dashboardHeader()

sidebar <- dashboardSidebar()

body <- dashboardBody()

dashboardPage(header, sidebar, body)
```

--------------------------------

### Create Info Boxes with infoBox - R

Source: https://rstudio.github.io/shinydashboard/structure

Illustrates the creation of information boxes using the infoBox function in shinydashboard. These boxes display simple numeric or text values with an icon and can be styled with or without a fill color. Dynamic content is supported via infoBoxOutput and renderInfoBox.

```r
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(title = "Info boxes"),
  dashboardSidebar(),
  dashboardBody(
    # infoBoxes with fill=FALSE
    fluidRow(
      # A static infoBox
      infoBox("New Orders", 10 * 2, icon = icon("credit-card")),
      # Dynamic infoBoxes
      infoBoxOutput("progressBox"),
      infoBoxOutput("approvalBox")
    ),

    # infoBoxes with fill=TRUE
    fluidRow(
      infoBox("New Orders", 10 * 2, icon = icon("credit-card"), fill = TRUE),
      infoBoxOutput("progressBox2"),
      infoBoxOutput("approvalBox2")
    ),

    fluidRow(
      # Clicking this will increment the progress amount
      box(width = 4, actionButton("count", "Increment progress"))
    )
  )
)

server <- function(input, output) {
  output$progressBox <- renderInfoBox({
    infoBox(
      "Progress", paste0(25 + input$count, "%"), icon = icon("list"),
      color = "purple"
    )
  })
  output$approvalBox <- renderInfoBox({
    infoBox(
      "Approval", "80%", icon = icon("thumbs-up", lib = "glyphicon"),
      color = "yellow"
    )
  })

  # Same as above, but with fill=TRUE
  output$progressBox2 <- renderInfoBox({
    infoBox(
      "Progress", paste0(25 + input$count, "%"), icon = icon("list"),
      color = "purple", fill = TRUE
    )
  })
  output$approvalBox2 <- renderInfoBox({
    infoBox(
      "Approval", "80%", icon = icon("thumbs-up", lib = "glyphicon"),
      color = "yellow", fill = TRUE
    )
  })
}

shinyApp(ui, server)
```

--------------------------------

### Generate Basic HTML Tags in R

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to use R functions like `div()` and `p()` to generate HTML content. These functions return objects that can be rendered as HTML in a Shiny application. No external dependencies are required.

```r
# A basic div
div(class = "my-class", "Div content")
```

```r
# Nested HTML tags
div(class = "my-class", p("Paragraph text"))
```

--------------------------------

### Define Basic Dashboard Page Structure

Source: https://rstudio.github.io/shinydashboard/structure

Provides the fundamental structure for a dashboard page using the `shinydashboard` package. It includes placeholders for the header, sidebar, and body, which are essential components of any dashboard.

```r
dashboardPage(
  dashboardHeader(),
  dashboardSidebar(),
  dashboardBody()
)
```

--------------------------------

### Create Shiny Input Elements

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to use Shiny functions like `textInput()` to generate common HTML form elements. These functions abstract away the underlying HTML complexity, providing a simpler interface for creating inputs.

```r
textInput("Id", "Label")
```

--------------------------------

### Implement Dynamic Message Menu in UI

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to create a placeholder for dynamic message content in the dashboard header's UI using `dropdownMenuOutput()`. This function is used in conjunction with server-side rendering.

```r
dashboardHeader(dropdownMenuOutput("messageMenu"))
```

--------------------------------

### shinydashboard Sidebar with Menu Items

Source: https://rstudio.github.io/shinydashboard/get_started

Defines the sidebar content for a shinydashboard, including menu items that act as navigation tabs. Each menuItem has a text label, a tabName for linking, and an optional icon.

```r
## Sidebar content
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", tabName = "widgets", icon = icon("th"))
    )
  )
```

--------------------------------

### Create Tabbed Sidebar Navigation in R

Source: https://rstudio.github.io/shinydashboard/structure

Illustrates how to build a `dashboardPage` with a `dashboardSidebar` containing `sidebarMenu` and `menuItem`s that link to `tabItem`s in the `dashboardBody`. Requires matching `tabName` values.

```r
## ui.R ##
sidebar <- dashboardSidebar(
  sidebarMenu(
    menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
    menuItem("Widgets", icon = icon("th"), tabName = "widgets",
             badgeLabel = "new", badgeColor = "green")
  )
)

body <- dashboardBody(
  tabItems(
    tabItem(tabName = "dashboard",
      h2("Dashboard tab content")
    ),

    tabItem(tabName = "widgets",
      h2("Widgets tab content")
    )
  )
)

# Put them together into a dashboardPage
dashboardPage(
  dashboardHeader(title = "Simple tabs"),
  sidebar,
  body
)
```

--------------------------------

### Render Dynamic Message Menu on Server

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to render a dynamic message menu on the server side using `renderMenu()`. This function generates `messageItem` objects based on data and returns them to be displayed in the UI.

```r
output$messageMenu <- renderMenu({
  # Code to generate each of the messageItems here, in a list. This assumes
  # that messageData is a data frame with two columns, 'from' and 'message'.
  msgs <- apply(messageData, 1, function(row) {
    messageItem(from = row[["from"]], message = row[["message"]])
  })

  # This is equivalent to calling:
  #   dropdownMenu(type="messages", msgs[[1]], msgs[[2]], ...)
  dropdownMenu(type = "messages", .list = msgs)
})
```

--------------------------------

### Dynamically Generate Individual Sidebar Menu Item in R

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to dynamically generate a single `menuItem` using `renderMenu` and `menuItemOutput`. The `server` function renders the individual menu item, which is then displayed in the `ui`.

```r
ui <- dashboardPage(
  dashboardHeader(title = "Dynamic sidebar"),
  dashboardSidebar(
    sidebarMenu(
      menuItemOutput("menuitem")
    )
  ),
  dashboardBody()
)

server <- function(input, output) {
  output$menuitem <- renderMenu({
    menuItem("Menu item", icon = icon("calendar"))
  })
}

shinyApp(ui, server)
```

--------------------------------

### Create Notification Menu Items in R

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to create a notification dropdown menu using `notificationItem` within `dropdownMenu`. Allows customization of text, icons, and status colors (e.g., 'success', 'warning').

```r
dropdownMenu(
  type = "notifications",
  notificationItem(
    text = "5 new users today",
    icon("users")
  ),
  notificationItem(
    text = "12 items delivered",
    icon("truck"),
    status = "success"
  ),
  notificationItem(
    text = "Server load at 86%",
    icon = icon("exclamation-triangle"),
    status = "warning"
  )
)
```

--------------------------------

### shinydashboard Body with Tab Items

Source: https://rstudio.github.io/shinydashboard/get_started

Defines the main body content of a shinydashboard, using tabItems to manage different views. Each tabItem corresponds to a menuItem in the sidebar via its tabName.

```r
## Body content
  dashboardBody(
    tabItems(
      # First tab content
      tabItem(tabName = "dashboard",
        fluidRow(
          box(plotOutput("plot1", height = 250)),

          box(
            title = "Controls",
            sliderInput("slider", "Number of observations:", 1, 100, 50)
          )
        )
      ),

      # Second tab content
      tabItem(tabName = "widgets",
        h2("Widgets tab content")
      )
    )
  )
```

--------------------------------

### Shiny Sidebar Menu Item Selection and Bookmarking

Source: https://rstudio.github.io/shinydashboard/behavior

This R code illustrates setting up a Shiny dashboard with a sidebar menu that supports bookmarking. The `sidebarMenu` is given an `id` ('tabs'), allowing the selection of menu items and sub-items to be automatically bookmarked. It requires 'shiny' and 'shinydashboard' libraries and enables URL-based bookmarking.

```R
library(shiny)
library(shinydashboard)

ui <- function(req) {
  dashboardPage(
    dashboardHeader(),
    dashboardSidebar(
      sidebarMenu(id = "tabs",
        menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
        menuItem("Widgets", icon = icon("th"), tabName = "widgets"),
        menuItem("Charts", icon = icon("bar-chart-o"),
          menuSubItem("Sub-item 1", tabName = "subitem1"),
          menuSubItem("Sub-item 2", tabName = "subitem2")
        )
      )
    ),
    dashboardBody(
      bookmarkButton()
    )
  )
}

server <- function(input, output, session) {}

shinyApp(ui, server, enableBookmarking = "url")
```

--------------------------------

### Create a Calendar Icon using Font-Awesome

Source: https://rstudio.github.io/shinydashboard/appearance

This snippet demonstrates how to generate an HTML calendar icon using the icon() function from the shinydashboard package. It relies on the Font-Awesome icon library by default. The output is an HTML <i> tag with appropriate classes.

```R
icon("calendar")
```

--------------------------------

### Create Basic Boxes in R shinydashboard

Source: https://rstudio.github.io/shinydashboard/structure

Constructs the main content area of a Shiny dashboard using 'box' elements within a 'fluidRow'. Boxes can contain various Shiny UI elements, such as outputs (e.g., plotOutput) and inputs (e.g., sliderInput, textInput).

```r
# This is just the body component of a dashboard
dashboardBody(
  fluidRow(
    box(plotOutput("plot1")),
    
    box(
      "Box content here", br(), "More box content",
      sliderInput("slider", "Slider input:", 1, 100, 50),
      textInput("text", "Text input:")
    )
  )
)
```

--------------------------------

### Create Tabbed Boxes with tabBox - R

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to create tabbed content containers using the tabBox function in shinydashboard. It allows for customization of title, height, side (left/right), and selection of tabs. Server-side interaction is possible via an assigned ID.

```r
body <- dashboardBody(
  fluidRow(
    tabBox(
      title = "First tabBox",
      # The id lets us use input$tabset1 on the server to find the current tab
      id = "tabset1", height = "250px",
      tabPanel("Tab1", "First tab content"),
      tabPanel("Tab2", "Tab content 2")
    ),
    tabBox(
      side = "right", height = "250px",
      selected = "Tab3",
      tabPanel("Tab1", "Tab content 1"),
      tabPanel("Tab2", "Tab content 2"),
      tabPanel("Tab3", "Note that when side=right, the tab order is reversed.")
    )
  ),
  fluidRow(
    tabBox(
      # Title can include an icon
      title = tagList(shiny::icon("gear"), "tabBox status"),
      tabPanel("Tab1",
        "Currently selected tab from first box:",
        verbatimTextOutput("tabset1Selected")
      ),
      tabPanel("Tab2", "Tab content 2")
    )
  )
)
shinyApp(
  ui = dashboardPage(
    dashboardHeader(title = "tabBoxes"),
    dashboardSidebar(),
    body
  ),
  server = function(input, output) {
    # The currently selected tab from the first box
    output$tabset1Selected <- renderText({
      input$tabset1
    })
  }
)
```

--------------------------------

### Create External Link Menu Item in R

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to add a `menuItem` to the sidebar that links to external content using the `href` argument. The `newtab` option controls whether the link opens in a new tab.

```r
menuItem("Source code", icon = icon("file-code-o"), 
           href = "https://github.com/rstudio/shinydashboard/")
```

--------------------------------

### Row-based layout for Shiny Dashboard Boxes

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates creating a row-based layout for Shiny dashboard boxes. Boxes are placed directly within `fluidRow` and their widths are specified using Bootstrap's 12-column grid system. The code defines the main body (`dashboardBody`) and a complete Shiny app structure.

```R
body <- dashboardBody(
  fluidRow(
    box(title = "Box title", "Box content"),
    box(status = "warning", "Box content")
  ),

  fluidRow(
    box(
      title = "Title 1", width = 4, solidHeader = TRUE, status = "primary",
      "Box content"
    ),
    box(
      title = "Title 2", width = 4, solidHeader = TRUE,
      "Box content"
    ),
    box(
      title = "Title 1", width = 4, solidHeader = TRUE, status = "warning",
      "Box content"
    )
  ),

  fluidRow(
    box(
      width = 4, background = "black",
      "A box with a solid black background"
    ),
    box(
      title = "Title 5", width = 4, background = "light-blue",
      "A box with a solid light-blue background"
    ),
    box(
      title = "Title 6",width = 4, background = "maroon",
      "A box with a solid maroon background"
    )
  )
)

# We'll save it in a variable `ui` so that we can preview it in the console
ui <- dashboardPage(
  dashboardHeader(title = "Row layout"),
  dashboardSidebar(),
  body
)

# Preview the UI in the consoleshinyApp(ui = ui, server = function(input, output) { })

```

--------------------------------

### Create and Dynamically Update Dropdown Menu in R Shiny

Source: https://rstudio.github.io/shinydashboard/behavior

This R code demonstrates how to create a dynamic dropdown menu within a shinydashboard application. It utilizes `reactiveValues` to manage menu items and `renderMenu` to construct the dropdown. A modal dialog allows users to add new tasks to the menu, updating the UI in real-time. This snippet requires the 'shiny' and 'shinydashboard' libraries.

```r
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(
    dropdownMenuOutput("menu")
  ),
  dashboardSidebar(
    helpText("Add another item to the dropdown menu by clicking ",
             "on the button below"),
    actionButton("addItem", "Add another item")
  ),
  dashboardBody()
)

server <- function(input, output, session) {
  tasks <-  reactiveValues(
      code = list(id = "code", value = 15, color = "aqua",
                  text = "Refactor code"),
      layout = list(id = "layout", value = 40, color = "green",
                    text = "Design new layout"),
      docs = list(id = "docs", value = 25, color = "red",
                  text = "Write documentation")
    )

  # actually render the dropdownMenu
  output$menu <- renderMenu({
    items <- lapply(tasks, function(el) {
      taskItem(value = el$value, color = el$color, text = el$text)
    })
    dropdownMenu(
      type = "tasks", badgeStatus = "danger",
      .list = items
    )
  })

  observeEvent(input$addItem, {
    showModal(modalDialog(title = "Add new task",
      textInput(paste0("id", input$addItem), "Task ID"),
      numericInput(paste0("val", input$addItem), "Task value", 0),
      selectInput(paste0("col", input$addItem), "Task color",
        choices = c("red", "yellow", "aqua", "blue",
          "light-blue", "green", "navy", "teal",
          "olive", "lime", "orange", "fuchsia",
          "purple", "maroon", "black")
      ),
      textInput(paste0("text", input$addItem), "Task text"),
      actionButton(paste0("go", input$addItem), "Add item"),
      easyClose = TRUE, footer = NULL
    ))

    observeEvent(input[[paste0("go", input$addItem)]], {
      tasks[[paste0("id", input$addItem)]] <- list(
        id = input[[paste0("id", input$addItem)]],
        value = input[[paste0("val", input$addItem)]],
        color = input[[paste0("col", input$addItem)]],
        text = input[[paste0("text", input$addItem)]]
      )
      removeModal()
    })
  })
}

shinyApp(ui, server)
```

--------------------------------

### Custom Logout Panel in R

Source: https://rstudio.github.io/shinydashboard/appearance

Demonstrates how to create a custom user panel with a logout link for authenticated sessions in Shiny Server Pro. It hides the default logout panel using CSS and renders a dynamic sidebar user panel.

```R
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(),
  dashboardSidebar(
    # Custom CSS to hide the default logout panel
    tags$head(tags$style(HTML('.shiny-server-account { display: none; }'))),

    # The dynamically-generated user panel
    uiOutput("userpanel")
  ),
  dashboardBody()
)

server <- function(input, output, session) {
  output$userpanel <- renderUI({
    # session$user is non-NULL only in authenticated sessions
    if (!is.null(session$user)) {
      sidebarUserPanel(
        span("Logged in as ", session$user),
        subtitle = a(icon("sign-out"), "Logout", href="__logout__"))
    }
  })
}

shinyApp(ui, server)
```

--------------------------------

### Create Task Menu Items with Progress Bars in R

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to construct a task dropdown menu using `taskItem` within `dropdownMenu`. Supports setting task progress (`value`), color, and a text label. Valid colors are detailed in `?validColors`.

```r
dropdownMenu(type = "tasks", badgeStatus = "success",
  taskItem(value = 90, color = "green",
    "Documentation"
  ),
  taskItem(value = 17, color = "aqua",
    "Project X"
  ),
  taskItem(value = 75, color = "yellow",
    "Server deployment"
  ),
  taskItem(value = 80, color = "red",
    "Overall project"
  )
)
```

--------------------------------

### Add Custom CSS to shinydashboard App (External File)

Source: https://rstudio.github.io/shinydashboard/appearance

Explains how to add custom CSS to a shinydashboard application by placing a CSS file in the 'www/' directory and linking it in the UI. This method is useful for organizing styles.

```CSS
.main-header .logo {
  font-family: "Georgia", Times, "Times New Roman", serif;
  font-weight: bold;
  font-size: 24px;
}
```

```R
## ui.R ##
dashboardPage(
  dashboardHeader(title = "Custom font"),
  dashboardSidebar(),
  dashboardBody(
    tags$head(
      tags$link(rel = "stylesheet", type = "text/css", href = "custom.css")
    )
  )
)
```

--------------------------------

### Define Sidebar Panel Content

Source: https://rstudio.github.io/shinydashboard/structure

Illustrates how to structure content within a `sidebarPanel` using `div()` elements. This is a fundamental way to organize UI elements in the sidebar of a Shiny application.

```r
sidebarPanel(
  div("First div"),
  div("Second div")
)
```

--------------------------------

### Add Custom CSS to shinydashboard App (Inline)

Source: https://rstudio.github.io/shinydashboard/appearance

Shows how to include custom CSS directly within the UI code of a shinydashboard application using `tags$style(HTML(...))`. This is a convenient way for small style modifications.

```R
## ui.R ##
dashboardPage(
  dashboardHeader(title = "Custom font"),
  dashboardSidebar(),
  dashboardBody(
    tags$head(tags$style(HTML('
      .main-header .logo {
        font-family: "Georgia", Times, "Times New Roman", serif;
        font-weight: bold;
        font-size: 24px;
      }
    ')))
  )
)
```

--------------------------------

### Create a Sidebar Search Form in R

Source: https://rstudio.github.io/shinydashboard/structure

Implements a search form within the sidebar of a Shiny dashboard. This form includes a text input for search queries and a button, styled as a magnifying glass by default. Server-side access to values is via input$textId and input$buttonId.

```r
sidebarSearchForm(textId = "searchText", buttonId = "searchButton",
                  label = "Search...")
```

--------------------------------

### Generate HTML for a Calendar Icon

Source: https://rstudio.github.io/shinydashboard/appearance

This snippet shows the direct HTML output generated by the icon() function for a calendar icon. Browsers interpret this HTML to render the icon from the Font-Awesome library.

```html
<i class="fa fa-calendar"></i>
```

--------------------------------

### Enable Tab Bookmarking in Sidebar Menu in R

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates enabling Shiny's bookmarking feature for selected tabs by assigning an `id` to the `sidebarMenu()` function. The `sidebarMenu` must be called within the UI function for restoration to work correctly.

```r
sidebarMenu(id = "sidebar",
  ....
)
```

--------------------------------

### Apply Solid Background to Boxes in R

Source: https://rstudio.github.io/shinydashboard/structure

Styles 'box' elements in a Shiny dashboard with solid background colors using the 'background' argument. This option allows for visually distinct boxes, with 'solidHeader=TRUE' recommended for consistency.

```r
box(
  title = "Histogram", background = "maroon", solidHeader = TRUE,
  plotOutput("plot4", height = 250)
),

box(
  title = "Inputs", background = "black",
  "Box content here", br(), "More box content",
  sliderInput("slider", "Slider input:", 1, 100, 50),
  textInput("text", "Text input:")
)
```

--------------------------------

### Column-based layout for Shiny Dashboard Boxes

Source: https://rstudio.github.io/shinydashboard/structure

Illustrates a column-based layout strategy for Shiny dashboards. Boxes are organized within `column` elements, which themselves are placed inside a `fluidRow`. Each box within a column has `width=NULL`, allowing the column to control its width.

```R
body <- dashboardBody(
  fluidRow(
    column(width = 4,
      box(
        title = "Box title", width = NULL, status = "primary",
        "Box content"
      ),
      box(
        title = "Title 1", width = NULL, solidHeader = TRUE, status = "primary",
        "Box content"
      ),
      box(
        width = NULL, background = "black",
        "A box with a solid black background"
      )
    ),

    column(width = 4,
      box(
        status = "warning", width = NULL,
        "Box content"
      ),
      box(
        title = "Title 3", width = NULL, solidHeader = TRUE, status = "warning",
        "Box content"
      ),
      box(
        title = "Title 5", width = NULL, background = "light-blue",
        "A box with a solid light-blue background"
      )
    ),

    column(width = 4,
      box(
        title = "Title 2", width = NULL, solidHeader = TRUE,
        "Box content"
      ),
      box(
        title = "Title 6", width = NULL, background = "maroon",
        "A box with a solid maroon background"
      )
    )
  )
)

# We'll save it in a variable `ui` so that we can preview it in the console
ui <- dashboardPage(
  dashboardHeader(title = "Column layout"),
  dashboardSidebar(),
  body
)

# Preview the UI in the consoleshinyApp(ui = ui, server = function(input, output) { })

```

--------------------------------

### Add Solid Headers and Collapsible Boxes in R

Source: https://rstudio.github.io/shinydashboard/structure

Configures 'box' elements in a Shiny dashboard to have solid-colored headers and an option to collapse. Setting 'solidHeader=TRUE' creates a solid header, while 'collapsible=TRUE' adds a toggle button for collapsing the box content.

```r
box(
  title = "Histogram", status = "primary", solidHeader = TRUE,
  collapsible = TRUE,
  plotOutput("plot3", height = 250)
),

box(
  title = "Inputs", status = "warning", solidHeader = TRUE,
  "Box content here", br(), "More box content",
  sliderInput("slider", "Slider input:", 1, 100, 50),
  textInput("text", "Text input:")
)
```

--------------------------------

### Shiny Dashboard Mixed Row/Column Layout (R)

Source: https://rstudio.github.io/shinydashboard/structure

This R code defines a dashboard body with a mixed layout. It uses fluidRow to group boxes horizontally and column to arrange boxes vertically within rows. The ui variable constructs the complete dashboard page, and shinyApp launches the application.

```r
body <- dashboardBody(
  fluidRow(
    box(
      title = "Box title", width = 6, status = "primary",
      "Box content"
    ),
    box(
      status = "warning", width = 6,
      "Box content"
    )
  ),
    
  fluidRow(
    column(width = 4,
      box(
        title = "Title 1", width = NULL, solidHeader = TRUE, status = "primary",
        "Box content"
      ),
      box(
        width = NULL, background = "black",
        "A box with a solid black background"
      )
    ),

    column(width = 4,
      box(
        title = "Title 3", width = NULL, solidHeader = TRUE, status = "warning",
        "Box content"
      ),
      box(
        title = "Title 5", width = NULL, background = "light-blue",
        "A box with a solid light-blue background"
      )
    ),

    column(width = 4,
      box(
        title = "Title 2", width = NULL, solidHeader = TRUE,
        "Box content"
      ),
      box(
        title = "Title 6", width = NULL, background = "maroon",
        "A box with a solid maroon background"
      )
    )
  )
)

# We'll save it in a variable `ui` so that we can preview it in the console
ui <- dashboardPage(
  dashboardHeader(title = "Mixed layout"),
  dashboardSidebar(),
  body
)

# Preview the UI in the console shinyApp(ui = ui, server = function(input, output) { })

```

--------------------------------

### Set Dashboard Header Title

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to set the title for the dashboard header using the `title` argument within the `dashboardHeader()` function. This is a simple way to brand your dashboard.

```r
dashboardHeader(title = "My Dashboard")
```

--------------------------------

### Dynamic Sidebar Menu with ID

Source: https://rstudio.github.io/shinydashboard/behavior

Demonstrates creating a dynamic sidebar menu in a Shinydashboard application. It shows how to assign an ID to the sidebar menu to track the selected tabName in the server function using input$. The menu items and sub-items require 'tabName' for clickability.

```r
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(), 
  dashboardSidebar(
    sidebarMenuOutput("menu"),
    textOutput("res")
  ),
  dashboardBody(
    tabItems(
      tabItem("dashboard", "Dashboard tab content"),
      tabItem("widgets", "Widgets tab content"),
      tabItem("subitem1", "Sub-item 1 tab content"),
      tabItem("subitem2", "Sub-item 2 tab content") 
    )
  )
)

server <- function(input, output, session) {
  output$res <- renderText({
    paste("You've selected:", input$tabs)
  })
  output$menu <- renderMenu({
    sidebarMenu(
      # Setting id makes input$tabs give the tabName of currently-selected tab
      id = "tabs",

      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", icon = icon("th"), tabName = "widgets"),
      menuItem("Charts", icon = icon("bar-chart-o"),
        menuSubItem("Sub-item 1", tabName = "subitem1"),
        menuSubItem("Sub-item 2", tabName = "subitem2")
      )
    )
  })
}

shinyApp(ui, server)
```

--------------------------------

### Create Boxes Without Colored Bar in R

Source: https://rstudio.github.io/shinydashboard/structure

Generates 'box' elements in a Shiny dashboard that feature a solid header but lack a colored bar, providing a cleaner look. This is achieved by setting 'solidHeader=TRUE' and omitting the 'status' argument, or setting 'status' to NULL.

```r
box(
  title = "Histogram", solidHeader = TRUE,
  collapsible = TRUE,
  plotOutput("plot3", height = 250)
),

box(
  title = "Inputs", solidHeader = TRUE,
  "Box content here", br(), "More box content",
  sliderInput("slider", "Slider input:", 1, 100, 50),
  textInput("text", "Text input:")
)
```

--------------------------------

### Tracking Expanded Sidebar Menu Items

Source: https://rstudio.github.io/shinydashboard/behavior

Shows how to detect which parent 'menuItem' in a Shinydashboard sidebar is currently expanded. It utilizes 'input$sidebarItemExpanded' in the server function to display the name of the expanded menu item. The 'startExpanded = TRUE' argument can be used to initially expand a menu item.

```r
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(), 
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", icon = icon("th"), tabName = "widgets"),
      menuItem("Charts", icon = icon("bar-chart-o"), startExpanded = TRUE,
        menuSubItem("Sub-item 1", tabName = "subitem1"),
        menuSubItem("Sub-item 2", tabName = "subitem2")
      )
    ),
    textOutput("res")
  ),
  dashboardBody(
    tabItems(
      tabItem("dashboard", "Dashboard tab content"),
      tabItem("widgets", "Widgets tab content"),
      tabItem("subitem1", "Sub-item 1 tab content"),
      tabItem("subitem2", "Sub-item 2 tab content") 
    )
  )
)

server <- function(input, output, session) {
  output$res <- renderText({
    req(input$sidebarItemExpanded)
    paste("Expanded menuItem:", input$sidebarItemExpanded)
  })
}

shinyApp(ui, server)
```

--------------------------------

### Track Visible Tab in Shinydashboard App

Source: https://rstudio.github.io/shinydashboard/behavior

This R code demonstrates how to identify the currently selected tab in a shinydashboard application. It requires the `shiny` and `shinydashboard` libraries. The `sidebarMenu` is assigned an `id` of 'tabs', and each `menuItem` and `menuSubItem` has a `tabName`. The selected tab's name is then displayed using `renderText` and accessed via `input$tabs`.

```R
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(), 
  dashboardSidebar(
    sidebarMenu(
      # Setting id makes input$tabs give the tabName of currently-selected tab
      id = "tabs",
      
      menuItem("Dashboard", tabName = "dashboard", icon = icon("dashboard")),
      menuItem("Widgets", icon = icon("th"), tabName = "widgets"),
      menuItem("Charts", icon = icon("bar-chart-o"),
        menuSubItem("Sub-item 1", tabName = "subitem1"),
        menuSubItem("Sub-item 2", tabName = "subitem2")
      )
    ),
    textOutput("res")
  ),
  dashboardBody(
    tabItems(
      tabItem("dashboard", "Dashboard tab content"),
      tabItem("widgets", "Widgets tab content"),
      tabItem("subitem1", "Sub-item 1 tab content"),
      tabItem("subitem2", "Sub-item 2 tab content") 
    )
  )
)

server <- function(input, output, session) {
  output$res <- renderText({
    paste("You've selected:", input$tabs)
  })
}

shinyApp(ui, server)
```

--------------------------------

### Customize Box Titles and Status Colors in R

Source: https://rstudio.github.io/shinydashboard/structure

Enhances the appearance of 'box' elements in a Shiny dashboard by adding titles and status-based header colors. The 'status' argument accepts predefined color names (e.g., 'primary', 'warning').

```r
box(title = "Histogram", status = "primary", plotOutput("plot2", height = 250)),

box(
  title = "Inputs", status = "warning",
  "Box content here", br(), "More box content",
  sliderInput("slider", "Slider input:", 1, 100, 50),
  textInput("text", "Text input:")
)
```

--------------------------------

### Setting fixed height for Shiny Dashboard Boxes

Source: https://rstudio.github.io/shinydashboard/structure

Shows how to set a fixed height in pixels for individual Shiny dashboard boxes. This can be used to ensure consistent visual appearance when content height varies, though it doesn't automatically align box bottoms across rows.

```R
box(title = "Box title", height = 300, "Box content")

```

--------------------------------

### Adjust shinydashboard Title Width

Source: https://rstudio.github.io/shinydashboard/appearance

Demonstrates how to increase the width allocated for the dashboard title in shinydashboard using the `titleWidth` option in `dashboardHeader`. It also includes custom CSS to match the title background color with the header.

```R
shinyApp(
  ui = dashboardPage(
    dashboardHeader(
      title = "Example of a long title that needs more space",
      titleWidth = 450
    ),
    dashboardSidebar(),
    dashboardBody(
      # Also add some custom CSS to make the title background area the same
      # color as the rest of the header.
      tags$head(tags$style(HTML('
        .skin-blue .main-header .logo {
          background-color: #3c8dbc;
        }
        .skin-blue .main-header .logo:hover {
          background-color: #3c8dbc;
        }
      ')))
    )
  ),
  server = function(input, output) { }
)
```

--------------------------------

### Disable Dashboard Header in R

Source: https://rstudio.github.io/shinydashboard/structure

A simple R code snippet to disable the header bar of a `dashboardPage` by setting the `disable` argument to `TRUE` in `dashboardHeader()`.

```r
dashboardHeader(disable = TRUE)
```

--------------------------------

### Detect Sidebar Collapsed/Expanded State in Shiny

Source: https://rstudio.github.io/shinydashboard/behavior

This R code snippet demonstrates how to use the `input$sidebarCollapsed` value within a Shiny application to determine if the sidebar is currently collapsed or expanded. It renders text indicating the sidebar's state. Requires the 'shiny' and 'shinydashboard' libraries.

```R
library(shiny)
library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(), 
  dashboardSidebar(),
  dashboardBody(
    textOutput("res")
  )
)

server <- function(input, output, session) {
  output$res <- renderText({
    if (input$sidebarCollapsed) {
      "Sidebar is collapsed"
    } else {
      "Sidebar is expanded"
    }
  })
}

shinyApp(ui, server)
```

--------------------------------

### Disable Sidebar in R shinydashboard

Source: https://rstudio.github.io/shinydashboard/structure

Demonstrates how to disable the sidebar in a Shiny dashboard. Setting the 'disable' argument to TRUE within the dashboardSidebar function will hide the sidebar.

```r
dashboardSidebar(disable = TRUE)
```
Tokens:
Raw