shinybusy

https://dreamrs.github.io/shinybusy/
Admin
shinybusy is an R package that provides automated and manual busy indicators, progress bars,...
Tokens:27,391
Snippets:197
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Shiny App with Modal Spinner Example

Source: https://dreamrs.github.io/shinybusy/reference/modal-spinner.html

An example Shiny application demonstrating the use of `show_modal_spinner` and `remove_modal_spinner` triggered by button clicks. Includes basic UI setup and server logic for handling button events and simulating long computations.

```R
if (interactive()) {

  library(shiny)
  library(shinybusy)

  ui <- fluidPage(

    tags$h1("Modal with spinner"),
    actionButton("sleep1", "Launch a long calculation"),
    actionButton("sleep2", "And another one")
  )

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

    observeEvent(input$sleep1, {
      show_modal_spinner()
      Sys.sleep(5)
      remove_modal_spinner()
    })

    observeEvent(input$sleep2, {
      show_modal_spinner(
        spin = "cube-grid",
        color = "firebrick",
        text = "Please wait..."
      )
      Sys.sleep(5)
      remove_modal_spinner()
    })

  }

  shinyApp(ui, server)

}
```

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

### Install shinybusy

Source: https://dreamrs.github.io/shinybusy/index.html

Installation commands for the package from CRAN or GitHub.

```R
install.packages("shinybusy")
```

```R
remotes::install_github("dreamRs/shinybusy")
```

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

### Shiny App with Loading State Example

Source: https://dreamrs.github.io/shinybusy/reference/add_loading_state.html

This example demonstrates how to use `add_loading_state` in a Shiny UI to show loading indicators for plot outputs. It includes server-side logic to simulate data regeneration with delays.

```R
library(shinybusy)
library(shiny)

ui <- fluidPage(

  # Use once in UI
  add_loading_state(
    ".shiny-plot-output",
    text = "Please wait...",
    svgColor = "steelblue"
  ),

  tags$h3("Loading state"),
  actionButton("refresh", "Refresh charts"),
  actionButton("modal", "Open modal window"),

  fluidRow(
    column(
      width = 6,
      plotOutput(outputId = "plot1")
    ),
    column(
      width = 6,
      plotOutput(outputId = "plot2")
    )
  )

)

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

  output$plot1 <- renderPlot({
    input$refresh
    if (input$refresh > 0) {
      Sys.sleep(2)
    }
    barplot(table(floor(runif(100) * 6)))
  })

  output$plot2 <- renderPlot({
    input$refresh
    if (input$refresh > 0) {
      Sys.sleep(2)
    }
    plot(rnorm(50), rnorm(50))
  })


  observeEvent(input$modal, {
    showModal(modalDialog(
      title = "Works in modal too",
      actionButton("refresh2", "Refresh chart"),
      plotOutput(outputId = "plot3")
    ))
  })

  output$plot3 <- renderPlot({
    input$refresh2
    if (input$refresh2 > 0) {
      Sys.sleep(2)
    }
    hist(rnorm(500))
  })

}

if (interactive())
  shinyApp(ui, server)



```

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

### Manual progress bar implementation example

Source: https://dreamrs.github.io/shinybusy/reference/manual-progressbar.html

Demonstrates a complete Shiny application using a manual progress bar controlled by an action button and a slider input.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(
  tags$h2("Manual nanobar"),
  use_busy_bar(color = "#01DF01", height = "15px"),
  actionButton(inputId = "go", label = "Go"),
  sliderInput(
    inputId = "set", label = "Set progress",
    min = 0, value = 0, max = 100
  )
)

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

  observeEvent(input$go, {
    update_busy_bar(0)
    for (i in 1:100) {
      Sys.sleep(0.1)
      update_busy_bar(i)
    }
  })

  observeEvent(input$set, {
    update_busy_bar(input$set)
  })

}

if (interactive()) {
  shinyApp(ui, server)
}
```

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

### Epic spinner demonstration

Source: https://dreamrs.github.io/shinybusy/reference/spin_epic.html

A complete Shiny application example showcasing all available epic spinner types within a grid layout.

```R
if (interactive()) {
  library(shiny)
  library(shinybusy)

  ui <- fluidPage(
    tags$h2("Epic spinner demo"),
    lapply(
      X = c(
        "flower", "pixel", "hollow-dots",
        "intersecting-circles", "orbit", "radar",
        "scaling-squares", "half-circle",
        "fulfilling-square", "circles-to-rhombuses"
      ),
      FUN = function(x) {
        tags$div(
          style = "display: table-cell; width: 150px; height: 100px; margin: 10px;",
          tags$b(x),
          spin_epic(x, color = "#08298A")
        )
      }
    ),
    tags$hr(),
    lapply(
      X = c(
        "semipolar", "self-building-square", "swapping-squares",
        "fulfilling-bouncing-circle", "fingerprint", "spring",
        "atom", "looping-rhombuses", "breeding-rhombus", "trinity-rings"
      ),
      FUN = function(x) {
        tags$div(
          style = "display: table-cell; width: 150px; height: 100px; margin: 10px;",
          tags$b(x),
          spin_epic(x, color = "#08298A")
        )
      }
    )
  )

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

  }

  shinyApp(ui, server)
}
```

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

### Busy Indicator at Start Up

Source: https://dreamrs.github.io/shinybusy/reference/busy-start-up.html

Show a full-page busy indicator when the application is initialized, and remove it automatically or manually.

```APIDOC
## busy_start_up

