In the first example of the previous chapter, the application was used to send an error message when the input number was left blank:

This error message is displayed because, as there is no input argument, the 1:input$number series in server.R returns NA, which, of course, results in an error while plotting. To avoid showing the user an error message, a conditionalPanel() builder can be included. In this case, the UI.R script would look as follows:

library(shiny)

# Starting line
shinyUI(fluidPage(

# Application title
titlePanel("Conditional Panel - Example 1"),

# Sidebar with a numeric input
# Sidebar
sidebarLayout( 
  sidebarPanel(
    numericInput("number",
        "Insert a number:",
          value = 30,
          min = 1,
          max = 50)),


  #The plot created in server.R is displayed
    mainPanel(
      conditionalPanel(condition= "input.number > 0",
      plotOutput("plot"))
    )
  )
))

conditionalPanel() is included inside mainPanel(), and plotOutput() is passed inside conditionalPanel() after the condition. Every argument passed after condition= must be an element to be displayed if the condition is met. It is particularly important to take into account while using conditionalPanel() that the condition must be a string object representing a JavaScript statement.

In the case of inputs, they are called as input.(variable) in JavaScript. In this case, as the condition to be met is input.number > 0, whenever the condition is not met, (for example, when the input box is left empty) the output is not shown. In this case, the error message is not displayed:

conditionalPanel() can also be used to selectively show inputs. Back to Example 1, if an optional parameter of color change is added, it would be coded as follows. In UI.R, a conditionalPanel() input is passed with the color change feature where the widget is inside conditionalPanel(), so it will consequently appear only if the condition passed to it is true (in this case, if the checkbox is ticked):

library(shiny)

# Starting line
shinyUI(fluidPage(
  
  # Application title
  titlePanel("Conditional Panel - Example 2"),
  
  # Sidebar with a numeric input
    # Sidebar
  sidebarLayout(  
  sidebarPanel(
      numericInput("number",
                  "Insert a number:",
                  value = 30,
                  min = 1,
                  max = 50),
      #Checkbox to select color
      
      checkboxInput("selectcolor",label = "Change color"),
      
      #Conditional Panel. When the checkbox is ticked, it displays
      #the radio button options
      
      conditionalPanel("input.selectcolor == true",
        radioButtons("color", "Pick up the color:",
                     c("red", "blue", "green")))),
    
    
  #The plot created in server.R is displayed
    mainPanel(
      conditionalPanel(condition= "input.number > 0",
      plotOutput("plot"))
    )
  )
))

server.R would be as follows:

library(shiny)

#initialization of server.R
shinyServer(function(input, output) {

  #Plot generation
  output$plot <- renderPlot({
    if(input$selectcolor){
      plot(1/1:input$number, col=input$color)
    } else {
      plot(1/1:input$number)
    }
  })

})

In this case, whenever the checkbox is ticked, the radio buttons are displayed. As conditionalPanel() only makes parts of the application visible or invisible but does not have any influence on the input or output values that are contained in it, the color input variable (the one that receives the value from the radio buttons) will have a value, whatever status the checkbox has.

For this reason, the plot creation in server.R has to be slightly changed. Instead of directly plotting, it looks for the checkbox's input value (which is directly TRUE or FALSE as explained in the inputs section under checkboxInput()) and, if TRUE, it plots with the passed color. Otherwise, it is plotted with the default color (black).

Lastly, as the condition in condtionalPanel() is passed in a string of JavaScript code, true and false are written in lower case.

In the case of the iris dataset, a Tabset panel with two tabs is displayed in the output section where one panel is for the table and the other one is for the graphics.

In UI.R, tabsetPanel() only receives the tabPanel() objects. Inside these, the outputs are passed. The following is the UI.R code:

library(shiny)

# Starting line
shinyUI(fluidPage(

# Application title
  titlePanel("Tabset Example"),

  # Sidebar
  sidebarLayout(
    sidebarPanel(
      #Species selection
      selectInput("species","Select a species:",
      c("setosa", "versicolor", "virginica"))),

      #The plot created in server.R is displayed
      mainPanel(
        tabsetPanel(
          tabPanel("Summaries",tableOutput("table")),
          tabPanel("Graphics",plotOutput("plot"))
      ))

    )
))

In server.R, apart from creating the outputs, a reactive object was included, which is then used by both renderTable() and renderPlot(). As it was explained in the previous chapter, this is a very good practice when working with datasets, especially if the same dataset is used both times. Following is the code:

library(shiny)
data(iris)

#initialization of server.R
shinyServer(function(input, output) {

  sset <- reactive({subset(iris, Species == input$species)[,-5]})
  
  #Table generation where the summary is displayed
  output$table <- renderTable({
    summary(sset())
  })
  
  output$plot <- renderPlot({
    plot(sset())
  })

})

The following is the final outcome:

Free inputs can mainly be divided in two big groups: numeric inputs and character inputs. They are as follows:

