diff --git a/rkward/rbackend/rpackages/rkward/DESCRIPTION b/rkward/rbackend/rpackages/rkward/DESCRIPTION index 80585be0..0431c5e6 100644 --- a/rkward/rbackend/rpackages/rkward/DESCRIPTION +++ b/rkward/rbackend/rpackages/rkward/DESCRIPTION @@ -1,44 +1,44 @@ Package: rkward Type: Package Title: Provides functions related to the RKWard GUI -Author: Thomas Friedrichsmeier and - the RKWard Team +Description: This package contains functions which are useful in + combination with the RKWard GUI. Many of these functions only + needed for the internal communication between RKWard and R, but + some are also useful in user scripts. +Author: Thomas Friedrichsmeier + and the RKWard Team + Maintainer: RKWard-devel mailing list -Depends: - R (>= 2.9.0),methods -Description: This package contains functions which are useful in combination - with the RKWard GUI. Many of these functions only needed for the internal - communication between RKWard and R, but some are also useful in user - scripts. +Depends: R (>= 2.9.0),methods +URL: https://rkward.kde.org +BugReports: https://rkward.kde.org/Bugs License: GPL (>= 2) Encoding: UTF-8 LazyLoad: yes -URL: http://rkward.kde.org Authors@R: c(person(given="Thomas", family="Friedrichsmeier", - email="thomas.friedrichsmeier@ruhr-uni-bochum.de", role=c("aut")), - person(given="RKWard-devel", family="mailing list", - email="rkward-devel@kde.org", role=c("cre","ctb"))) + email="thomas.friedrichsmeier@ruhr-uni-bochum.de", + role=c("aut")), person(given="the RKWard", family="team", + email="rkward-devel@kde.org", role=c("cre","ctb"))) Version: 0.7.1 -Date: 2018-04-20 -Collate: +Date: 2018-05-22 +RoxygenNote: 6.0.1 +Collate: 'base_overrides.R' 'internal.R' 'internal_debugger.R' 'internal_graphics.R' 'internal_help.R' 'public_graphics.R' 'rk.KDE_GUI-functions.R' 'rk.demo.R' 'rk.edit-functions.R' 'rk.filename-functions.R' 'rk.label-functions.R' 'rk.plugin-functions.R' 'rk.print-functions.R' 'rk.replace.function.R' 'rk.sessionInfo.R' 'rk.sync-functions.R' 'rk.utility-functions.R' 'rk.workspace-functions.R' 'rkward-package.R' - 'ver.R' -RoxygenNote: 6.0.1 diff --git a/rkward/rbackend/rpackages/rkward/NAMESPACE b/rkward/rbackend/rpackages/rkward/NAMESPACE index 5d7c6cd3..f769f386 100644 --- a/rkward/rbackend/rpackages/rkward/NAMESPACE +++ b/rkward/rbackend/rpackages/rkward/NAMESPACE @@ -1,124 +1,124 @@ # Generated by roxygen2: do not edit by hand export(.onAttach) -export(.rk.app.version) export(.rk.backups) export(.rk.cached.available.packages) export(.rk.callstack.info) export(.rk.cat.output) export(.rk.data.frame.delete.row) export(.rk.data.frame.insert.column) export(.rk.data.frame.insert.row) export(.rk.do.call) export(.rk.do.error) export(.rk.do.plain.call) export(.rk.find.package.pluginmaps) export(.rk.fix.assignments) export(.rk.fix.assignments.graphics) export(.rk.get.environment.children) export(.rk.get.installed.packages) export(.rk.get.meta) export(.rk.get.package.intallation.state) export(.rk.get.search.results) export(.rk.get.slots) export(.rk.get.structure) export(.rk.get.structure.global) export(.rk.get.vector.data) export(.rk.getHelp) export(.rk.getHelpBaseUrl) export(.rk.inside.rkward.session) export(.rk.killPreviewDevice) export(.rk.make.hr) export(.rk.make.short.name) export(.rk.make.watch.f) export(.rk.rerun.plugin.link) export(.rk.set.invalid.fields) export(.rk.set.levels) export(.rk.set.meta) export(.rk.set.reply) export(.rk.set.vector.mode) export(.rk.startPreviewDevice) export(.rk.try.get.namespace) export(.rk.unwatch.symbol) export(.rk.variables) export(.rk.watch.globalenv) export(.rk.watch.symbol) export(.rk.with.window.hints) export(RK) export(Sys.setlocale) export(X11) export(makeActiveBinding) export(q) export(quartz) export(quit) export(require) +export(rk.askYesNo) export(rk.assign.preview.data) export(rk.call.plugin) export(rk.clear.plot.history) export(rk.demo) export(rk.describe.alternative) export(rk.discard.preview.data) export(rk.duplicate.device) export(rk.edit) export(rk.edit.files) export(rk.embed.device) export(rk.first.plot) export(rk.flush.output) export(rk.force.append.plot) export(rk.get.description) export(rk.get.label) export(rk.get.output.html.file) export(rk.get.preview.data) export(rk.get.short.name) export(rk.get.tempfile.name) export(rk.get.workspace.url) export(rk.goto.plot) export(rk.graph.off) export(rk.graph.on) export(rk.header) export(rk.last.plot) export(rk.list) export(rk.list.labels) export(rk.list.names) export(rk.list.plugins) export(rk.load.pluginmaps) export(rk.make.repos.string) export(rk.next.plot) export(rk.old.packages) export(rk.plot.history.summary) export(rk.previous.plot) export(rk.print) export(rk.print.code) export(rk.print.literal) export(rk.printer.device) export(rk.record.commands) export(rk.record.plot) export(rk.relative.src.line) export(rk.removethis.plot) export(rk.rename.in.container) export(rk.replace.function) export(rk.restore.workplace) export(rk.results) export(rk.save.workplace) export(rk.screen.device) export(rk.select.CRAN.mirror) export(rk.select.list) export(rk.sessionInfo) export(rk.set.label) export(rk.set.output.html.file) export(rk.set.plugin.status) export(rk.show.files) export(rk.show.html) export(rk.show.message) export(rk.show.plot.info) export(rk.show.question) export(rk.switch.frontend.language) export(rk.sync) export(rk.sync.global) export(rk.toggle.plot.history) export(rk.verify.plot.hist.limits) export(rk.without.plot.history) export(setwd) export(win.graph) export(windows) export(x11) diff --git a/rkward/rbackend/rpackages/rkward/R/internal.R b/rkward/rbackend/rpackages/rkward/R/internal.R old mode 100644 new mode 100755 index 256ebc88..5250c8c5 --- a/rkward/rbackend/rpackages/rkward/R/internal.R +++ b/rkward/rbackend/rpackages/rkward/R/internal.R @@ -1,446 +1,446 @@ # check the context in which this package is loaded #' @export .onAttach <- function(...) { .rk.inside.rkward.session(warn = TRUE) } # this function shall test if the rkward package was loaded in a running RKWard session #' @export .rk.inside.rkward.session <- function(warn = FALSE){ inside.rkward <- is.loaded("rk.do.generic.request") if(isTRUE(warn) & !isTRUE(inside.rkward)){ warning("You've loaded the package 'rkward', but RKWard doesn't appear to be running. If this causes trouble, try detach(\"package:rkward\").", call. = FALSE) } return(inside.rkward) } #' @export ".rk.get.meta" <- function (x) { y <- attr (x, ".rk.meta"); c (names (y), as.character (y)) } #' @export ".rk.set.meta" <- function (x, m) { eval (substitute (attr (x, ".rk.meta") <<- m)) } ".rk.set.invalid.field" <- function (x, row, value) { l <- attr (x, ".rk.invalid.fields"); if (is.null (l)) l <- list (); l[[as.character(row)]] <- value; if (length (l) == 0) l <- NULL eval (substitute (attr (x, ".rk.invalid.fields") <<- l)) } -#' Work around some peculiarities in R's handling of levels +# Work around some peculiarities in R's handling of levels #' @export ".rk.set.levels" <- function (var, levels) { if (is.factor (var)) { if (is.null (levels)) levels <- NA # must never set NULL levels on a factor old_l <- levels (var) # using attr (..., "levels) instead of levels (...) in order to bypass checking eval (substitute (attr (var, "levels") <<- levels)) if ((length (var) > 0) && (is.null (old_l) || ((length (old_l) == 1L) && is.na (old_l[1L])))) { # if levels were empty, this means var is all NAs. R will set all to first level, instead, in some cases len <- length (var) eval(substitute(var[1:len] <<- NA)) } } else { eval (substitute (attr (var, "levels") <<- levels)) } } #' @export ".rk.set.invalid.fields" <- function (x, set, values, clear) { l <- attr (x, ".rk.invalid.fields"); if (is.null (l)) l <- list (); if (!missing (set)) { set <- as.character (set) l[set] <- as.character (values) } if (!missing (clear)) { l[as.character (clear)] <- NULL } if (length (l) == 0) l <- NULL eval (substitute (attr (x, ".rk.invalid.fields") <<- l)) } #' @export ".rk.data.frame.insert.row" <- function (x, index=0) { if ((index == 0) || (index > dim (x)[1])) { # insert row at end eval (substitute (x[dim(x)[1]+1,] <<- c (NA))) } else { for (i in dim (x)[1]:index) { eval (substitute (x[i+1,] <<- x[i,])) } eval (substitute (row.names (x) <<- c (1:dim(x)[1]))) eval (substitute (x[index,] <<- c (NA))) } } # TODO: is there a nice way to get rid of a row without removing the meta-data? #' @export ".rk.data.frame.delete.row" <- function (x, index) { attriblist <- list () for (i in 1:dim (x)[2]) { attriblist[[names (x)[i]]] <- attributes (x[[i]]) } newx <- x[-index, , drop=FALSE] row.names (newx) <- c (1:dim(newx)[1]) for (i in 1:dim (newx)[2]) { attributes (newx[[i]]) <- attriblist[[names (newx)[i]]] } eval (substitute (x <<- newx)) } # function below is only needed to ensure a nice ordering of the columns. Simply adding a new column would be much easier than this. #' @export ".rk.data.frame.insert.column" <- function (x, label, index=0) { column <- rep (as.numeric (NA), times=dim (x)[1]) if ((index == 0) || (index > dim (x)[2])) { # insert column at end eval (substitute (x[[label]] <<- column)) } else { for (i in dim (x)[2]:index) { eval (substitute (x[i+1] <<- x[[i]])) eval (substitute (names (x)[i+1] <<- names (x)[i])) } eval (substitute (x[index] <<- column)) eval (substitute (names (x)[index] <<- label)) } } #' @export ".rk.do.error" <- function () { # comment in R sources says, it may not be good to query options during error handling. But what can we do, if R_ShowErrorMessages is not longer exported? if (getOption ("show.error.messages")) { .Call ("rk.do.error", c (geterrmessage ()), PACKAGE="(embedding)"); } } #' @export ".rk.set.reply" <- function (x) .rk.variables$.rk.rkreply <- x #' @export ".rk.do.call" <- function (x, args=NULL) { .rk.set.reply (NULL) .Call ("rk.do.command", c (x, args), PACKAGE="(embedding)"); return (.rk.variables$.rk.rkreply) } #' @export ".rk.do.plain.call" <- function (x, args=NULL, synchronous=TRUE) { .Call ("rk.do.generic.request", c (x, args), isTRUE (synchronous), PACKAGE="(embedding)") } #' @export ".rk.find.package.pluginmaps" <- function (package, all.maps=FALSE) { if(isTRUE(all.maps)){ # look for all pluginmaps in the rkward folder pluginmaps <- sapply(package, function(this.package){ dir(system.file("rkward", package=this.package), pattern="*.pluginmap", full.names=TRUE) }) } else { # check if a main .pluginmap file is provided pluginmaps <- sapply(package, function(this.package){ system.file(file.path("rkward", paste(this.package, ".pluginmap", sep="")), package=this.package) }) } return(pluginmaps) } # Gather status information on installed and available packages. # Return value is used in class RKRPackageInstallationStatus of the frontend #' @export ".rk.get.package.intallation.state" <- function () { # fetch all status information available <- .rk.cached.available.packages () inst <- installed.packages (fields="Title") old <- as.data.frame (rk.old.packages (available=available), stringsAsFactors=FALSE) new <- new.packages (instPkgs=inst, available=available) # convert info to a more suitable format available <- as.data.frame (available, stringsAsFactors=FALSE) inst <- as.data.frame (inst, stringsAsFactors=FALSE) oldinst <- match (paste (old$Package, old$LibPath), paste (inst$Package, inst$LibPath)) # convert package names to position with in the installed packages info oldavail <- match (old$Package, available$Package) # convert package names to position with in the available packages info new <- match (new, available$Package) # same for new packages # as a side effect, we update the list of known installed packages in the frontend .rk.do.plain.call ("updateInstalledPackagesList", sort (unique (as.character (inst$Package))), synchronous=FALSE) list ("available" = list (available$Package, available$Title, available$Version, available$Repository, grepl ("rkward", available$Enhances)), "installed" = list (inst$Package, inst$Title, inst$Version, inst$LibPath, grepl ("rkward", inst$Enhances)), "new" = as.integer (new - 1), "old" = list (as.integer (oldinst - 1), as.integer (oldavail - 1)), "repos" = as.character (options("repos")$repos)) } # package information formats may - according to the help - be subject to change. Hence this function to cope with "missing" values # also it concatenates everything to a single vector, so we can easily get the whole structure with a single call #' @export ".rk.get.installed.packages" <- function () { x <- as.data.frame(installed.packages(fields="Title")) # does a package enhance RKWard, i.e. provide plugins? enhance.rk <- ifelse(is.na(x$Enhances), FALSE, grepl("rkward", x$Enhances)) # as a side effect, we update the list of known installed packages in the frontend .rk.do.plain.call ("updateInstalledPackagesList", sort (unique (as.character (x$Package))), synchronous=FALSE) # check for pluginmaps only in packages which enhance RKWard rk.load.pluginmaps (.rk.find.package.pluginmaps(x$Package[enhance.rk]), force.add=FALSE, force.reload=FALSE) return(list(Package=as.character(x$Package), Title=as.character(x$Title), Version=as.character(x$Version), LibPath=as.character(x$LibPath), EnhanceRK=as.logical(enhance.rk))) } # This function works like available.packages (with no arguments), but does simple caching of the result, and of course uses a cache if available. Cache is only used, if it is less than 1 hour old, and options("repos") is unchanged. #' @export ".rk.cached.available.packages" <- function () { x <- NULL if (exists ("available.packages.cache", envir=.rk.variables) && (!is.null (.rk.variables$available.packages.cache))) { if (.rk.variables$available.packages.cache$timestamp > (Sys.time () - 3600)) { if (all (.rk.variables$available.packages.cache$repos$repos == options ("repos")$repos)) { x <- .rk.variables$available.packages.cache$cache } } } if (is.null(x)) { x <- available.packages(fields="Title") .rk.variables$available.packages.cache <- list (cache = x, timestamp = Sys.time (), repos = options ("repos")) } return (x) } #".rk.init.handlers" <- function () { # options (warning.expression = expression ()) # .Internal (.addCondHands (c ("message", "warning", "error"), list (function (m) { .Call ("rk.do.condition", c ("m", conditionMessage (m))) }, function (w) { .Call ("rk.do.condition", c ("w", conditionMessage (w))) }, function (e) { .Call ("rk.do.condition", c ("e", conditionMessage (e))) }), globalenv (), NULL, TRUE)) #} # these functions can be used to track assignments to R objects. The main interfaces are .rk.watch.symbol (k) and .rk.unwatch.symbol (k). This works by copying the symbol to a local environment, removing it, and replacing it by an active binding to the backup location ".rk.watched.symbols" <- new.env () #' @export ".rk.make.watch.f" <- function (k) { # we need to make sure, the functions we use are *not* looked up as symbols in .GlobalEnv. # else, for instance, if the user names a symbol "missing", and we try to resolve it in the # wrapper function below, evaluation would recurse to look up "missing" in the .GlobalEnv # due to the call to "if (!missing(value))". missing <- base::missing .Call <- base::.Call # NOTE: - Another _small_ speedup (~10%) _could_ be achieved by pre-compiling the returned function (compiler::cmpfun()). # - Limiting the .Call()s (by keeping/clearing a flag of whether change has been signalled, before) does not have any measurable effect, but adds complexity function (value) { if (missing (value)) { x } else { .Call ("ws", k, PACKAGE="(embedding)"); x <<- value } } } #' @export ".rk.watch.symbol" <- function (k) { if (bindingIsActive(k, globalenv())) { # If the symbol already is an active binding, give up for now, as there is not currently a user-accessible way to copy an active binding (not just its value) message("Note: RKWard cannot watch active binding ", k, " for changes.") } else { f <- .rk.make.watch.f (k) .Call ("rk.copy.no.eval", k, globalenv(), "x", environment (f), PACKAGE="(embedding)"); rm (list=k, envir=globalenv ()) .rk.makeActiveBinding.default (k, f, globalenv ()) } .rk.watched.symbols[[k]] <- TRUE invisible (TRUE) } # not needed by rkward but provided for completeness #' @export ".rk.unwatch.symbol" <- function (k) { x <- get(k, envir=globalenv ()) rm (list=k, envir=globalenv ()) assign (k, x, envir=globalenv ()) rm (k, envir=.rk.watched.symbols); invisible (TRUE) } #' @export ".rk.watch.globalenv" <- function () { newlist <- ls (globalenv (), all.names=TRUE) oldlist <- ls (.rk.watched.symbols, all.names=TRUE) for (old in oldlist) { # unwatch no longer present items if (!(old %in% newlist)) { rm (list=old, envir=.rk.watched.symbols); } } for (new in newlist) { # watch new items if (!(new %in% oldlist)) { .rk.watch.symbol (new) } } } #' @export ".rk.get.vector.data" <- function (x) { ret <- list (); ret$data <- as.vector (unclass (x)); ret$levels <- levels (x) if (is.null (ret$levels)) ret$levels <- "" i <- attr (x, ".rk.invalid.fields") ret$invalids <- as.character (c (names (i), i)); if (length (ret$invalids) == 0) ret$invalids <- "" ret } # Change storage type of x to mode newmode. # Keeps the .rk.meta attribute, and levels attributes, but the data is erased! #' @export ".rk.set.vector.mode" <- function (x, fun, envir=parent.frame ()) { y <- fun(rep(NA, length.out = length(x))) newattrs <- attributes(y) if (is.null (newattrs)) newattrs <- list () newattrs[[".rk.meta"]] <- attributes(x)[[".rk.meta"]] lvls <- attributes(x)[["levels"]] if (!is.null (lvls)) newattrs[["levels"]] <- lvls attributes(y) <- newattrs eval (substitute (x <- y), envir=envir) } #' @export ".rk.get.structure" <- function (x, name, envlevel=0, namespacename=NULL) { .Call ("rk.get.structure", x, as.character (name), as.integer (envlevel), namespacename, PACKAGE="(embedding)") } #' @export ".rk.try.get.namespace" <- function (name) { tryCatch (asNamespace (name), error = function(e) NULL) } #' @export ".rk.get.structure.global" <- function (name, envlevel=0, namespacename=NULL) { .Call ("rk.get.structure.global", as.character (name), as.integer (envlevel), namespacename, PACKAGE="(embedding)") } #' @export ".rk.get.slots" <- function (x) { slotnames <- methods::slotNames (class (x)) ret <- lapply (slotnames, function (slotname) slot (x, slotname)) names (ret) <- slotnames ret } #' @export ".rk.get.environment.children" <- function (x, envlevel=0, namespacename=NULL) { ret <- list () if (envlevel < 2) { # prevent infinite recursion lst <- ls (x, all.names=TRUE) if (is.null (namespacename)) { for (childname in lst) { ret[[childname]] <- .rk.get.structure (name=childname, envlevel=envlevel, envir=x) } } else { # for R 2.4.0 or greater: operator "::" works if package has no namespace at all, or has a namespace with the symbol in it ns <- tryCatch (asNamespace (namespacename), error = function(e) NULL) for (childname in lst) { misplaced <- FALSE if ((!is.null (ns)) && (!exists (childname, envir=ns, inherits=FALSE))) misplaced <- TRUE ret[[childname]] <- .rk.get.structure (name=childname, envlevel=envlevel, misplaced=misplaced, envir=x) } } } ret } # hidden, as this is not portable to different output formats #' @export ".rk.cat.output" <- function (x) { cat (x, file = rk.get.output.html.file(), append = TRUE) } #' @export ".rk.rerun.plugin.link" <- function (plugin, settings, label) { .rk.cat.output (paste ("", label, "", sep="")) } #' @export ".rk.make.hr" <- function () { .rk.cat.output ("
\n"); } # General purpose storage environment (which will hopefully never get locked by R) #' @export ".rk.variables" <- new.env () assign(".rk.active.device", 1, envir=.rk.variables) assign(".rk.output.html.file", NULL, envir=.rk.variables) assign(".rk.rkreply", NULL, envir=.rk.variables) assign("available.packages.cache", NULL, envir=.rk.variables) #' @export ".rk.backups" <- new.env () # where masking is not enough, we need to assign in the original environment / namespace. This can only be done after package loading, # so we have a separate function for that. #' @export ".rk.fix.assignments" <- function () { ## History manipulation function (overloads for functions by the same name in package utils) rk.replace.function ("loadhistory", as.environment ("package:utils"), function (file = ".Rhistory") { invisible (.rk.do.plain.call ("commandHistory", c ("set", readLines (file)))) }, copy.formals = FALSE) rk.replace.function ("savehistory", as.environment ("package:utils"), function (file = ".Rhistory") { invisible (writeLines (.rk.do.plain.call ("commandHistory", "get"), file)) }, copy.formals = FALSE) rk.replace.function ("timestamp", as.environment ("package:utils"), function (stamp = date(), prefix = "##------ ", suffix = " ------##", quiet = FALSE) { stamp <- paste(prefix, stamp, suffix, sep = "") .rk.do.plain.call ("commandHistory", c ("append", stamp)) if (!quiet) cat(stamp, sep = "\n") invisible(stamp) }, copy.formals = FALSE) ## Interactive menus rk.replace.function ("select.list", as.environment ("package:utils"), function () { # the "list" parameter was renamed to "choices" in R 2.11.0 if (!exists ("list", inherits=FALSE)) list <- choices # the "graphics" parameter was introduced in R 2.11.0, so we cannot rely on its existance if (!exists ("graphics", inherits=FALSE)) graphics <- TRUE if (graphics) { return (rk.select.list (list, preselect, multiple, title)) } # for text list, use the default implementation eval (body (.rk.backups$select.list)) }) rk.replace.function ("menu", as.environment ("package:utils"), function () { if (graphics) { res <- rk.select.list (choices, multiple=FALSE, title=title) return (match(res, choices, nomatch = 0L)) } # for text menus, use the default implementation eval (body (.rk.backups$menu)) }) # call separate assignments functions: if (exists (".rk.fix.assignments.graphics")) eval (body (.rk.fix.assignments.graphics)) # internal_graphics.R } diff --git a/rkward/rbackend/rpackages/rkward/R/rk.KDE_GUI-functions.R b/rkward/rbackend/rpackages/rkward/R/rk.KDE_GUI-functions.R old mode 100644 new mode 100755 index 771abc0d..617dbfab --- a/rkward/rbackend/rpackages/rkward/R/rk.KDE_GUI-functions.R +++ b/rkward/rbackend/rpackages/rkward/R/rk.KDE_GUI-functions.R @@ -1,165 +1,183 @@ #' Message boxes and selection list using native KDE GUI #' #' Multi-purpose pop-up message boxes and selection list using native KDE GUI #' elements. The message boxes can be used either to show some information or #' ask some question. The selection list can be used to get a vector of #' selected items. #' #' For \code{rk.show.question}, the R interpreter always waits for the user's #' choice. #' #' \code{rk.select.list} replaces \code{utils::select.list} for the running #' session acting as a drop-in replacement for \code{tk_select.list}. Use #' \code{.rk.backups$select.list} for the original \code{utils::select.list} #' function (see Examples). #' #' @aliases rk.show.message rk.show.question rk.select.list #' @param message a string for the content of the message box. +#' @param msg like \code{message}, only the argument was renamed to mimic the formals of +#' \code{askYesNo}. #' @param caption a string for title of the message box. #' @param button.yes a string for the text label of the \bold{Yes} button. Can #' be an empty string (\code{""}), in which case the button is not displayed #' at all. Note that the default value of "yes" (lower case) means to use a default #' rendering of a "Yes" button, which may or may not be the literal string "Yes" #' (importantly, it will be translated, automatically). #' @param button.no a string used for the text label of the \bold{No} button. #' This behaves similar to \code{button.yes}, including the meaning of the #' default value "no". #' @param button.cancel a string used for the text label of the \bold{Cancel} button. #' This behaves similar to \code{button.yes}, including the meaning of the #' default value "cancel". #' @param prompts either a character vector containing 3 prompts corresponding to return #' values of TRUE, FALSE, or NA, or a single character value containing the prompts #' separated by \code{/} characters. #' @param default The expected or "safe" default response (e.g. \code{TRUE} for "Yes button"). #' The corresponding button will focused, so that it will become selected option, #' if the user simply presses enter. #' @param wait a logical (not NA) indicating whether the R interpreter should #' wait for the user's action, or run it asynchronously. #' @param list a vector, coerced into a character vector. #' @param preselct a vector, coerced into a character vector, items to be #' preselected. #' @param multiple a logical (not NA), when \code{TRUE} multiple selection #' selection is allowed. #' @param title a string, for the window title of the displayed list +#' @param is.rk.askYesNo a logical value, you can safely ignore this argument if you call +#' \code{rk.askYesNo} manually. This argument is needed if \code{rk.askYesNo} is set +#' via \code{options("askYesNo"=rk.askYesNo)} because otherwise we'd either need more +#' complicated function code there, fail with an error or end up in an infinite loop. #' @return \code{rk.show.message} always returns \code{TRUE}, invisibly. #' #' \code{rk.show.question} returns \code{TRUE} for \bold{Yes}, \code{FALSE} for #' \bold{No}, and \code{NULL} for \bold{Cancel} actions. If the dialog is closed #' without clicking on any button, \code{NULL} is returned, as well. #' +#' \code{rk.askYesNo} has the same return values as \code{rk.show.question}, except +#' it returns \code{NA} for \bold{Cancel} actions. +#' #' \code{rk.select.list} returns the value of \code{\link{select.list}}. #' @author Thomas Friedrichsmeier \email{rkward-devel@@kde.org} #' @seealso \code{\link{system}}, \code{\link{select.list}} #' @keywords utilities #' @rdname rk.show.messages #' @examples #' #' require (rkward) #' #' ## Message boxes #' if (rk.show.question ("Question:\nDo you want to know about RKWard?", #' button.yes = "Yes, I do!", button.no = "No, I don't care!", button.cancel = "")) { #' rk.show.message ("Message:\nRKWard is a KDE GUI for R.", "RKWard Info") #' } else { #' rk.show.message ("You must be joking!", "RKWard Info", wait = FALSE) ## Run asynchronously #' } #' #' ## Selection lists: #' rk.select.list (LETTERS, preselect = c("A", "E", "I", "O", "U"), #' multiple = TRUE, title = "vowels") #' .rk.backups$select.list (LETTERS, preselect = c("A", "E", "I", "O", "U"), #' multiple = TRUE, title = "vowels") #' @export "rk.show.message" <- function (message, caption = gettext("Information"), wait=TRUE) { .Call ("rk.dialog", caption, message, "ok", "", "", "ok", isTRUE (wait), PACKAGE="(embedding)") invisible (TRUE) } # to disable a button, set it to "" #' @export #' @rdname rk.show.messages "rk.show.question" <- function (message, caption = gettext("Question"), button.yes = "yes", button.no = "no", button.cancel = "cancel", default=TRUE) { .Deprecated("rk.askYesNo") if (isTRUE (default)) default_button <- button.yes else if (identical (default, FALSE)) default_button <- button.no else default_button <- button.cancel res <- .Call ("rk.dialog", caption, message, button.yes, button.no, button.cancel, default_button, TRUE, PACKAGE="(embedding)") if (res > 0) return (TRUE) else if (res < 0) return (FALSE) else return (NULL) # cancelled } #' @export #' @rdname rk.show.messages -"rk.askYesNo" <- function (message, default = TRUE, prompts = c("yes", "no", "cancel"), caption = gettext("Question")) { +"rk.askYesNo" <- function (msg, default = TRUE, prompts = c("yes", "no", "cancel"), caption = gettext("Question"), is.rk.askYesNo=TRUE, ...) { + if(is.function(prompts)){ + # using options() to set the prompts value for askYesNo() to this function also replaces our prompts and we'd + # end up in an infinite loop. we can check for the presence of the "rk.askYesNo" argument to see if that's the case + if(isTRUE(is.rk.askYesNo)){ + prompts <- eval(formals("rk.askYesNo")[["prompts"]]) + } else { + stop(simpleError("'rk.askYesNo' was designed to be used as the function code of 'askYesNo' and cannot be given a function ")) + } + } else {} if(is.character(prompts)){ if(length(prompts) == 1){ prompts <- unlist(strsplit(prompts, "/")) } else {} if(length(prompts) != 3){ stop(simpleError("'prompts' must be either a single character string or three character values!")) } else {} button.yes <- prompts[1] button.no <- prompts[2] button.cancel <- prompts[3] } else { stop(simpleError("'prompts' must be character!")) } default_button <- switch( as.character(as.logical(default)), "TRUE"=button.yes, "FALSE"=button.no, button.cancel ) res <- .Call( "rk.dialog", caption, - message, + msg, button.yes, button.no, button.cancel, default_button, TRUE, PACKAGE="(embedding)" ) if (res > 0){ return (TRUE) } else if (res < 0){ return (FALSE) } else { return (NA) # cancelled } } # drop-in-replacement for tk_select.list() #' @export #' @rdname rk.show.messages "rk.select.list" <- function (list, preselect = NULL, multiple = FALSE, title = NULL) { preselect <- as.character (preselect) preselect.len = length (preselect) list <- as.character (list) list.len <- length (list) params <- list () # serialize all parameters params[1] <- as.character (title) if (multiple) params[2] <- "multi" else params[2] <- "single" params[3] <- as.character (preselect.len) if (preselect.len) { for (i in 1:preselect.len) { params[3+i] <- preselect[i] } } if (list.len) { # we should hope, the list is not empty... for (i in 1:list.len) { params[3+preselect.len+i] <- list[i] } } .rk.do.plain.call ("select.list", params) } diff --git a/rkward/rbackend/rpackages/rkward/R/rkward-package.R b/rkward/rbackend/rpackages/rkward/R/rkward-package.R index bf9533e3..cb1bf585 100644 --- a/rkward/rbackend/rpackages/rkward/R/rkward-package.R +++ b/rkward/rbackend/rpackages/rkward/R/rkward-package.R @@ -1,24 +1,22 @@ -#' Provides functions related to the RKWard GUI. +#' \packageDescription{rkward} #' +#' The DESCRIPTION file: #' \tabular{ll}{ #' Package: \tab rkward\cr #' Type: \tab Package\cr -#' Version: \tab 0.6.3\cr -#' Date: \tab 2014-10-30\cr +#' Version: \tab 0.7.1\cr +#' Date: \tab 2018-05-22\cr #' Depends: \tab R (>= 2.9.0),methods\cr #' Encoding: \tab UTF-8\cr #' License: \tab GPL (>= 2)\cr #' LazyLoad: \tab yes\cr -#' URL: \tab http://rkward.kde.org\cr +#' URL: \tab https://rkward.kde.org\cr #' } #' -#' This package contains functions which are useful in combination with the RKWard GUI. Many of these -#' functions only needed for the internal communication between RKWard and R, but some are also useful in user scripts. +#' @title +#' \packageTitle{rkward} +#' @author +#' \packageAuthor{rkward} #' -#' @aliases rkward-package -#' @name rkward-package -#' @docType package -#' @title The rkward Package -#' @author Thomas Friedrichsmeier, with contributions from RKWard-devel mailing list -#' @keywords package -NULL +#' Maintainer: \packageMaintainer{rkward} +"_PACKAGE" diff --git a/rkward/rbackend/rpackages/rkward/inst/CITATION b/rkward/rbackend/rpackages/rkward/inst/CITATION index 49eff875..45451adb 100644 --- a/rkward/rbackend/rpackages/rkward/inst/CITATION +++ b/rkward/rbackend/rpackages/rkward/inst/CITATION @@ -1,14 +1,14 @@ bibentry("Manual", title="rkward: Provides functions related to the RKWard GUI", author="Thomas Friedrichsmeier", - year="2016", - note="(Version 0.6.6)", - url="http://rkward.kde.org", + year="2018", + note="(Version 0.7.1)", + url="https://rkward.kde.org", textVersion = - paste("Friedrichsmeier, T. (2016). ", - "rkward: Provides functions related to the RKWard GUI (Version 0.6.6). ", - "Available from http://rkward.kde.org", + paste("Friedrichsmeier, T. (2018). ", + "rkward: Provides functions related to the RKWard GUI (Version 0.7.1). ", + "Available from https://rkward.kde.org", sep=""), mheader = "To cite rkward in publications use:") diff --git a/rkward/rbackend/rpackages/rkward/man/RKdevice.Rd b/rkward/rbackend/rpackages/rkward/man/RKdevice.Rd index af3eaf2a..037a689a 100644 --- a/rkward/rbackend/rpackages/rkward/man/RKdevice.Rd +++ b/rkward/rbackend/rpackages/rkward/man/RKdevice.Rd @@ -1,32 +1,34 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/public_graphics.R \name{RK} \alias{RK} \title{Plot graphics to RKWard native device} \usage{ RK(width = getOption("rk.screendevice.width"), height = getOption("rk.screendevice.height"), pointsize = 12, family = NULL, bg = "white", title = "", antialias = TRUE) } \arguments{ \item{width}{Width of the device in inches. The default is to use the heigth configured in Settings -> Configure RKWard -> Onscreen Graphics.} \item{height}{Height of the device in inchesgraphics in pixels. The default is to use the heigth configured in Settings -> Configure RKWard -> Onscreen Graphics.} \item{pointsize}{Default pointsize} \item{family}{Default font family. This can be a character vector of length 1 or 2. The second value is used for -plotting symbols. Effectively the default is c("Helvetica", "Symbol"). A wide variety of sepcification is supported, +plotting symbols. Effectively the default is c("Helvetica", + "Symbol"). A wide variety of sepcification is supported, including the device independent fonts names "sans", "serif", and "mono"} \item{bg}{Background color.} \item{title}{Window title.} \item{antialias}{Antialiasing. Can be turned off for somewhat faster drawing.} } \description{ \code{RK()} creates an R on-screen device that will be rendered in the RKWard frontend. -The default settings for \code{width}, and \code{height} can be modified from Settings -> Configure RKWard -> Onscreen Graphics. +The default settings for \code{width}, + and \code{height} can be modified from Settings -> Configure RKWard -> Onscreen Graphics. } \keyword{devices} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.assign.preview.data.Rd b/rkward/rbackend/rpackages/rkward/man/rk.assign.preview.data.Rd index 9b30a067..7975da03 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.assign.preview.data.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.assign.preview.data.Rd @@ -1,62 +1,67 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.plugin-functions.R \name{rk.assign.preview.data} \alias{rk.assign.preview.data} \alias{rk.get.preview.data} \alias{.rk.discard.preview.data} \alias{rk.get.preview.data} \alias{rk.discard.preview.data} \title{Manage (shortly) persistent data for previews (for use in RKWard plugins wishing to provide custom previews)} \usage{ rk.assign.preview.data(id, value = list()) rk.get.preview.data(id) rk.discard.preview.data(id) } \arguments{ \item{id}{(character). Id associated with the data. Usually this will be the 'id' value of the -box.} -\item{value.}{The value to assign. If this is a list, and contains a function named "on.delete", this function +\item{value.}{The value to assign. If this is a list, + and contains a function named "on.delete", this function will be run by rk.discard.preview.data (with the \code{id} as argument. This is useful for running custom clearnup code, such as removing temporary files, etc.} } \value{ \code{rk.assign.preview.data} amd \code{rk.get.preview.data} returns the preview data (newly) associated with the given id. \code{rk.discard.preview.data} returns \code{NULL}, invisibly. -\bold{Note}: Plugins that want to produce a single plot, or open a single object via \code{\link{rk.edit}()} do \bold{not} - have to call these functions, manually. See the chapter on providing previews in the Introduction to +\bold{Note}: Plugins that want to produce a single plot, + or open a single object via \code{\link{rk.edit}()} do \bold{not} + have to call these functions, + manually. See the chapter on providing previews in the Introduction to writing plugins for RKWard. } \description{ \code{rk.assign.preview.data} stores data associated with a specific "id". Usually this id is provided by the -feature of a plugin. \code{rk.get.preview.data} retrieves data previously stored with \code{rk.assign.preview.data} \code{rk.discard.preview.data} discards data previously stored with \code{rk.assign.preview.data}. - This gets called by the -box of the plugin, automtically, when the plugin dialog is closed. - You do not generally have to call it manually. See the notes for running custom clearnup code, below. + This gets called by the -box of the plugin, automtically, + when the plugin dialog is closed. + You do not generally have to call it manually. See the notes for running custom clearnup code, + below. } \examples{ ## To be generated in the preview() code section of a plugin ## NOT RUN pdata <- rk.get.preview.data("SOMEID") if (is.null (pdata)) { outfile <- rk.get.tempfile.name(prefix="preview", extension=".txt") pdata <- list(filename=outfile, on.delete=function (id) { unlink(rk.get.preview.data(id)$filename) }) rk.assign.preview.data("SOMEID", pdata) } try ({ cat ("This is a test", pdata$filename) rk.edit.files(file=pdata$filename) }) ## END NOT RUN } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.call.plugin.Rd b/rkward/rbackend/rpackages/rkward/man/rk.call.plugin.Rd index 4e441155..c1dcb3bf 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.call.plugin.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.call.plugin.Rd @@ -1,73 +1,74 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.plugin-functions.R \name{rk.call.plugin} \alias{rk.call.plugin} \title{Call built-in RKWard plugin(s)} \usage{ rk.call.plugin(plugin, ..., submit.mode = c("manual", "auto", "submit")) } \arguments{ \item{plugin}{character string, giving the name of the plugin to call. See Details.} \item{\dots}{arguments passed to the \code{plugin}} \item{submit.mode}{character string, specifying the submission mode: \code{"manual"} will open the plugin GUI and leave it to the user to submit it manually, \code{"auto"} will try to submit the plugin, if it can be submitted with the current settings (i.e. if the "Submit"-button is enabled after applying all specified parameters). If the plugin cannot be submitted, with the current settings, it will behave like \code{"manual"}. \code{"submit"} is like \code{"auot"}, but will close the plugin, and generate an error, if it cannot be submitted. \code{"manual"} will always return immediately, \code{"auto"} may or may not return immediately, and \code{"submit"} will always wait until the plugin has been run, or produce an error.} } \value{ \code{rk.call.plugin} returns \code{TRUE} invisibly. } \description{ \code{rk.call.plugin} provides a high level wrapper to call any plugin available in RKWard. The exact string to be used as \code{plugin}, and the list of arguments available for a particular plugin, are generally not transparent to the user. \code{rk.list.plugins} can be used to obtain a list of current plugins. For plugin arguments, it is recommended to run the plugin, and inspect the "Run again" link that is generated on the output. } \details{ \bold{Warning}: Using \code{rk.call.plugin}, especially with submit.modes \code{"auto"} or \code{"submit"} to program a sequence of analyses has important drawbacks. First, the semantics of plugins are not guaranteed to remain unchanged across different versions of RKWard, thus your code may stop working after an upgrade. Second, your code will not be usable outside of an RKWard session. Consider copying the generated code for each plugin, instead. The primary use-cases for \code{rk.call.plugin} are automated tests, cross-references, and scripted tutorials. \bold{Note}: Even when using \code{"submit.mode=submit"}, the plugin code is run in the global context. Any local variables of the calling context are not available to the plugin. } \examples{ ## "t_test_two_vars" plugin: ## see the output: Windows->Show Output local({ x1 <- rnorm (100) x2 <- rnorm (100, 2) rk.call.plugin ("rkward::t_test_two_vars", - confint.state="1", conflevel.real="0.95", hypothesis.string="greater", paired.state="0", varequal.state="0", + confint.state="1", conflevel.real="0.95", hypothesis.string="greater", paired.state="0", + varequal.state="0", x.available="x1", y.available="x2", submit.mode="submit") }) } \seealso{ \code{\link{rk.results}}, \url{rkward://page/rkward_output} } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.embed.device.Rd b/rkward/rbackend/rpackages/rkward/man/rk.embed.device.Rd index c023e49b..0ef12175 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.embed.device.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.embed.device.Rd @@ -1,34 +1,41 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/public_graphics.R \name{rk.embed.device} \alias{rk.embed.device} \title{Embed non-RKWard device windows} \usage{ rk.embed.device(expr) } \arguments{ \item{expr}{Expression to evaluate.} } \description{ -\code{rk.embed.device} evaluates the given expression, and if this has created a window on the screen, tries to embed it as an RKWard window. +\code{rk.embed.device} evaluates the given expression, + and if this has created a window on the screen, tries to embed it as an RKWard window. } \details{ -Theoretically, \code{expr} can be any valid R expression. However typically this should be calls to X11(), Windows(), or, perhaps dev.copy(). - Importantly, the expression should create exactly one new window for \code{rk.embed.device()} to work. Keep in mind, that this is not - always the case for \code{plot(...)} and similar commands, which will re-use an existing plot window, if available. +Theoretically, + \code{expr} can be any valid R expression. However typically this should be calls to X11(), Windows(), or, perhaps dev.copy(). + Importantly, + the expression should create exactly one new window for \code{rk.embed.device()} to work. Keep in mind, that this is not + always the case for \code{plot(...)} and similar commands, + which will re-use an existing plot window, if available. } \note{ -\code{rk.embed.device()} will not work on all platforms (most importantly, not in most MacOSX binaries). Further, note that a captured - \code{X11()} or \code{Windows} device may look similar to an \code{RK()} device, but is actually a very different thing. Capturing a - window already "owned" by RKWard (importantly, \code{RK()} device windows) may lead to unexpected results, including crashes. +\code{rk.embed.device()} will not work on all platforms (most importantly, + not in most MacOSX binaries). Further, note that a captured + \code{X11()} or \code{Windows} device may look similar to an \code{RK()} device, + but is actually a very different thing. Capturing a + window already "owned" by RKWard (importantly, + \code{RK()} device windows) may lead to unexpected results, including crashes. } \examples{ ## Not run: rk.embed.device (grDevices::X11(title="X11 device window")) plot (rnorm (10)) } \seealso{ \link{RK} } diff --git a/rkward/rbackend/rpackages/rkward/man/rk.get.tempfile.name.Rd b/rkward/rbackend/rpackages/rkward/man/rk.get.tempfile.name.Rd index e4395f55..e5c46244 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.get.tempfile.name.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.get.tempfile.name.Rd @@ -1,104 +1,105 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.filename-functions.R \name{rk.get.tempfile.name} \alias{rk.get.tempfile.name} \alias{rk.get.workspace.url} \alias{rk.get.output.html.file} \alias{rk.set.output.html.file} \alias{rk.get.workspace.url} \alias{rk.get.output.html.file} \alias{rk.set.output.html.file} \alias{rk.flush.output} \title{RKWard file names} \usage{ rk.get.tempfile.name(prefix = "image", extension = ".jpg") rk.get.workspace.url() rk.get.output.html.file() rk.set.output.html.file(x, additional.header.contents = getOption("rk.html.header.additions"), style = c("regular", "preview"), css = getOption("rk.output.css.file")) rk.flush.output(x = rk.get.output.html.file(), flush.images = TRUE, ask = TRUE, ...) } \arguments{ \item{prefix}{a string, used as a filename prefix when saving images to the output file} \item{extension}{a string, used as a filename extension when saving images to the output file} \item{x}{a string, giving the filename of the of the output file} \item{additional.header.contents}{NULL or an additional string to add to the HTML header section. This could be scripts or additional CSS definitions, for example. Note that \emph{nothing} will be added to the header, if the file already exists.} \item{style}{Currently either "regular" or "preview". The latter omits table of contents and date.} -\item{css}{Local file name of CSS file to use, or NULL for no CSS file. The CSS file will be +\item{css}{Local file name of CSS file to use, + or NULL for no CSS file. The CSS file will be placed next to x, with file name extension ".css". Only effective when initializing a (non-existing) output file.} \item{ask}{Logical: Whether to ask before flushing the output file.} \item{...}{Further parameters passed to rk.set.output.html.file()} \item{flush.images.}{If true, any images used in the output file will be deleted as well.} } \value{ \code{rk.get.tempfile.name}, \code{rk.get.output.html.file}, and \code{rk.get.workspace.url} return a string while \code{rk.set.output.html.file} returns the \bold{previous} output html file. } \description{ In RKWard the output is saved as a html file which is located at "~/.rkward" by default. (\bold{TODO}: make this platform free). The name of this html file can be retrieved and set using \code{rk.get.output.html.file} and \code{rk.set.output.html.file}. \code{rk.flush.output.html.file} will delete the current (or specified) html file, and re-initialize it. } \details{ \code{rk.get.tempfile.name} returns a non-existing filename inside the directory of the output file. It is mainly used by \link{rk.graph.on} to create filenames suitable for storing images in the output. The filenames of the temporary files are of the form "\code{prefix}\emph{xyz}.\code{extension}". \code{rk.get.tempfile.name} is somewhat misnamed. For truly temporary files, \link{tempfile} is generally more suitable. \code{rk.get.workspace.url} returns the url of workspace file which has been loaded in RKWard, or NULL, if no workspace has been loaded. NOTE: This value is note affected by running \code{load} in R, only by loading R workspaces via the RKWard GUI. } \examples{ testfile.name <- rk.get.tempfile.name(prefix="test", extension=".txt") testfile <- file(testfile.name) cat("This is a test\\n", file=testfile) close(testfile) unlink(testfile.name) outfile <- rk.get.output.html.file() ## Not run rk.set.output.html.file("~/.rkward/another_file.html") rk.header("Output on a different output file") rk.show.html(rk.get.output.html.file()) rk.flush.output() rk.set.output.html.file(outfile) } \seealso{ \url{rkward://page/rkward_output}, \link{tempfile}, \link{file}, \link{rk.print} } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{IO} \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.graph.on.Rd b/rkward/rbackend/rpackages/rkward/man/rk.graph.on.Rd index 1dc01bf8..dface1bf 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.graph.on.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.graph.on.Rd @@ -1,61 +1,64 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/public_graphics.R \name{rk.graph.on} \alias{rk.graph.on} \alias{rk.graph.off} \alias{rk.graph.off} \title{Plot graphics to HTML output file} \usage{ rk.graph.on(device.type = getOption("rk.graphics.type"), width = getOption("rk.graphics.width"), height = getOption("rk.graphics.height"), quality, ...) rk.graph.off() } \arguments{ -\item{device.type}{Type of device to create / graphics format to use. Currently, supported devices are "PNG", "SVG", or "JPG". +\item{device.type}{Type of device to create / graphics format to use. Currently, + supported devices are "PNG", "SVG", or "JPG". The default is to use the format configured in Settings -> Configure RKWard -> Output.} \item{width}{Width of graphics in pixels. The default is to use the width configured in Settings -> Configure RKWard -> Output.} \item{height}{Height of graphics in pixels. The default is to use the heigth configured in Settings -> Configure RKWard -> Output.} \item{quality}{For device.type "JPG", quality of the JPG file from 0 to 100. The default is to use the quality configured in Settings -> Configure RKWard -> Output.} \item{...}{Further options will be passed to the graphics device used internally. \bold{Warning}: It is advised to use \code{rk.graph.off} and \bold{not} \code{dev.off} to close the device opened by -\code{rk.graph.on}. \code{dev.print(device = rk.graph.on)} is a \bold{wrong} usage for this "device," and will result in errors.} +\code{rk.graph.on}. \code{dev.print(device = rk.graph.on)} is a \bold{wrong} usage for this "device, + " and will result in errors.} } \description{ \code{rk.graph.on()} creates an R device that will plot to the output html page in RKWard (\url{rkward://page/rkward_output}). -The default settings for \code{device.type}, \code{width}, \code{height}, and \code{quality} can be modified from Settings -> Configure RKWard -> Output. +The default settings for \code{device.type}, \code{width}, \code{height}, + and \code{quality} can be modified from Settings -> Configure RKWard -> Output. \code{rk.graph.off()} closes the device that was opened by \code{rk.graph.on}. } \examples{ require (rkward) ## Plot directly to the output (html) file, by-passing screen device: rk.graph.on ("JPG", 480, 480, 75) plot (rnorm (100)) rk.graph.off () ## Copy the displayed plot to the output: plot (rnorm (100)) dev.copy (device = rk.graph.on) rk.graph.off () ## WRONG USAGE: not run: #plot (rnorm (100)) #dev.print (device = rk.graph.on) } \seealso{ \link{rk.results} \link{rk.print} \link{rk.get.output.html.file} \link{dev.off} \link{svg} \link{png} \link{jpg} } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{devices} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.list.plugins.Rd b/rkward/rbackend/rpackages/rkward/man/rk.list.plugins.Rd index 06aad83f..b0c621a4 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.list.plugins.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.list.plugins.Rd @@ -1,60 +1,64 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.plugin-functions.R \name{rk.list.plugins} \alias{rk.list.plugins} \alias{rk.set.plugin.status} \alias{rk.set.plugin.status} \title{List of modify loaded plugins} \usage{ rk.list.plugins() rk.set.plugin.status(id, context = "", visible = TRUE) } \arguments{ \item{id}{vector of ids (character) of the plugins to modify} \item{context}{in which the plugin should be shown / hidden. This can either be "", meaning the plugin will be affected in all contexts it occurs in, or a character vector of the same length as id.} \item{visible}{logical, controlling whether the plugin should be shown (\code{TRUE}) or hidden (\code{FALSE}). Hidden plugins are essentially removed from the menu. They may still be accessible embedded into other plugins.} } \value{ \code{rk.list.plugins} returns a data.frame listing plugin ids, context, menu path (tab-separated), and label of the plugin. If a plugin is available in more - than one context, it will be listed several times. The exact layout (number and order of columns) - of this data.frame might be subject to change. However, the \bold{names} of the columns in the + than one context, + it will be listed several times. The exact layout (number and order of columns) + of this data.frame might be subject to change. However, + the \bold{names} of the columns in the returned data.frame are expected to remain stable. \code{rk.set.plugin.status} returns \code{NULL}, invisibly \bold{Note}: Each call to \code{rk.set.plugin.status} will result in a complete rebuild of the menu (in the current implementation). While this should be hardly noticeable in interactive - use, it could be an issue when changing the status of many plugins, programatically. - In this case, make sure to do all changes in \bold{one} call to \code{rk.set.plugin.status}, + use, it could be an issue when changing the status of many plugins, + programatically. + In this case, + make sure to do all changes in \bold{one} call to \code{rk.set.plugin.status}, rather than many separate calls. } \description{ \code{rk.list.plugins} returns the a list of all currently registered plugins (in loaded pluginmaps). \code{rk.set.plugin.status} allows to control the status of the given plugin(s). Currently, only visibility can be controlled. } \examples{ ## list all current plugins rk.list.plugins () ## NOT RUN ## hide t.test plugin rk.set.plugin.status ("rkward::t_test", visible=FALSE) ## END NOT RUN } \seealso{ \code{\link{rk.call.plugin}} for invoking a plugin, programatically } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.load.pluginmaps.Rd b/rkward/rbackend/rpackages/rkward/man/rk.load.pluginmaps.Rd index 5c6cd94e..34c3390a 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.load.pluginmaps.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.load.pluginmaps.Rd @@ -1,46 +1,49 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.plugin-functions.R \name{rk.load.pluginmaps} \alias{rk.load.pluginmaps} \title{(Re-)load the given pluginmap files into the RKWard GUI} \usage{ rk.load.pluginmaps(pluginmap.files = NULL, force.add = TRUE, force.reload = TRUE) } \arguments{ \item{pluginmap.files}{a character vector of file names to add. This may be left empty, if the only desired effect is to reload all active pluginmaps.} \item{force.add}{logical. Whether the pluginmap files should also be added, if they had been previously de-selected in the settings menu, and regardless of their priority setting. In scripted usage, this should generally be set to FALSE.} -\item{force.reload}{logical. By default the active pluginmaps are reloaded, only if any new ones +\item{force.reload}{logical. By default the active pluginmaps are reloaded, + only if any new ones were added. If set to TRUE, pluginmaps are reloaded in any case. In scripted usage, this should generally be set to FALSE. NOTE: Since a reload always means reloading _all_ active pluginmaps, This may be slow, and should be used with care. -\bold{Note}: It is not necessary to reload the pluginmap, in order to refresh an individual - plugin (e.g. after modifying the dialog), as plugins are not kept in memory after closing. +\bold{Note}: It is not necessary to reload the pluginmap, + in order to refresh an individual + plugin (e.g. after modifying the dialog), + as plugins are not kept in memory after closing. Any currently opened plugins are not affected by this function.} } \description{ (Re-)load the given pluginmap files into the RKWard GUI } \examples{ ## NOT RUN ## reload all active pluginmaps rk.load.pluginmaps() ## END NOT RUN } \seealso{ \code{\link{rk.call.plugin}}, @seealso \code{\link{rkwarddev::rk.plugin.skeleton}} } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.old.packages.Rd b/rkward/rbackend/rpackages/rkward/man/rk.old.packages.Rd index 0a8e9f58..09dbf097 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.old.packages.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.old.packages.Rd @@ -1,34 +1,35 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.utility-functions.R \name{rk.old.packages} \alias{rk.old.packages} \title{Slightly smarter variant of old.packages()} \usage{ rk.old.packages(lib.loc = NULL, repos = getOption("repos"), contriburl = contrib.url(repos, type), instPkgs = installed.packages(lib.loc = lib.loc), method, available = NULL, checkBuilt = FALSE, type = getOption("pkgType")) } \value{ a character vector of packages which are really old } \description{ For most purposes, this function is identical to old.packages(). However, if the same package is installed to different locations, in different versions, old.packages() will treat each of these installations separately. Thus, e.g. if lib.loc == c("A", "B") and -package X is installed in B at an outdated version 0.1, but in A at the most recent version 0.2, +package X is installed in B at an outdated version 0.1, + but in A at the most recent version 0.2, old.packages() will report package X at B as old. In contrast rk.old.packages() will recognize that the current version is higher up in the path, and not report package X as old. } \examples{ ## NOT RUN rk.old.packages() } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{attribute} \keyword{misc} \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.record.commands.Rd b/rkward/rbackend/rpackages/rkward/man/rk.record.commands.Rd index 1423c1b8..1171af6e 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.record.commands.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.record.commands.Rd @@ -1,18 +1,19 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.utility-functions.R \name{rk.record.commands} \alias{rk.record.commands} \title{Start recording commands that are submitted from RKWard to R} \usage{ rk.record.commands(filename, include.all = FALSE) } \arguments{ \item{filename}{filename to write to (file will be truncated!).} -\item{include.all}{By default, some types of command are filtered (internal synchronisation commands, and run again links). Should these be included?} +\item{include.all}{By default, + some types of command are filtered (internal synchronisation commands, and run again links). Should these be included?} } \description{ To stop recording, supply NULL or "" as filename. Currently used for the purpose of automated testing, only. Perhaps in the future this or a similar mechanism could also be added as a user feature. } diff --git a/rkward/rbackend/rpackages/rkward/man/rk.record.plot.Rd b/rkward/rbackend/rpackages/rkward/man/rk.record.plot.Rd index dc18fe91..96b03bd9 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.record.plot.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.record.plot.Rd @@ -1,119 +1,126 @@ \name{rk.record.plot} \alias{rk.record.plot} \alias{rk.toggle.plot.history} \alias{rk.first.plot} \alias{rk.previous.plot} \alias{rk.next.plot} \alias{rk.last.plot} \alias{rk.goto.plot} \alias{rk.force.append.plot} \alias{rk.removethis.plot} \alias{rk.clear.plot.history} \alias{rk.show.plot.info} \alias{rk.verify.plot.hist.limits} \alias{rk.plot.history.summary} \alias{rk.duplicate.device} \title{Record screen device history and duplicate a screen device} \description{ TODO TODO } \usage{ rk.toggle.plot.history(x = TRUE) rk.first.plot(devId = dev.cur()) rk.previous.plot(devId = dev.cur()) rk.next.plot(devId = dev.cur()) rk.last.plot(devId = dev.cur()) rk.goto.plot(devId = dev.cur(), index=1) rk.force.append.plot(devId = dev.cur()) rk.removethis.plot(devId = dev.cur()) rk.clear.plot.history() rk.show.plot.info(devId = dev.cur()) rk.plot.history.summary(which = NULL, type = c("devices", "history")) rk.duplicate.device(devId = dev.cur()) } \arguments{ - \item{devId, which}{ an integer, the screen device on which an action is to be performed.} + \item{devId, which}{ an integer, + the screen device on which an action is to be performed.} \item{x}{ a logical (not NA), whether to enable the screen device history.} \item{index}{ an integer, which plot to jump to?} - \item{type}{ a string, either \code{"devices"} or \code{"history"}, the type of summary to be printed.} + \item{type}{ a string, either \code{"devices"} or \code{"history"}, + the type of summary to be printed.} } \details{ TODO TODO - \code{rk.record.plot} is an environment to store the screen device history. You should not use the functions / variables in this environment directly, instead use the many wrapper functions as described below. + \code{rk.record.plot} is an environment to store the screen device history. You should not use the functions / variables in this environment directly, + instead use the many wrapper functions as described below. - \code{rk.toggle.plot.history} enables or disables the screen device history. You should not use this function. Instead use the checkbox in Settings->Configure RKWard->Onscreen Graphics->Screen device history. After the needed initialization / clean up, it sets the option variable \code{"rk.enable.graphics.history"} to \code{x}. + \code{rk.toggle.plot.history} enables or disables the screen device history. You should not use this function. Instead use the checkbox in Settings->Configure RKWard->Onscreen Graphics->Screen device history. After the needed initialization / clean up, + it sets the option variable \code{"rk.enable.graphics.history"} to \code{x}. - \code{rk.first.plot}, \code{rk.previous.plot}, \code{rk.next.plot}, \code{rk.last.plot} these functions provide browing actions to respective plots saved in the history on the specified device (\code{devId}). + \code{rk.first.plot}, \code{rk.previous.plot}, \code{rk.next.plot}, + \code{rk.last.plot} these functions provide browing actions to respective plots saved in the history on the specified device (\code{devId}). \code{rk.goto.plot} this function provides a one step jump action to the plot specified by \code{index} on the specified device (\code{devId}). - \code{rk.force.append.plot} forcefully append the currently displayed plot to the history. This function ignores the type of plot (graphics / lattice) and by-passes the general recording mechanism, as a result the plot call can not be identified. + \code{rk.force.append.plot} forcefully append the currently displayed plot to the history. This function ignores the type of plot (graphics / lattice) and by-passes the general recording mechanism, + as a result the plot call can not be identified. \code{rk.removethis.plot} removes the plot displayed on the specified device from history. If there are more than one device showing the same plot then removing from one device does not wipe it from the other devices. They can be re-added to the history from the other devices. \code{rk.clear.plot.history} clears the screen device history. - \code{rk.show.plot.info} when available, shows some extra information regarding the displayed plot on the specified device. + \code{rk.show.plot.info} when available, + shows some extra information regarding the displayed plot on the specified device. \code{rk.plot.history.summary} provides some summaries of the screen device history. \code{type = "devices"} provides summary of all or one device(s) depending on whether \code{which = NULL} or \code{which} is a single number identifying the device. \code{type = "history"} provides summary of the entire stored history. \code{rk.duplicate.device} duplicates the specified screen device. The plot on the new device behaves independently of the one it was duplicated from. } \value{ Except those mentioned below, the rest return \code{NULL} invisibly. \code{rk.plot.history.summary} returns a data.frame with some messages. \code{rk.duplicate.device} returns the value of a \code{dev.copy} call. } \author{Prasenjit Kapat \email{rkward-devel@kde.org}} \section{Warning}{ TODO TODO } \seealso{ \code{\link{recordPlot}}, \code{\link{replayPlot}} \code{\link{print.trellis}}, \code{\link{trellis.last.object}} \url{rkward://page/rkward_plot_history} } \examples{ ## Example for this? require (rkward) .L. <- getOption ("rk.graphics.hist.max.length") local ({ options ("rk.graphics.hist.max.length" = 150) x <- seq(-2*pi,2*pi,length=400) xlim <- range(x); ylim <- c(-1,1) n <- 100; for (i in seq_len (n)) { plot(x, sin(x-(i-1)*4*pi/n), type='l', xlim=xlim, ylim=ylim, bty='n', xlab='', ylab='', xaxt='n', yaxt='n') } }) rk.first.plot () for (i in 1:(rk.record.plot$sP.length-1)) rk.next.plot () ## Not run rk.clear.plot.history () options ("rk.graphics.hist.max.length" = .L.) } \keyword{device} \keyword{dynamic} \keyword{environment} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.screen.device.Rd b/rkward/rbackend/rpackages/rkward/man/rk.screen.device.Rd index 3648cf85..6982f661 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.screen.device.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.screen.device.Rd @@ -1,14 +1,15 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/internal_graphics.R \name{rk.screen.device} \alias{rk.screen.device} \title{DEPRECATED: \code{rk.screen.device} is obsolete. It simply calls \code{dev.new()} in this version of RKWard.} \usage{ rk.screen.device(...) } \description{ -Depending on your use case, you should use \code{dev.new()}, \code{RK()} or \code{rk.embed.device()}, instead. +Depending on your use case, you should use \code{dev.new()}, + \code{RK()} or \code{rk.embed.device()}, instead. } \seealso{ \link{dev.new}, \link{RK}, \link{rk.embed.device} } diff --git a/rkward/rbackend/rpackages/rkward/man/rk.show.messages.Rd b/rkward/rbackend/rpackages/rkward/man/rk.show.messages.Rd index 62005ce4..99c20120 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.show.messages.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.show.messages.Rd @@ -1,102 +1,122 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.KDE_GUI-functions.R \name{rk.show.message} \alias{rk.show.message} \alias{rk.show.question} \alias{rk.select.list} \alias{rk.show.question} +\alias{rk.askYesNo} \alias{rk.select.list} \title{Message boxes and selection list using native KDE GUI} \usage{ rk.show.message(message, caption = gettext("Information"), wait = TRUE) rk.show.question(message, caption = gettext("Question"), button.yes = "yes", button.no = "no", button.cancel = "cancel", default = TRUE) +rk.askYesNo(msg, default = TRUE, prompts = c("yes", "no", "cancel"), + caption = gettext("Question"), is.rk.askYesNo = TRUE, ...) + rk.select.list(list, preselect = NULL, multiple = FALSE, title = NULL) } \arguments{ \item{message}{a string for the content of the message box.} \item{caption}{a string for title of the message box.} \item{wait}{a logical (not NA) indicating whether the R interpreter should wait for the user's action, or run it asynchronously.} \item{button.yes}{a string for the text label of the \bold{Yes} button. Can be an empty string (\code{""}), in which case the button is not displayed at all. Note that the default value of "yes" (lower case) means to use a default rendering of a "Yes" button, which may or may not be the literal string "Yes" (importantly, it will be translated, automatically).} \item{button.no}{a string used for the text label of the \bold{No} button. This behaves similar to \code{button.yes}, including the meaning of the default value "no".} \item{button.cancel}{a string used for the text label of the \bold{Cancel} button. This behaves similar to \code{button.yes}, including the meaning of the default value "cancel".} \item{default}{The expected or "safe" default response (e.g. \code{TRUE} for "Yes button"). The corresponding button will focused, so that it will become selected option, if the user simply presses enter.} +\item{msg}{like \code{message}, only the argument was renamed to mimic the formals of +\code{askYesNo}.} + +\item{prompts}{either a character vector containing 3 prompts corresponding to return +values of TRUE, FALSE, or NA, or a single character value containing the prompts +separated by \code{/} characters.} + +\item{is.rk.askYesNo}{a logical value, you can safely ignore this argument if you call +\code{rk.askYesNo} manually. This argument is needed if \code{rk.askYesNo} is set +via \code{options("askYesNo"=rk.askYesNo)} because otherwise we'd either need more +complicated function code there, fail with an error or end up in an infinite loop.} + \item{list}{a vector, coerced into a character vector.} \item{multiple}{a logical (not NA), when \code{TRUE} multiple selection selection is allowed.} \item{title}{a string, for the window title of the displayed list} \item{preselct}{a vector, coerced into a character vector, items to be preselected.} } \value{ \code{rk.show.message} always returns \code{TRUE}, invisibly. \code{rk.show.question} returns \code{TRUE} for \bold{Yes}, \code{FALSE} for \bold{No}, and \code{NULL} for \bold{Cancel} actions. If the dialog is closed without clicking on any button, \code{NULL} is returned, as well. +\code{rk.askYesNo} has the same return values as \code{rk.show.question}, except + it returns \code{NA} for \bold{Cancel} actions. + \code{rk.select.list} returns the value of \code{\link{select.list}}. } \description{ Multi-purpose pop-up message boxes and selection list using native KDE GUI elements. The message boxes can be used either to show some information or ask some question. The selection list can be used to get a vector of selected items. } \details{ For \code{rk.show.question}, the R interpreter always waits for the user's choice. \code{rk.select.list} replaces \code{utils::select.list} for the running session acting as a drop-in replacement for \code{tk_select.list}. Use \code{.rk.backups$select.list} for the original \code{utils::select.list} function (see Examples). } \examples{ require (rkward) ## Message boxes if (rk.show.question ("Question:\\nDo you want to know about RKWard?", button.yes = "Yes, I do!", button.no = "No, I don't care!", button.cancel = "")) { rk.show.message ("Message:\\nRKWard is a KDE GUI for R.", "RKWard Info") } else { - rk.show.message ("You must be joking!", "RKWard Info", wait = FALSE) ## Run asynchronously + rk.show.message ("You must be joking!", "RKWard Info", + wait = FALSE) ## Run asynchronously } ## Selection lists: rk.select.list (LETTERS, preselect = c("A", "E", "I", "O", "U"), multiple = TRUE, title = "vowels") .rk.backups$select.list (LETTERS, preselect = c("A", "E", "I", "O", "U"), multiple = TRUE, title = "vowels") } \seealso{ \code{\link{system}}, \code{\link{select.list}} } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rk.switch.frontend.language.Rd b/rkward/rbackend/rpackages/rkward/man/rk.switch.frontend.language.Rd index 00c84a94..e6f471ab 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.switch.frontend.language.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.switch.frontend.language.Rd @@ -1,22 +1,25 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.utility-functions.R \name{rk.switch.frontend.language} \alias{rk.switch.frontend.language} \title{Switch language / translation to use in the frontend.} \usage{ rk.switch.frontend.language(LANG = "C") } \arguments{ \item{LANG}{language code to use. "C" for no translation, i.e. generally English} } \description{ This feature is mostly intended for the purpose of automated testing, which needs a defined language to work. It might also be useful for translators, or e.g. to look up some terms untranslated in special cases where you are more familiar with the English terms than -your native language terms. Note that this will only strings that are translated after the call., only those which get -translated after the call. Most new dialogs you open, and importantly new plugin dialogs should +your native language terms. Note that this will only strings that are translated after the call., + only those which get +translated after the call. Most new dialogs you open, + and importantly new plugin dialogs should show strings in the new lanuage, however. } \details{ -To change the language in the backend, use \code{Sys.setenv(LANGUAGE=...)} or \code{Sys.setlocale()}. +To change the language in the backend, + use \code{Sys.setenv(LANGUAGE=...)} or \code{Sys.setlocale()}. } diff --git a/rkward/rbackend/rpackages/rkward/man/rk.with.window.hints.Rd b/rkward/rbackend/rpackages/rkward/man/rk.with.window.hints.Rd index d8b78413..0ec016cc 100644 --- a/rkward/rbackend/rpackages/rkward/man/rk.with.window.hints.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rk.with.window.hints.Rd @@ -1,51 +1,58 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rk.workspace-functions.R \name{.rk.with.window.hints} \alias{.rk.with.window.hints} \alias{rk.with.window.hints} \title{Control window placement and style} \usage{ .rk.with.window.hints(expr, placement = "", name = "", style = "") } \arguments{ -\item{expr}{Expression to evaluate, unsually an expression that is expected to create exactly one +\item{expr}{Expression to evaluate, + unsually an expression that is expected to create exactly one new window.} -\item{placement}{a character string specifying either "attached" or "detached" placement, or +\item{placement}{a character string specifying either "attached" or "detached" placement, + or (if left empty) the default placement for the type of window created.} -\item{name}{character string specifing a named position. If a name is given, and this position is -not yet known, the placement hint (see above) will be followed. If later a second window is +\item{name}{character string specifing a named position. If a name is given, + and this position is +not yet known, + the placement hint (see above) will be followed. If later a second window is created with the same given name, it will replace the first window.} -\item{style}{character string specifing a style hint. Currently, this can either be "preview" or -"" (default), with most types of window not implementing any special behavior for "preview".} +\item{style}{character string specifing a style hint. Currently, + this can either be "preview" or +"" (default), + with most types of window not implementing any special behavior for "preview".} } \value{ \code{NULL}, invisibly. } \description{ \code{.rk.with.window.hints} can be used to make windows appear in a specific location: attached, detached, or in a named position where a previous window is found. (The latter used for preview windows, importantly). It can also be used to pass -"style" hints, importantly indicating that the window is a preview window. All specifications +"style" hints, + importantly indicating that the window is a preview window. All specifications affect newly created windows, only, not existing ones. } \details{ NOTE: This function is still somewhat experimental, and it is not guaranteed that it will remain in place, with compatible parameters. } \examples{ ## Not run .rk.with.window.hints ({ RK () plot (1, 1) }, "attached") ## End not run } \author{ Thomas Friedrichsmeier \email{rkward-devel@kde.org} } \keyword{utilities} diff --git a/rkward/rbackend/rpackages/rkward/man/rkward-package.Rd b/rkward/rbackend/rpackages/rkward/man/rkward-package.Rd index 6cb42487..d4186c14 100644 --- a/rkward/rbackend/rpackages/rkward/man/rkward-package.Rd +++ b/rkward/rbackend/rpackages/rkward/man/rkward-package.Rd @@ -1,29 +1,37 @@ % Generated by roxygen2: do not edit by hand % Please edit documentation in R/rkward-package.R \docType{package} \name{rkward-package} +\alias{rkward} \alias{rkward-package} -\title{The rkward Package} +\title{\packageTitle{rkward}} \description{ -Provides functions related to the RKWard GUI. +\packageDescription{rkward} } \details{ +The DESCRIPTION file: \tabular{ll}{ Package: \tab rkward\cr Type: \tab Package\cr -Version: \tab 0.6.3\cr -Date: \tab 2014-10-30\cr +Version: \tab 0.7.1\cr +Date: \tab 2018-05-22\cr Depends: \tab R (>= 2.9.0),methods\cr Encoding: \tab UTF-8\cr License: \tab GPL (>= 2)\cr LazyLoad: \tab yes\cr -URL: \tab http://rkward.kde.org\cr +URL: \tab https://rkward.kde.org\cr +} +} +\seealso{ +Useful links: +\itemize{ + \item \url{https://rkward.kde.org} + \item Report bugs at \url{https://rkward.kde.org/Bugs} } -This package contains functions which are useful in combination with the RKWard GUI. Many of these -functions only needed for the internal communication between RKWard and R, but some are also useful in user scripts. } \author{ -Thomas Friedrichsmeier, with contributions from RKWard-devel mailing list +\packageAuthor{rkward} + +Maintainer: \packageMaintainer{rkward} } -\keyword{package}