### Description
Show a full-page busy indicator when application is initialized, then removed it after timeout, automatically or manually from server.

### Usage
```R
busy_start_up(
  loader,
  text = NULL,
  mode = c("timeout", "auto", "manual"),
  timeout = 500,
  color = "#112446",
  background = "#f0f0f0"
)

remove_start_up(timeout = 100, session = shiny::getDefaultReactiveDomain())
```

### Arguments

* **loader** (HTML tag or spinner) - A spinner created with `spin_epic` or `spin_kit` or a simple HTML tag, to include a GIF (see examples).
* **text** (string) - Optional text to be displayed under the loading animation.
* **mode** (string) - How to remove the start-up page: "timeout", "auto" or "manual".
* **timeout** (numeric) - Time (in milliseconds) to wait before removing the start-up page.
* **color** (string) - Color of text.
* **background** (string) - Background color.
* **session** (shiny::Session) - Shiny session.

### Value
HTML tag that can be included in UI definition.

### Details
Behavior according to `mode` argument:
  * **timeout** : Busy indicator will be removed after the time (in milliseconds) specified in `timeout`.
  * **manual** : Busy indicator will be removed with `remove_start_up` from server, timeout from `busy_start_up` is ignored in favor of that of `remove_start_up`.
  * **auto** : Busy indicator is removed after JavaScript `shiny:idle` is triggered for the first time, `timeout` is taken into account.

When using `timeout` or `auto`, you can still remove the busy indicator with `remove_start_up`.

### Examples

#### With timeout
```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = spin_epic("orbit", color = "#FFF"),
    text = "Loading...",
    timeout = 1500,
    color = "#FFF",
    background = "#112446"
  ),

  tags$h1("Ready to play!", class = "text-center")

)

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

}

if (interactive())
  shinyApp(ui, server)
```

#### Manual removal
```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = spin_kit(
      spin = "cube-grid",
      color = "#FFF",
      style = "width:50px; height:50px;"
    ),
    text = "Loading...",
    mode = "manual",
    color = "#FFF",
    background = "#112446"
  ),

  tags$h1("Ready to play!", class = "text-center")

)

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

  # Remove after 3 seconds (+timeout)
  observe({
    Sys.sleep(3)
    remove_start_up(timeout = 200)
  })

}

if (interactive())
  shinyApp(ui, server)
```

#### Auto mode & GIF loader
```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = tags$img(
      src = "https://jeroen.github.io/images/banana.gif",
      width = 100
    ),
    text = "Loading...",
    mode = "auto"
  ),

  tags$h1("Ready to play!", class = "text-center"),
  plotOutput(outputId = "plot")

)

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

  output$plot <- renderPlot({
    Sys.sleep(2)
    plot(rnorm(100))
  })

}

if (interactive())
  shinyApp(ui, server)
```
```

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

### Shiny App Notification Example

Source: https://dreamrs.github.io/shinybusy/reference/notify.html

Demonstrates how to integrate shinybusy notifications into a Shiny application. This example shows how to trigger different types of notifications (success, failure, info, warning) based on user actions via action buttons.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(
  tags$h2("notify examples"),
  tags$p(
    "More examples available on the official website:",
    tags$a("https://notiflix.github.io/notify")
  ),
  actionButton("success", "Success"),
  actionButton("failure", "Failure"),
  actionButton("info", "Info"),
  actionButton("warning", "Warning")
)

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

  observeEvent(input$success, {
    notify_success("Well done!")
  })

  observeEvent(input$failure, {
    notify_failure("Oups...")
  })

  observeEvent(input$info, {
    notify_info("For your information")
  })

  observeEvent(input$warning, {
    notify_warning("Be careful!")
  })

}

if (interactive())
  shinyApp(ui, server)
```

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

### Shiny App with SpinKit Spinners Demo

Source: https://dreamrs.github.io/shinybusy/reference/spin_kit.html

An interactive Shiny application demonstrating various SpinKit spinners. Ensure 'shiny' and 'shinybusy' libraries are loaded. This example displays different spinners in a grid layout.

```R
if (interactive()) {
  library(shiny)
  library(shinybusy)

  ui <- fluidPage(
    tags$h2("SpinKit demo"),
    fluidRow(lapply(
      X = c(
        "circle", "bounce", "folding-cube", "rotating-plane", "cube-grid",
        "fading-circle", "double-bounce", "dots", "cube"
      ),
      FUN = function(x) {
        column(
          width = 2,
          tags$b(x),
          tags$div(
            style = "width: 60px; height: 60px; position: relative;",
            spin_kit(spin = x)
          )
        )
      }
    ))
  )

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

  }

  shinyApp(ui, server)
}
```

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

### Interactive Shiny App with Manual Spinner

Source: https://dreamrs.github.io/shinybusy/reference/manual-spinner.html

A complete example demonstrating how to integrate a manual spinner into a Shiny application to indicate long-running calculations.

```R
if (interactive()) {
  library(shiny)
  library(shinybusy)

  ui <- fluidPage(

    # Use this function somewhere in UI
    use_busy_spinner(spin = "fading-circle"),

    headerPanel('Iris k-means clustering'),

    sidebarLayout(
      sidebarPanel(
        selectInput('xcol', 'X Variable', names(iris)),
        selectInput('ycol', 'Y Variable', names(iris),
                    selected=names(iris)[[2]]),
        numericInput('clusters', 'Cluster count', 3,
                     min = 1, max = 9),
        actionButton("sleep", "Long calculation")
      ),
      mainPanel(
        plotOutput('plot1')
      )
    )
  )

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

    selectedData <- reactive({
      iris[, c(input$xcol, input$ycol)]
    })

    clusters <- reactive({
      kmeans(selectedData(), input$clusters)
    })

    output$plot1 <- renderPlot({
      palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
                "#FF7F00", "#FFFF33", "#A65628", "#F781BF",
                "#999999"))

      par(mar = c(5.1, 4.1, 0, 1))
      plot(selectedData(),
           col = clusters()$cluster,
           pch = 20, cex = 3)
      points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
    })

    observeEvent(input$sleep, {
      show_spinner()
      Sys.sleep(5)
      hide_spinner()
    })

  }

  shinyApp(ui, server)
}
```

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

### Shiny App with Busy GIF Example

Source: https://dreamrs.github.io/shinybusy/reference/add_busy_gif.html

Example of integrating add_busy_gif into a Shiny UI and server. The GIF will appear for 5 seconds after the 'Long calculation' button is pressed.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  # Use this function somewhere in UI
  # with navBarPage use the "header" argument
  add_busy_gif(
    src = "https://jeroen.github.io/images/banana.gif",
    height = 70, width = 70
  ),

  actionButton("sleep", "Long calculation")
)

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

  observeEvent(input$sleep, {
    Sys.sleep(5)
  })

}

if (interactive()) {
  shinyApp(ui, server)
}

```

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

### Shiny App Example: Modal Progress Bars

Source: https://dreamrs.github.io/shinybusy/reference/modal-progress.html

A complete Shiny application demonstrating the use of line and circle progress bars with different customization options.

```R
if (interactive()) {

  library(shiny)
  library(shinybusy)

  ui <- fluidPage(

    tags$h1("Modal with progress bar"),
    actionButton("sleep1", "Launch a long calculation"),
    actionButton("sleep2", "And another one (different line options)"),
    tags$br(),
    actionButton("sleep3", "With a circle progress bar"),
    actionButton("sleep4", "With different circle options)")
  )

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

    observeEvent(input$sleep1, {
      show_modal_progress_line()
      for (i in 1:100) {
        update_modal_progress(
          value = i / 100
        )
        Sys.sleep(0.1)
      }
      remove_modal_progress()
    })

    observeEvent(input$sleep2, {
      show_modal_progress_line(
        color = "#DF0101",
        duration = 900,
        easing = "easeOut",
        text = "Starting computation"
      )
      Sys.sleep(0.1)
      for (i in 1:100) {
        update_modal_progress(
          value = i / 100,
          text = paste("Process", trunc(i/10), sprintf("(%02d%%)", i)) 
        )
        Sys.sleep(0.15)
      }
      remove_modal_progress()
    })


    observeEvent(input$sleep3, {
      show_modal_progress_circle()
      for (i in 1:100) {
        update_modal_progress(
          value = i / 100
        )
        Sys.sleep(0.1)
      }
      remove_modal_progress()
    })

    observeEvent(input$sleep4, {
      show_modal_progress_circle(
        color = "#DF0101",
        duration = 900,
        easing = "easeOut",
        text = "Starting computation",
        height = "300px"
      )
      Sys.sleep(0.1)
      for (i in 1:100) {
        update_modal_progress(
          value = i / 100,
          text = paste("Process", trunc(i/10), sprintf("(%02d%%)", i))
        )
        Sys.sleep(0.15)
      }
      remove_modal_progress()
    })

  }

  shinyApp(ui, server)

}
```

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

### Shiny App with Automatic Busy Spinner Example

Source: https://dreamrs.github.io/shinybusy/reference/add_busy_spinner.html

This example demonstrates how to integrate the add_busy_spinner function into a Shiny application's UI and server logic. It includes a button that triggers a long calculation to showcase the spinner's functionality.

```R
if (interactive()) {
  library(shiny)
  library(shinybusy)

  ui <- fluidPage(

    # Use this function somewhere in UI
    add_busy_spinner(spin = "cube-grid"),
    # or use a different spinner
    # add_busy_spinner(spin = "radar", margins = c(10, 20)),

    headerPanel('Iris k-means clustering'),

    sidebarLayout(
      sidebarPanel(
        selectInput('xcol', 'X Variable', names(iris)),
        selectInput('ycol', 'Y Variable', names(iris),
                    selected=names(iris)[[2]]),
        numericInput('clusters', 'Cluster count', 3,
                     min = 1, max = 9),
        actionButton("sleep", "Long calculation")
      ),
      mainPanel(
        plotOutput('plot1')
      )
    )
  )

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

    selectedData <- reactive({
      iris[, c(input$xcol, input$ycol)]
    })

    clusters <- reactive({
      kmeans(selectedData(), input$clusters)
    })

    output$plot1 <- renderPlot({
      palette(c("#E41A1C", "#377EB8", "#4DAF4A", "#984EA3",
                "#FF7F00", "#FFFF33", "#A65628", "#F781BF",
                "#999999"))

      par(mar = c(5.1, 4.1, 0, 1))
      plot(selectedData(),
           col = clusters()$cluster,
           pch = 20, cex = 3)
      points(clusters()$centers, pch = 4, cex = 4, lwd = 4)
    })

    observeEvent(input$sleep, {
      Sys.sleep(5)
    })

  }

  shinyApp(ui, server)
}