Although lists can be used for any other purpose, in most cases, lists are used to filter options. Conceptually, they can be subdivided into two big groups: unique and multiple selectors. Although for some of the list widgets to change from one type to another is as easy as setting multiple arguments to TRUE or FALSE, it is important to keep in mind that the object returned changes from a character to a character vector:

Shiny provides two built-in functions to select dates. Both of them have a very intuitive date-picker interface. The objects returned are date objects. However, in more advanced implementations, it is possible that in some cases, dates objects do not behave as expected:

An interface for user file-upload can be included via fileInput(). It is highly recommended to add an action button (see the following) and an observation/isolation clause on the server side (Chapter 7, Advanced Functions in Shiny).

fileInput() creates a traditional file selection interface (that is, a button that, when hit, opens a window browser). The handling of this object will depend on the purpose of the application (whether it has to be turned into a data frame, to a list of lines, and so on).

The following functions are the most important ones for buttons:

submitButton() with conditionalPanel()

Back to the second example shown in the conditionalPanel() section (with the optional color selection), a slight change is made so that the execution of the changes in the input is carried out upon button hit.

In UI.R, only submitButton() is added as follows:

library(shiny)

# Starting line
shinyUI(fluidPage(
  
  # Application title
  titlePanel("Submit Button Example"),
  
  # Sidebar with a numeric input
    # Sidebar
  sidebarLayout(  
  sidebarPanel(
      numericInput("number",
                  "Insert a number:",
                  value = 30,
                  min = 1,
                  max = 50),
      #Checkbox to select color
      checkboxInput("selectcolor",label = "Change color"),
      #Conditional Panel. When the checkbox is ticked, it displays 
      #the radio button options
      conditionalPanel("input.selectcolor == true",
        radioButtons("color", "Pick up the color:",
                     c("red", "blue", "green"))),
    submitButton("Apply changes")),
    
  #The plot created in server.R is displayed
    mainPanel(
      conditionalPanel(condition= "input.number > 0",
      plotOutput("plot"))
    )
  )
))

server.R remains the same.

Although the only change with respect to the original example is the inclusion of the submitButton() widget, the application does not work as expected. Firstly, when the checkbox is checked, the radio buttons are not displayed. They will only display after the submit button is hit:

No change after the box is checked.

After this, the window will appear. At this moment, the user can click on any of the options, but the window will only change color once the button is hit again. However, when unchecking the box, the same problem appears; the radio buttons are still visible when they should be hidden.

This behavior is explained by the fact that submitButton() changes all the inputs at the same time upon button hit. So, not only will the color change depend on the button hit but also the checkbox value, which decides the visibility and invisibility of the radio buttons.

The solution to this would be the use of actionButton() instead. However, as this also requires the use of isolate(), which is a topic that will be covered in Chapter 7, Advanced Functions in Shiny, this same example will be taken up at that stage where its use will be much clearer to the user.

• downloadButton(): The name of this widget is clearly self-explanatory. This functionality is always used along with downloadHandler() in server.R. downloadHandler() is a function that serves exclusively to download data.

The following is a small applied example with the iris dataset.

Here's what UI.R should look like:

library(shiny)

# Starting line
shinyUI(fluidPage(

  # Application title
  titlePanel("Example 2"),

  # Sidebar
  sidebarLayout(
  sidebarPanel(
    #Species selection
    selectInput("species","Select a species:",
      c("setosa", "versicolor", "virginica")),
      downloadButton("download", "Download Data")),

    #The plot created in server.R is displayed
    mainPanel(
      textOutput("report")
    )

  )
))

Here's what server.R should look like:

library(shiny)

data(iris)

#initialization of server.R
shinyServer(function(input, output) {

  sset <- reactive(subset(iris, Species == input$species))

  #Text to output
  output$report <- renderText(
    paste0("The filtered dataset contains ",nrow(sset()), " rows")
  )

  #Download Handler
  output$download <- downloadHandler(
    filename=paste0("Data_",input$species,"_",Sys.Date(),".csv"),
    content= function(file){
      write.csv(sset(),file, row.names=F)}
    )

})

The downloaded object has the name of the button that calls it. This means that in the flow of input/outputs, downloadButton() takes the object created by downloadHandler() and triggers the download.

downloadHandler() is a very special function that has a fixed structure that is unusual to traditional R coding under the argument content. Unlike normal CSV writing, Shiny writes the output to a temporary file and then constructs the file that will be downloaded. How this function works internally is very complex. However, respecting the structure as shown previously (content = function(file){...}), the application performs the data download with no problem.

While running these examples, it is important to keep in mind that the data download button does not work properly when running it on window (Run in Window option from the Run App button menu in RStudio). To do so, select Run External instead, and the application will be opened in a new tab on the active browser's session on newer versions of RStudio. In older ones, hit the Run App button and, once the window pops up, select Open in Browser: