diff --git a/.Rbuildignore b/.Rbuildignore
index 90264787..eaf615e4 100644
--- a/.Rbuildignore
+++ b/.Rbuildignore
@@ -5,18 +5,23 @@
^cran-comments\.md$
^README\.md$
^README\.Rmd$
-^\.travis\.yml$
^appveyor\.yml$
^\_pkgdown\.yaml$
^docs$
^CODE_OF_CONDUCT\.md$
-^node_modules/$
-^node_modules/
-^node_modules/.*
-^newfeatures/$
-^newfeatures/
-^newfeatures/.*
+^node_modules$
+^bower_components$
+^newfeatures$
^package\.json$
^package-lock\.json$
+^data-raw$
+^codecov\.yml$
+^_pkgdown\.yml$
+^pkgdown$
+^\.github$
+^CRAN-RELEASE$
^revdep$
-^bower_components$
+^HowTo\.html$
+^HowTo\.md$
+^HowTo\.rmd$
+^CRAN-SUBMISSION$
diff --git a/.github/.gitignore b/.github/.gitignore
new file mode 100644
index 00000000..2d19fc76
--- /dev/null
+++ b/.github/.gitignore
@@ -0,0 +1 @@
+*.html
diff --git a/.github/ISSUE_TEMPLATE/issue_template.md b/.github/ISSUE_TEMPLATE/issue_template.md
new file mode 100644
index 00000000..898687a4
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/issue_template.md
@@ -0,0 +1,14 @@
+---
+name: Bug report or feature request
+about: Describe a bug you've seen or make a case for a new feature
+---
+
+Please briefly describe your problem and what output you expect. If you have a question, please don't use this form. Instead, ask on .
+
+Brief description of the problem
+
+```r
+# insert reprex here
+```
diff --git a/.github/workflows/R-CMD-check.yaml b/.github/workflows/R-CMD-check.yaml
new file mode 100644
index 00000000..6c979ff2
--- /dev/null
+++ b/.github/workflows/R-CMD-check.yaml
@@ -0,0 +1,56 @@
+# For help debugging build failures open an issue on the RStudio community with the 'github-actions' tag.
+# https://community.rstudio.com/new-topic?category=Package%20development&tags=github-actions
+on:
+ push:
+ branches:
+ - main
+ - master
+ pull_request:
+ branches:
+ - main
+ - master
+
+name: R-CMD-check
+
+jobs:
+ R-CMD-check:
+ runs-on: ${{ matrix.config.os }}
+
+ name: ${{ matrix.config.os }} (${{ matrix.config.r }})
+
+ strategy:
+ fail-fast: false
+ matrix:
+ config:
+ - {os: windows-latest, r: 'release'}
+ - {os: macOS-latest, r: 'release'}
+ - {os: ubuntu-latest, r: 'devel', http-user-agent: 'release'}
+ - {os: ubuntu-latest, r: 'release'}
+ - {os: ubuntu-latest, r: 'oldrel-1'}
+
+ env:
+ GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+ R_KEEP_PKG_SOURCE: yes
+
+ steps:
+ - uses: actions/checkout@v4
+
+ - uses: r-lib/actions/setup-pandoc@v2
+
+ - uses: r-lib/actions/setup-r@v2
+ with:
+ r-version: ${{ matrix.config.r }}
+ http-user-agent: ${{ matrix.config.http-user-agent }}
+ use-public-rspm: true
+
+ - uses: r-lib/actions/setup-r-dependencies@v2
+ with:
+ extra-packages: any::rcmdcheck
+ needs: check
+
+ - uses: r-lib/actions/check-r-package@v2
+ with:
+ args: 'c("--no-manual", "--as-cran")'
+ upload-snapshots: true
+ build_args: 'c("--no-manual","--compact-vignettes=gs+qpdf")'
+
diff --git a/.github/workflows/pkgdown.yaml b/.github/workflows/pkgdown.yaml
new file mode 100644
index 00000000..57aba397
--- /dev/null
+++ b/.github/workflows/pkgdown.yaml
@@ -0,0 +1,48 @@
+# Workflow derived from https://github.com/r-lib/actions/tree/v2/examples
+# Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help
+on:
+ push:
+ branches: [main, master]
+ pull_request:
+ branches: [main, master]
+ release:
+ types: [published]
+ workflow_dispatch:
+
+name: pkgdown
+
+jobs:
+ pkgdown:
+ runs-on: ubuntu-latest
+ # Only restrict concurrency for non-PR jobs
+ concurrency:
+ group: pkgdown-${{ github.event_name != 'pull_request' || github.run_id }}
+ env:
+ GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
+ permissions:
+ contents: write
+ steps:
+ - uses: actions/checkout@v4
+
+ - uses: r-lib/actions/setup-pandoc@v2
+
+ - uses: r-lib/actions/setup-r@v2
+ with:
+ use-public-rspm: true
+
+ - uses: r-lib/actions/setup-r-dependencies@v2
+ with:
+ extra-packages: any::pkgdown, local::.
+ needs: website
+
+ - name: Build site
+ run: pkgdown::build_site_github_pages(new_process = FALSE, install = FALSE)
+ shell: Rscript {0}
+
+ - name: Deploy to GitHub pages ๐
+ if: github.event_name != 'pull_request'
+ uses: JamesIves/github-pages-deploy-action@v4.4.1
+ with:
+ clean: false
+ branch: gh-pages
+ folder: docs
diff --git a/.gitignore b/.gitignore
index fa032286..1c055fc8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,5 @@
.Rproj.user
newfeatures/
node_modules/
+docs/
+bower_components/
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index f633f265..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-# R for travis: see documentation at https://docs.travis-ci.com/user/languages/r
-
-language: R
-cache: packages
-sudo: required
-dist: trusty
-
-r_packages:
- - leaflet
-
-before_install:
- - sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable --yes
- - sudo apt-get --yes --force-yes update -qq
- - sudo apt-get install --yes libudunits2-dev libproj-dev libgeos-dev libgdal-dev
- - sudo ldconfig
diff --git a/DESCRIPTION b/DESCRIPTION
index 14a00fca..3e420059 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,29 +1,34 @@
Package: leaflet.extras2
Type: Package
Title: Extra Functionality for 'leaflet' Package
-Version: 1.0.0
+Version: 1.2.2.9000
Authors@R: c(
- person("Gatscha", "Sebastian", email = "sebastian_gatscha@gmax.at", role = c("aut", "cre"))
+ person("Gatscha", "Sebastian", email = "sebastian_gatscha@gmx.at", role = c("aut", "cre")),
+ person("Ricardo Rodrigo", "Basa", email = "radbasa@gmail.com", role = c("ctb")),
+ person(c("Jeffrey", "O"), "Hanson", email = "jeffrey.hanson@uqconnect.edu.au", role = c("ctb"), comment = c(ORCID = "0000-0002-4716-6134"))
)
-Description: This package serves as an add-on to the 'leaflet' package by
- providing extra functionality via 'leaflet' plugins.
+Description: Several 'leaflet' plugins are integrated, which are available as extension to the 'leaflet' package.
License: GPL-3 | file LICENSE
Encoding: UTF-8
LazyData: true
Depends:
- R (>= 3.1.0),
+ R (>= 3.5.0),
leaflet (>= 2.0.0)
Imports:
- htmlwidgets,
htmltools,
- shiny,
- jsonlite,
- magrittr
+ magrittr,
+ utils
Suggests:
+ jsonlite,
+ shiny,
sf,
+ geojsonsf,
sp,
- testthat (>= 3.0.0)
-URL: https://github.com/trafficonese/leaflet.extras2
+ testthat (>= 2.1.0),
+ fontawesome,
+ htmlwidgets,
+ covr,
+ curl
+URL: https://trafficonese.github.io/leaflet.extras2/, https://github.com/trafficonese/leaflet.extras2
BugReports: https://github.com/trafficonese/leaflet.extras2/issues
RoxygenNote: 7.3.1
-Config/testthat/edition: 3
diff --git a/HowTo.md b/HowTo.md
new file mode 100644
index 00000000..105e9fbe
--- /dev/null
+++ b/HowTo.md
@@ -0,0 +1,42 @@
+## How to include a new plugin โ
+
+------
+
+Fork this repo on your computer and create a **new branch** with the plugin name.
+
+The plugin [leaflet-arrowheads](https://github.com/slutske22/leaflet-arrowheads) will serve as example for this tutorial.
+
+1. Create a **new directory** in `./inst/htmlwidgets/` with the prefix `lfx-` and the plugin name. This snippet will do that for you:
+
+ usethis::use_directory("/inst/htmlwidgets/lfx-arrowhead")
+
+2. Install the **dependencies** via `npm`/`bower` etc if available. If the package cannot be installed, either fork/download the plugin-repo or copy/paste the JavaScript code manually. This plugin can be installed and requires 2 dependencies. I installed them with:
+
+ npm install leaflet-arrowheads --save
+ npm install leaflet-geometryutil --save
+This will add the dependencies in the directory `./node_modules/`. Find the directories with the source files and copy those into the new directory `lfx-arrowhead`. In this case the files: **leaflet.geometryutil.js** and **leaflet-arrowheads.js**
+
+3. Create a **new R-file** with the name of the plugin in `./R/`. In this case `arrowhead.R` or copy/paste another R-file and rename it accordingly. I copy/pasted the `antpath.R` file and search/replaced `antpath` with `arrowhead` and `Antpath` with `Arrowhead` and adapted the functions and options according to the plugin.
+
+4. Add a **JavaScript-binding** file in the directory `/inst/htmlwidgets/lfx-arrowhead`. Look at other plugins and their bindings for references and examples. In the beginning I use a lot of `console.log()` and `debugger` statements in the JS-methods to get an idea what the data looks like, if all arguments are passed correctly, etc. In this case I also copy/pasted the file `lfx-ant-path-bindings.js`, renamed it `leaflet-arrowheads-bindings.js` and adapted the JavaScript code.
+If the plugin exposes several methods, you can/should write an R-function for every JS-method. The R-function calls the JS-method with `invokeMethod` where the argument *method* should correspond to the JavaScript method you want to invoke. The arrowheads-plugin has the method **deleteArrowheads**. I used that method for two R and JS functions, one where you can remove the arrowheads by **group** (`clearArrowhead`) and one by **layerId** (`removeArrowhead`). In the JS methods `this` always refers to the map-object. If needed, you can also use the `LeafletWidget` object from R-leaflet and the `L` object by leaflet itself.
+
+5. Add an **example** in `./inst/examples/`. I use this directory to demonstrate/test the plugins in **ShinyApps**. Non-interactive examples go straight in the documentation of the function.
+
+6. Add a **test** in `./tests/testthat/` or use this function `usethis::use_test("arrowhead")`
+
+7. **Check** the package and run `devtools::test_coverage()` and try to test all R-code lines. โ
+You can also check the coverage of just one file with `devtools::test_coverage_file(paste0(getwd(),"/tests/testthat/test-arrowhead.R"))`. You may have to load some libraries manually before that.
+
+8. Add the new plugin in the **README.md** with a link to the github repo.
+
+8. Add a short description in the **NEWS.md** file that this plugin is now available.
+
+9. Add the plugin in the `_pkgdown.yml` file and make sure it matches all functions.
+
+10. If everything works correctly, push it to your fork and **open a PR**. I will be happy to merge it as soon as possible! ๐
+๐คท If you're stuck somewhere in the process and you just can't get it to work, you can still open a PR and explain what the problem is. I will look into it.
+
+11. ๐ Celebrate and use it ๐
+
+
diff --git a/NAMESPACE b/NAMESPACE
index e768508e..21777dcf 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -2,45 +2,100 @@
S3method("[",leaflet_mapkey_icon_set)
export(addAntpath)
+export(addArrowhead)
export(addBuildings)
+export(addContextmenu)
export(addEasyprint)
+export(addGIBS)
+export(addHeightgraph)
export(addHexbin)
+export(addHistory)
+export(addItemContextmenu)
+export(addLabelgun)
+export(addLatLngMoving)
+export(addLeafletsync)
+export(addLeafletsyncDependency)
export(addMapkeyMarkers)
+export(addMovingMarker)
export(addOpenweatherCurrent)
export(addOpenweatherTiles)
export(addPlayback)
export(addReachability)
export(addSidebar)
export(addSidebyside)
+export(addSpinner)
+export(addStationMoving)
export(addTangram)
+export(addTimeslider)
export(addVelocity)
export(addWMS)
export(antpathOptions)
+export(arrowheadOptions)
export(clearAntpath)
+export(clearArrowhead)
+export(clearFuture)
export(clearHexbin)
+export(clearHistory)
export(closeSidebar)
+export(context_mapmenuItems)
+export(context_markermenuItems)
+export(context_menuItem)
+export(disableContextmenu)
export(easyprintMap)
export(easyprintOptions)
+export(enableContextmenu)
+export(goBackHistory)
+export(goForwardHistory)
+export(heightgraphOptions)
export(hexbinOptions)
+export(hideContextmenu)
export(hideHexbin)
+export(historyOptions)
+export(insertItemContextmenu)
+export(isSynced)
+export(leafletsyncOptions)
export(makeMapkeyIcon)
export(mapkeyIconList)
export(mapkeyIcons)
+export(mapmenuItems)
+export(markermenuItems)
+export(menuItem)
+export(moveToMoving)
+export(movingMarkerOptions)
export(openSidebar)
+export(openweatherCurrentOptions)
+export(openweatherOptions)
+export(pauseMoving)
export(playbackOptions)
export(reachabilityOptions)
export(removeAntpath)
+export(removeArrowhead)
export(removeEasyprint)
+export(removeItemContextmenu)
export(removePlayback)
export(removeReachability)
export(removeSidebar)
export(removeSidebyside)
+export(removeTimeslider)
export(removeVelocity)
+export(removeallItemsContextmenu)
+export(resumeMoving)
export(setBuildingData)
export(setBuildingStyle)
+export(setDate)
+export(setDisabledContextmenu)
+export(setOptionsVelocity)
+export(setTransparent)
+export(showContextmenu)
export(showHexbin)
export(sidebar_pane)
export(sidebar_tabs)
+export(startMoving)
+export(startSpinner)
+export(stopMoving)
+export(stopSpinner)
+export(timesliderOptions)
+export(unsync)
export(updateBuildingTime)
export(updateHexbin)
export(velocityOptions)
@@ -49,8 +104,7 @@ importFrom(htmltools,htmlDependency)
importFrom(htmltools,tagGetAttribute)
importFrom(htmltools,tagList)
importFrom(htmltools,tags)
-importFrom(jsonlite,fromJSON)
-importFrom(jsonlite,read_json)
-importFrom(jsonlite,toJSON)
importFrom(magrittr,"%>%")
-importFrom(shiny,addResourcePath)
+importFrom(utils,adist)
+importFrom(utils,globalVariables)
+importFrom(utils,packageVersion)
diff --git a/R/antpath.R b/R/antpath.R
index 8f0dc3eb..9bcb2215 100644
--- a/R/antpath.R
+++ b/R/antpath.R
@@ -1,7 +1,7 @@
antpathDependency <- function() {
list(
htmltools::htmlDependency(
- "lfx-antpath", version = "2.1.0",
+ "lfx-antpath", version = "1.0.0",
src = system.file("htmlwidgets/lfx-antpath", package = "leaflet.extras2"),
script = c("lfx-ant-path.js",
"lfx-ant-path-bindings.js")
@@ -12,30 +12,38 @@ antpathDependency <- function() {
#' Add Antpath Lines
#'
#' Can be used almost exactly like \code{addPolylines} but instead of
-#' \code{pathOptions} you can use \code{\link{antpathOptions}}, to adapt the
-#' Antpath behaviour. See \href{https://github.com/rubenspgcavalcante/leaflet-ant-path}{leaflet-ant-path}
+#' \code{pathOptions} you can use \code{\link{antpathOptions}} to adapt the
+#' Antpath behaviour. See
+#' \href{https://github.com/rubenspgcavalcante/leaflet-ant-path}{leaflet-ant-path}
#' for further details.
#'
#' @inheritParams leaflet::addPolylines
#' @param options A named list of options. See \code{\link{antpathOptions}}
-#' @family Antpath Plugin
-#' @seealso https://github.com/rubenspgcavalcante/leaflet-ant-path
+#' @family Antpath Functions
+#' @references \url{https://github.com/rubenspgcavalcante/leaflet-ant-path}
+#' @return A modified leaflet map, with an 'ant-path' animated polyline
#' @export
-addAntpath <- function(map, lng = NULL, lat = NULL, layerId = NULL, group = NULL,
- stroke = TRUE, color = "#03F", weight = 5, opacity = 0.5,
- fill = FALSE, fillColor = color, fillOpacity = 0.2, dashArray = NULL,
- smoothFactor = 1, noClip = FALSE, popup = NULL, popupOptions = NULL,
- label = NULL, labelOptions = NULL, options = antpathOptions(),
- highlightOptions = NULL, data = getMapData(map)) {
+#' @examples
+#' library(leaflet)
+#' leaflet() %>%
+#' addAntpath(data = atlStorms2005)
+addAntpath <- function(map, lng = NULL, lat = NULL, layerId = NULL,
+ group = NULL, stroke = TRUE, color = "#03F", weight = 5,
+ opacity = 0.5, fill = FALSE, fillColor = color,
+ fillOpacity = 0.2, dashArray = NULL, smoothFactor = 1,
+ noClip = FALSE, popup = NULL, popupOptions = NULL,
+ label = NULL, labelOptions = NULL,
+ options = antpathOptions(), highlightOptions = NULL,
+ data = getMapData(map)) {
if (missing(labelOptions))
labelOptions <- labelOptions()
options <- c(options, filterNULL(
- list(stroke = stroke, color = color,
- weight = weight, opacity = opacity, fill = fill, fillColor = fillColor,
- fillOpacity = fillOpacity, dashArray = dashArray, smoothFactor = smoothFactor,
- noClip = noClip)))
+ list(stroke = stroke, color = color, weight = weight,
+ opacity = opacity, fill = fill, fillColor = fillColor,
+ fillOpacity = fillOpacity, dashArray = dashArray,
+ smoothFactor = smoothFactor, noClip = noClip)))
pgons <- derivePolygons(data, lng, lat, missing(lng), missing(lat),
"addPolylines")
@@ -50,6 +58,7 @@ addAntpath <- function(map, lng = NULL, lat = NULL, layerId = NULL, group = NULL
#' Antpath Options
#'
+#' Additional list of options for 'ant-path' animated polylines.
#' @inheritParams leaflet::pathOptions
#' @param delay Add a delay to the animation flux. Default is \code{400}
#' @param paused Should the animation be paused. Default is \code{FALSE}
@@ -59,7 +68,8 @@ addAntpath <- function(map, lng = NULL, lat = NULL, layerId = NULL, group = NULL
#' acceleration. Default is \code{FALSE}
#' @param dashArray The size of the animated dashes. Default is \code{c(10, 20)}
#' @param pulseColor Adds a color to the dashed flux. Default is \code{#ffffff}
-#' @family Antpath Plugin
+#' @family Antpath Functions
+#' @return A list of options for \code{addAntpath} animated polylines
#' @export
antpathOptions = function(
delay = 400,
@@ -70,7 +80,8 @@ antpathOptions = function(
pulseColor = "#ffffff",
lineCap = NULL, lineJoin = NULL,
interactive = TRUE, pointerEvents = NULL,
- className = "") {
+ className = "",
+ ...) {
filterNULL(list(
delay = delay,
@@ -83,21 +94,28 @@ antpathOptions = function(
lineJoin = lineJoin,
interactive = interactive,
pointerEvents = pointerEvents,
- className = className
+ className = className,
+ ...
))
}
+#' removeAntpath
+#'
#' Remove one or more Antpaths from a map, identified by \code{layerId}.
#' @inheritParams leaflet::removeShape
-#' @family Antpath Plugin
+#' @family Antpath Functions
+#' @inherit leaflet::removeShape return
#' @export
removeAntpath <- function(map, layerId = NULL) {
invokeMethod(map, NULL, "removeAntpath", layerId)
}
+#' clearAntpath
+#'
#' Clear all Antpaths
#' @inheritParams leaflet::clearShapes
-#' @family Antpath Plugin
+#' @family Antpath Functions
+#' @inherit leaflet::clearShapes return
#' @export
clearAntpath <- function(map) {
invokeMethod(map, NULL, "clearAntpath")
diff --git a/R/arrowhead.R b/R/arrowhead.R
new file mode 100644
index 00000000..0cbf0929
--- /dev/null
+++ b/R/arrowhead.R
@@ -0,0 +1,159 @@
+arrowheadDependency <- function() {
+ list(
+ htmltools::htmlDependency(
+ "lfx-arrowhead", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-arrowhead", package = "leaflet.extras2"),
+ script = c("leaflet.geometryutil.js",
+ "leaflet-arrowheads.js",
+ "leaflet-arrowheads-bindings.js")
+ )
+ )
+}
+
+#' Add Lines with an arrowhead
+#'
+#' Can be used almost exactly like \code{addPolylines} but instead of
+#' \code{pathOptions} you can use \code{\link{arrowheadOptions}}. See
+#' \href{https://github.com/slutske22/leaflet-arrowheads}{leaflet-arrowheads}
+#' for further details.
+#'
+#' @inheritParams leaflet::addPolylines
+#' @param options A named list of options. See \code{\link{arrowheadOptions}}
+#' @family Arrowhead Functions
+#' @references \url{https://github.com/slutske22/leaflet-arrowheads}
+#' @return A modified leaflet map with a polyline with arrowheads
+#' @export
+#' @examples
+#' library(leaflet)
+#' leaflet() %>%
+#' addArrowhead(data = atlStorms2005)
+addArrowhead <- function(map, lng = NULL, lat = NULL, layerId = NULL,
+ group = NULL, stroke = TRUE, color = "#03F", weight = 5,
+ opacity = 0.5, fill = FALSE, fillColor = color,
+ fillOpacity = 0.2, dashArray = NULL, smoothFactor = 1,
+ noClip = FALSE, popup = NULL, popupOptions = NULL,
+ label = NULL, labelOptions = NULL,
+ options = arrowheadOptions(), highlightOptions = NULL,
+ data = getMapData(map)) {
+
+ if (missing(labelOptions))
+ labelOptions <- labelOptions()
+
+ arrowheadOptions <- options
+ options <- filterNULL(
+ c(list(stroke = stroke, color = color, weight = weight,
+ opacity = opacity, fill = fill, fillColor = fillColor,
+ fillOpacity = fillOpacity, dashArray = dashArray,
+ smoothFactor = smoothFactor, noClip = noClip),
+ arrowheadOptions))
+
+
+ pgons <- derivePolygons(data, lng, lat, missing(lng), missing(lat),
+ "addPolylines")
+
+ map$dependencies <- c(map$dependencies, arrowheadDependency())
+
+ invokeMethod(map, data, "addArrowhead", pgons, layerId, group,
+ options, popup, popupOptions, safeLabel(label, data),
+ labelOptions, highlightOptions, arrowheadOptions) %>%
+ expandLimitsBbox(pgons)
+}
+
+#' Arrowhead Options
+#'
+#' Additional list of options for polylines with arrowheads. You can also pass
+#' options inherited from
+#' \href{https://leafletjs.com/reference.html#path}{L.Path}
+#'
+#' @param yawn Defines the width of the opening of the arrowhead, given in
+#' degrees. The larger the angle, the wider the arrowhead.
+#' @param size Determines the size of the arrowhead. Accepts three types of
+#' values:
+#' \itemize{
+#' \item A string with the suffix \code{'m'}, i.e. \code{'500m'} will set the
+#' size of the arrowhead to that number of meters.
+#' \item A string with the suffix \code{'\%'}, i.e. \code{'15\%'} will render
+#' arrows whose size is that percentage of the size of the parent polyline. If
+#' the polyline has multiple segments, it will take the percent of the
+#' average size of the segments.
+#' \item A string the suffix \code{'px'}, i.e. \code{'20px'} will render an
+#' arrowhead whose size stays at a constant pixel value, regardless of zoom
+#' level. Will look strange at low zoom levels or for smaller parent vectors.
+#' Ideal for larger parent vectors and at higher zoom levels.
+#' }
+#' @param frequency How many arrowheads are rendered on a polyline.
+#' \itemize{
+#' \item \code{'allvertices'} renders an arrowhead on each vertex.
+#' \item \code{'endonly'} renders only one at the end.
+#' \item A numeric value renders that number of arrowheads evenly spaced
+#' along the polyline.
+#' \item A string with suffix \code{'m'}, i.e. \code{'100m'} will render
+#' arrowheads spaced evenly along the polyline with roughly that many meters
+#' between each one.
+#' \item A string with suffix \code{'px'}, i.e. \code{'30px'} will render
+#' arrowheads spaced evenly with roughly that many pixels between each,
+#' regardless of zoom level. }
+#' @param proportionalToTotal Only relevant when size is given as a percent.
+#' Useful when frequency is set to \code{'endonly'}. Will render the
+#' arrowheads with a size proportional to the entire length of the
+#' multi-segmented polyline, rather than proportional to the average length of
+#' all the segments.
+#' @param offsets Enables the developer to have the arrowheads start or end at
+#' some offset from the start and/or end of the polyline. This option can be a list
+#' with `start` and `end` names. The values must be strings
+#' defining the size of the offset in either meters or pixels, i.e.
+#' \code{list('start' = '100m', 'end' = '15px')}.
+#' @param perArrowheadOptions Enables the developer to customize arrowheads on a
+#' one-by-one basis. Must be in the form of a function of i, which is the
+#' index of the arrowhead as it is rendered in the loop through all
+#' arrowheads. Must return an options object. Cannnot
+#' account for \code{frequency} or \code{proportionalToTotal} from within the
+#' \code{perArrowheadOptions} callback. See the example for details.
+#' @param ... Additional options for arrowheads, inherited from
+#' \href{https://leafletjs.com/reference.html#path}{L.Path}
+#' @references \url{https://github.com/slutske22/leaflet-arrowheads#options}
+#' @family Arrowhead Functions
+#' @return A list of options for \code{addArrowhead} polylines
+#' @export
+arrowheadOptions <- function(
+ yawn = 60,
+ size = '15%',
+ frequency = 'allvertices',
+ proportionalToTotal = FALSE,
+ offsets = NULL,
+ perArrowheadOptions = NULL,
+ ...) {
+
+ filterNULL(list(
+ yawn = yawn,
+ size = size,
+ frequency = frequency,
+ proportionalToTotal = proportionalToTotal,
+ offsets = offsets,
+ perArrowheadOptions = perArrowheadOptions,
+ ...
+ ))
+}
+
+#' Remove arrowheads from Lines by group
+#'
+#' @param map the map
+#' @param group A group name
+#' @family Arrowhead Functions
+#' @return A modified leaflet map
+#' @export
+clearArrowhead <- function(map, group) {
+ invokeMethod(map, getMapData(map), "clearArrowhead", group)
+}
+
+#' Remove arrowheads from Lines by layerId
+#'
+#' @param map the map
+#' @param layerId A single layerId or a vector of layerId's
+#' @family Arrowhead Functions
+#' @return A modified leaflet map
+#' @export
+removeArrowhead <- function(map, layerId) {
+ invokeMethod(map, getMapData(map), "removeArrowhead", layerId)
+}
+
diff --git a/R/contextmenu.R b/R/contextmenu.R
new file mode 100644
index 00000000..cc34bfdd
--- /dev/null
+++ b/R/contextmenu.R
@@ -0,0 +1,277 @@
+contextmenuDependency <- function() {
+ list(
+ htmltools::htmlDependency(
+ "lfx-contextmenu", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-contextmenu",
+ package = "leaflet.extras2"),
+ script = c("leaflet.contextmenu.js",
+ "leaflet.contextmenu-bindings.js"),
+ stylesheet = "leaflet.contextmenu.css"
+ )
+ )
+}
+
+#' Add contextmenu Plugin
+#'
+#' Add a contextmenu to the map or markers/vector layers.
+#' @param map a map widget object created from \code{\link[leaflet]{leaflet}}
+#' @family Contextmenu Functions
+#' @references \url{https://github.com/aratcliffe/Leaflet.contextmenu}
+#' @export
+#' @return A leaflet map object
+#'
+#' @details
+#' This function is only used to include the required JavaScript and CSS
+#' bindings and to set up some Shiny event handlers.
+#'
+#' \subsection{Contextmenu initialization}{
+#' The contextmenu for
+#' \itemize{
+#' \item {the \strong{map} must be defined in
+#' \code{\link[leaflet]{leafletOptions}}.}
+#' \item {the \strong{markers/vector layers} must be defined
+#' in \code{\link[leaflet]{markerOptions}} or
+#' \code{\link[leaflet]{pathOptions}}.}
+#' }
+#' }
+#'
+#' \subsection{Contextmenu selection}{
+#' When a contextmenu is selected, a Shiny input with the
+#' ID \code{"MAPID_contextmenu_select"} is set (`MAPID` refers to the map's id).
+#'
+#' If the selected contextmenu item is triggered from:
+#' \itemize{
+#' \item {the \strong{map}, the returned list contains the \code{text} of
+#' the item.}
+#' \item {the \strong{markers}, the returned list also contains the
+#' \code{layerId}, \code{group}, \code{lat},
+#' \code{lng} and \code{label}.}
+#' \item {the \strong{vector layers}, the returned list also contains the
+#' \code{layerId}, \code{group} and \code{label}.}
+#' }
+#' }
+#'
+#' @examples
+#' library(leaflet)
+#' leaflet(options = leafletOptions(
+#' contextmenu = TRUE,
+#' contextmenuWidth = 200,
+#' contextmenuItems =
+#' context_mapmenuItems(
+#' context_menuItem("Zoom Out", "function(e) {this.zoomOut()}", disabled=FALSE),
+#' "-",
+#' context_menuItem("Zoom In", "function(e) {this.zoomIn()}")))) %>%
+#' addTiles(group = "base") %>%
+#' addContextmenu() %>%
+#' addMarkers(data = breweries91, label = ~brewery,
+#' layerId = ~founded, group = "marker",
+#' options = markerOptions(
+#' contextmenu = TRUE,
+#' contextmenuWidth = 200,
+#' contextmenuItems =
+#' context_markermenuItems(
+#' context_menuItem(text = "Show Marker Coords",
+#' callback = "function(e) {alert(e.latlng);}",
+#' index = 1)
+#' )
+#' ))
+#'
+addContextmenu <- function(map) {
+ map$dependencies <- c(map$dependencies, contextmenuDependency())
+ leaflet::invokeMethod(map, NULL, "addContextmenu")
+}
+
+#' showContextmenu
+#'
+#' Open the contextmenu at certain lat/lng-coordinates
+#' @family Contextmenu Functions
+#' @inheritParams leaflet::addMarkers
+#' @return A leaflet map object
+#' @export
+showContextmenu <- function(map, lat = NULL, lng = NULL,
+ data = leaflet::getMapData(map)) {
+ pts <- leaflet::derivePoints(data, lng, lat,
+ missing(lng), missing(lat), "showContextmenu")
+ leaflet::invokeMethod(map, NULL, "showContextmenu", pts)
+}
+
+#' enableContextmenu
+#'
+#' Enable the contextmenu
+#' @family Contextmenu Functions
+#' @inheritParams addContextmenu
+#' @return A leaflet map object
+#' @export
+enableContextmenu <- function(map) {
+ leaflet::invokeMethod(map, NULL, "enableContextmenu")
+}
+
+#' disableContextmenu
+#'
+#' Disable the contextmenu
+#' @family Contextmenu Functions
+#' @inheritParams addContextmenu
+#' @return A leaflet map object
+#' @export
+disableContextmenu <- function(map) {
+ leaflet::invokeMethod(map, NULL, "disableContextmenu")
+}
+
+#' hideContextmenu
+#'
+#' Hide the contextmenu
+#' @family Contextmenu Functions
+#' @inheritParams addContextmenu
+#' @return A leaflet map object
+#' @export
+hideContextmenu <- function(map) {
+ leaflet::invokeMethod(map, NULL, "hideContextmenu")
+}
+
+#' addItemContextmenu
+#'
+#' Add a new contextmenu menu item
+#' @family Contextmenu Functions
+#' @inheritParams addContextmenu
+#' @param option new menu item to add
+#' @return A leaflet map object
+#' @export
+addItemContextmenu <- function(map, option) {
+ if (utils::packageVersion("leaflet") < "2.0.4") {
+ warning("The `addItemContextmenu` function requires leaflet `2.0.4` to correctly register callbacks.")
+ }
+ leaflet::invokeMethod(map, NULL, "addItemContextmenu", option)
+}
+# remotes::install_github("rstudio/leaflet#696")
+
+#' insertItemContextmenu
+#'
+#' Insert a new contextmenu menu item at a specific index
+#' @family Contextmenu Functions
+#' @inheritParams addItemContextmenu
+#' @inheritParams removeItemContextmenu
+#' @return A leaflet map object
+#' @export
+insertItemContextmenu <- function(map, option, index) {
+ if (utils::packageVersion("leaflet") < "2.0.4") {
+ warning("The `insertItemContextmenu` function requires leaflet `2.0.4` to correctly register callbacks.")
+ }
+ leaflet::invokeMethod(map, NULL, "insertItemContextmenu", option, index)
+}
+# remotes::install_github("rstudio/leaflet#696")
+
+#' removeItemContextmenu
+#'
+#' Remove a contextmenu item by index.
+#' @family Contextmenu Functions
+#' @inheritParams addContextmenu
+#' @param index Index of the contextmenu. (NOTE: Since the index is passed
+#' to JavaScript, it is zero-based)
+#' @return A leaflet map object
+#' @export
+removeItemContextmenu <- function(map, index) {
+ leaflet::invokeMethod(map, NULL, "removeItemContextmenu", index)
+}
+
+#' setDisabledContextmenu
+#'
+#' Enable/Disable a contextmenu item by index.
+#' @family Contextmenu Functions
+#' @inheritParams removeItemContextmenu
+#' @param disabled Set to \code{TRUE} to disable the element and \code{FALSE}
+#' to enable it. Default is \code{TRUE}
+#' @return A leaflet map object
+#' @export
+setDisabledContextmenu <- function(map, index, disabled=TRUE) {
+ leaflet::invokeMethod(map, NULL, "setDisabledContextmenu", index, disabled)
+}
+
+#' removeallItemsContextmenu
+#'
+#' Remove all contextmenu items from the map.
+#' @family Contextmenu Functions
+#' @inheritParams removeItemContextmenu
+#' @return A leaflet map object
+#' @export
+removeallItemsContextmenu <- function(map) {
+ leaflet::invokeMethod(map, NULL, "removeallItemsContextmenu")
+}
+
+
+
+#' context_menuItem
+#' @param text The label to use for the menu item
+#' @param callback A callback function to be invoked when the menu item is
+#' clicked. The callback is passed an object with properties identifying the
+#' location the menu was opened at: \code{latlng}, \code{layerPoint}
+#' and \code{containerPoint}. The callback-function must be valid JavaScript
+#' and will be wrapped in \code{\link[leaflet]{JS}}.
+#' @param ... For further options please visit
+#' \url{https://github.com/aratcliffe/Leaflet.contextmenu}
+#' @family Contextmenu Functions
+#' @return A contextmenu item list
+#' @export
+context_menuItem <- function(text, callback = NULL, ...) {
+ list(text = text,
+ callback = leaflet::JS(callback),
+ ...)
+}
+
+#' context_mapmenuItems
+#' @param ... contextmenu item/s
+#' @family Contextmenu Functions
+#' @return A list of \code{context_menuItem} for the map
+#' @export
+context_mapmenuItems <- function(...) {
+ list(...)
+}
+
+#' context_markermenuItems
+#' @param ... contextmenu item/s
+#' @family Contextmenu Functions
+#' @return A list of \code{context_menuItem} for markers
+#' @export
+context_markermenuItems <- function(...) {
+ list(list(...))
+}
+
+
+## Deprecated ###########
+#' menuItem
+#' @param text The label to use for the menu item
+#' @param callback A callback function to be invoked when the menu item is
+#' clicked. The callback is passed an object with properties identifying the
+#' location the menu was opened at: \code{latlng}, \code{layerPoint}
+#' and \code{containerPoint}. The callback-function must be valid JavaScript
+#' and will be wrapped in \code{\link[leaflet]{JS}}.
+#' @param ... For further options please visit
+#' \url{https://github.com/aratcliffe/Leaflet.contextmenu}
+#' @family Contextmenu Functions
+#' @return A contextmenu item list
+#' @export
+menuItem <- function(text, callback = NULL, ...) {
+ .Deprecated("context_menuItem")
+ list(text = text,
+ callback=leaflet::JS(callback),
+ ...)
+}
+
+#' mapmenuItems
+#' @param ... contextmenu item/s
+#' @family Contextmenu Functions
+#' @return A list of \code{menuItem} for the map
+#' @export
+mapmenuItems <- function(...) {
+ .Deprecated("context_mapmenuItems")
+ list(...)
+}
+
+#' markermenuItems
+#' @param ... contextmenu item/s
+#' @family Contextmenu Functions
+#' @return A list of \code{menuItem} for markers
+#' @export
+markermenuItems <- function(...) {
+ .Deprecated("context_markermenuItems")
+ list(list(...))
+}
diff --git a/R/data_docs.R b/R/data_docs.R
new file mode 100644
index 00000000..6165cfe2
--- /dev/null
+++ b/R/data_docs.R
@@ -0,0 +1,2 @@
+#' The available GIBS layers with attributes
+"gibs_layers"
diff --git a/R/easyprint.R b/R/easyprint.R
index db89df1f..1f948782 100644
--- a/R/easyprint.R
+++ b/R/easyprint.R
@@ -1,75 +1,135 @@
easyprintDependency <- function() {
list(
htmltools::htmlDependency(
- "lfx-easyprint", version = "2.1.0",
- src = system.file("htmlwidgets/lfx-easyprint", package = "leaflet.extras2"),
- script = c("lfx-easyprint.js",
- "lfx-easyprint-bindings.js")
+ "lfx-easyprint", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-easyprint",
+ package = "leaflet.extras2"),
+ script = c(
+ "dom-to-image.js",
+ "FileSaver.js",
+ # "lfx-easyprint.js",
+ "lfx-easyprint_full.js",
+ "lfx-easyprint-bindings.js")
)
)
}
#' Add easyPrint Plugin
-#' @param map the map to add easyPrint to.
+#'
+#' Add a control, which allows to print or export a map as .PNG.
+#' @param map a map widget object created from \code{\link[leaflet]{leaflet}}
#' @param options A named list of options. See \code{\link{easyprintOptions}}
-#' @family EasyPrint Plugin
-#' @seealso https://github.com/rowanwins/leaflet-easyPrint
+#' @family EasyPrint Functions
+#' @references \url{https://github.com/rowanwins/leaflet-easyPrint}
#' @export
+#' @return A leaflet map object
+#' @examples
+#' library(leaflet)
+#' leaflet() %>%
+#' addTiles() %>%
+#' addEasyprint(options = easyprintOptions(
+#' title = 'Print map',
+#' position = 'bottomleft',
+#' exportOnly = TRUE))
addEasyprint <- function(map, options = easyprintOptions()) {
-
map$dependencies <- c(map$dependencies, easyprintDependency())
-
leaflet::invokeMethod(map, NULL, "addEasyprint", options)
}
#' easyprintMap
+#'
+#' Print or export a map programmatically (e.g. in a Shiny environment).
#' @param map the map widget
-#' @param sizeModes Options available include Current, A4Portrait, A4Landscape
-#' or a custom size object. Default is \code{A4Portrait}
-#' @param filename Name of the file if export only option set to TRUE
-#' @family EasyPrint Plugin
+#' @param sizeModes Must match one of the given \code{sizeMode} names in
+#' \code{\link{easyprintOptions}}. The options are:
+#' \code{CurrentSize}, \code{A4Portrait} or \code{A4Landscape}. If you want to
+#' print the map with a \code{Custom} sizeMode you need to pass the Custom className.
+#' Default is \code{A4Portrait}
+#' @param filename Name of the file if \code{exportOnly} option is \code{TRUE}.
+#' @family EasyPrint Functions
+#' @inherit addEasyprint return
#' @export
+#' @examples
+#' ## Only run examples in interactive R sessions
+#' if (interactive()) {
+#' library(shiny)
+#' library(leaflet)
+#' library(leaflet.extras2)
+#'
+#' ui <- fluidPage(
+#' leafletOutput("map"),
+#' selectInput("scene", "Select Scene", choices = c("CurrentSize", "A4Landscape", "A4Portrait")),
+#' actionButton("print", "Print Map")
+#' )
+#'
+#' server <- function(input, output, session) {
+#' output$map <- renderLeaflet({
+#' input$print
+#' leaflet() %>%
+#' addTiles() %>%
+#' setView(10, 50, 9) %>%
+#' addEasyprint(options = easyprintOptions(
+#' exportOnly = TRUE
+#' ))
+#' })
+#' observeEvent(input$print, {
+#' leafletProxy("map") %>%
+#' easyprintMap(sizeModes = input$scene)
+#' })
+#' }
+#'
+#' shinyApp(ui, server)
+#' }
easyprintMap <- function(map, sizeModes = "A4Portrait", filename = "map") {
leaflet::invokeMethod(map, NULL, "easyprintMap", sizeModes, filename)
}
-#' easyprintMapremoveEasyprint
+#' removeEasyprint
+#'
+#' Removes the easyprint control from the map.
#' @param map the map widget
-#' @family EasyPrint Plugin
+#' @family EasyPrint Functions
+#' @inherit addEasyprint return
#' @export
removeEasyprint <- function(map) {
leaflet::invokeMethod(map, NULL, "removeEasyprint")
}
-
-
-#' easyPrint Options
+#' easyprintOptions
+#'
+#' Create a list of further options for the easyprint plugin.
#' @param title Sets the text which appears as the tooltip of the print/export button
#' @param position Positions the print button
-#' @param sizeModes Options available include Current, A4Portrait, A4Landscape
-#' or a custom size object
-#' @param defaultSizeTitles button tooltips for the default page sizes
-#' @param exportOnly If set to true the map is exported to a png file
-#' @param tileLayer A tile layer that you can wait for to draw (helpful when resizing)
+#' @param sizeModes Either a character vector with one of the following options:
+#' \code{CurrentSize}, \code{A4Portrait}, \code{A4Landscape}. If you want to
+#' include a \code{Custom} size mode you need to pass a named list, with
+#' \code{width}, \code{height}, \code{name} and \code{className} and assign a
+#' background-image in CSS.
+#' See the example in \code{./inst/examples/easyprint_app.R}.
+#' @param defaultSizeTitles Button tooltips for the default page sizes
+#' @param exportOnly If set to \code{TRUE} the map is exported to a .png file
+#' @param tileLayer The group name of one tile layer that you can wait for to draw
+#' (helpful when resizing)
#' @param tileWait How long to wait for the tiles to draw (helpful when resizing)
-#' @param filename Name of the file if export only option set to TRUE
-#' @param hidden Set to true if you don't want to display the toolbar.
+#' @param filename Name of the file if \code{exportOnly} option is \code{TRUE}
+#' @param hidden Set to \code{TRUE} if you don't want to display the toolbar.
#' Instead you can create your own buttons or fire print events programmatically.
-#' You still need to call addTo(map) to set the leaflet map context.
#' @param hideControlContainer Hides the leaflet controls like the zoom buttons
-#' and the attribution on the print out.
-#' @param hideClasses Hides classes on the print out. Use a list of strings as
-#' follow : list('div1', 'div2')
+#' and the attribution on the print out
+#' @param hideClasses Use a character vector or list of CSS-classes to hide on
+#' the output image.
#' @param customWindowTitle A title for the print window which will get
-#' added the printed paper.
-#' @param spinnerBgColor A valid css colour for the spinner background color.
+#' added to the printed paper
+#' @param spinnerBgColor A valid css colour for the spinner background color
#' @param customSpinnerClass A class for a custom css spinner to use while
#' waiting for the print.
-#' @family EasyPrint Plugin
+#' @family EasyPrint Functions
+#' @return A list of options for the 'easyprint' control
+#' @references \url{https://github.com/rowanwins/leaflet-easyPrint}
#' @export
easyprintOptions <- function(title = 'Print map',
position = 'topleft',
- sizeModes = list("A4Portrait", "A4Landscape", "Current"),
+ sizeModes = list("A4Portrait", "A4Landscape", "CurrentSize"),
defaultSizeTitles = NULL,
exportOnly = FALSE,
tileLayer = NULL,
@@ -77,10 +137,16 @@ easyprintOptions <- function(title = 'Print map',
filename = 'map',
hidden = FALSE,
hideControlContainer = TRUE,
- hideClasses = list(),
+ hideClasses = NULL,
customWindowTitle = NULL,
spinnerBgColor = '#0DC5C1',
customSpinnerClass = 'epLoader') {
+ if (inherits(sizeModes, "character")) sizeModes <- as.list(sizeModes)
+ if (inherits(hideClasses, "character")) hideClasses <- as.list(hideClasses)
+ if (length(sizeModes) == 0 || (is.null(sizeModes) || all(is.na(sizeModes)) || all(sizeModes == ""))) {
+ stop("The 'sizeModes' argument cannot be empty.\nUse one of the following ",
+ "options: 'A4Portrait', 'A4Landscape', 'CurrentSize' or define a 'Custom' sizeMode.")
+ }
leaflet::filterNULL(list(
title = title,
position = position,
diff --git a/R/gibs.R b/R/gibs.R
new file mode 100644
index 00000000..2ab919a9
--- /dev/null
+++ b/R/gibs.R
@@ -0,0 +1,119 @@
+gibsDependency <- function() {
+ list(
+ htmltools::htmlDependency(
+ "lfx-gibs", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-gibs", package = "leaflet.extras2"),
+ script = c(
+ "GIBSLayer.js",
+ "GIBSMetadata.js",
+ "gibs-bindings.js")
+ )
+ )
+}
+
+#' Add GIBS Layers
+#'
+#' A leaflet plugin for NASA EOSDIS GIBS imagery integration. 154 products are
+#' available. The date can be set dynamically for multi-temporal products. No-data
+#' pixels of MODIS Multiband Imagery can be made transparent.
+#' @inheritParams leaflet::addWMSTiles
+#' @param layers A character vector of GIBS-layers. See \code{\link{gibs_layers}}
+#' @param dates Date object. If multiple \code{layers} are added, you can add a
+#' Date vector of the same length
+#' @param opacity Numeric value determining the opacity. If multiple
+#' \code{layers} are added, you can add a numeric vector of the same length
+#' @param transparent Should the layer be transparent. If multiple \code{layers}
+#' are added, you can add a boolean vector of the same length
+#' @references \url{https://github.com/aparshin/leaflet-GIBS}
+#' @family GIBS Functions
+#' @export
+#' @inherit leaflet::addWMSTiles return
+#' @examples
+#' library(leaflet)
+#' library(leaflet.extras2)
+#'
+#' layers <- gibs_layers$title[c(35, 128, 185)]
+#'
+#' leaflet() %>%
+#' addTiles() %>%
+#' setView(9, 50, 4) %>%
+#' addGIBS(layers = layers,
+#' dates = Sys.Date() - 1,
+#' group = layers) %>%
+#' addLayersControl(overlayGroups = layers)
+addGIBS <- function(map, layers = NULL, group = NULL, dates = NULL,
+ opacity = 0.5, transparent = TRUE) {
+ ## Check required args ######################
+ if (is.null(layers))
+ stop("You must define one or multiple `layers`.\n",
+ "See `gibs_layers` for a list of all available layers and their attributes.")
+ if (is.null(dates))
+ stop("You must define one or multiple `dates` for each layer.")
+
+ ## Check if layers exist ######################
+ if (!all(layers %in% gibs_layers$title)) {
+ stop("The layer is not valid. Did you mean: `",
+ gibs_layers$title[which.min(adist(layers, gibs_layers$title))], "`?\n",
+ "If not, please see `gibs_layers` for a list of all available layers and their attributes.")
+ }
+
+ ## If multiple layers passed, repeat single values, so JS can always assume an array
+ lenlay = length(layers)
+ if (lenlay > 1) {
+ seqlen <- seq.int(lenlay)
+ if (lenlay != length(group)) {
+ group <- rep(group, lenlay)[seqlen]
+ }
+ if (lenlay != length(dates)) {
+ dates <- rep(dates, lenlay)[seqlen]
+ }
+ if (lenlay != length(opacity)) {
+ opacity <- rep(opacity, lenlay)[seqlen]
+ }
+ if (lenlay != length(transparent)) {
+ transparent <- rep(transparent, lenlay)[seqlen]
+ }
+ }
+
+ ## Add deps ################
+ map$dependencies <- c(map$dependencies, gibsDependency())
+
+ ## Invoke Leaflet ##########
+ invokeMethod(map, getMapData(map), "addGIBS", layers, group, dates, opacity, transparent)
+}
+
+#' Set Date for GIBS Layers
+#'
+#' Set a new date for multi-temporal layers.
+#' @inheritParams addGIBS
+#' @family GIBS Functions
+#' @inherit leaflet::addWMSTiles return
+#' @export
+setDate <- function(map, layers = NULL, dates = NULL) {
+ ## Check required args ######################
+ if (is.null(layers))
+ stop("You must define one or multiple `layers`.\n",
+ "See `gibs_layers` for a list of all available layers and their attributes.")
+ if (is.null(dates))
+ stop("You must define one or multiple `dates`.")
+
+ ## Invoke Leaflet ##########
+ invokeMethod(map, NULL, "setDate", layers, dates)
+}
+
+#' Set Transparency for GIBS Layers
+#'
+#' Change the transparency for no-data pixels.
+#' @inheritParams addGIBS
+#' @family GIBS Functions
+#' @inherit leaflet::addWMSTiles return
+#' @export
+setTransparent <- function(map, layers = NULL, transparent = TRUE) {
+ ## Check required args ######################
+ if (is.null(layers))
+ stop("You must define one or multiple `layers`.\n",
+ "See `gibs_layers` for a list of all available layers and their attributes.")
+
+ ## Invoke Leaflet ##########
+ invokeMethod(map, NULL, "setTransparent", layers, transparent)
+}
diff --git a/R/heightgraph.R b/R/heightgraph.R
new file mode 100644
index 00000000..c37bee82
--- /dev/null
+++ b/R/heightgraph.R
@@ -0,0 +1,184 @@
+heightgraphDependency <- function() {
+ list(
+ htmltools::htmlDependency(
+ "lfx-heightgraph", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-heightgraph", package = "leaflet.extras2"),
+ script = c(
+ # "d3.js",
+ "L.Control.Heightgraph.js",
+ "L.Control.Heightgraph-bindings.js"),
+ stylesheet = "L.Control.Heightgraph.css"
+ )
+ )
+}
+
+#' Add a Heightgraph layer
+#'
+#' Visualize height information and road attributes of linestring segments.
+#' The linestrings must be a Simple Feature LINESTRING Z and are transformed to
+#' GeoJSON. The function therefore inherits arguments from
+#' \code{\link[leaflet]{addGeoJSON}}.
+#'
+#' @inheritParams leaflet::addGeoJSON
+#' @param data A Simple Feature LINESTRING with Z dimension.
+#' @param columns A character vector of the columns you want to include in the
+#' heightgraph control
+#' @param pathOpts List of further options for the path. See
+#' \code{\link[leaflet]{pathOptions}}
+#' @param options List of further plugin options. See
+#' \code{\link{heightgraphOptions}}
+#'
+#' @note When used in Shiny, 3 events update a certain Shiny Input:
+#' \enumerate{
+#' \item A click updates \code{input$MAPID_heightgraph_click}
+#' \item A mouseover updates \code{input$MAPID_heightgraph_mouseover}
+#' \item A mouseout updates \code{input$MAPID_heightgraph_mouseout}
+#' }
+#' If you want to explicitly remove the Heightgraph control, please use
+#' \code{\link[leaflet]{removeControl}} with the \code{layerId = "hg_control"}.
+#' @references \url{https://github.com/GIScience/Leaflet.Heightgraph}
+#' @family Heightgraph Functions
+#' @inherit leaflet::addGeoJSON return
+#' @export
+#' @examples \dontrun{
+#' library(leaflet)
+#' library(leaflet.extras2)
+#' library(sf)
+#'
+#' data <- st_cast(st_as_sf(leaflet::atlStorms2005[4,]), "LINESTRING")
+#' data <- st_transform(data, 4326)
+#' data <- data.frame(st_coordinates(data))
+#' data$elev <- runif(nrow(data), 10, 500)
+#' data$L1 <- NULL
+#' L1 <- round(seq.int(1, 4, length.out = nrow(data)))
+#' data <- st_as_sf(st_sfc(lapply(split(data, L1), sfg_linestring)))
+#' data <- st_as_sf(st_sfc(lapply(split(data, L1), function(x) {
+#' st_linestring(as.matrix(x))
+#' })))
+#' data$steepness <- 1:nrow(data)
+#' data$suitability <- nrow(data):1
+#' data$popup <- apply(data, 1, function(x) {
+#' sprintf("Steepness: %s%s and %s ",
+#' Name, label),
+#' popupOptions = popupOptions(offset = c(0, -35)),
+#' options = playbackOptions(radius = 3,
+#' tickLen = 36000,
+#' speed = 50,
+#' maxInterpolationTime = 1000),
+#' pathOpts = pathOptions(weight = 5))
+#'
+#'
+#' ## Multiple Elements
+#' data <- sf::st_as_sf(leaflet::atlStorms2005[1:5,])
+#' data$Name <- as.character(data$Name)
+#' data <- st_cast(data, "POINT")
+#' data$time <- unlist(lapply(rle(data$Name)$lengths, function(x) {
+#' seq.POSIXt(as.POSIXct(Sys.Date()-2), as.POSIXct(Sys.Date()), length.out = x)
+#' }))
+#' data$time <- as.POSIXct(data$time, origin="1970-01-01")
+#' data$label <- paste0("Time: ", data$time)
+#' data$popup = sprintf("Customized Popup Name : %sTime : %s",
+#' data$Name, data$time)
+#' data <- split(data, f = data$Name)
+#'
+#' leaflet() %>%
+#' addTiles() %>%
+#' addPlayback(data = data,
+#' popup = ~popup,
+#' label = ~label,
+#' popupOptions = popupOptions(offset=c(0,-35)),
+#' labelOptions = labelOptions(noHide = TRUE),
+#' options = playbackOptions(radius = 3,
+#' tickLen = 1000000,
+#' speed = 5000,
+#' maxInterpolationTime = 10000,
+#' transitionpopup = FALSE,
+#' transitionlabel = FALSE,
+#' playCommand = "Let's go",
+#' stopCommand = "Stop it!",
+#' color = c("red","green","blue",
+#' "orange","yellow")),
+#' pathOpts = pathOptions(weight = 5))
+#' }
addPlayback <- function(map, data, time = "time", icon = NULL,
- pathOptions = pathOptions(),
- options = playbackOptions()){
+ pathOpts = pathOptions(),
+ popup = NULL,
+ label = NULL,
+ popupOptions = NULL,
+ labelOptions = NULL,
+ options = playbackOptions(),
+ name = NULL){
- ## If data is a `data.frame` / `data.table` or `matrix`
- if (inherits(data, "data.frame") || inherits(data, "matrix")) {
- ## Check if the `time` column exists. It is required!
- if (!any(colnames(data) == time)) stop("No column named `", time, "` in data.")
- ## If the `time` column is present but not numeric, convert it
- if (!is.null(data[,time]) && !is.numeric(data[,time])) {
- data$time <- as.numeric(data[,time][[1]])
- }
- ## If there is no `geometry` column, check if lat/lng are given as columns
- if (!any(colnames(data) %in% c("geom","geometry"))) {
- ## Check if any column has lat/lon values
- latnams <- c("y","lat","latitude")
- lonnams <- c("x","lon","lng","longitude")
- has_lat <- tolower(colnames(data)) %in% latnams
- has_lng <- tolower(colnames(data)) %in% lonnams
- if (any(has_lat) && any(has_lng)) {
- ## If data has lat/lon columns, use `sf` if possible to transform to Simple Feature
- if (requireNamespace("sf", quietly = TRUE)) {
- data <- sf::st_as_sf(data.frame(data), ## Convert to data.frame. Matrix wouldnt work otherwise
- coords = c(colnames(data)[which(has_lng)],
- colnames(data)[which(has_lat)]))
- } else {
- ## If `sf` is not available, build a list which can be read by the plugin
- data <- list(
- coordinates = cbind(data[,colnames(data)[which(has_lng)]],
- data[,colnames(data)[which(has_lat)]]),
- time = data[,time]
- )
- }
- } else {
- ## No lat/lng columns in data. Error
- stop("Cannot read Lat/Lon columns. The column names must match either: \n",
- paste(latnams, collapse = ","), " / ", paste(lonnams, collapse = ","))
- }
- }
+ if (!requireNamespace("sf")) {
+ stop("The package `sf` is needed for this plugin. ",
+ "Please install it with:\ninstall.packages('sf')")
}
- ## If data is a `SpatialPointsDataFrame`
- if (inherits(data, "SpatialPointsDataFrame")) {
- if (requireNamespace("sf", quietly = TRUE)) {
- ## If `sf` is available, use it to transform to Simple Features
- data <- sf::st_as_sf(data)
- } else {
- ## If `sf` is not available, build a list with coordinates and the time column.
- coords <- sp::coordinates(data)
- data <- list(
- coordinates = cbind(coords[,1], coords[,2]),
- time = data[,time]
- )
- }
- }
-
- ## If data is a `character`
- if (inherits(data, "character")) {
- ## Since `basename` does not work, when the string is too long, we count
- ## the number of characters first. 300 is chosen randomly, but I doubt that
- ## file paths would be that long. If it's longer, we assume that its a JSON string already
- if (nchar(data) < 300) {
- ## Check if it's a path or URL to a json file
- fileext <- gsub(".*\\.", "", basename(data))
- if (fileext == "json" || fileext == "geojson") {
- data <- jsonlite::read_json(data)
- }
- }
- ## Otherwise just pass the string (do nothing)
+ if (inherits(data, "list")) {
+ data <- lapply(data, function(x) {
+ to_jsonformat(x, time, popup, label, name)
+ })
+ bounds <- do.call(rbind, lapply(data, function(x) x$geometry$coordinates))
+ } else {
+ data <- to_jsonformat(data, time, popup, label, name)
+ bounds <- data$geometry$coordinates
}
map$dependencies <- c(map$dependencies, playbackDependencies())
- options = leaflet::filterNULL(c(icon = list(icon),
- pathOptions = list(pathOptions),
+ options <- leaflet::filterNULL(c(icon = list(icon),
+ pathOptions = list(pathOpts),
+ popupOptions = list(popupOptions),
+ labelOptions = list(labelOptions),
+ popups = if(is.null(popup)) NULL else TRUE,
+ labels = if(is.null(label)) NULL else TRUE,
options))
- invokeMethod(map, NULL, "addPlayback", data, options)
+ invokeMethod(map, NULL, "addPlayback", data, options) %>%
+ expandLimits(lat = as.numeric(bounds[,"Y"]),
+ lng = as.numeric(bounds[,"X"]))
}
#' playbackOptions
#'
+#' A list of options for \code{\link{addPlayback}}. For a full list please visit
+#' the \href{https://github.com/hallahan/LeafletPlayback}{plugin repository}.
+#' @param color colors of the CircleMarkers.
#' @param radius a numeric value for the radius of the CircleMarkers.
-#' @param tickLen Set tick length in miliseconds. Increasing this value, may
+#' @param tickLen Set tick length in milliseconds. Increasing this value, may
#' improve performance, at the cost of animation smoothness. Default is 250
-#' @param speed Set float multiplier for default animation speed. Default is 1
-#' @param maxInterpolationTime Set max interpolation time in seconds.
+#' @param speed Set float multiplier for default animation speed. Default is 50
+#' @param maxInterpolationTime Set max interpolation time in milliseconds.
#' Default is 5*60*1000 (5 minutes).
#' @param tracksLayer Set \code{TRUE} if you want to show layer control on the
#' map. Default is \code{TRUE}
@@ -140,25 +152,36 @@ addPlayback <- function(map, data, time = "time", icon = NULL,
#' Default is \code{TRUE}
#' @param sliderControl Set \code{TRUE} if slider control is needed.
#' Default is \code{TRUE}
+#' @param orientIcons Set \code{TRUE} if you want icons to orient themselves on each
+#' tick based on the bearing towards their next location. Default: \code{FALSE}
#' @param staleTime Set time before a track is considered stale and faded out.
#' Default is 60*60*1000 (1 hour)
+#' @param transitionpopup Should the position of the popup move smoothly,
+#' like the marker icon? Default: \code{TRUE}
+#' @param transitionlabel Should the position of the label move smoothly,
+#' like the marker icon? Default: \code{TRUE}
#' @param ... Further arguments passed to `L.Playback`
-#' @description Add extra options to \code{\link{addPlayback}}. For a full list
-#' please visit the \href{https://github.com/hallahan/LeafletPlayback}{plugin repository}
+#' @family Playback Functions
+#' @return A list of options for \code{addPlayback}
+#' @references \url{https://github.com/hallahan/LeafletPlayback}
#' @export
-#' @family Playback Plugin
playbackOptions = function(
+ color = "blue",
radius = 5,
tickLen = 250,
- speed = 1,
+ speed = 50,
maxInterpolationTime = 5*60*1000,
tracksLayer = TRUE,
playControl = TRUE,
dateControl = TRUE,
sliderControl = TRUE,
+ orientIcons = FALSE,
staleTime = 60*60*1000,
+ transitionpopup = TRUE,
+ transitionlabel = TRUE,
...) {
leaflet::filterNULL(list(
+ color = color,
radius = radius,
tickLen = tickLen,
speed = speed,
@@ -167,16 +190,79 @@ playbackOptions = function(
playControl = playControl,
dateControl = dateControl,
sliderControl = sliderControl,
+ orientIcons = orientIcons,
staleTime = staleTime,
+ transitionpopup = transitionpopup,
+ transitionlabel = transitionlabel,
...
))
}
#' removePlayback
-#' @param map the map widget.
-#' @description Remove the reachability controls
+#'
+#' Remove the Playback controls and markers.
+#' @param map the map widget
#' @export
-#' @family Playback Plugin
+#' @inherit leaflet::addMarkers return
+#' @family Playback Functions
removePlayback <- function(map){
invokeMethod(map, NULL, "removePlayback")
}
+
+
+
+
+#' to_jsonformat
+#' Transform object to JSON expected format
+#' @param data The data
+#' @param time Name of the time column.
+#' @param popup Name of the popup column.
+#' @param label Name of the label column.
+#' @param name Name of the name column.
+#' @return A list that is transformed to the expected JSON format
+to_jsonformat <- function(data, time, popup=NULL, label=NULL, name=NULL) {
+ if (inherits(data, "Spatial")) data <- sf::st_as_sf(data)
+ if (inherits(data, "sf")) {
+ stopifnot(inherits(sf::st_geometry(data), c("sfc_POINT")))
+ data <- to_ms(data, time)
+ dataorig <- data
+ data <- list("type"="Feature",
+ "name"=evalFormula(name, dataorig)[1],
+ "geometry"=list(
+ "type"="MultiPoint",
+ "coordinates"=sf::st_coordinates(data)
+ ),
+ "properties"=list(
+ "time"=data$time
+ ))
+
+ if (!is.null(popup)) {
+ data <- c(data, list("popupContent" = evalFormula(popup, dataorig)))
+ }
+ if (!is.null(label)) {
+ data <- c(data, list("tooltipContent" = evalFormula(label, dataorig)))
+ }
+ }
+ data
+}
+
+#' to_ms
+#' Change POSIX or Date to milliseconds
+#' @inheritParams to_jsonformat
+#' @return A data.frame with the time column in milliseconds
+to_ms <- function(data, time) {
+ coln <- colnames(data)
+ if (!any(coln == time)) {
+ stop("No column named `", time, "` found.")
+ }
+ if (time != "time") {
+ colnames(data)[coln == time] <- "time"
+ }
+ stopifnot(inherits(data[["time"]], c("POSIXt", "Date", "numeric")))
+ if (inherits(data[["time"]], "POSIXt")) {
+ data[["time"]] <- as.numeric(data[["time"]]) * 1000
+ } else if (inherits(data[["time"]], "Date")) {
+ data[["time"]] <- as.numeric(data[["time"]]) * 86400000
+ }
+ data
+}
diff --git a/R/reachability.R b/R/reachability.R
index f9493246..654016d7 100644
--- a/R/reachability.R
+++ b/R/reachability.R
@@ -1,10 +1,10 @@
reachabilityDependencies <- function() {
list(
htmlDependency(
- "leaflet.reachability", "1.0.0",
+ "lfx-reachability", "1.0.0",
src = system.file("htmlwidgets/lfx-reachability", package = "leaflet.extras2"),
script = c("leaflet.reachability.js",
- "leaflet.reachability.bindings.js"),
+ "leaflet.reachability-bindings.js"),
stylesheet = "leaflet.reachability.css"
)
)
@@ -12,37 +12,64 @@ reachabilityDependencies <- function() {
#' Add Isochrones to Leaflet
#'
+#' A leaflet plugin which shows areas of reachability based on time or distance
+#' for different modes of travel using the openrouteservice isochrones API.
+#' Based on the
+#' \href{https://github.com/traffordDataLab/leaflet.reachability}{leaflet.reachability
+#' plugin}
#' @param map a map widget
-#' @param apiKey a valid Openrouteservice API-key. Can be obtained from
+#' @param apikey a valid Openrouteservice API-key. Can be obtained from
#' \href{https://openrouteservice.org/dev/#/signup}{Openrouteservice}
-#' @param options see \code{\link{reachabilityOptions}}
-#' @description Add Leaflet Reachability Plugin Control. Based on the
-#' \href{https://github.com/traffordDataLab/leaflet.reachability}{leaflet.reachability plugin}
+#' @param options A list of further options. See \code{\link{reachabilityOptions}}
+#' @note When used in Shiny, 3 events update a certain shiny Input:
+#' \enumerate{
+#' \item reachability:displayed updates \code{input$MAPID_reachability_displayed}
+#' \item reachability:delete updates \code{input$MAPID_reachability_delete}
+#' \item reachability:error updates \code{input$MAPID_reachability_error}
+#' }
+#' @family Reachability Functions
+#' @references \url{https://github.com/traffordDataLab/leaflet.reachability}
+#' @inherit leaflet::addControl return
#' @export
-#' @seealso https://github.com/traffordDataLab/leaflet.reachability
-#' @family Reachability Plugin
-addReachability <- function(map, apiKey = NULL,
+#' @examples \dontrun{
+#' library(leaflet)
+#' library(leaflet.extras2)
+#'
+#' Sys.setenv("OPRS" = 'Your_API_Key')
+#'
+#' leaflet() %>%
+#' addTiles() %>%
+#' setView(8, 50, 10) %>%
+#' addReachability()
+#' }
+addReachability <- function(map, apikey = NULL,
options = reachabilityOptions()){
-
+ if (is.null(apikey)) {
+ apikey <- Sys.getenv("OPRS")
+ if (apikey == "") {
+ stop("You must either pass an Openrouteservice-`apikey` directly or save it as ",
+ "system variable under `OPRS`.")
+ }
+ }
map$dependencies <- c(map$dependencies, reachabilityDependencies())
- if (is.null(apiKey)) stop("You must provide an API Key")
- options = leaflet::filterNULL(c(apiKey = apiKey, options))
-
+ options = leaflet::filterNULL(c(apiKey = apikey, options))
invokeMethod(map, NULL, "addReachability", options)
}
#' reachabilityOptions
#'
+#' Add extra options. For a full list please visit the
+#' \href{https://github.com/traffordDataLab/leaflet.reachability}{plugin repository}.
#' @param collapsed Should the control widget start in a collapsed mode.
#' Default is \code{TRUE}
#' @param pane Leaflet pane to add the isolines GeoJSON to.
#' Default is \code{overlayPane}
#' @param position Leaflet control pane position. Default is \code{topleft}
#' @param ... Further arguments passed to `L.Control.Reachability`
-#' @description Add extra options. For a full list please visit the
-#' \href{https://github.com/traffordDataLab/leaflet.reachability}{plugin repository}
+#' @family Reachability Functions
+#' @references \url{https://github.com/traffordDataLab/leaflet.reachability}
+#' @return A list of options for \code{addReachability}
#' @export
-#' @family Reachability Plugin
reachabilityOptions = function(collapsed = TRUE,
pane = "overlayPane",
position = "topleft",
@@ -56,10 +83,12 @@ reachabilityOptions = function(collapsed = TRUE,
}
#' removeReachability
+#'
+#' Remove the reachability controls.
#' @param map the map widget.
-#' @description Remove the reachability controls
+#' @inherit leaflet::addControl return
#' @export
-#' @family Reachability Plugin
+#' @family Reachability Functions
removeReachability <- function(map){
invokeMethod(map, NULL, "removeReachability")
}
diff --git a/R/sidebar.R b/R/sidebar.R
index 6bd8a40e..9ca69444 100644
--- a/R/sidebar.R
+++ b/R/sidebar.R
@@ -1,97 +1,136 @@
sidebar_deps <- function(mini = FALSE) {
list(
htmlDependency(
- "sidebar", "1.0.0",
+ "lfx-sidebar", "1.0.0",
src = system.file("htmlwidgets/lfx-sidebar", package = "leaflet.extras2"),
script = c("leaflet-sidebar.js",
- "leaflet.sidebar.binding.js"),
+ "leaflet-sidebar-binding.js"),
stylesheet = "leaflet-sidebar.css"
)
)
}
-
-#' Adds a Sidebar Leaflet Control
+#' Add a Sidebar Leaflet Control
+#'
+#' The sidebar HTML must be created with \code{\link{sidebar_tabs}} and
+#' \code{\link{sidebar_pane}} before
+#' \code{\link[leaflet]{leafletOutput}} is called.
+#'
#' @param map A leaflet map widget
-#' @param id Id of the sidebar-div
-#' @param options A named list with \code{position} and \code{fit} elements.
-#' @seealso https://github.com/Turbo87/sidebar-v2
-#' @family Sidebar Plugin
+#' @param id Id of the sidebar-div. Must match with the \code{id} of
+#' \code{\link{sidebar_tabs}}
+#' @param options A named list with the only option \code{position}, which should
+#' be either \code{left} or \code{right}.
+#' @param ns The namespace function, if used in Shiny modules.
+#' @family Sidebar Functions
+#' @references \url{https://github.com/Turbo87/sidebar-v2}
#' @export
+#' @inherit leaflet::addControl return
+#' @inherit sidebar_tabs examples
addSidebar <- function(map, id = "sidebar",
- options = list(position = "left",
- fit = TRUE)) {
-
+ options = list(position = "left"),
+ ns = NULL) {
map$dependencies <- c(map$dependencies, sidebar_deps())
+ options$fit = TRUE
+ if (!is.null(ns)) id <- ns(id)
invokeMethod(map, NULL, "addSidebar", id, options)
}
#' Remove the Sidebar
#' @param map A leaflet map widget
-#' @family Sidebar Plugin
+#' @param sidebar_id The id of the sidebar (per \code{\link{sidebar_tabs}}).
+#' Defaults to \code{NULL} such that the first sidebar is removed.
+#' @family Sidebar Functions
+#' @inherit leaflet::addControl return
#' @export
-removeSidebar <- function(map) {
- invokeMethod(map, NULL, "removeSidebar")
+removeSidebar <- function(map, sidebar_id = NULL) {
+ invokeMethod(map, NULL, "removeSidebar", sidebar_id)
}
#' Close the Sidebar
#' @param map A leaflet map widget
-#' @family Sidebar Plugin
+#' @param sidebar_id The id of the sidebar (per \code{\link{sidebar_tabs}}).
+#' Defaults to \code{NULL} such that the first sidebar is used.
+#' @family Sidebar Functions
+#' @inherit leaflet::addControl return
#' @export
-closeSidebar <- function(map) {
- invokeMethod(map, NULL, "closeSidebar")
+closeSidebar <- function(map, sidebar_id = NULL) {
+ invokeMethod(map, NULL, "closeSidebar", sidebar_id)
}
-#' Open the Sidebar
-#' @param map A leaflet map widget
+#' Open the Sidebar by ID
#' @param id The id of the \code{\link{sidebar_pane}} to open.
-#' @family Sidebar Plugin
+#' @family Sidebar Functions
+#' @param ns The namespace function, if used in Shiny modules.
+#' @inheritParams closeSidebar
+#' @inherit leaflet::addControl return
#' @export
-openSidebar <- function(map, id) {
- invokeMethod(map, NULL, "openSidebar", id)
+openSidebar <- function(map, id, sidebar_id = NULL, ns = NULL) {
+ if (!is.null(ns)) id <- ns(id)
+ invokeMethod(map, NULL, "openSidebar", list(id = id, sidebar_id = sidebar_id))
}
-
-#' Create a Sidebar Panel
+#' Create a Sidebar Pane
#' @param title A title for the sidebar panel
#' @param id An id for the sidebar panel
-#' @param icon An icon for the sidebar panel.
+#' @param icon An icon for the sidebar panel
#' @param ... List of elements to include in the panel
-#' @family Sidebar Plugin
+#' @family Sidebar Functions
+#' @references \url{https://github.com/Turbo87/sidebar-v2},
+#' \url{https://github.com/Turbo87/sidebar-v2/blob/master/doc/usage.md}
+#' @return A \code{shiny.tag} with sidebar-specific HTML classes
#' @export
+#' @examples \dontrun{
+#' library(shiny)
+#' sidebar_pane(id = "id", icon = icon("cars"), tags$div())
+#' }
sidebar_pane <- function(title = "Sidebar Title",
id = NULL,
icon = icon("caret-right"), ...) {
if (is.null(id))
stop("The sidebar pane needs an `id`.")
- tags$div(class = "sidebar-pane", id = id,
- tags$h3(class = "sidebar-header", title,
- tags$span(class = "sidebar-close", icon)),
+ tags$div(class = "leafsidebar-pane", id = id,
+ tags$h3(class = "leafsidebar-header", title,
+ tags$span(class = "leafsidebar-close", icon)),
...)
}
-
#' Create a Sidebar
+#' @param id The id of the sidebar, which must match the \code{id} of
+#' \code{\link{addSidebar}}. Default is \code{"sidebar"}
#' @param iconList A list of icons to be shown, when the sidebar is collapsed.
#' The list is required and must match the amount of \code{\link{sidebar_pane}}.
-#' @param ... The individual \code{\link{sidebar_pane}}.
-#' @family Sidebar Plugin
+#' @param ... The individual \code{\link{sidebar_pane}}'s.
+#' @family Sidebar Functions
+#' @references \url{https://github.com/Turbo87/sidebar-v2},
+#' \url{https://github.com/Turbo87/sidebar-v2/blob/master/doc/usage.md}
+#' @return A \code{shiny.tag} with individual sidebar panes
#' @export
-sidebar_tabs <- function(iconList = NULL, ...){
+#' @examples \dontrun{
+#' library(shiny)
+#'
+#' # run example app showing a single sidebar
+#' runApp(paste0(system.file("examples", package = "leaflet.extras2"),
+#' "/sidebar_app.R"))
+#'
+#' # run example app showing two sidebars
+#' runApp(paste0(system.file("examples", package = "leaflet.extras2"),
+#' "/multi_sidebar_app.R"))
+#' }
+sidebar_tabs <- function(id = "sidebar", iconList = NULL, ...){
arg <- list(...)
ids <- lapply(arg, function(x) tagGetAttribute(x, "id"))
if (length(ids) != length(iconList))
stop("The number of icons needs to match the number of sidebar panes.")
- tags$div(id = "sidebar", class = "sidebar collapsed",
- tags$div(class = "sidebar-tabs",
+ tags$div(id = id, class = "leafsidebar collapsed",
+ tags$div(class = "leafsidebar-tabs", style = "display: none",
tags$ul(role = "tablist",
tagList(lapply(1:length(ids), function(x) {
tags$li(tags$a(href = paste0("#", ids[[x]]), role = "tab", iconList[[x]]))
}))
)
),
- tags$div(class = "sidebar-content",
+ tags$div(class = "leafsidebar-content", style = "display: none",
tagList(arg))
)
}
-
diff --git a/R/sidebyside.R b/R/sidebyside.R
index a434b3c6..66bce555 100644
--- a/R/sidebyside.R
+++ b/R/sidebyside.R
@@ -1,16 +1,18 @@
sidebysideDependencies <- function() {
list(
htmlDependency(
- "leaflet.sidebyside", "1.0.0",
+ "lfx-sidebyside", "1.0.0",
src = system.file("htmlwidgets/lfx-side-by-side", package = "leaflet.extras2"),
script = c("lfx-side-by-side.js",
- "lfx.addSidebyside.bindings.js")
+ "lfx-side-by-side-bindings.js")
)
)
}
#' Add Side by Side View
#'
+#' A Leaflet control to add a split screen to compare two map overlays.
+#' The plugin works with Panes, see the example.
#' @param map a map widget
#' @param layerId the layer id, needed for \code{\link{removeSidebyside}}
#' @param leftId the \code{layerId} of the Tile layer that should be
@@ -19,51 +21,32 @@ sidebysideDependencies <- function() {
#' visible on the \strong{right} side
#' @param options A list of options. Currently only \code{thumbSize} and
#' \code{padding} can be changed.
-#' @description Add Leaflet Sidebyside View. Based on the plugin
-#' \href{https://github.com/digidem/leaflet-side-by-side}{leaflet-side-by-side}.
-#' The plugin works with Panes, see the example.
-#' @note It is currently not working correctly if the \code{baseGroups} are defined in
-#' \code{\link[leaflet]{addLayersControl}}.
+#' @note It is currently not working correctly if the \code{baseGroups} are
+#' defined in \code{\link[leaflet]{addLayersControl}}.
+#' @family Sidebyside Functions
+#' @references \url{https://github.com/digidem/leaflet-side-by-side}
+#' @inherit leaflet::addControl return
#' @export
-#' @family Sidebyside Plugin
-#' @seealso https://github.com/digidem/leaflet-side-by-side
-#' @examples \dontrun{
-#' library(shiny)
+#' @examples
#' library(leaflet)
#' library(leaflet.extras2)
#'
-#' ui <- fluidPage(
-#' leafletOutput("map"),
-#' actionButton("removeSidebyside", "removeSidebyside")
-#' )
-#'
-#' server <- function(input, output, session) {
-#' output$map <- renderLeaflet({
-#' leaflet(quakes) %>%
-#' addMapPane("left", zIndex = 0) %>%
-#' addMapPane("right", zIndex = 0) %>%
-#' addTiles(group = "base", layerId = "baseid",
-#' options = pathOptions(pane = "right")) %>%
-#' addProviderTiles(providers$CartoDB.DarkMatter, group="carto", layerId = "cartoid",
-#' options = pathOptions(pane = "left")) %>%
-#' addCircleMarkers(data = breweries91[1:15,], color = "blue", group = "blue",
-#' options = pathOptions(pane = "left")) %>%
-#' addCircleMarkers(data = breweries91[15:20,], color = "yellow", group = "yellow") %>%
-#' addCircleMarkers(data = breweries91[15:30,], color = "red", group = "red",
-#' options = pathOptions(pane = "right")) %>%
-#' addLayersControl(overlayGroups = c("blue","red", "yellow")) %>%
-#' addSidebyside(layerId = "sidecontrols",
-#' rightId = "baseid",
-#' leftId = "opencycle")
-#' })
-#' observeEvent(input$removeSidebyside, {
-#' leafletProxy("map") %>%
-#' removeSidebyside("sidecontrols")
-#' })
-#' }
-#'
-#' shinyApp(ui, server)
-#' }
+#' leaflet(quakes) %>%
+#' addMapPane("left", zIndex = 0) %>%
+#' addMapPane("right", zIndex = 0) %>%
+#' addTiles(group = "base", layerId = "baseid",
+#' options = pathOptions(pane = "right")) %>%
+#' addProviderTiles(providers$CartoDB.DarkMatter, group="carto", layerId = "cartoid",
+#' options = pathOptions(pane = "left")) %>%
+#' addCircleMarkers(data = breweries91[1:15,], color = "blue", group = "blue",
+#' options = pathOptions(pane = "left")) %>%
+#' addCircleMarkers(data = breweries91[15:20,], color = "yellow", group = "yellow") %>%
+#' addCircleMarkers(data = breweries91[15:30,], color = "red", group = "red",
+#' options = pathOptions(pane = "right")) %>%
+#' addLayersControl(overlayGroups = c("blue","red", "yellow")) %>%
+#' addSidebyside(layerId = "sidecontrols",
+#' rightId = "baseid",
+#' leftId = "cartoid")
addSidebyside <- function(map, layerId = NULL,
leftId = NULL, rightId = NULL,
options = list(thumbSize = 42,
@@ -80,7 +63,8 @@ addSidebyside <- function(map, layerId = NULL,
#' @export
#' @param map a map widget
#' @param layerId the layer id of the \code{\link{addSidebyside}} layer
-#' @family Sidebyside Plugin
+#' @inherit leaflet::addControl return
+#' @family Sidebyside Functions
removeSidebyside <- function(map, layerId = NULL){
invokeMethod(map, NULL, "removeSidebyside", layerId)
}
diff --git a/R/spin.R b/R/spin.R
new file mode 100644
index 00000000..e352e835
--- /dev/null
+++ b/R/spin.R
@@ -0,0 +1,57 @@
+spinDependency <- function() {
+ list(
+ htmltools::htmlDependency(
+ "lfx-spin", version = "1.0.0",
+ src = system.file("htmlwidgets/lfx-spin", package = "leaflet.extras2"),
+ script = c("spin.min.js",
+ "leaflet.spin.min.js",
+ "leaflet.spin-binding.js"),
+ # stylesheet = c("spin.css"),
+ all_files = TRUE
+ )
+ )
+}
+
+#' Add Spin Plugin
+#'
+#' Adds an animated loading spinning over the map.
+#' @param map A map widget object created from \code{\link[leaflet]{leaflet}}
+#'
+#' @param options Spin.js options. Named list. See \url{http://spin.js.org}
+#'
+#' @return A leaflet map object
+#' @export
+#'
+#' @references \url{https://github.com/makinacorpus/Leaflet.Spin}
+#' @references \url{https://github.com/fgnass/spin.js}
+#'
+#' @name addSpinner
+#'
+#' @examples
+#' library(leaflet)
+#' library(leaflet.extras2)
+#'
+#' leaflet(data = quakes) %>%
+#' addTiles() %>%
+#' addSpinner() %>%
+#' startSpinner(options = list("lines" = 7, "length" = 20)) %>%
+#' addMarkers(~long, ~lat, popup = ~as.character(mag), label = ~as.character(mag)) %>%
+#' stopSpinner()
+addSpinner <- function(map) {
+ map$dependencies <- c(map$dependencies, spinDependency())
+ map
+}
+
+#' @export
+#'
+#' @rdname addSpinner
+startSpinner <- function(map, options = NULL) {
+ invokeMethod(map, NULL, 'spinner', TRUE, options)
+}
+
+#' @export
+#'
+#' @rdname addSpinner
+stopSpinner <- function(map) {
+ invokeMethod(map, NULL, 'spinner', FALSE)
+}
diff --git a/R/tangram.R b/R/tangram.R
index d679e5e7..3127a349 100644
--- a/R/tangram.R
+++ b/R/tangram.R
@@ -1,44 +1,41 @@
-tangram_deps <- function(mini = FALSE) {
+tangram_deps <- function() {
list(
htmlDependency(
- "tangram", "1.0.0",
+ "lfx-tangram", "1.0.0",
src = system.file("htmlwidgets/lfx-tangram", package = "leaflet.extras2"),
- script = c(ifelse(mini, "tangram.min.js", "tangram.js"),
+ script = c("tangram.min.js",
"leaflet.tangram.binding.js"))
)
}
-
#' Adds a Tangram layer to a Leaflet map in a Shiny App.
#'
-#' @param map A leaflet map widget
-#' @param scene Path to a required \bold{.yaml} or \bold{.zip} file. The file must be in the
-#' /www folder of a shinyApp. See the
-#' \href{https://github.com/tangrams/tangram}{Tangram repo} or the
-#' \href{https://tangrams.readthedocs.io/en/latest/}{Tangram docs} for further information
-#' on how to edit such a .yaml file.
-#' @param layerId A layer ID
-#' @param group The name of the group the newly created layer should belong to
-#' (for \code{\link{clearGroup}} and \code{\link{addLayersControl}} purposes).
-#' @param options A list of further options. See the app in the \code{examples/tangram} folder
-#' or the \href{https://tangrams.readthedocs.io/en/latest/Overviews/Tangram-Overview/#leaflet}{docs}
-#' for further information.
+#' @param scene Path to a required \bold{.yaml} or \bold{.zip} file. If the file
+#' is within the \code{/www} folder of a Shiny-App, only the filename must be
+#' given, otherwise the full path is needed. See the
+#' \href{https://github.com/tangrams/tangram}{Tangram repository} or the
+#' \href{https://tangrams.readthedocs.io/en/latest/}{Tangram docs} for further
+#' information on how to edit such a .yaml file.
+#' @param options A list of further options. See the app in the
+#' \code{examples/tangram} folder or the
+#' \href{https://tangrams.readthedocs.io/en/latest/Overviews/Tangram-Overview/#leaflet}{docs}
+#' for further information.
+#' @note Only works correctly in a Shiny-App environment.
+#' @references \url{https://github.com/tangrams/tangram}
+#' @family Tangram Functions
+#' @inheritParams leaflet::addPolygons
+#' @inherit leaflet::addWMSTiles return
#' @export
-#' @seealso https://github.com/tangrams/tangram
-#' @family Tangram Plugin
#' @examples \dontrun{
#' library(shiny)
#' library(leaflet)
#' library(leaflet.extras2)
#'
-#' ## In the /www folder of the ShinyApp. Must contain the Nextzen API-key
+#' ## In the /www folder of a ShinyApp. Must contain the Nextzen API-key
#' scene <- "scene.yaml"
#'
#' ui <- fluidPage(leafletOutput("map"))
#'
-#' ## The JS-source can be loaded in an unminified version with the options command below.
-#' # options("leaflet.extras2.minified" = FALSE)
-#'
#' server <- function(input, output, session) {
#' output$map <- renderLeaflet({
#' leaflet() %>%
@@ -56,23 +53,23 @@ tangram_deps <- function(mini = FALSE) {
addTangram <- function(map, scene = NULL, layerId = NULL, group = NULL,
options = NULL) {
- mini <- getOption("leaflet.extras2.minified", default = TRUE)
- map$dependencies <- c(map$dependencies, tangram_deps(mini))
-
if ((is.null(scene) || !is.character(scene) || (!gsub(".*\\.", "", scene) %in% c("yaml", "zip")))) {
stop("The scene must point to a valid .yaml or .zip file.\n",
"See the documentation for further information.")
}
- if (!requireNamespace("shiny")) {
- stop("Package `shiny` must be loaded for Tangram")
- }
- shiny::addResourcePath("tangram", paste0(getwd(), "/www"))
- scene <- basename(scene)
- options <- leaflet::filterNULL(c(scene = scene,
- options))
+ tngrscene <- list(
+ htmltools::htmlDependency(
+ name = "tangram_scene",
+ version = 1,
+ src = dirname(scene),
+ attachment = basename(scene)
+ ))
- invokeMethod(map, getMapData(map), "addTangram",
+ map$dependencies <- c(map$dependencies, tngrscene, tangram_deps())
+
+ options <- leaflet::filterNULL(c(list(scene = basename(scene)), options))
+
+ invokeMethod(map, NULL, "addTangram",
layerId, group, options)
}
-
diff --git a/R/timeslider.R b/R/timeslider.R
new file mode 100644
index 00000000..52373c47
--- /dev/null
+++ b/R/timeslider.R
@@ -0,0 +1,181 @@
+timesliderDependencies <- function() {
+ list(
+ htmlDependency(
+ "lfx-timeslider", "1.0.0",
+ src = system.file("htmlwidgets/lfx-timeslider", package = "leaflet.extras2"),
+ stylesheet = "jquery-ui.css",
+ script = c(
+ "jquery-ui.min.js",
+ "leaflet.SliderControl.min.js",
+ "leaflet.SliderControl-bindings.js")
+ )
+ )
+}
+
+#' Add Time Slider to Leaflet
+#'
+#' The \href{https://github.com/dwilhelm89/LeafletSlider}{LeafletSlider plugin}
+#' enables you to dynamically add and remove Markers/Lines on a map by using a
+#' JQuery UI slider.
+#' @param map a map widget
+#' @param data data must be a Simple Feature collection of type POINT or LINESTRING
+#' with a column of class Date or POSIXct.
+#' @param ordertime boolean value indicating whether to order the data by the
+#' time column. The slider will adopt the order of the timestamps.
+#' The default is \code{TRUE}.
+#' @param options List of additional options. See \code{\link{timesliderOptions}}
+#' @family Timeslider Functions
+#' @references \url{https://github.com/dwilhelm89/LeafletSlider}
+#' @export
+#' @inheritParams leaflet::addCircleMarkers
+#' @inherit leaflet::addMarkers return
+#' @examples \dontrun{
+#' library(leaflet)
+#' library(leaflet.extras2)
+#' library(sf)
+#' library(geojsonsf)
+#'
+#' data <- sf::st_as_sf(leaflet::atlStorms2005[1,])
+#' data <- st_cast(data, "POINT")
+#' data$time = as.POSIXct(
+#' seq.POSIXt(Sys.time() - 1000, Sys.time(), length.out = nrow(data)))
+#'
+#' leaflet() %>%
+#' addTiles() %>%
+#' addTimeslider(data = data,
+#' options = timesliderOptions(
+#' position = "topright",
+#' timeAttribute = "time",
+#' range = TRUE)) %>%
+#' setView(-72, 22, 4)
+#' }
+addTimeslider <- function(map, data, radius = 10,
+ stroke = TRUE, color = "#03F",
+ weight = 5, opacity = 0.5, fill = TRUE, fillColor = color,
+ fillOpacity = 0.2, dashArray = NULL,
+ popup = NULL, popupOptions = NULL,
+ label = NULL, labelOptions = NULL,
+ ordertime = TRUE,
+ options = timesliderOptions()){
+
+ ## Style Options
+ data$radius = leaflet::evalFormula(radius, data)
+ data$stroke = leaflet::evalFormula(stroke, data)
+ data$color = leaflet::evalFormula(color, data)
+ data$weight = leaflet::evalFormula(weight, data)
+ data$fillColor = leaflet::evalFormula(fillColor, data)
+ data$opacity = leaflet::evalFormula(opacity, data)
+ data$fill = leaflet::evalFormula(fill, data)
+ data$dashArray = leaflet::evalFormula(dashArray, data)
+ data$fillOpacity = leaflet::evalFormula(fillOpacity, data)
+
+ ## Order by time
+ if (ordertime) {
+ data <- data[order(data[[options$timeAttribute]]),]
+ }
+
+ ## Popup
+ if (!is.null(popup) && !isFALSE(popup)) {
+ data$popup = leaflet::evalFormula(popup, data)
+ }
+
+ ## Label
+ if (!is.null(label) && !isFALSE(label)) {
+ data$label = leaflet::evalFormula(label, data)
+ }
+
+ ## BBOX
+ if (!requireNamespace("sf")) {
+ stop("The package `sf` is needed for this plugin. ",
+ "Please install it with:\ninstall.packages('sf')")
+ }
+ bbox <- sf::st_bbox(data)
+
+ ## Make GeoJSON
+ if (!requireNamespace("geojsonsf")) {
+ stop("The package `geojsonsf` is needed for this plugin. ",
+ "Please install it with:\ninstall.packages('geojsonsf')")
+ }
+ data <- geojsonsf::sf_geojson(data)
+
+ ## Add Deps and invoke Leaflet
+ map$dependencies <- c(map$dependencies, timesliderDependencies())
+ invokeMethod(map, NULL, "addTimeslider", data, options, popupOptions, labelOptions) %>%
+ expandLimits(bbox[c(2,4)], bbox[c(1,3)])
+}
+
+#' timesliderOptions
+#'
+#' A list of options for \code{\link{addTimeslider}}.
+#' @param position position of control: "topleft", "topright", "bottomleft", or
+#' "bottomright". Default is \code{topright}.
+#' @param timeAttribute The column name of the time property.
+#' Default is \code{"time"}
+#' @param isEpoch whether the time attribute is seconds elapsed from epoch.
+#' Default is \code{FALSE}
+#' @param startTimeIdx where to start looking for a timestring
+#' Default is \code{0}
+#' @param timeStrLength the size of \code{yyyy-mm-dd hh:mm:ss} - if milliseconds are
+#' present this will be larger. Default is \code{19}
+#' @param maxValue Set the maximum value of the slider. Default is \code{-1}
+#' @param minValue Set the minimum value of the slider. Default is \code{0}
+#' @param showAllOnStart Specify whether all markers should be initially visible.
+#' Default is \code{FALSE}
+#' @param range To use a range-slider, set to \code{TRUE.} Default is \code{FALSE}
+#' Default is \code{FALSE}
+#' @param follow To display only the markers at the specific timestamp specified
+#' by the slider. Specify a value of 1 (or true) to display only a single data
+#' point at a time, and a value of null (or false) to display the current marker
+#' and all previous markers. The range property overrides the follow property.
+#' Default is \code{FALSE}
+#' @param alwaysShowDate Should the Date always be visible. Default is \code{FALSE}
+#' @param rezoom Use the rezoom property to ensure the markers being displayed
+#' remain in view. Default is \code{NULL}
+#' @param sameDate Show only data with the current selected time.
+#' Default is \code{FALSE}
+#' @family Timeslider Functions
+#' @return A list of options for \code{addTimeslider}
+#' @references \url{https://github.com/dwilhelm89/LeafletSlider}
+#' @export
+timesliderOptions = function(
+ position = c("topright", "bottomleft", "bottomright", "topleft"),
+ timeAttribute = "time",
+ isEpoch = FALSE,
+ startTimeIdx = 0,
+ timeStrLength = 19,
+ maxValue = -1,
+ minValue = 0,
+ showAllOnStart = FALSE,
+ range = FALSE,
+ follow = FALSE,
+ alwaysShowDate = FALSE,
+ rezoom = NULL,
+ sameDate = FALSE) {
+
+ leaflet::filterNULL(list(
+ position = match.arg(position),
+ timeAttribute = timeAttribute,
+ isEpoch = isEpoch,
+ startTimeIdx = startTimeIdx,
+ timeStrLength = timeStrLength,
+ maxValue = maxValue,
+ minValue = minValue,
+ showAllOnStart = showAllOnStart,
+ range = range,
+ follow = follow,
+ alwaysShowDate = alwaysShowDate,
+ rezoom = rezoom,
+ sameDate = sameDate
+ ))
+}
+
+#' removeTimeslider
+#'
+#' Remove the Timeslider controls and markers.
+#' @param map the map widget
+#' @export
+#' @inherit leaflet::addMarkers return
+#' @family Timeslider Functions
+removeTimeslider <- function(map){
+ invokeMethod(map, NULL, "removeTimeslider")
+}
diff --git a/R/velocity.R b/R/velocity.R
index 3a79b3e8..a99e6142 100644
--- a/R/velocity.R
+++ b/R/velocity.R
@@ -1,7 +1,7 @@
velocityDependencies <- function() {
list(
htmlDependency(
- "leaflet.velocity", "1.0.0",
+ "lfx-velocity", "1.0.0",
src = system.file("htmlwidgets/lfx-velocity", package = "leaflet.extras2"),
script = c("leaflet-velocity.js",
"leaflet-velocity-bindings.js"),
@@ -12,55 +12,56 @@ velocityDependencies <- function() {
#' Add Velocity Animation
#'
-#' @param map a map widget
-#' @param layerId the layer id
-#' @param group the name of the group the newly created layers should belong to
-#' (for \code{clearGroup} and \code{addLayersControl} purposes). Human-friendly
-#' group names are permittedโthey need not be short, identifier-style names.
-#' Any number of layers and even different types of layers (e.g. markers and
-#' polygons) can share the same group name.
-#' @param content a JSON File respresenting the velocity data or a URL pointing
-#' to such a JSON file.
-#' @param options see \code{\link{velocityOptions}}
-#' @description Add velocity animated data to leaflet. Based on the
-#' \href{https://github.com/danwild/leaflet-velocity}{leaflet-velocity plugin}
+#' Add velocity animated data to leaflet. Based on the
+#' \href{https://github.com/onaci/leaflet-velocity}{leaflet-velocity plugin}
+#' @inheritParams leaflet::addMarkers
+#' @param content the path or URL to a JSON file representing the velocity data
+#' or a data.frame which can be transformed to such a JSON file. Please see the
+#' \href{https://github.com/onaci/leaflet-velocity/tree/master/demo}{demo
+#' files} for some example data.
+#' @param options List of further options. See \code{\link{velocityOptions}}
#' @export
-#' @family Velocity Plugin
-#' @seealso https://github.com/danwild/leaflet-velocity
+#' @family Velocity Functions
+#' @references \url{https://github.com/onaci/leaflet-velocity}
+#' @inherit leaflet::addMarkers return
#' @examples \dontrun{
#' library(leaflet)
#' library(leaflet.extras2)
-#' content <- system.file("examples/velocity/wind-global.json", package = "leaflet.extras2")
+#' content <- "https://raw.githubusercontent.com/onaci/leaflet-velocity/master/demo/water-gbr.json"
#' leaflet() %>%
#' addTiles(group = "base") %>%
-#' addLayersControl(baseGroups = "base", overlayGroups = "velo") %>%
-#' addVelocity(content = content, group = "velo", layerId = "veloid")
+#' setView(145, -20, 4) %>%
+#' addVelocity(content = content, group = "velo", layerId = "veloid") %>%
+#' addLayersControl(baseGroups = "base", overlayGroups = "velo")
#' }
addVelocity <- function(map, layerId = NULL, group = NULL,
content = NULL, options = velocityOptions()) {
+ if (!requireNamespace("jsonlite")) {
+ stop("Package `jsonlite` must be loaded to parse the `content`")
+ }
## Check Content
- if (is.null(content)) stop("The content is empty. Please include a JSON or a URL for a specific JSON")
+ if (is.null(content)) stop("The velocity-content is NULL")
if (inherits(content, "character")) {
- # grepl("https:", content) || grepl("http:", content)
content <- jsonlite::fromJSON(content)
content <- jsonlite::toJSON(content)
} else if (inherits(content, "data.frame")) {
content <- jsonlite::toJSON(content)
} else if (inherits(content, "json")) {
} else {
- stop("Content is does not point to a JSON file nor is it a data.frame")
+ stop("Content does not point to a JSON file nor is it a data.frame")
}
map$dependencies <- c(map$dependencies, velocityDependencies())
+ options <- filterNULL(options)
+
invokeMethod(
map, NULL, "addVelocity",
layerId, group, content, options
)
}
-
#' velocityOptions
#' @description Define further options for the velocity layer.
#' @param speedUnit Could be 'm/s' for meter per second, 'k/h' for kilometer
@@ -70,9 +71,10 @@ addVelocity <- function(map, layerId = NULL, group = NULL,
#' @param velocityScale scale for wind velocity
#' @param colorScale A vector of hex colors or an RGB matrix
#' @param ... Further arguments passed to the Velocity layer and Windy.js.
-#' For more information, please visit \href{https://github.com/danwild/leaflet-velocity}{leaflet-velocity plugin}
+#' For more information, please visit \href{https://github.com/onaci/leaflet-velocity}{leaflet-velocity plugin}
+#' @return A list of further options for \code{addVelocity}
#' @export
-#' @family Velocity Plugin
+#' @family Velocity Functions
velocityOptions <- function(speedUnit = c("m/s", "k/h", "kt"),
minVelocity = 0,
maxVelocity = 10,
@@ -99,7 +101,20 @@ velocityOptions <- function(speedUnit = c("m/s", "k/h", "kt"),
#' @param map the map widget
#' @param group the group to remove
#' @export
-#' @family Velocity Plugin
+#' @inherit leaflet::removeMarker return
+#' @family Velocity Functions
removeVelocity <- function(map, group){
invokeMethod(map, NULL, "removeVelocity", group)
}
+
+#' setOptionsVelocity
+#' @param map the map widget
+#' @param layerId the layer id
+#' @param options see \code{\link{velocityOptions}}
+#' @inherit leaflet::removeMarker return
+#' @export
+#' @family Velocity Functions
+setOptionsVelocity <- function(map, layerId, options){
+ options <- filterNULL(options)
+ invokeMethod(map, NULL, "setOptionsVelocity", layerId, options)
+}
diff --git a/R/wms.R b/R/wms.R
index f945c9d0..015bd218 100644
--- a/R/wms.R
+++ b/R/wms.R
@@ -1,7 +1,7 @@
wmsDependency <- function() {
list(
htmltools::htmlDependency(
- "lfx-wms", version = "2.1.0",
+ "lfx-wms", version = "1.0.0",
src = system.file("htmlwidgets/lfx-wms", package = "leaflet.extras2"),
script = c("leaflet.wms.js",
"leaflet.wms-bindings.js")
@@ -9,43 +9,58 @@ wmsDependency <- function() {
)
}
-
#' Add Queryable WMS Layer
#'
-#' @param map a map widget object created from \code{\link[leaflet]{leaflet}}
-#' @param baseUrl a base URL of the WMS service
-#' @param layers vector or list of WMS layers to show. The name of the layer is
-#' used as the \code{layerId} (for \code{\link[leaflet]{removeTiles}}
-#' purposes)
-#' @param group the name of the group the newly created layers should belong to
-#' (for clearGroup and addLayersControl purposes). Human-friendly group names
-#' are permittedโthey need not be short, identifier-style names. Any number of
-#' layers and even different types of layers (e.g. markers and polygons) can
-#' share the same group name. NOTE: If multiple \code{layers} are included,
-#' the group argument will be ignored and the the layer-names will serve as
-#' group names.
-#' @param options List of further options. See
-#' \code{\link[leaflet]{WMSTileOptions}}
-#' @param attribution the attribution text of the tile layer (HTML)
-#' @param data the data object from which the argument values are derived; by
-#' default, it is the data object provided to \code{\link[leaflet]{leaflet}}
-#' initially, but can be overridden.
+#' @description
+#' A Leaflet plugin for working with Web Map services, providing:
+#' single-tile/untiled/nontiled layers, shared WMS sources, and
+#' \bold{GetFeatureInfo}-powered identify.
+#'
+#' You can also use \bold{CQL-Filters} by appending a string to the \code{'baseUrl'}.
#'
-#' @seealso https://github.com/heigeo/leaflet.wms
-#' @family WMS Plugin
+#' Something like \code{'http://server/wms?cql_filter=attribute=value'}
+#'
+#' @inheritParams leaflet::addWMSTiles
+#' @param checkempty Should the returned HTML-content be checked for emptiness?
+#' If the HTML-body is empty no popup is opened. Default is \code{FALSE}
+#' @param popupOptions List of popup options. See
+#' \code{\link[leaflet]{popupOptions}}. Default is NULL.
+#' @inherit leaflet::addWMSTiles return
+#' @references \url{https://github.com/heigeo/leaflet.wms}
+#' @family WMS Functions
#' @export
-addWMS <- function(map, baseUrl, layers = "", group = NULL,
- options = WMSTileOptions(), attribution = NULL,
+#' @examples
+#' library(leaflet)
+#' library(leaflet.extras2)
+#'
+#' leaflet() %>%
+#' addTiles(group = "base") %>%
+#' setView(9, 50, 5) %>%
+#' addWMS(baseUrl = "https://maps.dwd.de/geoserver/dwd/wms",
+#' layers = "dwd:BRD_1km_winddaten_10m",
+#' popupOptions = popupOptions(maxWidth = 600),
+#' checkempty = TRUE,
+#' options = WMSTileOptions(
+#' transparent = TRUE,
+#' format = "image/png",
+#' info_format = "text/html"))
+addWMS <- function(map, baseUrl, layerId = NULL, group = NULL,
+ options = WMSTileOptions(),
+ attribution = NULL,
+ layers = NULL,
+ popupOptions = NULL,
+ checkempty = FALSE,
data = getMapData(map)) {
- if (identical(layers, "")) {
+ if (is.null(layers)) {
stop("layers is a required argument with comma-separated list of WMS layers to show")
}
options$attribution <- attribution
options$layers <- layers
+ options$checkempty <- checkempty
map$dependencies <- c(map$dependencies, wmsDependency())
- invokeMethod(map, data, "addWMS", baseUrl, layers,
- group, options)
+ invokeMethod(map, data, "addWMS", baseUrl, layerId,
+ group, options, popupOptions)
}
diff --git a/README.md b/README.md
index 00f42957..1cba6f58 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,24 @@
# leaflet.extras2
-
-The goal of `leaflet.extras2` package is to provide extra functionality to the [leaflet](https://cran.r-project.org/web/packages/leaflet/index.html) and [leaflet.extras](https://github.com/bhaskarvk/leaflet.extras) R packages using various [leaflet plugins](http://leafletjs.com/plugins).
+
+[](https://github.com/trafficonese/leaflet.extras2/actions/workflows/R-CMD-check.yaml)
+[](https://CRAN.R-project.org/package=leaflet.extras2)
+[](https://cran.r-project.org/web/checks/check_results_leaflet.extras2.html)
+[](/commits/master)
+[](https://cran.rstudio.com/web/packages/leaflet.extras2/index.html)
+[](https://cran.r-project.org/package=leaflet.extras2)
+[](https://app.codecov.io/gh/trafficonese/leaflet.extras2?branch=master)
+
+
+The goal of `leaflet.extras2` package is to provide extra functionality to the [leaflet](https://cran.r-project.org/package=leaflet) and [leaflet.extras](https://github.com/trafficonese/leaflet.extras) R packages using various leaflet plugins.
### Installation
-For CRAN version (Not yet)
+For CRAN version
-~~`install.packages('leaflet.extras2')`~~
+``` r
+install.packages('leaflet.extras2')
+```
For latest development version
@@ -15,30 +26,37 @@ For latest development version
remotes::install_github('trafficonese/leaflet.extras2')
```
-### Progress
+### Integrated Plugins
-Plugins integrated so far ...
+If you need a plugin that is not already implemented create an [issue](https://github.com/trafficonese/leaflet.extras2/issues/new). See the [FAQ](#FAQ) section below for details.
- [Ant Path](https://github.com/rubenspgcavalcante/leaflet-ant-path)
+- [Arrowheads](https://github.com/slutske22/leaflet-arrowheads)
+- [Contextmenu](https://github.com/aratcliffe/Leaflet.contextmenu)
- [Easy Print](https://github.com/rowanwins/leaflet-easyPrint)
-- [Hexbin-D3](https://github.com/Asymmetrik/leaflet-d3#hexbins-api)
+- [GIBS](https://github.com/aparshin/leaflet-GIBS)
+- [Heightgraph](https://github.com/GIScience/Leaflet.Heightgraph)
+- [Hexbin-D3](https://github.com/bluehalo/leaflet-d3#hexbins-api)
+- [History](https://github.com/cscott530/leaflet-history)
+- [Labelgun](https://github.com/Geovation/labelgun)
+- [Leaflet.Sync](https://github.com/jieter/Leaflet.Sync)
- [Mapkey Icons](https://github.com/mapshakers/leaflet-mapkey-icon)
+- [Moving Markers](https://github.com/ewoken/Leaflet.MovingMarker)
+- [OpenWeatherMap](https://github.com/trafficonese/leaflet-openweathermap)
- [Playback](https://github.com/hallahan/LeafletPlayback)
- [Reachability](https://github.com/traffordDataLab/leaflet.reachability)
- [Sidebar-v2](https://github.com/Turbo87/sidebar-v2)
- [Side-by-Side](https://github.com/digidem/leaflet-side-by-side)
+- [Spin](https://github.com/makinacorpus/Leaflet.Spin)
+- [Timeslider](https://github.com/dwilhelm89/LeafletSlider)
- [Tangram](https://github.com/tangrams/tangram)
-- [Velocity](https://github.com/danwild/leaflet-velocity)
+- [Velocity](https://github.com/onaci/leaflet-velocity)
- [WMS](https://github.com/heigeo/leaflet.wms)
-If you need a plugin that is not already implemented create an [issue](https://github.com/trafficonese/leaflet.extras2/issues/new). See the [FAQ](#FAQ) section below for details.
-
### Documentation
-The R functions have been documented using roxygen, and should provide enough help to get started on using a feature. However some plugins have lots of options and it's not feasible to document every single detail. In such cases you are encouraged to check the plugin's documentation.
-
-Currently there are no vignettes (contributions welcome), but there are plenty of [examples](https://github.com/trafficonese/leaflet.extras2/tree/master/inst/examples) available.
+The R functions have been documented using roxygen, and should provide enough help to get started on using a feature. However some plugins have lots of options and it's not feasible to document every single detail. In such cases you are encouraged to check the plugin's documentation and the [examples](https://github.com/trafficonese/leaflet.extras2/tree/master/inst/examples).
### FAQ
@@ -46,11 +64,11 @@ Currently there are no vignettes (contributions welcome), but there are plenty o
- **Good Solution**: Create issues for plugins you wish incorporated but before that search the existing issues to see if issue already exists and if so comment on that issue instead of creating duplicates.
- **Better Solution**: It would help in prioritizing if you can include additional details like why you need the plugin, how helpful will it be to everyone etc.
-- **Best Solution**: Code it yourself and submit a pull request. This is the fastest way to get a plugin into the package.
+- **Best Solution**: Code it yourself and submit a pull request. This is the fastest way to get a plugin into the package. Checkout this little [tutorial](https://github.com/trafficonese/leaflet.extras2/blob/master/HowTo.md).
*I submitted an issue for a plugin long time ago but it is still not available.*
-This package is being developed purely on a voluntary basis on spare time without any monetary compensation. So the development progress can stall at times. It may also not be possible to prioritize one-off requests that no one else is interested in. Getting more people interested in a feature request will help prioritize development. Other option is to contribute code. That will get you added to the contributer list and a thanks tweet.
+This package is being developed purely on a voluntary basis on spare time without any monetary compensation. So the development progress can stall at times. It may also not be possible to prioritize one-off requests that no one else is interested in. Getting more people interested in a feature request will help prioritize development. Other option is to contribute code. That will get you added to the contributor list.
*I found a bug.*
diff --git a/_pkgdown.yml b/_pkgdown.yml
new file mode 100644
index 00000000..7a18070c
--- /dev/null
+++ b/_pkgdown.yml
@@ -0,0 +1,113 @@
+title: leaflet.extras2
+
+template:
+ params:
+ bootswatch: yeti
+
+reference:
+ - title: Package Documentation
+ desc: ~
+ contents:
+ - '`leaflet.extras2`'
+ - title: Ant Path
+ contents:
+ - matches("Antpath")
+ - matches("antpath")
+ - title: Arrowhead
+ contents:
+ - matches("Arrowhead")
+ - matches("arrowhead")
+ - title: Contextmenu
+ contents:
+ - matches("Contextmenu")
+ - matches("contextmenu")
+ - matches("context_")
+ - menuItem
+ - mapmenuItems
+ - markermenuItems
+ - title: Easy Print
+ contents:
+ - matches("Easyprint")
+ - matches("easyprint")
+ - title: GIBS
+ contents:
+ - matches("GIBS")
+ - setDate
+ - setTransparent
+ - gibs_layers
+ - title: Heightgraph
+ contents:
+ - matches("Heightgraph")
+ - matches("heightgraph")
+ - title: Hexbin-D3
+ contents:
+ - matches("Hexbin")
+ - matches("hexbin")
+ - title: History
+ contents:
+ - matches("History")
+ - matches("history")
+ - clearFuture
+ - title: Labelgun
+ contents:
+ - matches("Labelgun")
+ - title: Moving Markers
+ - title: Mapkey Icons
+ contents:
+ - matches("Mapkey")
+ - matches("mapkey")
+ - title: Moving Markers
+ contents:
+ - matches("movingMarker")
+ - matches("Moving")
+ - title: OpenWeatherMap
+ contents:
+ - matches("Openweather")
+ - matches("openweather")
+ - title: Playback
+ contents:
+ - matches("Playback")
+ - matches("playback")
+ - to_jsonformat
+ - to_ms
+ - title: Reachability
+ contents:
+ - matches("Reachability")
+ - matches("reachability")
+ - title: Sidebar-v2
+ contents:
+ - matches("Sidebar")
+ - matches("sidebar")
+ - title: Side-by-Side
+ contents:
+ - matches("Sidebyside")
+ - title: Spinner
+ contents:
+ - matches("Spinner")
+ - title: Sync
+ contents:
+ - matches("sync")
+ - matches("Sync")
+ - title: Tangram
+ contents:
+ - matches("Tangram")
+ - title: Timeslider
+ contents:
+ - matches("Timeslider")
+ - matches("timeslider")
+ - title: Velocity
+ contents:
+ - matches("Velocity")
+ - matches("velocity")
+ - title: WMS
+ contents:
+ - matches("WMS")
+
+destination: docs
+
+development:
+ mode: auto
+
+authors:
+ Sebastian Gatscha:
+ href: https://github.com/trafficonese
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index 58772741..00000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,60 +0,0 @@
-# DO NOT CHANGE the "init" and "install" sections below
-
-# Download script file from GitHub
-init:
- ps: |
- $ErrorActionPreference = "Stop"
- Invoke-WebRequest http://raw.github.com/krlmlr/r-appveyor/master/scripts/appveyor-tool.ps1 -OutFile "..\appveyor-tool.ps1"
- Import-Module '..\appveyor-tool.ps1'
-
-install:
- ps: Bootstrap
-
-# cache is causing errors
-# cache:
-# - C:\RLibrary
-
-# Adapt as necessary starting from here
-
-build_script:
- - travis-tool.sh install_deps
-
-test_script:
- - travis-tool.sh run_tests
-
-on_failure:
- - 7z a failure.zip *.Rcheck\*
- - appveyor PushArtifact failure.zip
-
-artifacts:
- - path: '*.Rcheck\**\*.log'
- name: Logs
-
- - path: '*.Rcheck\**\*.out'
- name: Logs
-
- - path: '*.Rcheck\**\*.fail'
- name: Logs
-
- - path: '*.Rcheck\**\*.Rout'
- name: Logs
-
- - path: '\*_*.tar.gz'
- name: Bits
-
- - path: '\*_*.zip'
- name: Bits
-
-environment:
- global:
- _R_CHECK_FORCE_SUGGESTS_: false
-
-notifications:
- - provider: Email
- to:
- - sebastian_gatscha@gmx.at
- subject: 'r-appveyor build {{status}}'
- message: "https://ci.appveyor.com/project/trafficones/leaflet.extras2"
- on_build_success: false
- on_build_failure: true
- on_build_status_changed: true
diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 00000000..8f36b6cc
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,12 @@
+comment: false
+
+coverage:
+ status:
+ project:
+ default:
+ target: auto
+ threshold: 1%
+ patch:
+ default:
+ target: auto
+ threshold: 1%
diff --git a/cran-comments.md b/cran-comments.md
new file mode 100644
index 00000000..d6b17a20
--- /dev/null
+++ b/cran-comments.md
@@ -0,0 +1,5 @@
+## R CMD check results `(devtools::check(args = c('--as-cran')))`
+
+0 errors v | 0 warnings v | 0 notes v
+
+* This is a patch release for the leaflet 2.2.0 release.
diff --git a/data-raw/data-raw.R b/data-raw/data-raw.R
new file mode 100644
index 00000000..f1d20114
--- /dev/null
+++ b/data-raw/data-raw.R
@@ -0,0 +1,10 @@
+
+gibs_layerslink <- paste0(system.file("htmlwidgets/lfx-gibs", package = "leaflet.extras2"), "/gibs_layers_meta.json")
+gibs_layers <- jsonify::from_json(json = gibs_layerslink, simplify = TRUE)
+gibs_layers <- data.frame(do.call(rbind, gibs_layers), stringsAsFactors = FALSE)
+gibs_layers$title <- as.character(gibs_layers$title)
+gibs_layers$template <- as.character(gibs_layers$template)
+gibs_layers$zoom <- as.integer(gibs_layers$zoom)
+gibs_layers$date <- as.logical(gibs_layers$date)
+rownames(gibs_layers) <- NULL
+usethis::use_data(gibs_layers, overwrite = TRUE)
diff --git a/data/gibs_layers.rda b/data/gibs_layers.rda
new file mode 100644
index 00000000..02b9a774
Binary files /dev/null and b/data/gibs_layers.rda differ
diff --git a/inst/examples/antpath_app.R b/inst/examples/antpath_app.R
index d72f1423..4bec7e4a 100644
--- a/inst/examples/antpath_app.R
+++ b/inst/examples/antpath_app.R
@@ -20,7 +20,7 @@ ui <- fluidPage(
server <- function(input, output, session) {
output$map <- renderLeaflet({
leaflet() %>%
- addTiles() %>%
+ addTiles() %>% addMapPane("my-pane", 420) %>%
addAntpath(data = coords,
layerId = ~FGN,
label = ~sprintf("Ant-Colony of %s", district),
@@ -30,11 +30,13 @@ server <- function(input, output, session) {
popup = ~FGN,
opacity = 1,
options = antpathOptions(
- pulseColor = colorNumeric("Reds", domain = as.numeric(coords$FKN))(as.numeric(coords$FKN)),
- delay = c(rep(300, 50), rep(3000, 50)),
+ pulseColor = colorNumeric("Reds",
+ domain = as.numeric(coords$FKN))(as.numeric(coords$FKN)),
+ delay = 4000,
paused = FALSE,
+ renderer= JS('L.svg({pane: "my-pane"})'),
reverse = TRUE,
- dashArray = c(40, 50),
+ dashArray = c(40, 10),
hardwareAccelerated = T,
interactive = TRUE,
lineCap = "butt",
diff --git a/inst/examples/arrowhead_app.R b/inst/examples/arrowhead_app.R
new file mode 100644
index 00000000..69f3d489
--- /dev/null
+++ b/inst/examples/arrowhead_app.R
@@ -0,0 +1,81 @@
+library(shiny)
+library(leaflet)
+library(leaflet.extras2)
+
+ui <- fluidPage(
+ leafletOutput("map", height=800),
+ actionButton("clear", "Clear Group"),
+ actionButton("remove", "Remove"),
+ actionButton("clearArrowhead", "Remove Arrowheads by group"),
+ actionButton("removeArrowhead", "Remove Arrowheads by layerId's")
+)
+
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ leaflet() %>%
+ addTiles() %>%
+ addLayersControl(overlayGroups = c("blue","red")) %>%
+ ## Blue #############
+ addArrowhead(data = atlStorms2005[1:10,], color="blue",
+ group="blue",
+ options = arrowheadOptions(
+ yawn = 60,
+ size = '7%',
+ frequency = 'endonly',
+ fill = TRUE,
+ opacity=0.5, stroke=FALSE, fillOpacity=0.4,
+ proportionalToTotal = TRUE,
+ offsets = NULL,
+ perArrowheadOptions = NULL)) %>%
+ ## Red #############
+ addArrowhead(data = atlStorms2005[11:20,], color = "red",
+ group = "red",
+ layerId = paste0("inp",1:10),
+ options = arrowheadOptions(
+ yawn = 90,
+ size = '10px',
+ frequency = 'allvertices',
+ fill = TRUE,
+ offsets = NULL,
+ perArrowheadOptions = NULL)) %>%
+ ## Green #############
+ addArrowhead(data = atlStorms2005[21,], color = "green", group="green",
+ options = arrowheadOptions(
+ size = '10px',
+ frequency = '50px',
+ offsets = list('start' = '100m', 'end' = '15px'),
+ fill = TRUE)) %>%
+ ## Yellow #############
+ addArrowhead(data = atlStorms2005[22,], color = "yellow",
+ options = arrowheadOptions(
+ size = "25000m",
+ frequency = '200000m',
+ fill = TRUE)) %>%
+ ## Purple #############
+ addArrowhead(data = atlStorms2005[24,], color = "purple",
+ options = arrowheadOptions(
+ opacity=1, fillOpacity=1,
+ frequency = "30px",
+ size= "20px", fill=TRUE,
+ perArrowheadOptions = leaflet::JS("(i) => ({
+ color: `rgba(150, 20, ${0 + 20 * i}, 1)`,
+ })")))
+ })
+ observeEvent(input$clear, {
+ leafletProxy("map") %>%
+ leaflet::clearGroup("blue")
+ })
+ observeEvent(input$remove, {
+ leafletProxy("map") %>%
+ leaflet::removeShape(layerId = "inp3")
+ })
+ observeEvent(input$clearArrowhead, {
+ leafletProxy("map") %>%
+ clearArrowhead(group = "blue")
+ })
+ observeEvent(input$removeArrowhead, {
+ leafletProxy("map") %>%
+ removeArrowhead(paste0("inp",1:5))
+ })
+}
+shinyApp(ui, server)
diff --git a/inst/examples/contextmenu_app.R b/inst/examples/contextmenu_app.R
new file mode 100644
index 00000000..3aef5aa9
--- /dev/null
+++ b/inst/examples/contextmenu_app.R
@@ -0,0 +1,220 @@
+library(shiny)
+library(leaflet)
+library(leaflet.extras2)
+
+ui <- fluidPage(
+ leafletOutput("map", height = "800px"),
+ actionButton("show", "Show Contextmenu at given Coordinates"),
+ actionButton("hide", "Hide Contextmenu"),
+ actionButton("add", "Add Options to Contextmenu"),
+ actionButton("ins", "Insert Options to Contextmenu"),
+ actionButton("rm", "Remove Option 2"),
+ actionButton("disable", "Disable Contextmenu Item 1"),
+ actionButton("enable", "Enable Contextmenu Item 1"),
+ actionButton("disable_all", "Disable Contextmenu"),
+ actionButton("enable_all", "Enable Contextmenu"),
+ actionButton("rmall", "Remove All Map Items"),
+ splitLayout(
+ div(
+ h4("Contextmenu Selection:"),
+ verbatimTextOutput("print"),
+ ),
+ div(
+ h4("Custom Marker Selection:"),
+ verbatimTextOutput("print1")
+ )
+ )
+)
+
+server <- function(input, output, session) {
+ data <- reactiveVal()
+ data1 <- reactiveVal()
+
+ output$map <- renderLeaflet({
+ ## Basemap ####################
+ suppressWarnings(
+ leaflet(options = leafletOptions(
+ contextmenu=TRUE,
+ contextmenuWidth = 200,
+ contextmenuItems =
+ context_mapmenuItems(
+ context_menuItem("Zoom Out", "function(e) {this.zoomOut();}", disabled=TRUE),
+ context_menuItem("Zoom In", "function(e) {this.zoomIn();}"),
+ "-",
+ context_menuItem("Disable index 0",
+ "function(e) {this.contextmenu.setDisabled(0, true)}",
+ hideOnSelect = TRUE),
+ context_menuItem("Enable index 0",
+ "function(e) {this.contextmenu.setDisabled(0, false)}",
+ hideOnSelect = FALSE),
+ "-",
+ context_menuItem(text="Center Map",
+ callback="function(e) {this.panTo(e.latlng);}",
+ icon="https://cdn3.iconfinder.com/data/icons/web-15/128/RSSvgLink-2-512.png"),
+ list(text="Console Log",
+ callback=JS("function(e) {console.log('e');console.log(e);}"))
+ ))) %>%
+ addTiles(group = "base") %>%
+ addContextmenu() %>%
+
+ ## Points ###############################
+ addMarkers(data = sf::st_as_sf(leaflet::breweries91),
+ label=~brewery, layerId = ~founded, group="marker",
+ options = markerOptions(
+ contextmenu=TRUE,
+ contextmenuWidth = 200,
+ contextmenuItems =
+ context_markermenuItems(
+ context_menuItem(
+ text = "Show Marker Coords",
+ "function(e) {
+ Shiny.setInputValue(map.id + '_mymarkertrigger', {
+ menuid: e.relatedTarget.options.contextmenuItems[0].id,
+ layerId: e.relatedTarget.options.layerId,
+ lat: e.relatedTarget.options.lat,
+ lng: e.relatedTarget.options.lng,
+ opacity: e.relatedTarget.options.opacity
+ });
+ alert(e.latlng);}",
+ id = "somemarkerid",
+ icon="https://upload.wikimedia.org/wikipedia/commons/thumb/d/d8/Person_icon_BLACK-01.svg/1200px-Person_icon_BLACK-01.svg.png",
+ index=0)
+ )
+ )) %>%
+ ## Lines ###############################
+ addPolylines(data = sf::st_as_sf(leaflet::atlStorms2005),
+ layerId = ~Name, group="lines",
+ label = ~Name,
+ options = pathOptions(
+ contextmenu=TRUE,
+ contextmenuWidth = 400,
+ contextmenuInheritItems = FALSE,
+ contextmenuItems =
+ context_markermenuItems(
+ context_menuItem(text = "Get Line Data",
+ NULL,
+ index=0),
+ context_menuItem(text = "Delete Line",
+ "function(e) {e.relatedTarget.remove()}",
+ icon="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAANAAAADyCAMAAAALHrt7AAAAdVBMVEUAAAD///+FhYVRUVFfX19paWk/Pz+ioqLHx8f7+/vm5ube3t739/fx8fG6urru7u7Pz8+MjIxISEi0tLR6enrAwMBWVlarq6vX19chISGPj48REREZGRmvr68tLS0mJiabm5s1NTV0dHRlZWU7OzscHBxLS0v96C8XAAAKaUlEQVR4nO2d60LjOAyFk5ZLoYVSCmWAmaHlMu//iMttSmwdRUeJd+2wOb+dRF/iiyQ7dlWn1mxyeVtx+rm5m6d+fJX4fjcky17PF2kNSAx04OV51VVSC5ICLe478FTVNKUNSYGeO/FU1WNCG1ICTTryVNU6nREJgU4781T36axICNT9A6X8RAmBuvUIHzpMZkU6oB417lXJzEh3p4teQMtUZqQDOu8FlMwFGoFUjUAjEKV0QNe9gE5TmfEJtLi+uzrspz+9gA56Pn11vmgC3fUyphBNTv4CLdmQuXSdfgCd5bYjnc7egS5zm5FOR29A69xWpNT6FegotxEpdVlX36gFvems6uf1F6eLapbbhLSajUCFawQqXSNQ6RqBStcIVLpGoNI1ApWuEah0jUClawQqXbNqntuEtJpX9c/cNqTUbV3V36rOzd6S9f2m3orS9cf80OL8bvINtPq1qNMv0cyuEah0jUClawQqXSNQ6RqBStcIVLpGoNI1ApWuEah0/U+ATv5jKxJKAs2uju6rn5vpALR5PP5hAa2Hlkh9uGkDOpnmtq+Dfi9VoMVDbuO6aa4B9ft9IaOWGOg4t12d9QCBFrnN6qEbBPQrt1U99ICAnnJb1UenACi3Tb20/m5A2xGocN0AoEH/GHUNgA5zG9VHcwB0lduoPkLd9ja3UX20AECD/hmvBkBDXoBxi4B+5Laqh6YIaJnbqh66QkBDDh9WCOikzz42mXWMgDpvbVWAriHQEFM+n7qAQAP2feYQaMDbRJxAoOFmfZpBUANouL7PCwYa7n/uUwzUb/+xnDrEQMP1fa4w0Eluuzpri4F67eGXVWsFaJfbsK6aKUBd9pEtQnMFqM8+mFl1pgAN1vdZKEDurZgL0W2tALn+vHmePm3oOdnLg41jQ6Sjg4NLz3TvkQbEp0mmFx/+7ZzJTn4WPruhhoX7448WseTry0YDon2fRr//w7Ty/Kvwo33r5p607BRcc8fucJ0CeYNgQ8WlsVQjKLz12EZ3uw1HoRNQtFNx+2+J0Q7uxje6DEuTWYHmYpIQiNoK8Dl6aGtvL3Y1br93vPck9w/ndfP+wfUb7+XvatsATWz3uW279VNcmrOouYIpBCIabTCKfUpfgXIkyrZ2PHLbbWqtQfO7hkBMI/wtHtpyGTgxoO3ecvtWaiQ5a94+uJxJk/yRNuojxrEs3DbAyk2qqUYUvK/gcmZ73LgjqtvqhRNIrqRkvlDT84mAGN9nJ23U00VOIFmaAQpecXgP5gP/lE/Vp8p6AzGZqODYiPAe1IyKrBf6U3sDMY1g1bwgWqLJAMluW/+wPiDQgTIeatPziRfRMq6CBNLzXz4g0N9sCYPOmxdEQMxqEtm3pgKSjgIVRAfuYgTEpEnk6Kf7Pj4gMAyvvAZFQEy8Jk9A0vuS3kCMQUEbiIC2xPWzWkgN8nxAK1maifGCCyIgplMR3nZd/04DtJWlmZXXbUDMapLzWkhNufqAbmRpYiI79OgjIMbT8BjpAwKvikj+hDFkBMSkSe7kY9VI2QcEKvOLbU/YlURAzO7bE/lYten6gEB3Q9gTtrzYfSJSZ57O1QckfgainMswzI2B3HX2Xep47gOSQzYzqRhW1BiI8H0OpJHbNEDSqWLadPhdYyBiNQlwIdXQ3QckAxMG6Cy4IgYifKeHWkiNwX1AsjAzjISvIb7JlriDfK4ahvUFInICUQQtfirsBKSGrC4gENwTAWuU+outY2J4+Vy1ZriAdrIwkWfchFfE1jFpEtl21atcQK6M317RyZoxENPxO3pXFxAYD4jMZ+SJifpDADnGPxdQtwi89cdcDsjhobiAwLGsRMAauegCiFhNAk4hTgIEvF5inI9erwAiYl6HU+wCAnEJMT0UzZEJIP9HfpPmpLuAQMBKTElGXZQA8jfDN2lJBRfQL0/hvaIrBBAxlIFchuaku4DAl1ezL3vdRlcIICJNAuq61vJcQCACt+PNeNJTABG+D+iNtJbnApK9JzF5EIebAoiIQEAMrs2yuoDkgE1E4HFyUgARLwW4KFoY5QKSLhUBFDdo6Trb93DMevQEIqpLvBJAAtmuwk5aqXnFLqAzUZYIWOOGJ4HssexFXKMGYi4gOZNG9FBxw5NAtvsEDo7XQmUPkGs2eq+4nkogYjWJfLL2Kj1AYIaViMDjS6RxREwl64ZW2T1AO1mWyHDYQMRN+BUsHiBPvm8v8RbA3lg2kDxRWQtZPUAbWdb2lOV6PHETou8HR0QnAAI5c7s9C69FAhFpEhmDpwACLqK9fk84yhKIcDf4kNUDBJx4ewgRMRTogu3VJCBwUZYGe4BAmGUvmxAhBwCyfR8QWioX/XvzsZ8yN8yrmcQEeLQy/e4xErwmu7KIEQQA2WkSvnJ4gEDAaloi09IAaGveBaz4UJqvB8iR7vuSvETexR6eQciqdLAeIH4w+JJYFI+AbBcXJKGVIdAD1CUCl95Fp2lA4KRs+wPxDtWXpHcBgGzfB7iRSsjqAZIBqz1ZJVszALI/tPwBQPPRPUBdFm3LJC4AspsiH4p5gGRROwKXPgsCMtOV9/JlKkFHPyA7kpFdPQKyV5PQ6QwHEEgp2LGm7EgQkO2000u3HUA7WdQeEWXsjIDssEp2SEoP6wCayqJb0xBZ9xGQfR/5pZWFdg4gELCa63TAKh0EZCeP6GljB5BjCmAvMH4goC6di5LjdwB1icCBD4aA7PGMXhzqAOoyZQzcfgRkLzylVzo7gECQZQas4BoEZLsK8m9G5eEOIMdU9F4gyIVApqsA7MSjsQMIVGNz/3wUEyIg81PT9d0B5Pml4q9QTIiAzOwR6GJxDO4A6jJlLB0FDGR2l/QyIweQfNt25wRsh0BmjhxMG+OVCmBw0eqR/EJ2pMkC2atJ5DX4xcvYVg2rZY9lDvAgLsNAHXwfzU7h9aketExUmDUfVBQMZEeKwpPUaqnoPvSeK2a3mxDomzAQMaMS1Xi9ukfJqRYHOv5EHeZSNCDmp5vgfZ60/OYTdK2trTP0zIi5XuBcYCBqC9dGM5q3/rbU+Jjb9ls2RwOj6LvAWIyBiGVqr5p8fqSlFbY8frAvrk0P5Pav/zOjtjUCno8CRG5fv5usJk8U/GZ1Re68dPm4WrEbroK5XgVoIId0INMxEPPDcgHigba5TaW044GGcdANmATRgIaxhStIfGlA3A5OuQVceQ1oGHvSIkdBARrGFq4gVaMBDeOkG+T5aEDU8J9byFHQgKhd0HILpEhUoEGcdCNnqXSgIfg+YC5FBxrCFq5gLkUHGsJJNyhFogINwfeBjoIGNARXAcyl6EBDcBWg56MBDcFVgI6CCkRt4ZpXcjlaG9AATrqBno8KNICTbvDh5RrQAHwfbLgGVP5JN9jzUYHKP+kGpkh0oPJ9HzSX0gJUfpoErCJpA2JmVPIKzEe3AZV/yh9MkehA5R+Kh+ZS2oCKj1nxuKoDld4r4PCuBaj0xI9S41qAyo7xYKK+Haho7+dFaUGtQAX3C/cwx2gCFZvMOlS/jwFUn5YYFh3h2JsCenWB1pPDg3J0OFnjQHWvfwAGBoka5A1PPAAAAABJRU5ErkJggg==",
+ index=1),
+ context_menuItem(text = "Change Color/Weight",
+ "function(e) {e.relatedTarget.setStyle({color: '#'+(0x1000000+(Math.random())*0xffffff).toString(16).substr(1,6),
+ weight: Math.round(Math.random()*10)});}",
+ icon = "https://cdn3.iconfinder.com/data/icons/ui-glynh-blue-02-of-5/100/UI_Blue_2_of_3_30-512.png",
+ index = 2),
+ context_menuItem(text = "Add Centroid",
+ "function(e) {L.marker(Object.values(e.relatedTarget.getCenter())).addTo(this);}",
+ icon = "https://bodylab.ch/wp-content/uploads/2015/11/map-marker-icon.png",
+ index = 3),
+ context_menuItem(text = "Log GeoJSON",
+ "function(e) {console.log(e.relatedTarget.toGeoJSON());}",
+ icon = "https://cdn0.iconfinder.com/data/icons/outlinecons-filetypes/512/log-512.png",
+ index = 4),
+ context_menuItem(text = "-", separator=TRUE,
+ index = 5)
+ )
+ )) %>%
+ ## Shapes ###############################
+ addPolygons(data = sf::st_as_sf(leaflet::gadmCHE),
+ label=~NAME_1, layerId = ~OBJECTID, group="shapes",
+ options = pathOptions(
+ contextmenu=TRUE,
+ contextmenuWidth = 200,
+ contextmenuItems =
+ context_markermenuItems(
+ context_menuItem(text = "Get Polygon Coords",
+ "function(e) {console.log(e.latlng);}",
+ index = 0),
+ context_menuItem(text = "Delete Polygon",
+ "function(e) {e.relatedTarget.remove()}",
+ index = 1),
+ context_menuItem(text = "Change Color",
+ "function(e) {e.relatedTarget.setStyle({color: '#4B1BDE',
+ fillColor : '#'+(0x1000000+(Math.random())*0xffffff).toString(16).substr(1,6),
+ fillOpacity: 1});}",
+ index = 2),
+ context_menuItem(text = "Add Centroid",
+ "function(e) {L.marker(Object.values(e.relatedTarget.getCenter())).addTo(this);}",
+ index = 3),
+ context_menuItem(text = "Log GeoJSON",
+ "function(e) {console.log(e.relatedTarget.toGeoJSON());}",
+ index = 4),
+ context_menuItem(text = "-", NULL, separator=TRUE,
+ index = 5)
+ )
+ ))
+ )
+ })
+
+ observeEvent(input$map_contextmenu_select, {
+ txt <- input$map_contextmenu_select
+ data(txt)
+ print(txt)
+ })
+ observeEvent(input$map_mymarkertrigger, {
+ message("Return Value from 'Show Marker Coords' - callback")
+ txt <- rbind(input$map_mymarkertrigger)
+ data1(txt)
+ print(txt)
+ })
+ observeEvent(input$show, {
+ leafletProxy("map") %>%
+ showContextmenu(data = leaflet::breweries91[sample(1:32, 1),])
+ })
+ observeEvent(input$hide, {
+ leafletProxy("map") %>%
+ hideContextmenu()
+ })
+ observeEvent(input$disable_all, {
+ leafletProxy("map") %>%
+ disableContextmenu()
+ })
+ observeEvent(input$enable_all, {
+ leafletProxy("map") %>%
+ enableContextmenu()
+ })
+ observeEvent(input$add, {
+ ## Requires https://github.com/rstudio/leaflet/pull/696 to be merged!
+ leafletProxy("map") %>%
+ addItemContextmenu(
+ context_menuItem(text = "Added Menu Item",
+ callback = ("function(e) {alert('I am a new menuItem!');
+ console.log('e');console.log(e);}")))
+ })
+ observeEvent(input$ins, {
+ ## Requires https://github.com/rstudio/leaflet/pull/696 to be merged!
+ leafletProxy("map") %>%
+ addItemContextmenu(
+ context_menuItem(text = "Inserted Menu Item at Index 2",
+ callback = ("function(e) {alert('I am an inserted menuItem!');
+ console.log('e');console.log(e);}")))
+ })
+ observeEvent(input$rm, {
+ leafletProxy("map") %>%
+ removeItemContextmenu(2)
+ })
+ observeEvent(input$disable, {
+ leafletProxy("map") %>%
+ setDisabledContextmenu(1, TRUE)
+ })
+ observeEvent(input$enable, {
+ leafletProxy("map") %>%
+ setDisabledContextmenu(1, FALSE)
+ })
+ observeEvent(input$rmall, {
+ leafletProxy("map") %>%
+ removeallItemsContextmenu()
+ })
+
+ output$print <- renderPrint({
+ txt <- req(data())
+ print(txt)
+ })
+ output$print1 <- renderPrint({
+ txt <- req(data1())
+ print(txt)
+ })
+}
+
+shinyApp(ui, server)
diff --git a/inst/examples/easyprint_app.R b/inst/examples/easyprint_app.R
index ffa12d26..75899ed5 100644
--- a/inst/examples/easyprint_app.R
+++ b/inst/examples/easyprint_app.R
@@ -1,13 +1,24 @@
-
library(shiny)
-library(shinycssloaders)
library(leaflet)
-library(leaflet.extras)
-
+library(leaflet.extras2)
ui <- fluidPage(
- withSpinner(leafletOutput("map")),
- selectInput("scene", "Select Scene", choices = c("Current", "CurrentSize", "A4Landscape", "A4Portrait")),
+ tags$head(tags$style(".easyPrintHolder .customCssClass {
+ background-image: url(data:image/svg+xml;utf8;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/Pgo8IS0tIEdlbmVyYXRvcjogQWRvYmUgSWxsdXN0cmF0b3IgMTguMS4xLCBTVkcgRXhwb3J0IFBsdWctSW4gLiBTVkcgVmVyc2lvbjogNi4wMCBCdWlsZCAwKSAgLS0+CjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ0NC44MzMgNDQ0LjgzMyIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDQ0LjgzMyA0NDQuODMzOyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij4KPGc+Cgk8Zz4KCQk8cGF0aCBkPSJNNTUuMjUsNDQ0LjgzM2gzMzQuMzMzYzkuMzUsMCwxNy03LjY1LDE3LTE3VjEzOS4xMTdjMC00LjgxNy0xLjk4My05LjM1LTUuMzgzLTEyLjQ2N0wyNjkuNzMzLDQuNTMzICAgIEMyNjYuNjE3LDEuNywyNjIuMzY3LDAsMjU4LjExNywwSDU1LjI1Yy05LjM1LDAtMTcsNy42NS0xNywxN3Y0MTAuODMzQzM4LjI1LDQzNy4xODMsNDUuOSw0NDQuODMzLDU1LjI1LDQ0NC44MzN6ICAgICBNMzcyLjU4MywxNDYuNDgzdjAuODVIMjU2LjQxN3YtMTA4LjhMMzcyLjU4MywxNDYuNDgzeiBNNzIuMjUsMzRoMTUwLjE2N3YxMzAuMzMzYzAsOS4zNSw3LjY1LDE3LDE3LDE3aDEzMy4xNjd2MjI5LjVINzIuMjVWMzR6ICAgICIgZmlsbD0iIzAwMDAwMCIvPgoJPC9nPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+Cjwvc3ZnPgo=);
+ transform: rotate(90deg);
+ }
+ .easyPrintHolder .customCssClass1 {
+ background-image: url(data:image/svg+xml;utf8;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/Pgo8IS0tIEdlbmVyYXRvcjogQWRvYmUgSWxsdXN0cmF0b3IgMTguMS4xLCBTVkcgRXhwb3J0IFBsdWctSW4gLiBTVkcgVmVyc2lvbjogNi4wMCBCdWlsZCAwKSAgLS0+CjxzdmcgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIgdmVyc2lvbj0iMS4xIiBpZD0iQ2FwYV8xIiB4PSIwcHgiIHk9IjBweCIgdmlld0JveD0iMCAwIDQ0NC44MzMgNDQ0LjgzMyIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgNDQ0LjgzMyA0NDQuODMzOyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgd2lkdGg9IjUxMnB4IiBoZWlnaHQ9IjUxMnB4Ij4KPGc+Cgk8Zz4KCQk8cGF0aCBkPSJNNTUuMjUsNDQ0LjgzM2gzMzQuMzMzYzkuMzUsMCwxNy03LjY1LDE3LTE3VjEzOS4xMTdjMC00LjgxNy0xLjk4My05LjM1LTUuMzgzLTEyLjQ2N0wyNjkuNzMzLDQuNTMzICAgIEMyNjYuNjE3LDEuNywyNjIuMzY3LDAsMjU4LjExNywwSDU1LjI1Yy05LjM1LDAtMTcsNy42NS0xNywxN3Y0MTAuODMzQzM4LjI1LDQzNy4xODMsNDUuOSw0NDQuODMzLDU1LjI1LDQ0NC44MzN6ICAgICBNMzcyLjU4MywxNDYuNDgzdjAuODVIMjU2LjQxN3YtMTA4LjhMMzcyLjU4MywxNDYuNDgzeiBNNzIuMjUsMzRoMTUwLjE2N3YxMzAuMzMzYzAsOS4zNSw3LjY1LDE3LDE3LDE3aDEzMy4xNjd2MjI5LjVINzIuMjVWMzR6ICAgICIgZmlsbD0iIzAwMDAwMCIvPgoJPC9nPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+CjxnPgo8L2c+Cjwvc3ZnPgo=);
+ transform: rotate(180deg);
+ }")
+ ),
+ leafletOutput("map", height = 700, width = "100%"),
+ selectInput("scene", "Select Scene",
+ choices = c("CurrentSize"="CurrentSize",
+ "A4Landscape"="A4Landscape",
+ "A4Portrait"="A4Portrait",
+ "Custom Landscape"="customCssClass",
+ "Custom Portrait"="customCssClass1")),
textInput("fn", "Filename", value = "map"),
actionButton("print", "Print Map"),
actionButton("rem", "removeEasyprint"),
@@ -16,21 +27,50 @@ ui <- fluidPage(
server <- function(input, output, session) {
output$map <- renderLeaflet({
- input$print
leaflet() %>%
- addTiles() %>%
- addEasyprint(options = easyprintOptions(title = 'Give me that map',
- position = 'bottomleft',
- exportOnly = FALSE,
- filename = "mapit",
- hideClasses = list("div1","div2"),
- customWindowTitle = "Some Fancy Title",
- customSpinnerClass = "shiny-spinner-placeholder",
- spinnerBgColor = "#b48484"))
+ addTiles(group = "basemap") %>%
+ addCircleMarkers(data=leaflet::breweries91,
+ group = "markers", popup = ~brewery, label=~brewery) %>%
+ addPopups(data=leaflet::breweries91[1:5,],
+ group = "popups", popup = ~brewery) %>%
+ addEasyprint(options = easyprintOptions(
+ title = 'Give me that map',
+ position = 'bottomleft',
+ exportOnly = TRUE,
+ # hideClasses = list("leaflet-overlay-pane", "leaflet-popup"),
+ # hidden = FALSE, hideControlContainer = TRUE,
+ filename = "mapit",
+ tileLayer = "basemap",
+ tileWait = 5000,
+ defaultSizeTitles = list(
+ "CurrentSize" = "The current map extent",
+ "A4Landscape" = "A4 (Landscape) extent with w:1045, h:715",
+ "A4Portrait" = "A4 (Portrait) extent with w:715, h:1045"
+ ),
+ # sizeModes = c("A4Portrait","A4Landscape"),
+ sizeModes = list("CurrentSize" = "CurrentSize",
+ "A4Landscape" = "A4Landscape",
+ "A4Portrait" = "A4Portrait",
+ "Custom Landscape"=list(
+ width= 1800,
+ height= 700,
+ name = "A custom landscape size tooltip",
+ className= 'customCssClass'),
+ "Custom Portrait"=list(
+ width= 700,
+ height= 1800,
+ name = "A custom portrait size tooltip",
+ className= 'customCssClass1')
+ ),
+ customWindowTitle = "Some Fancy Title",
+ customSpinnerClass = "shiny-spinner-placeholder",
+ spinnerBgColor = "#b48484"))
})
observeEvent(input$print, {
+ scene <- input$scene
leafletProxy("map") %>%
- easyprintMap(sizeModes = input$scene, filename = input$fn)
+ easyprintMap(sizeModes = scene, filename = input$fn)
+ # easyprintMap(sizeModes = scene, filename = scene)
})
observeEvent(input$rem, {
leafletProxy("map") %>%
@@ -39,24 +79,9 @@ server <- function(input, output, session) {
observeEvent(input$cle, {
leafletProxy("map") %>%
clearControls()
- # clearGroup("easyprintgroup")
})
}
shinyApp(ui, server)
-#
-# (title = 'Print map',
-# position = 'topleft',
-# sizeModes = NULL,
-# defaultSizeTitles = NULL,
-# exportOnly = FALSE,
-# tileLayer = NULL,
-# tileWait = 500,
-# filename = 'map',
-# hidden = FALSE,
-# hideControlContainer = TRUE,
-# hideClasses = list(),
-# customWindowTitle = NULL,
-# spinnerBgColor = '#0DC5C1',
-# customSpinnerClass = 'epLoader')
+
diff --git a/inst/examples/gibs_app.R b/inst/examples/gibs_app.R
new file mode 100644
index 00000000..e4eb751c
--- /dev/null
+++ b/inst/examples/gibs_app.R
@@ -0,0 +1,36 @@
+library(shiny)
+library(leaflet)
+library(leaflet.extras2)
+
+ui <- fluidPage(
+ leafletOutput("map", height = "700px"),
+ dateInput("date", "Date:", max = Sys.Date(), value = Sys.Date()-10),
+ actionButton("go", "Set the new Date"),
+ checkboxInput("trans", "Transparency", value = TRUE),
+ actionButton("go1", "Set the new Transparency")
+)
+
+layers <- gibs_layers$title[c(35, 128, 185)]
+
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ leaflet() %>%
+ addTiles() %>%
+ setView(9, 50, 6) %>%
+ addGIBS(layers = layers,
+ dates = Sys.Date() - 10,
+ group = layers, opacity = c(0.5, 0.3, 1)) %>%
+ addLayersControl(overlayGroups = layers)
+ })
+
+ observeEvent(input$go, {
+ leafletProxy("map",session) %>%
+ setDate(layers, input$date)
+ })
+ observeEvent(input$go1, {
+ leafletProxy("map",session) %>%
+ setTransparent(layers, input$trans)
+ })
+}
+
+shinyApp(ui, server)
diff --git a/inst/examples/heightgraph_app.R b/inst/examples/heightgraph_app.R
new file mode 100644
index 00000000..f7cd9b6a
--- /dev/null
+++ b/inst/examples/heightgraph_app.R
@@ -0,0 +1,123 @@
+library(shiny)
+library(leaflet)
+library(leaflet.extras2)
+library(sf)
+library(sfheaders)
+
+data(atlStorms2005)
+data <- st_cast(st_as_sf(atlStorms2005[1,]), "LINESTRING")
+data <- st_transform(data, 4326)
+data <- data.frame(st_coordinates(data))
+data$elev <- runif(nrow(data), 10, 500)
+data$L1 <- round(seq.int(1, 4, length.out = nrow(data)))
+data <- sfheaders::sf_linestring(data, x = "X",
+ y = "Y", z = "elev", linestring_id = "L1")
+data$steepness <- 1:nrow(data)
+data$suitability <- nrow(data):1
+data$popup <- apply(data, 1, function(x) {
+ sprintf("Steepness: %spopup for time:", data$time," ")
+# data$label1 <- paste("Time: ", data$time)
+
+## Multiple Trails ##############
+n = 150
+rows <- c(10, 21)
+trail_pts <- sf::st_line_sample(x = st_cast(mapview::trails[rows,], "LINESTRING"), n = n)
+trail_pts <- st_transform(trail_pts, 4326)
+data <- sf::st_as_sf(st_cast(trail_pts, "POINT"))
+colnames(data) <- "geometry"
+st_geometry(data) <- "geometry"
+nrows <- length(rows)
+data$id <- rep(1:nrows, each = n)
+time <- as.POSIXct(seq.POSIXt(Sys.time() - 1000, Sys.time(),
+ length.out = nrow(data)/nrows))
+data$time <- rep(time, nrows)
+data <- data[, c("id", "time","geometry")]
+data$popup1 <- paste("This is a popup for Track ID: ",
+ data$id," and time:", data$time," ")
+data$label1 <- paste("Track ID: ",data$id,"Customized Popup Name : %sTime : %s",
+ data$Name, data$time)
+data <- split(data, f = data$Name)
+
+
+ui <- fluidPage(
+ leafletOutput("map", height=800)
+)
+
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ map <- leaflet() %>%
+ addTiles()
+ map$dependencies <- c(map$dependencies,
+ leaflet:::leafletAwesomeMarkersDependencies())
+ map %>%
+ addPlayback(data = data,
+ popup = ~popup,
+ label = ~label,
+ name = ~Name,
+ popupOptions = popupOptions(offset=c(0,-35)),
+ options = playbackOptions(radius = 3, tickLen = 1000000,
+ speed = 5000,
+ marker = htmlwidgets::JS("
+ function(feature) {
+ var color = 'blue';
+ var icon = null;
+ switch (feature.name) {
+ case 'ALPHA':
+ color = 'red';
+ icon = 'glass';
+ break;
+ case 'ARLENE':
+ color = 'green';
+ icon = 'flag';
+ break;
+ case 'BRET':
+ color = 'blue';
+ icon = 'star';
+ break;
+ case 'CINDY':
+ color = 'orange';
+ icon = 'home';
+ break;
+ case 'DELTA':
+ color = 'purple';
+ icon = 'bookmark';
+ break;
+ }
+ return {
+ icon: L.AwesomeMarkers.icon({
+ icon: icon,
+ markerColor: color
+ })
+ }
+ }"),
+ maxInterpolationTime = 10000,
+ transitionpopup = FALSE,
+ transitionlabel = FALSE,
+ playCommand = "Let's go",
+ stopCommand = "Stop it!",
+ color = c("red","green","blue",
+ "orange","purple")),
+ pathOpts = pathOptions(weight = 5))
+ })
+}
+shinyApp(ui, server)
diff --git a/inst/examples/playback_app_divicon.R b/inst/examples/playback_app_divicon.R
new file mode 100644
index 00000000..864a3eef
--- /dev/null
+++ b/inst/examples/playback_app_divicon.R
@@ -0,0 +1,110 @@
+library(shiny)
+library(sf)
+library(leaflet)
+library(leaflet.extras2)
+
+data(atlStorms2005)
+data <- sf::st_as_sf(leaflet::atlStorms2005)[1:5,]
+data$Name <- as.character(data$Name)
+data <- st_cast(data, "POINT")
+data$time <- unlist(lapply(rle(data$Name)$lengths, function(x) {
+ seq.POSIXt(as.POSIXct(Sys.Date()-2), as.POSIXct(Sys.Date()), length.out = x)
+}))
+data$time <- as.POSIXct(data$time, origin="1970-01-01")
+data$label <- paste0("Time: ", data$time)
+data$popup = sprintf("Customized Popup Name : %sTime : %s",
+ data$Name, data$time)
+data <- split(data, f = data$Name)
+
+
+ui <- fluidPage(
+ tags$head(tags$style("
+ .leaflet-div-icon {
+ background: transparent !important;
+ border: unset !important;
+ }
+ .divicon {
+ border: 1px solid #666;
+ border-radius: 50%;
+ font-size: 14px;
+ color: black;
+ text-align: center;
+ width: 30px !important;
+ height: 30px !important;
+ padding-top: 3px;
+ font-weight: 800;
+ }
+ .red {
+ background-color: #db0a0a;
+ }
+ .green {
+ background-color: #1fdb0a;
+ }
+ .blue {
+ background-color: #0a34db;
+ }
+ .orange {
+ background-color: #f4ba27;
+ }
+ .purple {
+ background-color: #f127f4;
+ }
+ ")),
+ leafletOutput("map", height=800)
+)
+
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ leaflet() %>%
+ addTiles() %>%
+ addPlayback(data = data,
+ popup = ~popup,
+ label = ~label,
+ name = ~Name,
+ popupOptions = popupOptions(offset=c(8,0)),
+ labelOptions = labelOptions(offset=c(8,-10)),
+ options = playbackOptions(radius = 3, tickLen = 1000000,
+ speed = 5000,
+ marker = htmlwidgets::JS("
+ function(feature) {
+ var CssClass = 'blue';
+ var text = null;
+ switch (feature.name) {
+ case 'ALPHA':
+ CssClass = 'red';
+ text = 'A';
+ break;
+ case 'ARLENE':
+ CssClass = 'green';
+ text = 'B';
+ break;
+ case 'BRET':
+ CssClass = 'blue';
+ text = 'C';
+ break;
+ case 'CINDY':
+ CssClass = 'orange';
+ text = 'D';
+ break;
+ case 'DELTA':
+ CssClass = 'purple';
+ text = 'E';
+ break;
+ }
+ return {
+ icon: L.divIcon({
+ html: '' + text + '
'
+ })
+ }
+ }"),
+ maxInterpolationTime = 10000,
+ transitionpopup = FALSE,
+ transitionlabel = FALSE,
+ playCommand = "Let's go",
+ stopCommand = "Stop it!",
+ color = c("red","green","blue",
+ "orange","purple")),
+ pathOpts = pathOptions(weight = 5))
+ })
+}
+shinyApp(ui, server)
diff --git a/inst/examples/reachability_app.R b/inst/examples/reachability_app.R
index 2e30515c..0ae82a7f 100644
--- a/inst/examples/reachability_app.R
+++ b/inst/examples/reachability_app.R
@@ -1,9 +1,10 @@
+library(shiny)
library(leaflet)
library(leaflet.extras2)
-library(shiny)
-## TODO - Include your own Openrouteservice API-key.
-apiKey <- Sys.getenv("OPRS")
+## Include your API-Key
+# Sys.setenv("OPRS" = 'Your_API_Key')
+apikey <- Sys.getenv("OPRS")
ui <- fluidPage(
icon("cars"), ## needed to load FontAwesome Lib
@@ -17,7 +18,7 @@ server <- function(input, output, session) {
addTiles(group = "base") %>%
setView(8, 50, 11) %>%
addLayersControl(baseGroups = "base") %>%
- addReachability(apiKey = apiKey,
+ addReachability(apikey = apikey,
options = reachabilityOptions(
collapsed = FALSE,
drawButtonContent = as.character(icon("plus")),
diff --git a/inst/examples/side_by_side_app.R b/inst/examples/side_by_side_app.R
index 1d8965c4..0e252bd6 100644
--- a/inst/examples/side_by_side_app.R
+++ b/inst/examples/side_by_side_app.R
@@ -14,12 +14,16 @@ server <- function(input, output, session) {
addMapPane("right", zIndex = 0) %>%
addTiles(group = "base", layerId = "baseid",
options = pathOptions(pane = "right")) %>%
- addProviderTiles(providers$CartoDB.DarkMatter, group="carto", layerId = "cartoid",
+ addProviderTiles(providers$CartoDB.DarkMatter,
+ group="carto", layerId = "cartoid",
options = pathOptions(pane = "left")) %>%
- addCircleMarkers(data = breweries91[1:15,], color = "blue", group = "blue",
+ addCircleMarkers(data = breweries91[1:15,],
+ color = "blue", group = "blue",
options = pathOptions(pane = "left")) %>%
- addCircleMarkers(data = breweries91[15:20,], color = "yellow", group = "yellow") %>%
- addCircleMarkers(data = breweries91[15:30,], color = "red", group = "red",
+ addCircleMarkers(data = breweries91[15:20,],
+ color = "yellow", group = "yellow") %>%
+ addCircleMarkers(data = breweries91[15:30,],
+ color = "red", group = "red",
options = pathOptions(pane = "right")) %>%
addLayersControl(overlayGroups = c("blue","red", "yellow")) %>%
addSidebyside(layerId = "sidecontrols",
diff --git a/inst/examples/sidebar_app.R b/inst/examples/sidebar_app.R
index a81fe075..37c3f6c8 100644
--- a/inst/examples/sidebar_app.R
+++ b/inst/examples/sidebar_app.R
@@ -5,56 +5,67 @@ library(leaflet.extras2)
data(breweries91, package = "leaflet")
+breweries_data <- breweries91 |>
+ st_as_sf()
+
+sample_brewery_data <- function(data, n_obs){
+ ii <- sample.int(nrow(data),n_obs,replace = TRUE)
+ data[ii,]
+}
+
ui <- fluidPage(
+ tags$head(tags$style(".btn-default {display: block;}")),
h4("Leaflet Sidebar Plugin"),
- splitLayout(cellWidths = c("30%", "70%"),
+ splitLayout(cellWidths = c("20%", "80%"),
tagList(
actionButton("open", "Open Sidebar"),
actionButton("close", "Close Sidebar"),
- actionButton("clear", "Clear Sidebar")
+ actionButton("clear", "Clear Sidebar"),
+ verbatimTextOutput("whichtab")
),
tagList(
- sidebar_tabs(
- list(icon("car"), icon("user"), icon("envelope")),
- sidebar_pane(
- title = "home", id = "home_id", icon = icon("home"),
- tagList(
- sliderInput("obs", "Number of observations:",
- min = 1, max = 32, value = 10
- ),
- dateRangeInput("daterange4", "Date range:",
- start = Sys.Date() - 10,
- end = Sys.Date() + 10
- ),
- verbatimTextOutput("tab1")
- )
- ),
- sidebar_pane(
- title = "profile", id = "profile_id", icon = icon("wrench"),
- tagList(
- textInput("caption", "Caption", "Data Summary"),
- selectInput("label", "Label", choices = c("brewery", "address", "zipcode", "village")),
- passwordInput("password", "Password:"),
- actionButton("go", "Go"),
- verbatimTextOutput("value")
- )
- ),
- sidebar_pane(
- title = "messages", id = "messages_id", icon = icon("person"),
- tagList(
- checkboxGroupInput(
- "variable", "Variables to show:",
- c(
- "Cylinders" = "cyl",
- "Transmission" = "am",
- "Gears" = "gear"
- )
- ),
- tableOutput("data")
- )
- )
+ sidebar_tabs(id = "mysidebarid",
+ list(icon("car"), icon("user"), icon("envelope")),
+ sidebar_pane(
+ title = "home", id = "home_id", icon = icon("home"),
+ tagList(
+ sliderInput("obs", "Number of observations:",
+ min = 1, max = 32, value = 10),
+ sliderInput("opa", "Point Opacity:",
+ min = 0, max = 1, value = 0.5),
+ sliderInput("fillopa", "Fill Opacity:",
+ min = 0, max = 1, value = 0.2),
+ dateRangeInput("daterange4", "Date range:",
+ start = Sys.Date() - 10,
+ end = Sys.Date() + 10),
+ verbatimTextOutput("tab1")
+ )
+ ),
+ sidebar_pane(
+ title = "profile", id = "profile_id", icon = icon("wrench"),
+ tagList(
+ textInput("caption", "Caption", "Data Summary"),
+ selectInput("label", "Label",
+ choices = c("brewery", "address",
+ "zipcode", "village")),
+ passwordInput("password", "Password:"),
+ actionButton("go", "Go"),
+ verbatimTextOutput("value")
+ )
+ ),
+ sidebar_pane(
+ title = "messages", id = "messages_id",
+ icon = icon("person", verify_fa = FALSE),
+ tagList(
+ checkboxGroupInput("variable", "Variables to show:",
+ c("Cylinders" = "cyl",
+ "Transmission" = "am",
+ "Gears" = "gear")),
+ tableOutput("data")
+ )
+ )
),
- leafletOutput("map")
+ leafletOutput("map", height = "700px")
)
)
)
@@ -64,31 +75,40 @@ server <- function(input, output, session) {
leaflet() %>%
addTiles() %>%
addSidebar(
- id = "sidebar",
- options = list(position = "left", fit = TRUE)
+ id = "mysidebarid",
+ options = list(position = "left")
)
})
+ output$whichtab <- renderPrint({
+ paste0(req(input$mysidebarid), " is open")
+ })
+
observe({
req(input$obs)
- df <- breweries91[sample.int(nrow(breweries91), input$obs), ]
- bbox <- st_bbox(df)
+
+ df <- breweries_data |>
+ sample_brewery_data(n_obs = input$obs)
+
+ bbox <- suppressWarnings(st_bbox(df))
leafletProxy("map", session) %>%
clearGroup("pts") %>%
- addCircleMarkers(data = df, label = df[[input$label]], group = "pts") %>%
+ addCircleMarkers(data = df,
+ label = df[[input$label]],
+ opacity = input$opa,
+ fillOpacity = input$fillopa,
+ group = "pts") %>%
fitBounds(bbox[[1]], bbox[[2]], bbox[[3]], bbox[[4]])
})
output$tab1 <- renderText({
input$obs
})
-
output$value <- renderText({
req(input$go)
isolate(input$password)
})
-
output$data <- renderTable(rownames = FALSE, {
- mtcars[, c("mpg", input$variable), drop = FALSE]
+ mtcars[, c("mpg", input$variable), drop = FALSE]
})
observeEvent(input$open, {
diff --git a/inst/examples/spin_app.R b/inst/examples/spin_app.R
new file mode 100644
index 00000000..fa1d3d5f
--- /dev/null
+++ b/inst/examples/spin_app.R
@@ -0,0 +1,36 @@
+library(shiny)
+library(leaflet)
+library(leaflet.extras2)
+
+dlat <- 1 / 111000 * 100 # degrees per metre
+
+ui <- fluidRow(
+ tags$h2("Using Leaflet.Spin in Shiny"),
+ actionButton("plotbutton", label = "Show Spinner While Adding Markers"),
+ leafletOutput("map")
+)
+
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ leaflet() %>%
+ addTiles() %>%
+ setView(175.322, -37.789, zoom = 17) %>%
+ addSpinner()
+ })
+
+ observeEvent(input$plotbutton, {
+ n <- ceiling(runif(1) * 10000)
+ leafletProxy("map") %>%
+ startSpinner(list("lines" = 7, "length" = 40,
+ "width" = 20, "radius" = 10)) %>%
+ clearShapes() %>%
+ addCircles(
+ lng = 175.322 + (runif(n) * 2 - 1) * dlat * 6,
+ lat = -37.789 + (runif(n) * 2 - 1) * dlat * 1.5,
+ radius = dlat * runif(n) * dlat
+ ) %>%
+ stopSpinner()
+ })
+}
+
+shinyApp(ui = ui, server = server)
diff --git a/inst/examples/tangram/tangram_app.R b/inst/examples/tangram/tangram_app.R
index 90623f2c..15efffd0 100644
--- a/inst/examples/tangram/tangram_app.R
+++ b/inst/examples/tangram/tangram_app.R
@@ -2,10 +2,7 @@ library(shiny)
library(leaflet)
library(leaflet.extras2)
-## Load Tangram-JS in debug mode
-options("leaflet.extras2.minified" = FALSE)
-
-## File is in /www folder. (Enter your API-Key in the global section)
+## File is in /www folder. (Enter your Nextzen API-Key in the global section)
scene <- "scene.yaml"
ui <- fluidPage(leafletOutput("map"))
@@ -21,9 +18,14 @@ server <- function(input, output, session) {
modifyZoomBehavior = TRUE,
webGLContextOptions = list(
preserveDrawingBuffer = TRUE,
- antialias = FALSE)
- # ,postUpdate = htmlwidgets::JS("function(didRender) {console.log('postUpdate!');
- # if (didRender) {console.log('new frame rendered!');}}")
+ antialias = FALSE),
+ postUpdate = htmlwidgets::JS("
+ function(didRender) {
+ console.log('postUpdate!');
+ if (didRender) {
+ console.log('New frame rendered!');
+ }
+ }")
)) %>%
addCircleMarkers(data = breweries91, group = "brews") %>%
setView(11, 49.4, 14) %>%
diff --git a/inst/examples/tangram/www/pois.png b/inst/examples/tangram/www/pois.png
new file mode 100644
index 00000000..3818d492
Binary files /dev/null and b/inst/examples/tangram/www/pois.png differ
diff --git a/inst/examples/tangram/www/scene.yaml b/inst/examples/tangram/www/scene.yaml
index 098cefa6..9b82f8a5 100644
--- a/inst/examples/tangram/www/scene.yaml
+++ b/inst/examples/tangram/www/scene.yaml
@@ -1,5 +1,5 @@
global:
- api_key: '__YOUR__NEXTZEN_API_KEY__' # put your nextzen API key here
+ api_key: 'Your_API_Key' # put your nextzen API key here
language: en # optional ISO 2-char code
language_text_source: |
function() {
@@ -41,7 +41,7 @@ fonts:
textures:
icons:
- url: images/pois.png
+ url: pois.png
filtering: mipmap
sprites:
# define sprites: [x origin, y origin, width, height]
diff --git a/inst/examples/timeslider_app.R b/inst/examples/timeslider_app.R
new file mode 100644
index 00000000..51513cf5
--- /dev/null
+++ b/inst/examples/timeslider_app.R
@@ -0,0 +1,45 @@
+library(leaflet)
+library(leaflet.extras2)
+library(sf)
+library(geojsonsf)
+library(shiny)
+
+data <- sf::st_as_sf(leaflet::atlStorms2005[1,])
+data <- suppressWarnings(st_cast(data, "POINT"))
+data$time = as.POSIXct(
+ seq.POSIXt(as.POSIXct(paste0(2020-nrow(data)+1,"-01-01")),
+ as.POSIXct("2020-01-01"), by = "year"))
+data1 <- sf::st_as_sf(leaflet::atlStorms2005[2,])
+data1 <- suppressWarnings(st_cast(data1, "POINT"))
+data1$time = as.POSIXct(
+ seq.POSIXt(as.POSIXct(paste0(2020-nrow(data1)+1,"-01-01")),
+ as.POSIXct("2020-01-01"), by = "year"))
+data <- rbind(data, data1)
+
+ui <- fluidPage(leafletOutput("map", height = "600px"))
+server <- function(input, output, session) {
+ output$map <- renderLeaflet({
+ opac <- runif(nrow(data), 0.5, 1)
+ leaflet() %>%
+ addTiles() %>%
+ addTimeslider(
+ data = data,
+ color = colorNumeric("viridis",
+ seq.int(nrow(data)))(seq.int(nrow(data))),
+ opacity = opac, fillOpacity = opac,
+ radius = sample(5:15, nrow(data), TRUE),
+ popupOptions = popupOptions(maxWidth = 1000,
+ closeOnClick = TRUE,
+ closeButton = FALSE),
+ popup = ~sprintf("Time: %sm'
+ * @param {string} value
+ * @returns Boolean
+ */
+function isInMeters(value) {
+ return (
+ value
+ .toString()
+ .trim()
+ .slice(value.toString().length - 1, value.toString().length) === 'm'
+ );
+}
+
+/**
+ * Whether or not a string is in the format '%'
+ * @param {string} value
+ * @returns Boolean
+ */
+function isInPercent(value) {
+ return (
+ value
+ .toString()
+ .trim()
+ .slice(value.toString().length - 1, value.toString().length) === '%'
+ );
+}
+
+/**
+ * Whether or not a string is in the format 'px'
+ * @param {string} value
+ * @returns Boolean
+ */
+function isInPixels(value) {
+ return (
+ value
+ .toString()
+ .trim()
+ .slice(value.toString().length - 2, value.toString().length) === 'px'
+ );
+}
+
+function pixelsToMeters(pixels, map) {
+ let refPoint1 = map.getCenter();
+ let xy1 = map.latLngToLayerPoint(refPoint1);
+ let xy2 = {
+ x: xy1.x + Number(pixels),
+ y: xy1.y,
+ };
+ let refPoint2 = map.layerPointToLatLng(xy2);
+ let derivedMeters = map.distance(refPoint1, refPoint2);
+ return derivedMeters;
+}
+
+L.Polyline.include({
+ /**
+ * Adds arrowheads to an L.polyline
+ * @param {object} options The options for the arrowhead. See documentation for details
+ * @returns The L.polyline instance that they arrowheads are attached to
+ */
+ arrowheads: function (options = {}) {
+ // Merge user input options with default options:
+ const defaults = {
+ yawn: 60,
+ size: '15%',
+ frequency: 'allvertices',
+ proportionalToTotal: false,
+ };
+
+ this.options.noClip = true;
+
+ let actualOptions = Object.assign({}, defaults, options);
+ this._arrowheadOptions = actualOptions;
+
+ this._hatsApplied = true;
+ return this;
+ },
+
+ buildVectorHats: function (options) {
+ // Reset variables from previous this._update()
+ if (this._arrowheads) {
+ this._arrowheads.remove();
+ }
+
+ if (this._ghosts) {
+ this._ghosts.remove();
+ }
+
+ // -------------------------------------------------------- //
+ // ------------ FILTER THE OPTIONS ----------------------- //
+ /*
+ * The next 3 lines folds the options of the parent polyline into the default options for all polylines
+ * The options for the arrowhead are then folded in as well
+ * All options defined in parent polyline will be inherited by the arrowhead, unless otherwise specified in the arrowhead(options) call
+ */
+
+ let defaultOptionsOfParent = Object.getPrototypeOf(
+ Object.getPrototypeOf(this.options)
+ );
+
+ // merge default options of parent polyline (this.options's prototype's prototype) with options passed to parent polyline (this.options).
+ let parentOptions = Object.assign({}, defaultOptionsOfParent, this.options);
+
+ // now merge in the options the user has put in the arrowhead call
+ let hatOptions = Object.assign({}, parentOptions, options);
+
+ // ...with a few exceptions:
+ hatOptions.smoothFactor = 1;
+ hatOptions.fillOpacity = 1;
+ hatOptions.fill = options.fill ? true : false;
+ hatOptions.interactive = false;
+
+ // ------------ FILTER THE OPTIONS END -------------------- //
+ // --------------------------------------------------------- //
+
+ // --------------------------------------------------------- //
+ // ------ LOOP THROUGH EACH POLYLINE SEGMENT --------------- //
+ // ------ TO CALCULATE HAT SIZES AND CAPTURE IN ARRAY ------ //
+
+ let size = options.size.toString(); // stringify if its a number
+ let allhats = []; // empty array to receive hat polylines
+ const { frequency, offsets } = options;
+
+ if (offsets?.start || offsets?.end) {
+ this._buildGhosts({ start: offsets.start, end: offsets.end });
+ }
+
+ const lineToTrace = this._ghosts || this;
+
+ lineToTrace._parts.forEach((peice, index) => {
+ // Immutable variables for each peice
+ const latlngs = peice.map((point) => this._map.layerPointToLatLng(point));
+
+ const totalLength = (() => {
+ let total = 0;
+ for (var i = 0; i < peice.length - 1; i++) {
+ total += this._map.distance(latlngs[i], latlngs[i + 1]);
+ }
+ return total;
+ })();
+
+ // TBD by options if tree below
+ let derivedLatLngs;
+ let derivedBearings;
+ let spacing;
+ let noOfPoints;
+
+ // Determining latlng and bearing arrays based on frequency choice:
+ if (!isNaN(frequency)) {
+ spacing = 1 / frequency;
+ noOfPoints = frequency;
+ } else if (isInPercent(frequency)) {
+ console.error(
+ 'Error: arrowhead frequency option cannot be given in percent. Try another unit.'
+ );
+ } else if (isInMeters(frequency)) {
+ spacing = frequency.slice(0, frequency.length - 1) / totalLength;
+ noOfPoints = 1 / spacing;
+ // round things out for more even spacing:
+ noOfPoints = Math.floor(noOfPoints);
+ spacing = 1 / noOfPoints;
+ } else if (isInPixels(frequency)) {
+ spacing = (() => {
+ let chosenFrequency = frequency.slice(0, frequency.length - 2);
+ let derivedMeters = pixelsToMeters(chosenFrequency, this._map);
+ return derivedMeters / totalLength;
+ })();
+
+ noOfPoints = 1 / spacing;
+
+ // round things out for more even spacing:
+ noOfPoints = Math.floor(noOfPoints);
+ spacing = 1 / noOfPoints;
+ }
+
+ if (options.frequency === 'allvertices') {
+ derivedBearings = (() => {
+ let bearings = [];
+ for (var i = 1; i < latlngs.length; i++) {
+ let bearing =
+ L.GeometryUtil.angle(
+ this._map,
+ latlngs[modulus(i - 1, latlngs.length)],
+ latlngs[i]
+ ) + 180;
+ bearings.push(bearing);
+ }
+ return bearings;
+ })();
+
+ derivedLatLngs = latlngs;
+ derivedLatLngs.shift();
+ } else if (options.frequency === 'endonly' && latlngs.length >= 2) {
+ derivedLatLngs = [latlngs[latlngs.length - 1]];
+
+ derivedBearings = [
+ L.GeometryUtil.angle(
+ this._map,
+ latlngs[latlngs.length - 2],
+ latlngs[latlngs.length - 1]
+ ) + 180,
+ ];
+ } else {
+ derivedLatLngs = [];
+ let interpolatedPoints = [];
+ for (var i = 0; i < noOfPoints; i++) {
+ let interpolatedPoint = L.GeometryUtil.interpolateOnLine(
+ this._map,
+ latlngs,
+ spacing * (i + 1)
+ );
+
+ if (interpolatedPoint) {
+ interpolatedPoints.push(interpolatedPoint);
+ derivedLatLngs.push(interpolatedPoint.latLng);
+ }
+ }
+
+ derivedBearings = (() => {
+ let bearings = [];
+
+ for (var i = 0; i < interpolatedPoints.length; i++) {
+ let bearing = L.GeometryUtil.angle(
+ this._map,
+ latlngs[interpolatedPoints[i].predecessor + 1],
+ latlngs[interpolatedPoints[i].predecessor]
+ );
+ bearings.push(bearing);
+ }
+ return bearings;
+ })();
+ }
+
+ let hats = [];
+
+ // Function to build hats based on index and a given hatsize in meters
+ const pushHats = (size, localHatOptions = {}) => {
+ let yawn = localHatOptions.yawn ?? options.yawn;
+
+ let leftWingPoint = L.GeometryUtil.destination(
+ derivedLatLngs[i],
+ derivedBearings[i] - yawn / 2,
+ size
+ );
+
+ let rightWingPoint = L.GeometryUtil.destination(
+ derivedLatLngs[i],
+ derivedBearings[i] + yawn / 2,
+ size
+ );
+
+ let hatPoints = [
+ [leftWingPoint.lat, leftWingPoint.lng],
+ [derivedLatLngs[i].lat, derivedLatLngs[i].lng],
+ [rightWingPoint.lat, rightWingPoint.lng],
+ ];
+
+ let hat = options.fill
+ ? L.polygon(hatPoints, { ...hatOptions, ...localHatOptions })
+ : L.polyline(hatPoints, { ...hatOptions, ...localHatOptions });
+
+ hats.push(hat);
+ }; // pushHats()
+
+ // Function to build hats based on pixel input
+ const pushHatsFromPixels = (size, localHatOptions = {}) => {
+ let sizePixels = size.slice(0, size.length - 2);
+ let yawn = localHatOptions.yawn ?? options.yawn;
+
+ let derivedXY = this._map.latLngToLayerPoint(derivedLatLngs[i]);
+
+ let bearing = derivedBearings[i];
+
+ let thetaLeft = (180 - bearing - yawn / 2) * (Math.PI / 180),
+ thetaRight = (180 - bearing + yawn / 2) * (Math.PI / 180);
+
+ let dxLeft = sizePixels * Math.sin(thetaLeft),
+ dyLeft = sizePixels * Math.cos(thetaLeft),
+ dxRight = sizePixels * Math.sin(thetaRight),
+ dyRight = sizePixels * Math.cos(thetaRight);
+
+ let leftWingXY = {
+ x: derivedXY.x + dxLeft,
+ y: derivedXY.y + dyLeft,
+ };
+ let rightWingXY = {
+ x: derivedXY.x + dxRight,
+ y: derivedXY.y + dyRight,
+ };
+
+ let leftWingPoint = this._map.layerPointToLatLng(leftWingXY),
+ rightWingPoint = this._map.layerPointToLatLng(rightWingXY);
+
+ let hatPoints = [
+ [leftWingPoint.lat, leftWingPoint.lng],
+ [derivedLatLngs[i].lat, derivedLatLngs[i].lng],
+ [rightWingPoint.lat, rightWingPoint.lng],
+ ];
+
+ let hat = options.fill
+ ? L.polygon(hatPoints, { ...hatOptions, ...localHatOptions })
+ : L.polyline(hatPoints, { ...hatOptions, ...localHatOptions });
+
+ hats.push(hat);
+ }; // pushHatsFromPixels()
+
+ // ------- LOOP THROUGH POINTS IN EACH SEGMENT ---------- //
+ for (var i = 0; i < derivedLatLngs.length; i++) {
+ let { perArrowheadOptions, ...globalOptions } = options;
+
+ perArrowheadOptions = perArrowheadOptions ? perArrowheadOptions(i) : {};
+ perArrowheadOptions = Object.assign(
+ globalOptions,
+ definedProps(perArrowheadOptions)
+ );
+
+ size = perArrowheadOptions.size ?? size;
+
+ // ---- If size is chosen in meters -------------------------
+ if (isInMeters(size)) {
+ let hatSize = size.slice(0, size.length - 1);
+ pushHats(hatSize, perArrowheadOptions);
+
+ // ---- If size is chosen in percent ------------------------
+ } else if (isInPercent(size)) {
+ let sizePercent = size.slice(0, size.length - 1);
+ let hatSize = (() => {
+ if (
+ options.frequency === 'endonly' &&
+ options.proportionalToTotal
+ ) {
+ return (totalLength * sizePercent) / 100;
+ } else {
+ let averageDistance = totalLength / (peice.length - 1);
+ return (averageDistance * sizePercent) / 100;
+ }
+ })(); // hatsize calculation
+
+ pushHats(hatSize, perArrowheadOptions);
+
+ // ---- If size is chosen in pixels --------------------------
+ } else if (isInPixels(size)) {
+ pushHatsFromPixels(options.size, perArrowheadOptions);
+
+ // ---- If size unit is not given -----------------------------
+ } else {
+ console.error(
+ 'Error: Arrowhead size unit not defined. Check your arrowhead options.'
+ );
+ } // if else block for Size
+ } // for loop for each point witin a peice
+
+ allhats.push(...hats);
+ }); // forEach peice
+
+ // --------- LOOP THROUGH EACH POLYLINE END ---------------- //
+ // --------------------------------------------------------- //
+
+ let arrowheads = L.layerGroup(allhats);
+ this._arrowheads = arrowheads;
+
+ return this;
+ },
+
+ getArrowheads: function () {
+ if (this._arrowheads) {
+ return this._arrowheads;
+ } else {
+ return console.error(
+ `Error: You tried to call '.getArrowheads() on a shape that does not have a arrowhead. Use '.arrowheads()' to add a arrowheads before trying to call '.getArrowheads()'`
+ );
+ }
+ },
+
+ /**
+ * Builds ghost polylines that are clipped versions of the polylines based on the offsets
+ * If offsets are used, arrowheads are drawn from 'this._ghosts' rather than 'this'
+ */
+ _buildGhosts: function ({ start, end }) {
+ if (start || end) {
+ let latlngs = this.getLatLngs();
+
+ latlngs = Array.isArray(latlngs[0]) ? latlngs : [latlngs];
+
+ const newLatLngs = latlngs.map((segment) => {
+ // Get total distance of original latlngs
+ const totalLength = (() => {
+ let total = 0;
+ for (var i = 0; i < segment.length - 1; i++) {
+ total += this._map.distance(segment[i], segment[i + 1]);
+ }
+ return total;
+ })();
+
+ // Modify latlngs to end at interpolated point
+ if (start) {
+ let endOffsetInMeters = (() => {
+ if (isInMeters(start)) {
+ return Number(start.slice(0, start.length - 1));
+ } else if (isInPixels(start)) {
+ let pixels = Number(start.slice(0, start.length - 2));
+ return pixelsToMeters(pixels, this._map);
+ }
+ })();
+
+ let newStart = L.GeometryUtil.interpolateOnLine(
+ this._map,
+ segment,
+ endOffsetInMeters / totalLength
+ );
+
+ segment = segment.slice(
+ newStart.predecessor === -1 ? 1 : newStart.predecessor + 1,
+ segment.length
+ );
+ segment.unshift(newStart.latLng);
+ }
+
+ if (end) {
+ let endOffsetInMeters = (() => {
+ if (isInMeters(end)) {
+ return Number(end.slice(0, end.length - 1));
+ } else if (isInPixels(end)) {
+ let pixels = Number(end.slice(0, end.length - 2));
+ return pixelsToMeters(pixels, this._map);
+ }
+ })();
+
+ let newEnd = L.GeometryUtil.interpolateOnLine(
+ this._map,
+ segment,
+ (totalLength - endOffsetInMeters) / totalLength
+ );
+
+ segment = segment.slice(0, newEnd.predecessor + 1);
+ segment.push(newEnd.latLng);
+ }
+
+ return segment;
+ });
+
+ this._ghosts = L.polyline(newLatLngs, {
+ ...this.options,
+ color: 'rgba(0,0,0,0)',
+ stroke: 0,
+ smoothFactor: 0,
+ interactive: false,
+ });
+ this._ghosts.addTo(this._map);
+ }
+ },
+
+ deleteArrowheads: function () {
+ if (this._arrowheads) {
+ this._arrowheads.remove();
+ delete this._arrowheads;
+ delete this._arrowheadOptions;
+ this._hatsApplied = false;
+ }
+ if (this._ghosts) {
+ this._ghosts.remove();
+ }
+ },
+
+ _update: function () {
+ if (!this._map) {
+ return;
+ }
+
+ this._clipPoints();
+ this._simplifyPoints();
+ this._updatePath();
+
+ if (this._hatsApplied) {
+ this.buildVectorHats(this._arrowheadOptions);
+ this._map.addLayer(this._arrowheads);
+ }
+ },
+
+ remove: function () {
+ if (this._arrowheads) {
+ this._arrowheads.remove();
+ }
+ if (this._ghosts) {
+ this._ghosts.remove();
+ }
+ return this.removeFrom(this._map || this._mapToAdd);
+ },
+});
+
+L.LayerGroup.include({
+ removeLayer: function (layer) {
+ var id = layer in this._layers ? layer : this.getLayerId(layer);
+
+ if (this._map && this._layers[id]) {
+ if (this._layers[id]._arrowheads) {
+ this._layers[id]._arrowheads.remove();
+ }
+ this._map.removeLayer(this._layers[id]);
+ }
+
+ delete this._layers[id];
+
+ return this;
+ },
+
+ onRemove: function (map, layer) {
+ for (var layer in this._layers) {
+ if (this._layers[layer]) {
+ this._layers[layer].remove();
+ }
+ }
+
+ this.eachLayer(map.removeLayer, map);
+ },
+});
+
+L.Map.include({
+ removeLayer: function (layer) {
+ var id = L.Util.stamp(layer);
+
+ if (layer._arrowheads) {
+ layer._arrowheads.remove();
+ }
+ if (layer._ghosts) {
+ layer._ghosts.remove();
+ }
+
+ if (!this._layers[id]) {
+ return this;
+ }
+
+ if (this._loaded) {
+ layer.onRemove(this);
+ }
+
+ if (layer.getAttribution && this.attributionControl) {
+ this.attributionControl.removeAttribution(layer.getAttribution());
+ }
+
+ delete this._layers[id];
+
+ if (this._loaded) {
+ this.fire('layerremove', { layer: layer });
+ layer.fire('remove');
+ }
+
+ layer._map = layer._mapToAdd = null;
+
+ return this;
+ },
+});
+
+L.GeoJSON.include({
+ geometryToLayer: function (geojson, options) {
+ var geometry = geojson.type === 'Feature' ? geojson.geometry : geojson,
+ coords = geometry ? geometry.coordinates : null,
+ layers = [],
+ pointToLayer = options && options.pointToLayer,
+ _coordsToLatLng =
+ (options && options.coordsToLatLng) || L.GeoJSON.coordsToLatLng,
+ latlng,
+ latlngs,
+ i,
+ len;
+
+ if (!coords && !geometry) {
+ return null;
+ }
+
+ switch (geometry.type) {
+ case 'Point':
+ latlng = _coordsToLatLng(coords);
+ return this._pointToLayer(pointToLayer, geojson, latlng, options);
+
+ case 'MultiPoint':
+ for (i = 0, len = coords.length; i < len; i++) {
+ latlng = _coordsToLatLng(coords[i]);
+ layers.push(
+ this._pointToLayer(pointToLayer, geojson, latlng, options)
+ );
+ }
+ return new L.FeatureGroup(layers);
+
+ case 'LineString':
+ case 'MultiLineString':
+ latlngs = L.GeoJSON.coordsToLatLngs(
+ coords,
+ geometry.type === 'LineString' ? 0 : 1,
+ _coordsToLatLng
+ );
+ var polyline = new L.Polyline(latlngs, options);
+ if (options.arrowheads) {
+ polyline.arrowheads(options.arrowheads);
+ }
+ return polyline;
+
+ case 'Polygon':
+ case 'MultiPolygon':
+ latlngs = L.GeoJSON.coordsToLatLngs(
+ coords,
+ geometry.type === 'Polygon' ? 1 : 2,
+ _coordsToLatLng
+ );
+ return new L.Polygon(latlngs, options);
+
+ case 'GeometryCollection':
+ for (i = 0, len = geometry.geometries.length; i < len; i++) {
+ var layer = this.geometryToLayer(
+ {
+ geometry: geometry.geometries[i],
+ type: 'Feature',
+ properties: geojson.properties,
+ },
+ options
+ );
+
+ if (layer) {
+ layers.push(layer);
+ }
+ }
+ return new L.FeatureGroup(layers);
+
+ default:
+ throw new Error('Invalid GeoJSON object.');
+ }
+ },
+
+ addData: function (geojson) {
+ var features = L.Util.isArray(geojson) ? geojson : geojson.features,
+ i,
+ len,
+ feature;
+
+ if (features) {
+ for (i = 0, len = features.length; i < len; i++) {
+ // only add this if geometry or geometries are set and not null
+ feature = features[i];
+ if (
+ feature.geometries ||
+ feature.geometry ||
+ feature.features ||
+ feature.coordinates
+ ) {
+ this.addData(feature);
+ }
+ }
+ return this;
+ }
+
+ var options = this.options;
+
+ if (options.filter && !options.filter(geojson)) {
+ return this;
+ }
+
+ var layer = this.geometryToLayer(geojson, options);
+ if (!layer) {
+ return this;
+ }
+ layer.feature = L.GeoJSON.asFeature(geojson);
+
+ layer.defaultOptions = layer.options;
+ this.resetStyle(layer);
+
+ if (options.onEachFeature) {
+ options.onEachFeature(geojson, layer);
+ }
+
+ return this.addLayer(layer);
+ },
+
+ _pointToLayer: function (pointToLayerFn, geojson, latlng, options) {
+ return pointToLayerFn
+ ? pointToLayerFn(geojson, latlng)
+ : new L.Marker(
+ latlng,
+ options && options.markersInheritOptions && options
+ );
+ },
+});
diff --git a/inst/htmlwidgets/lfx-arrowhead/leaflet.geometryutil.js b/inst/htmlwidgets/lfx-arrowhead/leaflet.geometryutil.js
new file mode 100644
index 00000000..9bb53b30
--- /dev/null
+++ b/inst/htmlwidgets/lfx-arrowhead/leaflet.geometryutil.js
@@ -0,0 +1,767 @@
+// Packaging/modules magic dance.
+(function (factory) {
+ var L;
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['leaflet'], factory);
+ } else if (typeof module !== 'undefined') {
+ // Node/CommonJS
+ L = require('leaflet');
+ module.exports = factory(L);
+ } else {
+ // Browser globals
+ if (typeof window.L === 'undefined')
+ throw 'Leaflet must be loaded first';
+ factory(window.L);
+ }
+}(function (L) {
+"use strict";
+
+L.Polyline._flat = L.LineUtil.isFlat || L.Polyline._flat || function (latlngs) {
+ // true if it's a flat array of latlngs; false if nested
+ return !L.Util.isArray(latlngs[0]) || (typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined');
+};
+
+/**
+ * @fileOverview Leaflet Geometry utilities for distances and linear referencing.
+ * @name L.GeometryUtil
+ */
+
+L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
+
+ /**
+ Shortcut function for planar distance between two {L.LatLng} at current zoom.
+
+ @tutorial distance-length
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlngA geographical point A
+ @param {L.LatLng} latlngB geographical point B
+ @returns {Number} planar distance
+ */
+ distance: function (map, latlngA, latlngB) {
+ return map.latLngToLayerPoint(latlngA).distanceTo(map.latLngToLayerPoint(latlngB));
+ },
+
+ /**
+ Shortcut function for planar distance between a {L.LatLng} and a segment (A-B).
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @returns {Number} planar distance
+ */
+ distanceSegment: function (map, latlng, latlngA, latlngB) {
+ var p = map.latLngToLayerPoint(latlng),
+ p1 = map.latLngToLayerPoint(latlngA),
+ p2 = map.latLngToLayerPoint(latlngB);
+ return L.LineUtil.pointToSegmentDistance(p, p1, p2);
+ },
+
+ /**
+ Shortcut function for converting distance to readable distance.
+ @param {Number} distance distance to be converted
+ @param {String} unit 'metric' or 'imperial'
+ @returns {String} in yard or miles
+ */
+ readableDistance: function (distance, unit) {
+ var isMetric = (unit !== 'imperial'),
+ distanceStr;
+ if (isMetric) {
+ // show metres when distance is < 1km, then show km
+ if (distance > 1000) {
+ distanceStr = (distance / 1000).toFixed(2) + ' km';
+ }
+ else {
+ distanceStr = distance.toFixed(1) + ' m';
+ }
+ }
+ else {
+ distance *= 1.09361;
+ if (distance > 1760) {
+ distanceStr = (distance / 1760).toFixed(2) + ' miles';
+ }
+ else {
+ distanceStr = distance.toFixed(1) + ' yd';
+ }
+ }
+ return distanceStr;
+ },
+
+ /**
+ Returns true if the latlng belongs to segment A-B
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @param {?Number} [tolerance=0.2] tolerance to accept if latlng belongs really
+ @returns {boolean}
+ */
+ belongsSegment: function(latlng, latlngA, latlngB, tolerance) {
+ tolerance = tolerance === undefined ? 0.2 : tolerance;
+ var hypotenuse = latlngA.distanceTo(latlngB),
+ delta = latlngA.distanceTo(latlng) + latlng.distanceTo(latlngB) - hypotenuse;
+ return delta/hypotenuse < tolerance;
+ },
+
+ /**
+ * Returns total length of line
+ * @tutorial distance-length
+ *
+ * @param {L.Polyline|Array|Array} coords Set of coordinates
+ * @returns {Number} Total length (pixels for Point, meters for LatLng)
+ */
+ length: function (coords) {
+ var accumulated = L.GeometryUtil.accumulatedLengths(coords);
+ return accumulated.length > 0 ? accumulated[accumulated.length-1] : 0;
+ },
+
+ /**
+ * Returns a list of accumulated length along a line.
+ * @param {L.Polyline|Array|Array} coords Set of coordinates
+ * @returns {Array} Array of accumulated lengths (pixels for Point, meters for LatLng)
+ */
+ accumulatedLengths: function (coords) {
+ if (typeof coords.getLatLngs == 'function') {
+ coords = coords.getLatLngs();
+ }
+ if (coords.length === 0)
+ return [];
+ var total = 0,
+ lengths = [0];
+ for (var i = 0, n = coords.length - 1; i< n; i++) {
+ total += coords[i].distanceTo(coords[i+1]);
+ lengths.push(total);
+ }
+ return lengths;
+ },
+
+ /**
+ Returns the closest point of a {L.LatLng} on the segment (A-B)
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.LatLng} latlng - The position to search
+ @param {L.LatLng} latlngA geographical point A of the segment
+ @param {L.LatLng} latlngB geographical point B of the segment
+ @returns {L.LatLng} Closest geographical point
+ */
+ closestOnSegment: function (map, latlng, latlngA, latlngB) {
+ var maxzoom = map.getMaxZoom();
+ if (maxzoom === Infinity)
+ maxzoom = map.getZoom();
+ var p = map.project(latlng, maxzoom),
+ p1 = map.project(latlngA, maxzoom),
+ p2 = map.project(latlngB, maxzoom),
+ closest = L.LineUtil.closestPointOnSegment(p, p1, p2);
+ return map.unproject(closest, maxzoom);
+ },
+
+ /**
+ Returns the closest latlng on layer.
+
+ Accept nested arrays
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array|Array>|L.PolyLine|L.Polygon} layer - Layer that contains the result
+ @param {L.LatLng} latlng - The position to search
+ @param {?boolean} [vertices=false] - Whether to restrict to path vertices.
+ @returns {L.LatLng} Closest geographical point or null if layer param is incorrect
+ */
+ closest: function (map, layer, latlng, vertices) {
+
+ var latlngs,
+ mindist = Infinity,
+ result = null,
+ i, n, distance, subResult;
+
+ if (layer instanceof Array) {
+ // if layer is Array>
+ if (layer[0] instanceof Array && typeof layer[0][0] !== 'number') {
+ // if we have nested arrays, we calc the closest for each array
+ // recursive
+ for (i = 0; i < layer.length; i++) {
+ subResult = L.GeometryUtil.closest(map, layer[i], latlng, vertices);
+ if (subResult && subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ }
+ return result;
+ } else if (layer[0] instanceof L.LatLng
+ || typeof layer[0][0] === 'number'
+ || typeof layer[0].lat === 'number') { // we could have a latlng as [x,y] with x & y numbers or {lat, lng}
+ layer = L.polyline(layer);
+ } else {
+ return result;
+ }
+ }
+
+ // if we don't have here a Polyline, that means layer is incorrect
+ // see https://github.com/makinacorpus/Leaflet.GeometryUtil/issues/23
+ if (! ( layer instanceof L.Polyline ) )
+ return result;
+
+ // deep copy of latlngs
+ latlngs = JSON.parse(JSON.stringify(layer.getLatLngs().slice(0)));
+
+ // add the last segment for L.Polygon
+ if (layer instanceof L.Polygon) {
+ // add the last segment for each child that is a nested array
+ var addLastSegment = function(latlngs) {
+ if (L.Polyline._flat(latlngs)) {
+ latlngs.push(latlngs[0]);
+ } else {
+ for (var i = 0; i < latlngs.length; i++) {
+ addLastSegment(latlngs[i]);
+ }
+ }
+ };
+ addLastSegment(latlngs);
+ }
+
+ // we have a multi polygon / multi polyline / polygon with holes
+ // use recursive to explore and return the good result
+ if ( ! L.Polyline._flat(latlngs) ) {
+ for (i = 0; i < latlngs.length; i++) {
+ // if we are at the lower level, and if we have a L.Polygon, we add the last segment
+ subResult = L.GeometryUtil.closest(map, latlngs[i], latlng, vertices);
+ if (subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ }
+ return result;
+
+ } else {
+
+ // Lookup vertices
+ if (vertices) {
+ for(i = 0, n = latlngs.length; i < n; i++) {
+ var ll = latlngs[i];
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ if (distance < mindist) {
+ mindist = distance;
+ result = ll;
+ result.distance = distance;
+ }
+ }
+ return result;
+ }
+
+ // Keep the closest point of all segments
+ for (i = 0, n = latlngs.length; i < n-1; i++) {
+ var latlngA = latlngs[i],
+ latlngB = latlngs[i+1];
+ distance = L.GeometryUtil.distanceSegment(map, latlng, latlngA, latlngB);
+ if (distance <= mindist) {
+ mindist = distance;
+ result = L.GeometryUtil.closestOnSegment(map, latlng, latlngA, latlngB);
+ result.distance = distance;
+ }
+ }
+ return result;
+ }
+
+ },
+
+ /**
+ Returns the closest layer to latlng among a list of layers.
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array} layers Set of layers
+ @param {L.LatLng} latlng - The position to search
+ @returns {object} ``{layer, latlng, distance}`` or ``null`` if list is empty;
+ */
+ closestLayer: function (map, layers, latlng) {
+ var mindist = Infinity,
+ result = null,
+ ll = null,
+ distance = Infinity;
+
+ for (var i = 0, n = layers.length; i < n; i++) {
+ var layer = layers[i];
+ if (layer instanceof L.LayerGroup) {
+ // recursive
+ var subResult = L.GeometryUtil.closestLayer(map, layer.getLayers(), latlng);
+ if (subResult.distance < mindist) {
+ mindist = subResult.distance;
+ result = subResult;
+ }
+ } else {
+ // Single dimension, snap on points, else snap on closest
+ if (typeof layer.getLatLng == 'function') {
+ ll = layer.getLatLng();
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ }
+ else {
+ ll = L.GeometryUtil.closest(map, layer, latlng);
+ if (ll) distance = ll.distance; // Can return null if layer has no points.
+ }
+ if (distance < mindist) {
+ mindist = distance;
+ result = {layer: layer, latlng: ll, distance: distance};
+ }
+ }
+ }
+ return result;
+ },
+
+ /**
+ Returns the n closest layers to latlng among a list of input layers.
+
+ @param {L.Map} map - Leaflet map to be used for this method
+ @param {Array} layers - Set of layers
+ @param {L.LatLng} latlng - The position to search
+ @param {?Number} [n=layers.length] - the expected number of output layers.
+ @returns {Array} an array of objects ``{layer, latlng, distance}`` or ``null`` if the input is invalid (empty list or negative n)
+ */
+ nClosestLayers: function (map, layers, latlng, n) {
+ n = typeof n === 'number' ? n : layers.length;
+
+ if (n < 1 || layers.length < 1) {
+ return null;
+ }
+
+ var results = [];
+ var distance, ll;
+
+ for (var i = 0, m = layers.length; i < m; i++) {
+ var layer = layers[i];
+ if (layer instanceof L.LayerGroup) {
+ // recursive
+ var subResult = L.GeometryUtil.closestLayer(map, layer.getLayers(), latlng);
+ results.push(subResult);
+ } else {
+ // Single dimension, snap on points, else snap on closest
+ if (typeof layer.getLatLng == 'function') {
+ ll = layer.getLatLng();
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ }
+ else {
+ ll = L.GeometryUtil.closest(map, layer, latlng);
+ if (ll) distance = ll.distance; // Can return null if layer has no points.
+ }
+ results.push({layer: layer, latlng: ll, distance: distance});
+ }
+ }
+
+ results.sort(function(a, b) {
+ return a.distance - b.distance;
+ });
+
+ if (results.length > n) {
+ return results.slice(0, n);
+ } else {
+ return results;
+ }
+ },
+
+ /**
+ * Returns all layers within a radius of the given position, in an ascending order of distance.
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array} layers - A list of layers.
+ @param {L.LatLng} latlng - The position to search
+ @param {?Number} [radius=Infinity] - Search radius in pixels
+ @return {object[]} an array of objects including layer within the radius, closest latlng, and distance
+ */
+ layersWithin: function(map, layers, latlng, radius) {
+ radius = typeof radius == 'number' ? radius : Infinity;
+
+ var results = [];
+ var ll = null;
+ var distance = 0;
+
+ for (var i = 0, n = layers.length; i < n; i++) {
+ var layer = layers[i];
+
+ if (typeof layer.getLatLng == 'function') {
+ ll = layer.getLatLng();
+ distance = L.GeometryUtil.distance(map, latlng, ll);
+ }
+ else {
+ ll = L.GeometryUtil.closest(map, layer, latlng);
+ if (ll) distance = ll.distance; // Can return null if layer has no points.
+ }
+
+ if (ll && distance < radius) {
+ results.push({layer: layer, latlng: ll, distance: distance});
+ }
+ }
+
+ var sortedResults = results.sort(function(a, b) {
+ return a.distance - b.distance;
+ });
+
+ return sortedResults;
+ },
+
+ /**
+ Returns the closest position from specified {LatLng} among specified layers,
+ with a maximum tolerance in pixels, providing snapping behaviour.
+
+ @tutorial closest
+
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array} layers - A list of layers to snap on.
+ @param {L.LatLng} latlng - The position to snap
+ @param {?Number} [tolerance=Infinity] - Maximum number of pixels.
+ @param {?boolean} [withVertices=true] - Snap to layers vertices or segment points (not only vertex)
+ @returns {object} with snapped {LatLng} and snapped {Layer} or null if tolerance exceeded.
+ */
+ closestLayerSnap: function (map, layers, latlng, tolerance, withVertices) {
+ tolerance = typeof tolerance == 'number' ? tolerance : Infinity;
+ withVertices = typeof withVertices == 'boolean' ? withVertices : true;
+
+ var result = L.GeometryUtil.closestLayer(map, layers, latlng);
+ if (!result || result.distance > tolerance)
+ return null;
+
+ // If snapped layer is linear, try to snap on vertices (extremities and middle points)
+ if (withVertices && typeof result.layer.getLatLngs == 'function') {
+ var closest = L.GeometryUtil.closest(map, result.layer, result.latlng, true);
+ if (closest.distance < tolerance) {
+ result.latlng = closest;
+ result.distance = L.GeometryUtil.distance(map, closest, latlng);
+ }
+ }
+ return result;
+ },
+
+ /**
+ Returns the Point located on a segment at the specified ratio of the segment length.
+ @param {L.Point} pA coordinates of point A
+ @param {L.Point} pB coordinates of point B
+ @param {Number} the length ratio, expressed as a decimal between 0 and 1, inclusive.
+ @returns {L.Point} the interpolated point.
+ */
+ interpolateOnPointSegment: function (pA, pB, ratio) {
+ return L.point(
+ (pA.x * (1 - ratio)) + (ratio * pB.x),
+ (pA.y * (1 - ratio)) + (ratio * pB.y)
+ );
+ },
+
+ /**
+ Returns the coordinate of the point located on a line at the specified ratio of the line length.
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {Array|L.PolyLine} latlngs Set of geographical points
+ @param {Number} ratio the length ratio, expressed as a decimal between 0 and 1, inclusive
+ @returns {Object} an object with latLng ({LatLng}) and predecessor ({Number}), the index of the preceding vertex in the Polyline
+ (-1 if the interpolated point is the first vertex)
+ */
+ interpolateOnLine: function (map, latLngs, ratio) {
+ latLngs = (latLngs instanceof L.Polyline) ? latLngs.getLatLngs() : latLngs;
+ var n = latLngs.length;
+ if (n < 2) {
+ return null;
+ }
+
+ // ensure the ratio is between 0 and 1;
+ ratio = Math.max(Math.min(ratio, 1), 0);
+
+ if (ratio === 0) {
+ return {
+ latLng: latLngs[0] instanceof L.LatLng ? latLngs[0] : L.latLng(latLngs[0]),
+ predecessor: -1
+ };
+ }
+ if (ratio == 1) {
+ return {
+ latLng: latLngs[latLngs.length -1] instanceof L.LatLng ? latLngs[latLngs.length -1] : L.latLng(latLngs[latLngs.length -1]),
+ predecessor: latLngs.length - 2
+ };
+ }
+
+ // project the LatLngs as Points,
+ // and compute total planar length of the line at max precision
+ var maxzoom = map.getMaxZoom();
+ if (maxzoom === Infinity)
+ maxzoom = map.getZoom();
+ var pts = [];
+ var lineLength = 0;
+ for(var i = 0; i < n; i++) {
+ pts[i] = map.project(latLngs[i], maxzoom);
+ if(i > 0)
+ lineLength += pts[i-1].distanceTo(pts[i]);
+ }
+
+ var ratioDist = lineLength * ratio;
+
+ // follow the line segments [ab], adding lengths,
+ // until we find the segment where the points should lie on
+ var cumulativeDistanceToA = 0, cumulativeDistanceToB = 0;
+ for (var i = 0; cumulativeDistanceToB < ratioDist; i++) {
+ var pointA = pts[i], pointB = pts[i+1];
+
+ cumulativeDistanceToA = cumulativeDistanceToB;
+ cumulativeDistanceToB += pointA.distanceTo(pointB);
+ }
+
+ if (pointA == undefined && pointB == undefined) { // Happens when line has no length
+ var pointA = pts[0], pointB = pts[1], i = 1;
+ }
+
+ // compute the ratio relative to the segment [ab]
+ var segmentRatio = ((cumulativeDistanceToB - cumulativeDistanceToA) !== 0) ? ((ratioDist - cumulativeDistanceToA) / (cumulativeDistanceToB - cumulativeDistanceToA)) : 0;
+ var interpolatedPoint = L.GeometryUtil.interpolateOnPointSegment(pointA, pointB, segmentRatio);
+ return {
+ latLng: map.unproject(interpolatedPoint, maxzoom),
+ predecessor: i-1
+ };
+ },
+
+ /**
+ Returns a float between 0 and 1 representing the location of the
+ closest point on polyline to the given latlng, as a fraction of total line length.
+ (opposite of L.GeometryUtil.interpolateOnLine())
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.PolyLine} polyline Polyline on which the latlng will be search
+ @param {L.LatLng} latlng The position to search
+ @returns {Number} Float between 0 and 1
+ */
+ locateOnLine: function (map, polyline, latlng) {
+ var latlngs = polyline.getLatLngs();
+ if (latlng.equals(latlngs[0]))
+ return 0.0;
+ if (latlng.equals(latlngs[latlngs.length-1]))
+ return 1.0;
+
+ var point = L.GeometryUtil.closest(map, polyline, latlng, false),
+ lengths = L.GeometryUtil.accumulatedLengths(latlngs),
+ total_length = lengths[lengths.length-1],
+ portion = 0,
+ found = false;
+ for (var i=0, n = latlngs.length-1; i < n; i++) {
+ var l1 = latlngs[i],
+ l2 = latlngs[i+1];
+ portion = lengths[i];
+ if (L.GeometryUtil.belongsSegment(point, l1, l2, 0.001)) {
+ portion += l1.distanceTo(point);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ throw "Could not interpolate " + latlng.toString() + " within " + polyline.toString();
+ }
+ return portion / total_length;
+ },
+
+ /**
+ Returns a clone with reversed coordinates.
+ @param {L.PolyLine} polyline polyline to reverse
+ @returns {L.PolyLine} polyline reversed
+ */
+ reverse: function (polyline) {
+ return L.polyline(polyline.getLatLngs().slice(0).reverse());
+ },
+
+ /**
+ Returns a sub-part of the polyline, from start to end.
+ If start is superior to end, returns extraction from inverted line.
+ @param {L.Map} map Leaflet map to be used for this method
+ @param {L.PolyLine} polyline Polyline on which will be extracted the sub-part
+ @param {Number} start ratio, expressed as a decimal between 0 and 1, inclusive
+ @param {Number} end ratio, expressed as a decimal between 0 and 1, inclusive
+ @returns {Array} new polyline
+ */
+ extract: function (map, polyline, start, end) {
+ if (start > end) {
+ return L.GeometryUtil.extract(map, L.GeometryUtil.reverse(polyline), 1.0-start, 1.0-end);
+ }
+
+ // Bound start and end to [0-1]
+ start = Math.max(Math.min(start, 1), 0);
+ end = Math.max(Math.min(end, 1), 0);
+
+ var latlngs = polyline.getLatLngs(),
+ startpoint = L.GeometryUtil.interpolateOnLine(map, polyline, start),
+ endpoint = L.GeometryUtil.interpolateOnLine(map, polyline, end);
+ // Return single point if start == end
+ if (start == end) {
+ var point = L.GeometryUtil.interpolateOnLine(map, polyline, end);
+ return [point.latLng];
+ }
+ // Array.slice() works indexes at 0
+ if (startpoint.predecessor == -1)
+ startpoint.predecessor = 0;
+ if (endpoint.predecessor == -1)
+ endpoint.predecessor = 0;
+ var result = latlngs.slice(startpoint.predecessor+1, endpoint.predecessor+1);
+ result.unshift(startpoint.latLng);
+ result.push(endpoint.latLng);
+ return result;
+ },
+
+ /**
+ Returns true if first polyline ends where other second starts.
+ @param {L.PolyLine} polyline First polyline
+ @param {L.PolyLine} other Second polyline
+ @returns {bool}
+ */
+ isBefore: function (polyline, other) {
+ if (!other) return false;
+ var lla = polyline.getLatLngs(),
+ llb = other.getLatLngs();
+ return (lla[lla.length-1]).equals(llb[0]);
+ },
+
+ /**
+ Returns true if first polyline starts where second ends.
+ @param {L.PolyLine} polyline First polyline
+ @param {L.PolyLine} other Second polyline
+ @returns {bool}
+ */
+ isAfter: function (polyline, other) {
+ if (!other) return false;
+ var lla = polyline.getLatLngs(),
+ llb = other.getLatLngs();
+ return (lla[0]).equals(llb[llb.length-1]);
+ },
+
+ /**
+ Returns true if first polyline starts where second ends or start.
+ @param {L.PolyLine} polyline First polyline
+ @param {L.PolyLine} other Second polyline
+ @returns {bool}
+ */
+ startsAtExtremity: function (polyline, other) {
+ if (!other) return false;
+ var lla = polyline.getLatLngs(),
+ llb = other.getLatLngs(),
+ start = lla[0];
+ return start.equals(llb[0]) || start.equals(llb[llb.length-1]);
+ },
+
+ /**
+ Returns horizontal angle in degres between two points.
+ @param {L.Point} a Coordinates of point A
+ @param {L.Point} b Coordinates of point B
+ @returns {Number} horizontal angle
+ */
+ computeAngle: function(a, b) {
+ return (Math.atan2(b.y - a.y, b.x - a.x) * 180 / Math.PI);
+ },
+
+ /**
+ Returns slope (Ax+B) between two points.
+ @param {L.Point} a Coordinates of point A
+ @param {L.Point} b Coordinates of point B
+ @returns {Object} with ``a`` and ``b`` properties.
+ */
+ computeSlope: function(a, b) {
+ var s = (b.y - a.y) / (b.x - a.x),
+ o = a.y - (s * a.x);
+ return {'a': s, 'b': o};
+ },
+
+ /**
+ Returns LatLng of rotated point around specified LatLng center.
+ @param {L.LatLng} latlngPoint: point to rotate
+ @param {double} angleDeg: angle to rotate in degrees
+ @param {L.LatLng} latlngCenter: center of rotation
+ @returns {L.LatLng} rotated point
+ */
+ rotatePoint: function(map, latlngPoint, angleDeg, latlngCenter) {
+ var maxzoom = map.getMaxZoom();
+ if (maxzoom === Infinity)
+ maxzoom = map.getZoom();
+ var angleRad = angleDeg*Math.PI/180,
+ pPoint = map.project(latlngPoint, maxzoom),
+ pCenter = map.project(latlngCenter, maxzoom),
+ x2 = Math.cos(angleRad)*(pPoint.x-pCenter.x) - Math.sin(angleRad)*(pPoint.y-pCenter.y) + pCenter.x,
+ y2 = Math.sin(angleRad)*(pPoint.x-pCenter.x) + Math.cos(angleRad)*(pPoint.y-pCenter.y) + pCenter.y;
+ return map.unproject(new L.Point(x2,y2), maxzoom);
+ },
+
+ /**
+ Returns the bearing in degrees clockwise from north (0 degrees)
+ from the first L.LatLng to the second, at the first LatLng
+ @param {L.LatLng} latlng1: origin point of the bearing
+ @param {L.LatLng} latlng2: destination point of the bearing
+ @returns {float} degrees clockwise from north.
+ */
+ bearing: function(latlng1, latlng2) {
+ var rad = Math.PI / 180,
+ lat1 = latlng1.lat * rad,
+ lat2 = latlng2.lat * rad,
+ lon1 = latlng1.lng * rad,
+ lon2 = latlng2.lng * rad,
+ y = Math.sin(lon2 - lon1) * Math.cos(lat2),
+ x = Math.cos(lat1) * Math.sin(lat2) -
+ Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon2 - lon1);
+
+ var bearing = ((Math.atan2(y, x) * 180 / Math.PI) + 360) % 360;
+ return bearing >= 180 ? bearing-360 : bearing;
+ },
+
+ /**
+ Returns the point that is a distance and heading away from
+ the given origin point.
+ @param {L.LatLng} latlng: origin point
+ @param {float} heading: heading in degrees, clockwise from 0 degrees north.
+ @param {float} distance: distance in meters
+ @returns {L.latLng} the destination point.
+ Many thanks to Chris Veness at http://www.movable-type.co.uk/scripts/latlong.html
+ for a great reference and examples.
+ */
+ destination: function(latlng, heading, distance) {
+ heading = (heading + 360) % 360;
+ var rad = Math.PI / 180,
+ radInv = 180 / Math.PI,
+ R = 6378137, // approximation of Earth's radius
+ lon1 = latlng.lng * rad,
+ lat1 = latlng.lat * rad,
+ rheading = heading * rad,
+ sinLat1 = Math.sin(lat1),
+ cosLat1 = Math.cos(lat1),
+ cosDistR = Math.cos(distance / R),
+ sinDistR = Math.sin(distance / R),
+ lat2 = Math.asin(sinLat1 * cosDistR + cosLat1 *
+ sinDistR * Math.cos(rheading)),
+ lon2 = lon1 + Math.atan2(Math.sin(rheading) * sinDistR *
+ cosLat1, cosDistR - sinLat1 * Math.sin(lat2));
+ lon2 = lon2 * radInv;
+ lon2 = lon2 > 180 ? lon2 - 360 : lon2 < -180 ? lon2 + 360 : lon2;
+ return L.latLng([lat2 * radInv, lon2]);
+ },
+
+ /**
+ Returns the the angle of the given segment and the Equator in degrees,
+ clockwise from 0 degrees north.
+ @param {L.Map} map: Leaflet map to be used for this method
+ @param {L.LatLng} latlngA: geographical point A of the segment
+ @param {L.LatLng} latlngB: geographical point B of the segment
+ @returns {Float} the angle in degrees.
+ */
+ angle: function(map, latlngA, latlngB) {
+ var pointA = map.latLngToContainerPoint(latlngA),
+ pointB = map.latLngToContainerPoint(latlngB),
+ angleDeg = Math.atan2(pointB.y - pointA.y, pointB.x - pointA.x) * 180 / Math.PI + 90;
+ angleDeg += angleDeg < 0 ? 360 : 0;
+ return angleDeg;
+ },
+
+ /**
+ Returns a point snaps on the segment and heading away from the given origin point a distance.
+ @param {L.Map} map: Leaflet map to be used for this method
+ @param {L.LatLng} latlngA: geographical point A of the segment
+ @param {L.LatLng} latlngB: geographical point B of the segment
+ @param {float} distance: distance in meters
+ @returns {L.latLng} the destination point.
+ */
+ destinationOnSegment: function(map, latlngA, latlngB, distance) {
+ var angleDeg = L.GeometryUtil.angle(map, latlngA, latlngB),
+ latlng = L.GeometryUtil.destination(latlngA, angleDeg, distance);
+ return L.GeometryUtil.closestOnSegment(map, latlng, latlngA, latlngB);
+ },
+});
+
+return L.GeometryUtil;
+
+}));
diff --git a/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu-bindings.js b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu-bindings.js
new file mode 100644
index 00000000..c1b4491c
--- /dev/null
+++ b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu-bindings.js
@@ -0,0 +1,70 @@
+/* global LeafletWidget, $, L, Shiny, HTMLWidgets */
+LeafletWidget.methods.addContextmenu = function() {
+ var map = this;
+
+ if (HTMLWidgets.shinyMode) {
+ map.on("contextmenu.select", function(e) {
+ var obj = {
+ text: e.el.innerText
+ };
+ if (e.data.relatedTarget) {
+ var data = {
+ layerId: e.data.relatedTarget.options.layerId,
+ group: e.data.relatedTarget.options.group,
+ lat: e.data.relatedTarget.options.lat,
+ lng: e.data.relatedTarget.options.lng,
+ label: e.data.relatedTarget.options.label
+ };
+ obj = Object.assign(obj, data);
+ } else {
+ obj = Object.assign(obj, e.data.latlng);
+ }
+ Shiny.setInputValue(map.id + "_contextmenu_select", obj, {priority: "event"});
+ });
+ }
+};
+
+LeafletWidget.methods.showContextmenu = function(coords) {
+ this.contextmenu.showAt(new L.LatLng(coords.lat[0], coords.lng[0]));
+};
+LeafletWidget.methods.hideContextmenu = function() {
+ this.contextmenu.hide();
+};
+LeafletWidget.methods.enableContextmenu = function() {
+ this.contextmenu.enable();
+};
+LeafletWidget.methods.disableContextmenu = function() {
+ this.contextmenu.disable();
+};
+LeafletWidget.methods.addItemContextmenu = function(options) {
+ // Requires https://github.com/rstudio/leaflet/pull/696 to be merged!
+ this.contextmenu.addItem(options);
+};
+LeafletWidget.methods.insertItemContextmenu = function(options, index) {
+ // Requires https://github.com/rstudio/leaflet/pull/696 to be merged!
+ this.contextmenu.insertItem(options, index);
+};
+LeafletWidget.methods.removeItemContextmenu = function(index) {
+ var map = this;
+ if (Array.isArray(index)) {
+ index.forEach(function(i) {
+ map.contextmenu.removeItem(index);
+ })
+ } else {
+ map.contextmenu.removeItem(index);
+ }
+};
+LeafletWidget.methods.setDisabledContextmenu = function(index, disabled) {
+ var map = this;
+ if (Array.isArray(index)) {
+ index.forEach(function(i) {
+ map.contextmenu.setDisabled(i, disabled);
+ })
+ } else {
+ map.contextmenu.setDisabled(index, disabled);
+ }
+};
+LeafletWidget.methods.removeallItemsContextmenu = function() {
+ this.contextmenu.removeAllItems();
+};
+
diff --git a/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.css b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.css
new file mode 100644
index 00000000..0b5e2def
--- /dev/null
+++ b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.css
@@ -0,0 +1,54 @@
+.leaflet-contextmenu {
+ display: none;
+ box-shadow: 0 1px 7px rgba(0,0,0,0.4);
+ -webkit-border-radius: 4px;
+ border-radius: 4px;
+ padding: 4px 0;
+ background-color: #fff;
+ cursor: default;
+ -webkit-user-select: none;
+ -moz-user-select: none;
+ user-select: none;
+}
+
+.leaflet-contextmenu a.leaflet-contextmenu-item {
+ display: block;
+ color: #222;
+ font-size: 12px;
+ line-height: 20px;
+ text-decoration: none;
+ padding: 0 12px;
+ border-top: 1px solid transparent;
+ border-bottom: 1px solid transparent;
+ cursor: default;
+ outline: none;
+}
+
+.leaflet-contextmenu a.leaflet-contextmenu-item-disabled {
+ opacity: 0.5;
+}
+
+.leaflet-contextmenu a.leaflet-contextmenu-item.over {
+ background-color: #f4f4f4;
+ border-top: 1px solid #f0f0f0;
+ border-bottom: 1px solid #f0f0f0;
+}
+
+.leaflet-contextmenu a.leaflet-contextmenu-item-disabled.over {
+ background-color: inherit;
+ border-top: 1px solid transparent;
+ border-bottom: 1px solid transparent;
+}
+
+.leaflet-contextmenu-icon {
+ margin: 2px 8px 0 0;
+ width: 16px;
+ height: 16px;
+ float: left;
+ border: 0;
+}
+
+.leaflet-contextmenu-separator {
+ border-bottom: 1px solid #ccc;
+ margin: 5px 0;
+}
diff --git a/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.js b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.js
new file mode 100644
index 00000000..7a901e27
--- /dev/null
+++ b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.js
@@ -0,0 +1,602 @@
+/*
+ Leaflet.contextmenu, a context menu for Leaflet.
+ (c) 2015, Adam Ratcliffe, GeoSmart Maps Limited
+
+ @preserve
+*/
+
+(function(factory) {
+ // Packaging/modules magic dance
+ var L;
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['leaflet'], factory);
+ } else if (typeof module === 'object' && typeof module.exports === 'object') {
+ // Node/CommonJS
+ L = require('leaflet');
+ module.exports = factory(L);
+ } else {
+ // Browser globals
+ if (typeof window.L === 'undefined') {
+ throw new Error('Leaflet must be loaded first');
+ }
+ factory(window.L);
+ }
+})(function(L) {
+L.Map.mergeOptions({
+ contextmenuItems: []
+});
+
+L.Map.ContextMenu = L.Handler.extend({
+ _touchstart: L.Browser.msPointer ? 'MSPointerDown' : L.Browser.pointer ? 'pointerdown' : 'touchstart',
+
+ statics: {
+ BASE_CLS: 'leaflet-contextmenu'
+ },
+
+ initialize: function (map) {
+ L.Handler.prototype.initialize.call(this, map);
+
+ this._items = [];
+ this._visible = false;
+
+ var container = this._container = L.DomUtil.create('div', L.Map.ContextMenu.BASE_CLS, map._container);
+ container.style.zIndex = 10000;
+ container.style.position = 'absolute';
+
+ if (map.options.contextmenuWidth) {
+ container.style.width = map.options.contextmenuWidth + 'px';
+ }
+
+ this._createItems();
+
+ L.DomEvent
+ .on(container, 'click', L.DomEvent.stop)
+ .on(container, 'mousedown', L.DomEvent.stop)
+ .on(container, 'dblclick', L.DomEvent.stop)
+ .on(container, 'contextmenu', L.DomEvent.stop);
+ },
+
+ addHooks: function () {
+ var container = this._map.getContainer();
+
+ L.DomEvent
+ .on(container, 'mouseleave', this._hide, this)
+ .on(document, 'keydown', this._onKeyDown, this);
+
+ if (L.Browser.touch) {
+ L.DomEvent.on(document, this._touchstart, this._hide, this);
+ }
+
+ this._map.on({
+ contextmenu: this._show,
+ mousedown: this._hide,
+ zoomstart: this._hide
+ }, this);
+ },
+
+ removeHooks: function () {
+ var container = this._map.getContainer();
+
+ L.DomEvent
+ .off(container, 'mouseleave', this._hide, this)
+ .off(document, 'keydown', this._onKeyDown, this);
+
+ if (L.Browser.touch) {
+ L.DomEvent.off(document, this._touchstart, this._hide, this);
+ }
+
+ this._map.off({
+ contextmenu: this._show,
+ mousedown: this._hide,
+ zoomstart: this._hide
+ }, this);
+ },
+
+ showAt: function (point, data) {
+ if (point instanceof L.LatLng) {
+ point = this._map.latLngToContainerPoint(point);
+ }
+
+ this._showAtPoint(point, data);
+ },
+
+ hide: function () {
+ this._hide();
+ },
+
+ addItem: function (options) {
+ return this.insertItem(options);
+ },
+
+ insertItem: function (options, index) {
+ index = index !== undefined ? index: this._items.length;
+
+ var item = this._createItem(this._container, options, index);
+
+ this._items.push(item);
+
+ this._sizeChanged = true;
+
+ this._map.fire('contextmenu.additem', {
+ contextmenu: this,
+ el: item.el,
+ index: index
+ });
+
+ return item.el;
+ },
+
+ removeItem: function (item) {
+ var container = this._container;
+
+ if (!isNaN(item)) {
+ item = container.children[item];
+ }
+
+ if (item) {
+ this._removeItem(L.Util.stamp(item));
+
+ this._sizeChanged = true;
+
+ this._map.fire('contextmenu.removeitem', {
+ contextmenu: this,
+ el: item
+ });
+
+ return item;
+ }
+
+ return null;
+ },
+
+ removeAllItems: function () {
+ var items = this._container.children,
+ item;
+
+ while (items.length) {
+ item = items[0];
+ this._removeItem(L.Util.stamp(item));
+ }
+ return items;
+ },
+
+ hideAllItems: function () {
+ var item, i, l;
+
+ for (i = 0, l = this._items.length; i < l; i++) {
+ item = this._items[i];
+ item.el.style.display = 'none';
+ }
+ },
+
+ showAllItems: function () {
+ var item, i, l;
+
+ for (i = 0, l = this._items.length; i < l; i++) {
+ item = this._items[i];
+ item.el.style.display = '';
+ }
+ },
+
+ setDisabled: function (item, disabled) {
+ var container = this._container,
+ itemCls = L.Map.ContextMenu.BASE_CLS + '-item';
+
+ if (!isNaN(item)) {
+ item = container.children[item];
+ }
+
+ if (item && L.DomUtil.hasClass(item, itemCls)) {
+ if (disabled) {
+ L.DomUtil.addClass(item, itemCls + '-disabled');
+ this._map.fire('contextmenu.disableitem', {
+ contextmenu: this,
+ el: item
+ });
+ } else {
+ L.DomUtil.removeClass(item, itemCls + '-disabled');
+ this._map.fire('contextmenu.enableitem', {
+ contextmenu: this,
+ el: item
+ });
+ }
+ }
+ },
+
+ isVisible: function () {
+ return this._visible;
+ },
+
+ _createItems: function () {
+ var itemOptions = this._map.options.contextmenuItems,
+ item,
+ i, l;
+
+ for (i = 0, l = itemOptions.length; i < l; i++) {
+ this._items.push(this._createItem(this._container, itemOptions[i]));
+ }
+ },
+
+ _createItem: function (container, options, index) {
+ if (options.separator || options === '-') {
+ return this._createSeparator(container, index);
+ }
+
+ var itemCls = L.Map.ContextMenu.BASE_CLS + '-item',
+ cls = options.disabled ? (itemCls + ' ' + itemCls + '-disabled') : itemCls,
+ el = this._insertElementAt('a', cls, container, index),
+ callback = this._createEventHandler(el, options.callback, options.context, options.hideOnSelect),
+ icon = this._getIcon(options),
+ iconCls = this._getIconCls(options),
+ html = '';
+
+ if (icon) {
+ html = '';
+ } else if (iconCls) {
+ html = '';
+ }
+
+ el.innerHTML = html + options.text;
+ el.href = '#';
+
+ L.DomEvent
+ .on(el, 'mouseover', this._onItemMouseOver, this)
+ .on(el, 'mouseout', this._onItemMouseOut, this)
+ .on(el, 'mousedown', L.DomEvent.stopPropagation)
+ .on(el, 'click', callback);
+
+ if (L.Browser.touch) {
+ L.DomEvent.on(el, this._touchstart, L.DomEvent.stopPropagation);
+ }
+
+ // Devices without a mouse fire "mouseover" on tap, but never โmouseout"
+ if (!L.Browser.pointer) {
+ L.DomEvent.on(el, 'click', this._onItemMouseOut, this);
+ }
+
+ return {
+ id: L.Util.stamp(el),
+ el: el,
+ callback: callback
+ };
+ },
+
+ _removeItem: function (id) {
+ var item,
+ el,
+ i, l, callback;
+
+ for (i = 0, l = this._items.length; i < l; i++) {
+ item = this._items[i];
+
+ if (item.id === id) {
+ el = item.el;
+ callback = item.callback;
+
+ if (callback) {
+ L.DomEvent
+ .off(el, 'mouseover', this._onItemMouseOver, this)
+ .off(el, 'mouseover', this._onItemMouseOut, this)
+ .off(el, 'mousedown', L.DomEvent.stopPropagation)
+ .off(el, 'click', callback);
+
+ if (L.Browser.touch) {
+ L.DomEvent.off(el, this._touchstart, L.DomEvent.stopPropagation);
+ }
+
+ if (!L.Browser.pointer) {
+ L.DomEvent.on(el, 'click', this._onItemMouseOut, this);
+ }
+ }
+
+ this._container.removeChild(el);
+ this._items.splice(i, 1);
+
+ return item;
+ }
+ }
+ return null;
+ },
+
+ _createSeparator: function (container, index) {
+ var el = this._insertElementAt('div', L.Map.ContextMenu.BASE_CLS + '-separator', container, index);
+
+ return {
+ id: L.Util.stamp(el),
+ el: el
+ };
+ },
+
+ _createEventHandler: function (el, func, context, hideOnSelect) {
+ var me = this,
+ map = this._map,
+ disabledCls = L.Map.ContextMenu.BASE_CLS + '-item-disabled',
+ hideOnSelect = (hideOnSelect !== undefined) ? hideOnSelect : true;
+
+ return function (e) {
+ if (L.DomUtil.hasClass(el, disabledCls)) {
+ return;
+ }
+
+ var map = me._map,
+ containerPoint = me._showLocation.containerPoint,
+ layerPoint = map.containerPointToLayerPoint(containerPoint),
+ latlng = map.layerPointToLatLng(layerPoint),
+ relatedTarget = me._showLocation.relatedTarget,
+ data = {
+ containerPoint: containerPoint,
+ layerPoint: layerPoint,
+ latlng: latlng,
+ relatedTarget: relatedTarget
+ };
+
+ if (hideOnSelect) {
+ me._hide();
+ }
+
+ if (func) {
+ func.call(context || map, data);
+ }
+
+ me._map.fire('contextmenu.select', {
+ contextmenu: me,
+ el: el,
+ data: data
+ });
+ };
+ },
+
+ _insertElementAt: function (tagName, className, container, index) {
+ var refEl,
+ el = document.createElement(tagName);
+
+ el.className = className;
+
+ if (index !== undefined) {
+ refEl = container.children[index];
+ }
+
+ if (refEl) {
+ container.insertBefore(el, refEl);
+ } else {
+ container.appendChild(el);
+ }
+
+ return el;
+ },
+
+ _show: function (e) {
+ this._showAtPoint(e.containerPoint, e);
+ },
+
+ _showAtPoint: function (pt, data) {
+ if (this._items.length) {
+ var map = this._map,
+ event = L.extend(data || {}, {contextmenu: this});
+
+ this._showLocation = {
+ containerPoint: pt
+ };
+ if (data && data.relatedTarget){
+ this._showLocation.relatedTarget = data.relatedTarget;
+ }
+
+ this._setPosition(pt);
+
+ if (!this._visible) {
+ this._container.style.display = 'block';
+ this._visible = true;
+ }
+
+ this._map.fire('contextmenu.show', event);
+ }
+ if(data){
+ L.DomEvent.stopPropagation(data);
+ }
+ },
+
+ _hide: function () {
+ if (this._visible) {
+ this._visible = false;
+ this._container.style.display = 'none';
+ this._map.fire('contextmenu.hide', {contextmenu: this});
+ }
+ },
+
+ _getIcon: function (options) {
+ return L.Browser.retina && options.retinaIcon || options.icon;
+ },
+
+ _getIconCls: function (options) {
+ return L.Browser.retina && options.retinaIconCls || options.iconCls;
+ },
+
+ _setPosition: function (pt) {
+ var mapSize = this._map.getSize(),
+ container = this._container,
+ containerSize = this._getElementSize(container),
+ anchor;
+
+ if (this._map.options.contextmenuAnchor) {
+ anchor = L.point(this._map.options.contextmenuAnchor);
+ pt = pt.add(anchor);
+ }
+
+ container._leaflet_pos = pt;
+
+ if (pt.x + containerSize.x > mapSize.x) {
+ container.style.left = 'auto';
+ container.style.right = Math.min(Math.max(mapSize.x - pt.x, 0), mapSize.x - containerSize.x - 1) + 'px';
+ } else {
+ container.style.left = Math.max(pt.x, 0) + 'px';
+ container.style.right = 'auto';
+ }
+
+ if (pt.y + containerSize.y > mapSize.y) {
+ container.style.top = 'auto';
+ container.style.bottom = Math.min(Math.max(mapSize.y - pt.y, 0), mapSize.y - containerSize.y - 1) + 'px';
+ } else {
+ container.style.top = Math.max(pt.y, 0) + 'px';
+ container.style.bottom = 'auto';
+ }
+ },
+
+ _getElementSize: function (el) {
+ var size = this._size,
+ initialDisplay = el.style.display;
+
+ if (!size || this._sizeChanged) {
+ size = {};
+
+ el.style.left = '-999999px';
+ el.style.right = 'auto';
+ el.style.display = 'block';
+
+ size.x = el.offsetWidth;
+ size.y = el.offsetHeight;
+
+ el.style.left = 'auto';
+ el.style.display = initialDisplay;
+
+ this._sizeChanged = false;
+ }
+
+ return size;
+ },
+
+ _onKeyDown: function (e) {
+ var key = e.keyCode;
+
+ // If ESC pressed and context menu is visible hide it
+ if (key === 27) {
+ this._hide();
+ }
+ },
+
+ _onItemMouseOver: function (e) {
+ L.DomUtil.addClass(e.target || e.srcElement, 'over');
+ },
+
+ _onItemMouseOut: function (e) {
+ L.DomUtil.removeClass(e.target || e.srcElement, 'over');
+ }
+});
+
+L.Map.addInitHook('addHandler', 'contextmenu', L.Map.ContextMenu);
+L.Mixin.ContextMenu = {
+ bindContextMenu: function (options) {
+ L.setOptions(this, options);
+ this._initContextMenu();
+
+ return this;
+ },
+
+ unbindContextMenu: function (){
+ this.off('contextmenu', this._showContextMenu, this);
+
+ return this;
+ },
+
+ addContextMenuItem: function (item) {
+ this.options.contextmenuItems.push(item);
+ },
+
+ removeContextMenuItemWithIndex: function (index) {
+ var items = [];
+ for (var i = 0; i < this.options.contextmenuItems.length; i++) {
+ if (this.options.contextmenuItems[i].index == index){
+ items.push(i);
+ }
+ }
+ var elem = items.pop();
+ while (elem !== undefined) {
+ this.options.contextmenuItems.splice(elem,1);
+ elem = items.pop();
+ }
+ },
+
+ replaceContextMenuItem: function (item) {
+ this.removeContextMenuItemWithIndex(item.index);
+ this.addContextMenuItem(item);
+ },
+
+ _initContextMenu: function () {
+ this._items = [];
+
+ this.on('contextmenu', this._showContextMenu, this);
+ },
+
+ _showContextMenu: function (e) {
+ var itemOptions,
+ data, pt, i, l;
+
+ if (this._map.contextmenu) {
+ data = L.extend({relatedTarget: this}, e);
+
+ pt = this._map.mouseEventToContainerPoint(e.originalEvent);
+
+ if (!this.options.contextmenuInheritItems) {
+ this._map.contextmenu.hideAllItems();
+ }
+ if(this.options.contextmenuWidth) {
+ this._map.contextmenu._container.style.width = this.options.contextmenuWidth + 'px';
+ }
+
+ for (i = 0, l = this.options.contextmenuItems.length; i < l; i++) {
+ itemOptions = this.options.contextmenuItems[i];
+ this._items.push(this._map.contextmenu.insertItem(itemOptions, itemOptions.index));
+ }
+
+ //this._map.once('contextmenu.hide', this._hideContextMenu, this);
+ this._map.once('contextmenu.hide', this._hideContextMenu(this._map), this);
+
+ this._map.contextmenu.showAt(pt, data);
+ }
+ },
+
+ _hideContextMenu: function (m) {
+ return function() {
+ var i, l;
+
+ for (i = 0, l = this._items.length; i < l; i++) {
+ m.contextmenu.removeItem(this._items[i]);
+ }
+ this._items.length = 0;
+
+ if (!this.options.contextmenuInheritItems) {
+ m.contextmenu.showAllItems();
+ }
+ }
+ }
+};
+
+var classes = [L.Marker, L.Path, L.ImageOverlay],
+ defaultOptions = {
+ contextmenu: false,
+ contextmenuItems: [],
+ contextmenuInheritItems: true
+ },
+ cls, i, l;
+
+for (i = 0, l = classes.length; i < l; i++) {
+ cls = classes[i];
+
+ // L.Class should probably provide an empty options hash, as it does not test
+ // for it here and add if needed
+ if (!cls.prototype.options) {
+ cls.prototype.options = defaultOptions;
+ } else {
+ cls.mergeOptions(defaultOptions);
+ }
+
+ cls.addInitHook(function () {
+ if (this.options.contextmenu) {
+ this._initContextMenu();
+ }
+ });
+
+ cls.include(L.Mixin.ContextMenu);
+}
+return L.Map.ContextMenu;
+});
diff --git a/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.css b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.css
new file mode 100644
index 00000000..ef6c6a0e
--- /dev/null
+++ b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.css
@@ -0,0 +1 @@
+.leaflet-contextmenu{display:none;box-shadow:0 1px 7px rgba(0,0,0,0.4);-webkit-border-radius:4px;border-radius:4px;padding:4px 0;background-color:#fff;cursor:default;-webkit-user-select:none;-moz-user-select:none;user-select:none}.leaflet-contextmenu a.leaflet-contextmenu-item{display:block;color:#222;font-size:12px;line-height:20px;text-decoration:none;padding:0 12px;border-top:1px solid transparent;border-bottom:1px solid transparent;cursor:default;outline:0}.leaflet-contextmenu a.leaflet-contextmenu-item-disabled{opacity:.5}.leaflet-contextmenu a.leaflet-contextmenu-item.over{background-color:#f4f4f4;border-top:1px solid #f0f0f0;border-bottom:1px solid #f0f0f0}.leaflet-contextmenu a.leaflet-contextmenu-item-disabled.over{background-color:inherit;border-top:1px solid transparent;border-bottom:1px solid transparent}.leaflet-contextmenu-icon{margin:2px 8px 0 0;width:16px;height:16px;float:left;border:0}.leaflet-contextmenu-separator{border-bottom:1px solid #ccc;margin:5px 0}
diff --git a/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.js b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.js
new file mode 100644
index 00000000..80a88708
--- /dev/null
+++ b/inst/htmlwidgets/lfx-contextmenu/leaflet.contextmenu.min.js
@@ -0,0 +1,7 @@
+/*
+ Leaflet.contextmenu, a context menu for Leaflet.
+ (c) 2015, Adam Ratcliffe, GeoSmart Maps Limited
+
+ @preserve
+*/
+(function(t){var e;if(typeof define==="function"&&define.amd){define(["leaflet"],t)}else if(typeof module==="object"&&typeof module.exports==="object"){e=require("leaflet");module.exports=t(e)}else{if(typeof window.L==="undefined"){throw new Error("Leaflet must be loaded first")}t(window.L)}})(function(t){t.Map.mergeOptions({contextmenuItems:[]});t.Map.ContextMenu=t.Handler.extend({_touchstart:t.Browser.msPointer?"MSPointerDown":t.Browser.pointer?"pointerdown":"touchstart",statics:{BASE_CLS:"leaflet-contextmenu"},initialize:function(e){t.Handler.prototype.initialize.call(this,e);this._items=[];this._visible=false;var n=this._container=t.DomUtil.create("div",t.Map.ContextMenu.BASE_CLS,e._container);n.style.zIndex=1e4;n.style.position="absolute";if(e.options.contextmenuWidth){n.style.width=e.options.contextmenuWidth+"px"}this._createItems();t.DomEvent.on(n,"click",t.DomEvent.stop).on(n,"mousedown",t.DomEvent.stop).on(n,"dblclick",t.DomEvent.stop).on(n,"contextmenu",t.DomEvent.stop)},addHooks:function(){var e=this._map.getContainer();t.DomEvent.on(e,"mouseleave",this._hide,this).on(document,"keydown",this._onKeyDown,this);if(t.Browser.touch){t.DomEvent.on(document,this._touchstart,this._hide,this)}this._map.on({contextmenu:this._show,mousedown:this._hide,zoomstart:this._hide},this)},removeHooks:function(){var e=this._map.getContainer();t.DomEvent.off(e,"mouseleave",this._hide,this).off(document,"keydown",this._onKeyDown,this);if(t.Browser.touch){t.DomEvent.off(document,this._touchstart,this._hide,this)}this._map.off({contextmenu:this._show,mousedown:this._hide,zoomstart:this._hide},this)},showAt:function(e,n){if(e instanceof t.LatLng){e=this._map.latLngToContainerPoint(e)}this._showAtPoint(e,n)},hide:function(){this._hide()},addItem:function(t){return this.insertItem(t)},insertItem:function(t,e){e=e!==undefined?e:this._items.length;var n=this._createItem(this._container,t,e);this._items.push(n);this._sizeChanged=true;this._map.fire("contextmenu.additem",{contextmenu:this,el:n.el,index:e});return n.el},removeItem:function(e){var n=this._container;if(!isNaN(e)){e=n.children[e]}if(e){this._removeItem(t.Util.stamp(e));this._sizeChanged=true;this._map.fire("contextmenu.removeitem",{contextmenu:this,el:e});return e}return null},removeAllItems:function(){var e=this._container.children,n;while(e.length){n=e[0];this._removeItem(t.Util.stamp(n))}return e},hideAllItems:function(){var t,e,n;for(e=0,n=this._items.length;e'}else if(m){u=''}h.innerHTML=u+n.text;h.href="#";t.DomEvent.on(h,"mouseover",this._onItemMouseOver,this).on(h,"mouseout",this._onItemMouseOut,this).on(h,"mousedown",t.DomEvent.stopPropagation).on(h,"click",r);if(t.Browser.touch){t.DomEvent.on(h,this._touchstart,t.DomEvent.stopPropagation)}if(!t.Browser.pointer){t.DomEvent.on(h,"click",this._onItemMouseOut,this)}return{id:t.Util.stamp(h),el:h,callback:r}},_removeItem:function(e){var n,i,o,s,h;for(o=0,s=this._items.length;on.x){i.style.left="auto";i.style.right=Math.min(Math.max(n.x-e.x,0),n.x-o.x-1)+"px"}else{i.style.left=Math.max(e.x,0)+"px";i.style.right="auto"}if(e.y+o.y>n.y){i.style.top="auto";i.style.bottom=Math.min(Math.max(n.y-e.y,0),n.y-o.y-1)+"px"}else{i.style.top=Math.max(e.y,0)+"px";i.style.bottom="auto"}},_getElementSize:function(t){var e=this._size,n=t.style.display;if(!e||this._sizeChanged){e={};t.style.left="-999999px";t.style.right="auto";t.style.display="block";e.x=t.offsetWidth;e.y=t.offsetHeight;t.style.left="auto";t.style.display=n;this._sizeChanged=false}return e},_onKeyDown:function(t){var e=t.keyCode;if(e===27){this._hide()}},_onItemMouseOver:function(e){t.DomUtil.addClass(e.target||e.srcElement,"over")},_onItemMouseOut:function(e){t.DomUtil.removeClass(e.target||e.srcElement,"over")}});t.Map.addInitHook("addHandler","contextmenu",t.Map.ContextMenu);t.Mixin.ContextMenu={bindContextMenu:function(e){t.setOptions(this,e);this._initContextMenu();return this},unbindContextMenu:function(){this.off("contextmenu",this._showContextMenu,this);return this},addContextMenuItem:function(t){this.options.contextmenuItems.push(t)},removeContextMenuItemWithIndex:function(t){var e=[];for(var n=0;n' + xhtml + '';
+ })
+ .then(function (foreignObject) {
+ return '' +
+ foreignObject + ' ';
+ })
+ .then(function (svg) {
+ return 'data:image/svg+xml;charset=utf-8,' + svg;
+ });
+ }
+
+ function newUtil() {
+ return {
+ escape: escape,
+ parseExtension: parseExtension,
+ mimeType: mimeType,
+ dataAsUrl: dataAsUrl,
+ isDataUrl: isDataUrl,
+ canvasToBlob: canvasToBlob,
+ resolveUrl: resolveUrl,
+ getAndEncode: getAndEncode,
+ uid: uid(),
+ delay: delay,
+ asArray: asArray,
+ escapeXhtml: escapeXhtml,
+ makeImage: makeImage,
+ width: width,
+ height: height
+ };
+
+ function mimes() {
+ /*
+ * Only WOFF and EOT mime types for fonts are 'real'
+ * see http://www.iana.org/assignments/media-types/media-types.xhtml
+ */
+ var WOFF = 'application/font-woff';
+ var JPEG = 'image/jpeg';
+
+ return {
+ 'woff': WOFF,
+ 'woff2': WOFF,
+ 'ttf': 'application/font-truetype',
+ 'eot': 'application/vnd.ms-fontobject',
+ 'png': 'image/png',
+ 'jpg': JPEG,
+ 'jpeg': JPEG,
+ 'gif': 'image/gif',
+ 'tiff': 'image/tiff',
+ 'svg': 'image/svg+xml'
+ };
+ }
+
+ function parseExtension(url) {
+ var match = /\.([^\.\/]*?)$/g.exec(url);
+ if (match) return match[1];
+ else return '';
+ }
+
+ function mimeType(url) {
+ var extension = parseExtension(url).toLowerCase();
+ return mimes()[extension] || '';
+ }
+
+ function isDataUrl(url) {
+ return url.search(/^(data:)/) !== -1;
+ }
+
+ function toBlob(canvas) {
+ return new Promise(function (resolve) {
+ var binaryString = window.atob(canvas.toDataURL().split(',')[1]);
+ var length = binaryString.length;
+ var binaryArray = new Uint8Array(length);
+
+ for (var i = 0; i < length; i++)
+ binaryArray[i] = binaryString.charCodeAt(i);
+
+ resolve(new Blob([binaryArray], {
+ type: 'image/png'
+ }));
+ });
+ }
+
+ function canvasToBlob(canvas) {
+ if (canvas.toBlob)
+ return new Promise(function (resolve) {
+ canvas.toBlob(resolve);
+ });
+
+ return toBlob(canvas);
+ }
+
+ function resolveUrl(url, baseUrl) {
+ var doc = document.implementation.createHTMLDocument();
+ var base = doc.createElement('base');
+ doc.head.appendChild(base);
+ var a = doc.createElement('a');
+ doc.body.appendChild(a);
+ base.href = baseUrl;
+ a.href = url;
+ return a.href;
+ }
+
+ function uid() {
+ var index = 0;
+
+ return function () {
+ return 'u' + fourRandomChars() + index++;
+
+ function fourRandomChars() {
+ /* see http://stackoverflow.com/a/6248722/2519373 */
+ return ('0000' + (Math.random() * Math.pow(36, 4) << 0).toString(36)).slice(-4);
+ }
+ };
+ }
+
+ function makeImage(uri) {
+ return new Promise(function (resolve, reject) {
+ var image = new Image();
+ image.onload = function () {
+ resolve(image);
+ };
+ image.onerror = reject;
+ image.src = uri;
+ });
+ }
+
+ function getAndEncode(url) {
+ var TIMEOUT = 30000;
+ if(domtoimage.impl.options.cacheBust) {
+ // Cache bypass so we dont have CORS issues with cached images
+ // Source: https://developer.mozilla.org/en/docs/Web/API/XMLHttpRequest/Using_XMLHttpRequest#Bypassing_the_cache
+ url += ((/\?/).test(url) ? "&" : "?") + (new Date()).getTime();
+ }
+
+ return new Promise(function (resolve) {
+ var request = new XMLHttpRequest();
+
+ request.onreadystatechange = done;
+ request.ontimeout = timeout;
+ request.responseType = 'blob';
+ request.timeout = TIMEOUT;
+ request.open('GET', url, true);
+ request.send();
+
+ var placeholder;
+ if(domtoimage.impl.options.imagePlaceholder) {
+ var split = domtoimage.impl.options.imagePlaceholder.split(/,/);
+ if(split && split[1]) {
+ placeholder = split[1];
+ }
+ }
+
+ function done() {
+ if (request.readyState !== 4) return;
+
+ if (request.status !== 200) {
+ if(placeholder) {
+ resolve(placeholder);
+ } else {
+ fail('cannot fetch resource: ' + url + ', status: ' + request.status);
+ }
+
+ return;
+ }
+
+ var encoder = new FileReader();
+ encoder.onloadend = function () {
+ var content = encoder.result.split(/,/)[1];
+ resolve(content);
+ };
+ encoder.readAsDataURL(request.response);
+ }
+
+ function timeout() {
+ if(placeholder) {
+ resolve(placeholder);
+ } else {
+ fail('timeout of ' + TIMEOUT + 'ms occured while fetching resource: ' + url);
+ }
+ }
+
+ function fail(message) {
+ console.error(message);
+ resolve('');
+ }
+ });
+ }
+
+ function dataAsUrl(content, type) {
+ return 'data:' + type + ';base64,' + content;
+ }
+
+ function escape(string) {
+ return string.replace(/([.*+?^${}()|\[\]\/\\])/g, '\\$1');
+ }
+
+ function delay(ms) {
+ return function (arg) {
+ return new Promise(function (resolve) {
+ setTimeout(function () {
+ resolve(arg);
+ }, ms);
+ });
+ };
+ }
+
+ function asArray(arrayLike) {
+ var array = [];
+ var length = arrayLike.length;
+ for (var i = 0; i < length; i++) array.push(arrayLike[i]);
+ return array;
+ }
+
+ function escapeXhtml(string) {
+ return string.replace(/#/g, '%23').replace(/\n/g, '%0A');
+ }
+
+ function width(node) {
+ var leftBorder = px(node, 'border-left-width');
+ var rightBorder = px(node, 'border-right-width');
+ return node.scrollWidth + leftBorder + rightBorder;
+ }
+
+ function height(node) {
+ var topBorder = px(node, 'border-top-width');
+ var bottomBorder = px(node, 'border-bottom-width');
+ return node.scrollHeight + topBorder + bottomBorder;
+ }
+
+ function px(node, styleProperty) {
+ var value = window.getComputedStyle(node).getPropertyValue(styleProperty);
+ return parseFloat(value.replace('px', ''));
+ }
+ }
+
+ function newInliner() {
+ var URL_REGEX = /url\(['"]?([^'"]+?)['"]?\)/g;
+
+ return {
+ inlineAll: inlineAll,
+ shouldProcess: shouldProcess,
+ impl: {
+ readUrls: readUrls,
+ inline: inline
+ }
+ };
+
+ function shouldProcess(string) {
+ return string.search(URL_REGEX) !== -1;
+ }
+
+ function readUrls(string) {
+ var result = [];
+ var match;
+ while ((match = URL_REGEX.exec(string)) !== null) {
+ result.push(match[1]);
+ }
+ return result.filter(function (url) {
+ return !util.isDataUrl(url);
+ });
+ }
+
+ function inline(string, url, baseUrl, get) {
+ return Promise.resolve(url)
+ .then(function (url) {
+ return baseUrl ? util.resolveUrl(url, baseUrl) : url;
+ })
+ .then(get || util.getAndEncode)
+ .then(function (data) {
+ return util.dataAsUrl(data, util.mimeType(url));
+ })
+ .then(function (dataUrl) {
+ return string.replace(urlAsRegex(url), '$1' + dataUrl + '$3');
+ });
+
+ function urlAsRegex(url) {
+ return new RegExp('(url\\([\'"]?)(' + util.escape(url) + ')([\'"]?\\))', 'g');
+ }
+ }
+
+ function inlineAll(string, baseUrl, get) {
+ if (nothingToInline()) return Promise.resolve(string);
+
+ return Promise.resolve(string)
+ .then(readUrls)
+ .then(function (urls) {
+ var done = Promise.resolve(string);
+ urls.forEach(function (url) {
+ done = done.then(function (string) {
+ return inline(string, url, baseUrl, get);
+ });
+ });
+ return done;
+ });
+
+ function nothingToInline() {
+ return !shouldProcess(string);
+ }
+ }
+ }
+
+ function newFontFaces() {
+ return {
+ resolveAll: resolveAll,
+ impl: {
+ readAll: readAll
+ }
+ };
+
+ function resolveAll() {
+ return readAll(document)
+ .then(function (webFonts) {
+ return Promise.all(
+ webFonts.map(function (webFont) {
+ return webFont.resolve();
+ })
+ );
+ })
+ .then(function (cssStrings) {
+ return cssStrings.join('\n');
+ });
+ }
+
+ function readAll() {
+ return Promise.resolve(util.asArray(document.styleSheets))
+ .then(getCssRules)
+ .then(selectWebFontRules)
+ .then(function (rules) {
+ return rules.map(newWebFont);
+ });
+
+ function selectWebFontRules(cssRules) {
+ return cssRules
+ .filter(function (rule) {
+ return rule.type === CSSRule.FONT_FACE_RULE;
+ })
+ .filter(function (rule) {
+ return inliner.shouldProcess(rule.style.getPropertyValue('src'));
+ });
+ }
+
+ function getCssRules(styleSheets) {
+ var cssRules = [];
+ styleSheets.forEach(function (sheet) {
+ try {
+ util.asArray(sheet.cssRules || []).forEach(cssRules.push.bind(cssRules));
+ } catch (e) {
+ console.log('Error while reading CSS rules from ' + sheet.href, e.toString());
+ }
+ });
+ return cssRules;
+ }
+
+ function newWebFont(webFontRule) {
+ return {
+ resolve: function resolve() {
+ var baseUrl = (webFontRule.parentStyleSheet || {}).href;
+ return inliner.inlineAll(webFontRule.cssText, baseUrl);
+ },
+ src: function () {
+ return webFontRule.style.getPropertyValue('src');
+ }
+ };
+ }
+ }
+ }
+
+ function newImages() {
+ return {
+ inlineAll: inlineAll,
+ impl: {
+ newImage: newImage
+ }
+ };
+
+ function newImage(element) {
+ return {
+ inline: inline
+ };
+
+ function inline(get) {
+ if (util.isDataUrl(element.src)) return Promise.resolve();
+
+ return Promise.resolve(element.src)
+ .then(get || util.getAndEncode)
+ .then(function (data) {
+ return util.dataAsUrl(data, util.mimeType(element.src));
+ })
+ .then(function (dataUrl) {
+ return new Promise(function (resolve, reject) {
+ element.onload = resolve;
+ element.onerror = reject;
+ element.src = dataUrl;
+ });
+ });
+ }
+ }
+
+ function inlineAll(node) {
+ if (!(node instanceof Element)) return Promise.resolve(node);
+
+ return inlineBackground(node)
+ .then(function () {
+ if (node instanceof HTMLImageElement)
+ return newImage(node).inline();
+ else
+ return Promise.all(
+ util.asArray(node.childNodes).map(function (child) {
+ return inlineAll(child);
+ })
+ );
+ });
+
+ function inlineBackground(node) {
+ var background = node.style.getPropertyValue('background');
+
+ if (!background) return Promise.resolve(node);
+
+ return inliner.inlineAll(background)
+ .then(function (inlined) {
+ node.style.setProperty(
+ 'background',
+ inlined,
+ node.style.getPropertyPriority('background')
+ );
+ })
+ .then(function () {
+ return node;
+ });
+ }
+ }
+ }
+})(this);
diff --git a/inst/htmlwidgets/lfx-easyprint/lfx-easyprint-bindings.js b/inst/htmlwidgets/lfx-easyprint/lfx-easyprint-bindings.js
index 151b9ca7..80c4534d 100644
--- a/inst/htmlwidgets/lfx-easyprint/lfx-easyprint-bindings.js
+++ b/inst/htmlwidgets/lfx-easyprint/lfx-easyprint-bindings.js
@@ -7,7 +7,22 @@ LeafletWidget.methods.addEasyprint = function(options) {
delete map.easyprint;
}
- map.easyprint = new L.Control.EasyPrint(options);
+ // If a group name of a tilelayer is given, get the layer (the method isLoading will be used)
+ if (options.tileLayer !== undefined) {
+ // If multiple group names are given, take only the first layer
+ if (Array.isArray(options.tileLayer)) {
+ options.tileLayer = options.tileLayer[0];
+ }
+ var layers = map.layerManager._byGroup[options.tileLayer]
+ if (layers !== undefined) {
+ options.tileLayer = layers[Object.keys(layers)];
+ } else {
+ options.tileLayer = undefined;
+ }
+ }
+
+ options.sizeModes = Object.values(options.sizeModes)
+ map.easyprint = L.easyPrint(options);
map.controls.add(map.easyprint);
}).call(this);
@@ -26,8 +41,10 @@ LeafletWidget.methods.removeEasyprint = function() {
LeafletWidget.methods.easyprintMap = function(sizeModes, filename) {
(function(){
if (this.easyprint) {
- // Hack based on @urakovaliaskar in https://github.com/rowanwins/leaflet-easyPrint/issues/105#issuecomment-550370793_
- this.easyprint.printMap(sizeModes + " page", filename);
+ if (typeof sizeModes === "object" && sizeModes.className) {
+ sizeModes.target = {className: sizeModes.className}
+ }
+ this.easyprint.printMap(sizeModes, filename);
}
}).call(this);
};
diff --git a/inst/htmlwidgets/lfx-easyprint/lfx-easyprint_src.js b/inst/htmlwidgets/lfx-easyprint/lfx-easyprint_full.js
similarity index 71%
rename from inst/htmlwidgets/lfx-easyprint/lfx-easyprint_src.js
rename to inst/htmlwidgets/lfx-easyprint/lfx-easyprint_full.js
index 9236bd4e..324ffc38 100644
--- a/inst/htmlwidgets/lfx-easyprint/lfx-easyprint_src.js
+++ b/inst/htmlwidgets/lfx-easyprint/lfx-easyprint_full.js
@@ -1,11 +1,9 @@
-var domtoimage = require('dom-to-image');
-var fileSaver = require('file-saver');
L.Control.EasyPrint = L.Control.extend({
options: {
title: 'Print map',
position: 'topleft',
- sizeModes: ['Current'],
+ sizeModes: ['CurrentSize'],
filename: 'map',
exportOnly: false,
hidden: false,
@@ -13,21 +11,21 @@ L.Control.EasyPrint = L.Control.extend({
hideControlContainer: true,
hideClasses: [],
customWindowTitle: window.document.title,
- spinnerBgCOlor: '#0DC5C1',
+ spinnerBgColor: '#0DC5C1',
customSpinnerClass: 'epLoader',
defaultSizeTitles: {
- Current: 'Current Size',
+ CurrentSize: 'CurrentSize',
A4Landscape: 'A4 Landscape',
A4Portrait: 'A4 Portrait'
}
},
- onAdd: function () {
+ onAdd: function () {
this.mapContainer = this._map.getContainer();
this.options.sizeModes = this.options.sizeModes.map(function (sizeMode) {
- if (sizeMode === 'Current') {
+ if (sizeMode === 'CurrentSize') {
return {
- name: this.options.defaultSizeTitles.Current,
+ name: this.options.defaultSizeTitles.CurrentSize,
className: 'CurrentSize'
}
}
@@ -36,7 +34,7 @@ L.Control.EasyPrint = L.Control.extend({
height: this._a4PageSize.height,
width: this._a4PageSize.width,
name: this.options.defaultSizeTitles.A4Landscape,
- className: 'A4Landscape page'
+ className: 'A4Landscape'
}
}
if (sizeMode === 'A4Portrait') {
@@ -44,12 +42,12 @@ L.Control.EasyPrint = L.Control.extend({
height: this._a4PageSize.width,
width: this._a4PageSize.height,
name: this.options.defaultSizeTitles.A4Portrait,
- className: 'A4Portrait page'
+ className: 'A4Portrait'
}
};
return sizeMode;
}, this);
-
+
var container = L.DomUtil.create('div', 'leaflet-control-easyPrint leaflet-bar leaflet-control');
if (!this.options.hidden) {
this._addCss();
@@ -83,13 +81,16 @@ L.Control.EasyPrint = L.Control.extend({
}
if (!this.options.exportOnly) {
this._page = window.open("", "_blank", 'toolbar=no,status=no,menubar=no,scrollbars=no,resizable=no,left=10, top=10, width=200, height=250, visible=none');
- this._page.document.write(this._createSpinner(this.options.customWindowTitle, this.options.customSpinnerClass, this.options.spinnerBgCOlor));
+ this._page.document.write(this._createSpinner(this.options.customWindowTitle, this.options.customSpinnerClass, this.options.spinnerBgColor));
}
+ //var mapsize = this._map.getSize()
this.originalState = {
mapWidth: this.mapContainer.style.width,
+ //mapWidth: mapsize.x,
widthWasAuto: false,
widthWasPercentage: false,
mapHeight: this.mapContainer.style.height,
+ //mapHeight: mapsize.y,
zoom: this._map.getZoom(),
center: this._map.getCenter()
};
@@ -106,7 +107,7 @@ L.Control.EasyPrint = L.Control.extend({
this._togglePageSizeButtons({type: null});
}
if (this.options.hideControlContainer) {
- this._toggleControls();
+ this._toggleControls();
}
if (this.options.hideClasses) {
this._toggleClasses(this.options.hideClasses);
@@ -125,25 +126,30 @@ L.Control.EasyPrint = L.Control.extend({
_createImagePlaceholder: function (sizeMode) {
var plugin = this;
domtoimage.toPng(this.mapContainer, {
- width: parseInt(this.originalState.mapWidth.replace('px')),
- height: parseInt(this.originalState.mapHeight.replace('px'))
- })
- .then(function (dataUrl) {
- plugin.blankDiv = document.createElement("div");
- var blankDiv = plugin.blankDiv;
- plugin.outerContainer.parentElement.insertBefore(blankDiv, plugin.outerContainer);
- blankDiv.className = 'epHolder';
- blankDiv.style.backgroundImage = 'url("' + dataUrl + '")';
- blankDiv.style.position = 'absolute';
- blankDiv.style.zIndex = 1011;
- blankDiv.style.display = 'initial';
- blankDiv.style.width = plugin.originalState.mapWidth;
- blankDiv.style.height = plugin.originalState.mapHeight;
- plugin._resizeAndPrintMap(sizeMode);
- })
- .catch(function (error) {
- console.error('oops, something went wrong!', error);
- });
+ width: parseInt(this.originalState.mapWidth.replace('px')),
+ height: parseInt(this.originalState.mapHeight.replace('px'))
+ })
+ .then(function (dataUrl) {
+ plugin.blankDiv = document.createElement("div");
+ var blankDiv = plugin.blankDiv;
+ plugin.outerContainer.parentElement.insertBefore(blankDiv, plugin.outerContainer);
+ blankDiv.className = 'epHolder';
+ blankDiv.style.backgroundImage = 'url("' + dataUrl + '")';
+ blankDiv.style.position = 'absolute';
+ blankDiv.style.zIndex = 1011;
+ blankDiv.style.display = 'initial';
+ blankDiv.style.width = plugin.originalState.mapWidth;
+ blankDiv.style.height = plugin.originalState.mapHeight;
+ plugin._resizeAndPrintMap(sizeMode);
+ })
+ .catch(function (error) {
+ plugin._toggleControls(true);
+ plugin._toggleClasses(plugin.options.hideClasses, true);
+ if (plugin.outerContainer) {
+ plugin._removeOuterContainer(plugin.mapContainer, plugin.outerContainer, plugin.blankDiv)
+ }
+ console.error('oops, something went wrong!', error);
+ })
},
_resizeAndPrintMap: function (sizeMode) {
@@ -171,7 +177,7 @@ L.Control.EasyPrint = L.Control.extend({
_pausePrint: function (sizeMode) {
var plugin = this
- var loadingTest = setInterval(function () {
+ var loadingTest = setInterval(function () {
if(!plugin.options.tileLayer.isLoading()) {
clearInterval(loadingTest);
plugin._printOpertion(sizeMode)
@@ -182,51 +188,57 @@ L.Control.EasyPrint = L.Control.extend({
_printOpertion: function (sizemode) {
var plugin = this;
var widthForExport = this.mapContainer.style.width
- if (this.originalState.widthWasAuto && sizemode === 'CurrentSize' || this.originalState.widthWasPercentage && sizemode === 'CurrentSize') {
+ if (this.originalState.widthWasAuto && sizemode === 'CurrentSize' ||
+ this.originalState.widthWasPercentage && sizemode === 'CurrentSize') {
widthForExport = this.originalState.mapWidth
}
- domtoimage.toPng(plugin.mapContainer, {
- width: parseInt(widthForExport),
- height: parseInt(plugin.mapContainer.style.height.replace('px'))
- })
- .then(function (dataUrl) {
- var blob = plugin._dataURItoBlob(dataUrl);
- if (plugin.options.exportOnly) {
- fileSaver.saveAs(blob, plugin.options.filename + '.png');
- } else {
- plugin._sendToBrowserPrint(dataUrl, plugin.orientation);
- }
- plugin._toggleControls(true);
- plugin._toggleClasses(plugin.options.hideClasses, true);
- if (plugin.outerContainer) {
- if (plugin.originalState.widthWasAuto) {
- plugin.mapContainer.style.width = 'auto'
- } else if (plugin.originalState.widthWasPercentage) {
- plugin.mapContainer.style.width = plugin.originalState.percentageWidth
- }
- else {
- plugin.mapContainer.style.width = plugin.originalState.mapWidth;
- }
- plugin.mapContainer.style.height = plugin.originalState.mapHeight;
- plugin._removeOuterContainer(plugin.mapContainer, plugin.outerContainer, plugin.blankDiv)
- plugin._map.invalidateSize();
- plugin._map.setView(plugin.originalState.center);
- plugin._map.setZoom(plugin.originalState.zoom);
- }
- plugin._map.fire("easyPrint-finished");
- })
- .catch(function (error) {
- console.error('Print operation failed', error);
- });
+ function restorePlugin(plugin) {
+ plugin._toggleControls(true);
+ plugin._toggleClasses(plugin.options.hideClasses, true);
+
+ if (plugin.outerContainer) {
+ if (plugin.originalState.widthWasAuto) {
+ plugin.mapContainer.style.width = 'auto'
+ } else if (plugin.originalState.widthWasPercentage) {
+ plugin.mapContainer.style.width = plugin.originalState.percentageWidth
+ }
+ else {
+ plugin.mapContainer.style.width = plugin.originalState.mapWidth;
+ }
+ plugin.mapContainer.style.height = plugin.originalState.mapHeight;
+ plugin._removeOuterContainer(plugin.mapContainer, plugin.outerContainer, plugin.blankDiv)
+ plugin._map.invalidateSize();
+ plugin._map.setView(plugin.originalState.center);
+ plugin._map.setZoom(plugin.originalState.zoom);
+ }
+ }
+ domtoimage.toPng(plugin.mapContainer, {
+ width: parseInt(widthForExport),
+ height: parseInt(plugin.mapContainer.style.height.replace('px'))
+ })
+ .then(function (dataUrl) {
+ var blob = plugin._dataURItoBlob(dataUrl);
+ if (plugin.options.exportOnly) {
+ saveAs(blob, plugin.options.filename + '.png');
+ } else {
+ plugin._sendToBrowserPrint(dataUrl, plugin.orientation);
+ }
+ restorePlugin(plugin);
+ plugin._map.fire("easyPrint-finished");
+ })
+ .catch(function (error) {
+ console.error('Print operation failed', error);
+ restorePlugin(plugin);
+ })
},
_sendToBrowserPrint: function (img, orientation) {
- this._page.resizeTo(600, 800);
+ this._page.resizeTo(600, 800);
var pageContent = this._createNewWindow(img, orientation, this)
this._page.document.body.innerHTML = ''
this._page.document.write(pageContent);
- this._page.document.close();
+ this._page.document.close();
},
_createSpinner: function (title, spinnerClass, spinnerColor) {
@@ -234,93 +246,93 @@ L.Control.EasyPrint = L.Control.extend({
body{
background: ` + spinnerColor + `;
}
- .epLoader,
- .epLoader:before,
- .epLoader:after {
- border-radius: 50%;
- }
- .epLoader {
- color: #ffffff;
+ .epLoader,
+ .epLoader:before,
+ .epLoader:after {
+ border-radius: 50%;
+ }
+ .epLoader {
+ color: #ffffff;
font-size: 11px;
- text-indent: -99999em;
- margin: 55px auto;
- position: relative;
- width: 10em;
- height: 10em;
- box-shadow: inset 0 0 0 1em;
- -webkit-transform: translateZ(0);
- -ms-transform: translateZ(0);
- transform: translateZ(0);
- }
- .epLoader:before,
- .epLoader:after {
- position: absolute;
- content: '';
- }
- .epLoader:before {
- width: 5.2em;
- height: 10.2em;
- background: #0dc5c1;
+ text-indent: -99999em;
+ margin: 55px auto;
+ position: relative;
+ width: 10em;
+ height: 10em;
+ box-shadow: inset 0 0 0 1em;
+ -webkit-transform: translateZ(0);
+ -ms-transform: translateZ(0);
+ transform: translateZ(0);
+ }
+ .epLoader:before,
+ .epLoader:after {
+ position: absolute;
+ content: '';
+ }
+ .epLoader:before {
+ width: 5.2em;
+ height: 10.2em;
+ background: #0dc5c1;
border-radius: 10.2em 0 0 10.2em;
- top: -0.1em;
- left: -0.1em;
- -webkit-transform-origin: 5.2em 5.1em;
- transform-origin: 5.2em 5.1em;
- -webkit-animation: load2 2s infinite ease 1.5s;
- animation: load2 2s infinite ease 1.5s;
- }
- .epLoader:after {
- width: 5.2em;
- height: 10.2em;
- background: #0dc5c1;
+ top: -0.1em;
+ left: -0.1em;
+ -webkit-transform-origin: 5.2em 5.1em;
+ transform-origin: 5.2em 5.1em;
+ -webkit-animation: load2 2s infinite ease 1.5s;
+ animation: load2 2s infinite ease 1.5s;
+ }
+ .epLoader:after {
+ width: 5.2em;
+ height: 10.2em;
+ background: #0dc5c1;
border-radius: 0 10.2em 10.2em 0;
- top: -0.1em;
- left: 5.1em;
- -webkit-transform-origin: 0px 5.1em;
- transform-origin: 0px 5.1em;
- -webkit-animation: load2 2s infinite ease;
- animation: load2 2s infinite ease;
+ top: -0.1em;
+ left: 5.1em;
+ -webkit-transform-origin: 0px 5.1em;
+ transform-origin: 0px 5.1em;
+ -webkit-animation: load2 2s infinite ease;
+ animation: load2 2s infinite ease;
+ }
+ @-webkit-keyframes load2 {
+ 0% {
+ -webkit-transform: rotate(0deg);
+ transform: rotate(0deg);
}
- @-webkit-keyframes load2 {
- 0% {
- -webkit-transform: rotate(0deg);
- transform: rotate(0deg);
- }
- 100% {
- -webkit-transform: rotate(360deg);
- transform: rotate(360deg);
- }
+ 100% {
+ -webkit-transform: rotate(360deg);
+ transform: rotate(360deg);
}
- @keyframes load2 {
- 0% {
- -webkit-transform: rotate(0deg);
- transform: rotate(0deg);
- }
- 100% {
- -webkit-transform: rotate(360deg);
- transform: rotate(360deg);
- }
+ }
+ @keyframes load2 {
+ 0% {
+ -webkit-transform: rotate(0deg);
+ transform: rotate(0deg);
}
-
- Loading...