```

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

### Shiny App with Configured Reports

Source: https://dreamrs.github.io/shinybusy/reference/config_report.html

This example demonstrates how to use the config_report() function within a Shiny application to customize the appearance of success, failure, and info reports. It shows how to set specific colors and dimensions for different report types.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(
  tags$h2("Config for report() examples"),
  actionButton("success", "Success"),
  actionButton("failure", "Failure"),
  actionButton("info", "Info")
)

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

  observeEvent(input$success, {
    report_success(
      "Well done!",
      "All in order",
      config_report(
        svgColor = "#0431B4",
        titleColor = "#0431B4"
      )
    )
  })

  observeEvent(input$failure, {
    report_failure(
      "Oups...",
      "Something went wrong",
      config_report(
        svgColor = "#DF01D7",
        titleColor = "#DF01D7"
      )
    )
  })

  observeEvent(input$info, {
    report_info(
      "For your information",
      tags$p(
        style = "font-style: italic;",
        "Lorem ipsum dolor sit amet"
      ),
      config_report(width = "560px", borderRadius = "5px")
    )
  })

}

if (interactive())
  shinyApp(ui, server)

```

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

### Implement UI element blocking in Shiny

Source: https://dreamrs.github.io/shinybusy/reference/block.html

Example demonstrating manual blocking of a plot output and automatic blocking during a reactive calculation.

```R
library(shinybusy)
library(shiny)

ui <- fluidPage(
  tags$h3("Block Output"),
  fluidRow(
    column(
      width = 6,
      plotOutput(outputId = "plot1"),
      actionButton("block_manually", "Block / unblock")
    ),
    column(
      width = 6,
      plotOutput(outputId = "plot2"),
      actionButton("block_reac", "Block when calculating in reactive()")
    )
  )
)

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

  output$plot1 <- renderPlot({
    barplot(table(floor(runif(100) * 6)))
  })

  observeEvent(input$block_manually, {
    if (input$block_manually %% 2 == 1) {
      block(id = "plot1", type = "pulse", svgColor = "#5ea4d8")
    } else {
      unblock(id = "plot1")
    }
  })

  data_r <- reactive({
    input$block_reac
    block(
      id = "plot2",
      type = "circle",
      text = "Calculating, please wait...",
      messageColor = "#FFF",
      svgColor = "#FFF",
      backgroundColor = "#5ea4d8"
    )
    Sys.sleep(3)
    data <- data.frame(x = rnorm(50), y = rnorm(50))
    unblock(id = "plot2", timeout = 300)
    return(data)
  })

  output$plot2 <- renderPlot({
    plot(data_r())
  })

}

if (interactive())
  shinyApp(ui, server)
```

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

### Implement manual start-up indicator removal

Source: https://dreamrs.github.io/shinybusy/reference/busy-start-up.html

Displays a busy indicator that remains until explicitly removed from the server side.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = spin_kit(
      spin = "cube-grid",
      color = "#FFF",
      style = "width:50px; height:50px;"
    ),
    text = "Loading...",
    mode = "manual",
    color = "#FFF",
    background = "#112446"
  ),

  tags$h1("Ready to play!", class = "text-center")

)

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

  # Remove after 3 seconds (+timeout)
  observe({
    Sys.sleep(3)
    remove_start_up(timeout = 200)
  })

}

if (interactive())
  shinyApp(ui, server)
```

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

### Load shinybusy library

Source: https://dreamrs.github.io/shinybusy/articles/shinybusy.html

Initializes the package for use in a Shiny application.

```R
library(shinybusy)
```

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

### Define start-up busy indicator functions

Source: https://dreamrs.github.io/shinybusy/reference/busy-start-up.html

Functions used to define the UI component and trigger its removal from the server.

```R
busy_start_up(
  loader,
  text = NULL,
  mode = c("timeout", "auto", "manual"),
  timeout = 500,
  color = "#112446",
  background = "#f0f0f0"
)

remove_start_up(timeout = 100, session = shiny::getDefaultReactiveDomain())
```

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

### GET logo_silex

Source: https://dreamrs.github.io/shinybusy/reference/logo_silex.html

Retrieves the file path to the Silex logo GIF for use in Shiny applications.

```APIDOC
## logo_silex

### Description
Returns the path to the Silex logo gif for use in Shiny applications.

### Usage
logo_silex()

### Value
- **path** (string) - The file path to the gif.
```

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

### Implement timeout-based start-up indicator

Source: https://dreamrs.github.io/shinybusy/reference/busy-start-up.html

Displays a busy indicator that automatically disappears after a specified timeout period.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = spin_epic("orbit", color = "#FFF"),
    text = "Loading...",
    timeout = 1500,
    color = "#FFF",
    background = "#112446"
  ),

  tags$h1("Ready to play!", class = "text-center")

)

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

}

if (interactive())
  shinyApp(ui, server)
```

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

### Manual Spinner Configuration and Control

Source: https://dreamrs.github.io/shinybusy/reference/manual-spinner.html

Functions for initializing the spinner in the UI and toggling its visibility from the server.

```R
use_busy_spinner(
  spin = "double-bounce",
  color = "#112446",
  position = c("top-right", "top-left", "bottom-right", "bottom-left", "full-page"),
  margins = c(10, 10),
  spin_id = NULL,
  height = "50px",
  width = "50px"
)

show_spinner(spin_id = NULL, session = shiny::getDefaultReactiveDomain())

hide_spinner(spin_id = NULL, session = shiny::getDefaultReactiveDomain())
```

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

### Manual progress bar usage syntax

Source: https://dreamrs.github.io/shinybusy/reference/manual-progressbar.html

Defines the UI initialization and server-side update functions for the progress bar.

```R
use_busy_bar(color = "#112446", centered = FALSE, height = "8px")

update_busy_bar(value, session = shiny::getDefaultReactiveDomain())
```

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

### Configure report() options

Source: https://dreamrs.github.io/shinybusy/reference/config_report.html

Use this function to set custom configurations for report() and other report_* functions. It allows modification of colors, text styles, button properties, and more. The returned list can be passed directly to the report functions.

```R
config_report(
  svgColor = NULL,
  titleColor = NULL,
  messageColor = NULL,
  buttonBackground = NULL,
  buttonColor = NULL,
  backOverlayColor = NULL,
  className = NULL,
  width = NULL,
  backgroundColor = NULL,
  borderRadius = NULL,
  rtl = NULL,
  zindex = NULL,
  backOverlay = NULL,
  fontFamily = NULL,
  svgSize = NULL,
  plainText = NULL,
  titleFontSize = NULL,
  titleMaxLength = NULL,
  messageFontSize = NULL,
  messageMaxLength = NULL,
  buttonFontSize = NULL,
  buttonMaxLength = NULL,
  cssAnimation = NULL,
  cssAnimationDuration = NULL,
  cssAnimationStyle = NULL,
  ...
)
```

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

### Display Spin Kit Spinner: Cube

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'cube' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("cube", style = style)
```

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

### Display Spin Kit Spinner: Cube Grid

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'cube-grid' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("cube-grid", style = style)
```

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

### Default progress line usage

Source: https://dreamrs.github.io/shinybusy/reference/progress.html

Demonstrates the default usage of `progress_line` with an initial value of 0.5.

```R
progress_line(value = 0.5)
```

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

### Shiny App with Blocked Outputs

Source: https://dreamrs.github.io/shinybusy/reference/block_output.html

Demonstrates how to use block_output in a Shiny application to block plot outputs. Different blocking types and custom styling are shown. Ensure 'shinybusy' and 'shiny' libraries are loaded.

```R
library(shinybusy)
library(shiny)

ui <- fluidPage(
  tags$h3("Block Output from UI"),
  actionButton("refresh", "Refresh outputs"),
  actionButton("open_modal", "Open modal"),
  fluidRow(
    column(
      width = 4,
      block_output(plotOutput(outputId = "plot1"))
    ),
    column(
      width = 4,
      block_output(
        plotOutput(outputId = "plot2"),
        type = "hourglass",
        messageColor = "#FFF",
        svgColor = "#FFF",
        svgSize = "70px",
        backgroundColor = "#5ea4d8"
      )
    ),
    column(
      width = 4,
      plotOutput(outputId = "plot3")
    )
  )
)

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

  output$plot1 <- renderPlot({
    input$refresh
    barplot(table(floor(runif(100) * 6)))
  })

  data_r <- reactive({
    input$refresh
    Sys.sleep(3)
    data <- data.frame(x = rnorm(50), y = rnorm(50))
    return(data)
  })

  output$plot2 <- renderPlot({
    plot(data_r())
  })

  output$plot3 <- renderPlot({
    plot(data_r(), main = "Not blocked")
  })


  observeEvent(input$open_modal, {
    showModal(modalDialog(
      block_output(plotOutput(outputId = "plot_modal")),
      actionButton("refresh_modal", "Refresh plot")
    ))
  })

  output$plot_modal <- renderPlot({
    input$refresh_modal
    Sys.sleep(1)
    barplot(table(floor(runif(100) * 6)))
  })
}

if (interactive())
  shinyApp(ui, server)

```

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

### Display Spin Kit Spinner: Folding Cube

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'folding-cube' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("folding-cube", style = style)
```

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

### Implement a manual GIF busy indicator in a Shiny app

Source: https://dreamrs.github.io/shinybusy/reference/manual-gif.html

Demonstrates integrating a GIF indicator into a UI and controlling it via action buttons in the server logic.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  # Use this function somewhere in UI
  use_busy_gif(
    src = "https://jeroen.github.io/images/banana.gif",
    height = 70, width = 70
  ),

  actionButton("play", "Play GIF"),
  actionButton("stop", "Stop GIF")
)

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

  observeEvent(input$play, {
    play_gif()
  })

  observeEvent(input$stop, {
    stop_gif()
  })

}

if (interactive()) {
  shinyApp(ui, server)
}
```

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

### Display Spin Kit Spinner: Bounce

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'bounce' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("bounce", style = style)
```

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

### Display Spin Kit Spinner: Dots

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'dots' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("dots", style = style)
```

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

### Configure and control manual GIF busy indicators

Source: https://dreamrs.github.io/shinybusy/reference/manual-gif.html

Defines the configuration parameters for the GIF indicator and the server-side functions to trigger or hide it.

```R
use_busy_gif(
  src,
  timeout = 100,
  position = c("top-right", "top-left", "bottom-right", "bottom-left", "full-page",
    "free"),
  margins = c(10, 10),
  overlay_color = "rgba(0, 0, 0, 0.5)",
  overlay_css = NULL,
  height = "50px",
  width = "50px"
)

play_gif(session = shiny::getDefaultReactiveDomain())

stop_gif(session = shiny::getDefaultReactiveDomain())
```

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

### Shiny Application Report Implementation

Source: https://dreamrs.github.io/shinybusy/reference/report.html

Demonstrates how to trigger different report notification types using action buttons within a Shiny server function.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(
  tags$h2("Report examples"),
  tags$p(
    "More examples available on the official website:",
    tags$a("https://notiflix.github.io/report")
  ),
  actionButton("success", "Success"),
  actionButton("failure", "Failure"),
  actionButton("info", "Info"),
  actionButton("warning", "Warning")
)

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

  observeEvent(input$success, {
    report_success(
      "Well done!",
      "All in order"
    )
  })

  observeEvent(input$failure, {
    report_failure(
      "Oups...",
      "Something went wrong"
    )
  })

  observeEvent(input$info, {
    report_info(
      "For your information",
      tags$p(
        style = "font-style: italic;",
        "Lorem ipsum dolor sit amet"
      )
    )
  })

  observeEvent(input$warning, {
    report_warning(
      "Be careful!",
      "There were 30 warnings (use warnings() to see them)"
    )
  })

}

if (interactive())
  shinyApp(ui, server)
```

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

### Show Modal with Line Progress Bar

Source: https://dreamrs.github.io/shinybusy/reference/modal-progress.html

Displays a modal dialog with a customizable line progress bar. Use this to indicate progress for computations.

```R
show_modal_progress_line(
  value = 0,
  text = "auto",
  color = "#112446",
  stroke_width = 4,
  easing = "linear",
  duration = 1000,
  trail_color = "#eee",
  trail_width = 1,
  height = "15px",
  session = shiny::getDefaultReactiveDomain()
)
```

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

### Display Spin Kit Spinner: Circle

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'circle' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("circle", style = style)
```

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

### Show Modal with GIF

Source: https://dreamrs.github.io/shinybusy/reference/modal-gif.html

Displays a modal window with a GIF to indicate a long-running computation. The modal is automatically removed when the computation finishes.

```APIDOC
## POST /modal-gif

### Description
Shows a modal with a GIF during long computations. The modal is removed when the computation is finished.

### Method
POST

### Endpoint
/modal-gif

### Parameters
#### Request Body
- **src** (string) - Required - Path to the GIF, an URL or a file in www/ folder.
- **text** (string) - Optional - Additional text to appear under the spinner.
- **height** (string) - Optional - Height of the spinner, default to '100px'.
- **width** (string) - Optional - Width of the spinner, default to '100px'.
- **modal_size** (string) - Optional - One of 's' for small (the default), 'm' for medium, or 'l' for large.
- **session** (object) - Optional - The session object passed to function given to shinyServer.

### Request Example
```json
{
  "src": "https://jeroen.github.io/images/banana.gif",
  "text": "Please wait...",
  "height": "200px",
  "width": "200px",
  "modal_size": "m"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the modal was shown successfully.

#### Response Example
```json
{
  "message": "Modal with GIF shown successfully."
}
```
```

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

### Manage JavaScript Assets

Source: https://dreamrs.github.io/shinybusy/index.html

Commands for managing and bundling JavaScript assets using the packer package.

```R
packer::npm_install()
```

```R
packer::bundle()
```

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

### Default progress circle usage

Source: https://dreamrs.github.io/shinybusy/reference/progress.html

Demonstrates the default usage of `progress_circle` with an initial value of 0.5.

```R
progress_circle(value = 0.5)
```

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

### Show a modal with a GIF

Source: https://dreamrs.github.io/shinybusy/reference/modal-gif.html

Use `show_modal_gif` to display a GIF in a modal window during long computations. Ensure `remove_modal_gif` is called to close the modal when the computation is finished. The GIF source can be a URL or a file in the www/ folder.

```R
show_modal_gif(
  src,
  text = NULL,
  height = "100px",
  width = "100px",
  modal_size = "s",
  session = shiny::getDefaultReactiveDomain()
)

remove_modal_gif(session = getDefaultReactiveDomain())
```

```R
if (interactive()) {

  library(shiny)
  library(shinybusy)

  ui <- fluidPage(

    tags$h1("Modal with spinner"),
    actionButton("sleep1", "Launch a long calculation"),
    actionButton("sleep2", "And another one")
  )

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

    observeEvent(input$sleep1, {
      show_modal_gif(
        src = "https://jeroen.github.io/images/banana.gif"
      )
      Sys.sleep(5)
      remove_modal_gif()
    })

    observeEvent(input$sleep2, {
      show_modal_gif(
        src = "https://jeroen.github.io/images/banana.gif",
        width = "300px", height = "300px",
        modal_size = "m",
        text = "Please wait..."
      )
      Sys.sleep(5)
      remove_modal_gif()
    })

  }

  shinyApp(ui, server)

}
```

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

### Retrieve Silex logo path

Source: https://dreamrs.github.io/shinybusy/reference/logo_silex.html

Returns the file path to the Silex logo GIF.

```R
logo_silex()
```

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

### Show Modal with Circle Progress Bar

Source: https://dreamrs.github.io/shinybusy/reference/modal-progress.html

Displays a modal dialog with a customizable circle progress bar. Ideal for visually representing task completion.

```R
show_modal_progress_circle(
  value = 0,
  text = "auto",
  color = "#112446",
  stroke_width = 4,
  easing = "linear",
  duration = 1000,
  trail_color = "#eee",
  trail_width = 1,
  height = "200px",
  session = shiny::getDefaultReactiveDomain()
)
```

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

### Configure add_busy_bar parameters

Source: https://dreamrs.github.io/shinybusy/reference/add_busy_bar.html

Defines the visual and timing properties for the progress bar.

```R
add_busy_bar(
  timeout = 1000,
  color = "#112446",
  centered = FALSE,
  height = "8px"
)
```

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

### Load HTML dependencies for shinybusy

Source: https://dreamrs.github.io/shinybusy/reference/html-dependencies.html

Functions to retrieve htmltools::htmlDependency objects for various UI components.

```R
html_dependency_spinkit()

html_dependency_epic()

html_dependency_shinybusy()

html_dependency_freezeframe()

html_dependency_nanobar()

html_dependency_notiflix()

html_dependency_startup()

html_dependency_loading()

html_dependency_busy()

html_dependency_notify()

html_dependency_report()

html_dependency_block()
```

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

### Display Spin Kit Spinner: Double Bounce

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'double-bounce' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("double-bounce", style = style)
```

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

### Shiny application with multiple progress indicators

Source: https://dreamrs.github.io/shinybusy/reference/progress.html

An interactive Shiny application demonstrating the use of `progress_line`, `progress_circle`, and `progress_semicircle` with server-side updates controlled by sliders and text inputs.

```R
if (interactive()) {
  library(shiny)
  library(shinybusy)

  ui <- fluidPage(
    tags$h2("Progress bars examples"),
    fluidRow(
      column(
        width = 4,
        tags$p("Default bar:"),
        progress_line(value = 0, shiny_id = "bar"),
        sliderInput(
          inputId = "update_bar",
          label = "Update:",
          min = 0, max = 1,
          value = 0, step = 0.1
        ),
        tags$p("Set custom text:"),
        progress_line(
          value = 0.5,
          text = "To update",
          shiny_id = "text"
        ),
        textInput(
          inputId = "update_text",
          label = "Update:"
        )
      ),
      column(
        width = 4,
        tags$p("Default circle:"),
        progress_circle(value = 0, shiny_id = "circle"),
        sliderInput(
          inputId = "update_circle",
          label = "Update:",
          min = 0, max = 1,
          value = 0, step = 0.1,
          width = "100%"
        )
      ),
      column(
        width = 4,
        tags$p("Default semi-circle:"),
        progress_semicircle(value = 0, shiny_id = "semicircle"),
        sliderInput(
          inputId = "update_semicircle",
          label = "Update:",
          min = 0, max = 1,
          value = 0, step = 0.1,
          width = "100%"
        )
      )
    )
  )

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

    observe({
      update_progress("bar", input$update_bar)
    })

    observe({
      update_progress("circle", input$update_circle)
    })

    observe({
      update_progress("semicircle", input$update_semicircle)
    })

    observe({
      req(input$update_text)
      update_progress("text", 0.5, input$update_text)
    })

  }

  shinyApp(ui, server)
}
```

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

### Display Spin Kit Spinner: Fading Circle

Source: https://dreamrs.github.io/shinybusy/articles/spinners.html

Use the `spin_kit()` function to display the 'fading-circle' spinner with custom styling. The 'style' argument allows for CSS modifications.

```r
style <- "position: relative; height: 50px; width: 50px;"
spin_kit("fading-circle", style = style)
```

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

### Manual GIF Busy Indicator

Source: https://dreamrs.github.io/shinybusy/reference/manual-gif.html

This section covers the functions for manually controlling GIF busy indicators. `use_busy_gif` is used in the UI to set up the indicator, while `play_gif` and `stop_gif` control its visibility during the application's runtime.

```APIDOC
## Manual GIF Busy Indicator

### Description
This section covers the functions for manually controlling GIF busy indicators. `use_busy_gif` is used in the UI to set up the indicator, while `play_gif` and `stop_gif` control its visibility during the application's runtime.

### Functions

#### `use_busy_gif`

##### Description
Initializes a manual GIF busy indicator in the Shiny UI.

##### Usage
```R
use_busy_gif(
  src,
  timeout = 100,
  position = c("top-right", "top-left", "bottom-right", "bottom-left", "full-page", "free"),
  margins = c(10, 10),
  overlay_color = "rgba(0, 0, 0, 0.5)",
  overlay_css = NULL,
  height = "50px",
  width = "50px"
)
```

##### Arguments
* **src** (string) - Path to the GIF, an URL or a file in www/ folder.
* **timeout** (numeric) - Number of milliseconds after the server is busy to display the GIF.
* **position** (character) - Where to display the GIF: `'top-right'`, `'top-left'`, `'bottom-right'`, `'bottom-left'`, `'full-page'`.
* **margins** (numeric vector) - Distance from margins, a vector of length two, where first element is distance from top/bottom, second element distance from right/left.
* **overlay_color** (string) - Background color for the overlay if `position = "full-page"`.
* **overlay_css** (string) - Additional CSS for the overlay, for example `"z-index: 1000;"` to make it appear above everything.
* **height** (string) - Height of the spinner, default to `'50px'`.
* **width** (string) - Width of the spinner, default to `'50px'`.

##### Value
An HTML tag that should be used in UI.

#### `play_gif`

##### Description
Starts the GIF busy indicator.

##### Usage
```R
play_gif(session = shiny::getDefaultReactiveDomain())
```

##### Arguments
* **session** (shiny::reactive) - Shiny session.

#### `stop_gif`

##### Description
Stops the GIF busy indicator.

##### Usage
```R
stop_gif(session = shiny::getDefaultReactiveDomain())
```

##### Arguments
* **session** (shiny::reactive) - Shiny session.

### Example
```R
library(shiny)
library(shinybusy)

ui <- fluidPage(
  use_busy_gif(
    src = "https://jeroen.github.io/images/banana.gif",
    height = 70, width = 70
  ),
  actionButton("play", "Play GIF"),
  actionButton("stop", "Stop GIF")
)

server <- function(input, output, session) {
  observeEvent(input$play, {
    play_gif()
  })
  observeEvent(input$stop, {
    stop_gif()
  })
}

if (interactive()) {
  shinyApp(ui, server)
}
```
```

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

### Modal progress bar control

Source: https://dreamrs.github.io/shinybusy/articles/shinybusy.html

Display a modal progress bar to track server tasks.

```R
# in server
show_modal_progress_line() # show the modal window
update_modal_progress(0.2) # update progress bar value
remove_modal_progress() # remove it when done
```

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

### HTML Dependencies

Source: https://dreamrs.github.io/shinybusy/reference/html-dependencies.html

Functions to retrieve HTML dependencies for various components used by shinybusy.

```APIDOC
## HTML Dependencies

### Description
Functions to retrieve HTML dependencies for various components used by shinybusy.

### Usage
```R
html_dependency_spinkit()
html_dependency_epic()
html_dependency_shinybusy()
html_dependency_freezeframe()
html_dependency_nanobar()
html_dependency_notiflix()
html_dependency_startup()
html_dependency_loading()
html_dependency_busy()
html_dependency_notify()
html_dependency_report()
html_dependency_block()
```

### Value
An `htmltools::htmlDependency()` object.
```

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

### Implement auto-removal with GIF loader

Source: https://dreamrs.github.io/shinybusy/reference/busy-start-up.html

Displays a custom GIF loader that automatically removes the indicator once the application is idle.

```R
library(shiny)
library(shinybusy)

ui <- fluidPage(

  busy_start_up(
    loader = tags$img(
      src = "https://jeroen.github.io/images/banana.gif",
      width = 100
    ),
    text = "Loading...",
    mode = "auto"
  ),

  tags$h1("Ready to play!", class = "text-center"),
  plotOutput(outputId = "plot")

)

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

  output$plot <- renderPlot({
    Sys.sleep(2)
    plot(rnorm(100))
  })

}

if (interactive())
  shinyApp(ui, server)
```

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

### Manual spinner control

Source: https://dreamrs.github.io/shinybusy/articles/shinybusy.html

Manually trigger a spinner indicator from the server.

```R
# in UI
use_busy_spinner(spin = "fading-circle")

# in server
show_spinner() # show the spinner
hide_spinner() # hide the spinner
```
Tokens:
Raw