Package 'g6R'

Description

Configures animation settings for G6 graph elements. These settings control how graph elements animate when changes occur.

Usage

animation_config(
  delay = NULL,
  direction = c("forward", "alternate", "alternate-reverse", "normal", "reverse"),
  duration = NULL,
  easing = NULL,
  fill = c("none", "auto", "backwards", "both", "forwards"),
  iterations = NULL
)

Arguments

Details

Animation configuration allows fine-tuning the timing and behavior of animations in G6 graphs. This includes controlling the duration, delay, easing function, direction, and other aspects of how graph elements animate.

Value

A list containing animation configuration that can be passed to g6_options().

Examples

# Basic animation with duration
config <- animation_config(
  duration = 500
)

# Complex animation configuration
config <- animation_config(
  delay = 100,
  duration = 800,
  easing = "ease-in-out",
  direction = "alternate",
  fill = "forwards",
  iterations = 2
)

# Infinite animation
config <- animation_config(
  duration = 1000,
  easing = "linear",
  iterations = Inf
)

Description

This function creates a configuration list for G6 AntV Dagre layout with all available options as parameters.

Usage

antv_dagre_layout(
  rankdir = c("TB", "BT", "LR", "RL"),
  align = c("UL", "UR", "DL", "DR"),
  nodesep = 50,
  nodesepFunc = NULL,
  ranksep = 100,
  ranksepFunc = NULL,
  ranker = c("network-simplex", "tight-tree", "longest-path"),
  nodeSize = NULL,
  controlPoints = FALSE,
  begin = NULL,
  sortByCombo = FALSE,
  edgeLabelSpace = TRUE,
  nodeOrder = NULL,
  radial = FALSE,
  focusNode = NULL,
  preset = NULL,
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV Dagre layout.

Examples

# Basic dagre layout
dagre_config <- antv_dagre_layout()

# Horizontal layout with custom spacing
dagre_config <- antv_dagre_layout(
  rankdir = "LR",
  align = "UL",
  nodesep = 80,
  ranksep = 150
)

# Radial layout with focus node
dagre_config <- antv_dagre_layout(
  radial = TRUE,
  focusNode = "node1",
  ranker = "tight-tree"
)

Description

Coerce to a g6 element object

Usage

as_g6_node(x, ...)

## S3 method for class 'g6_node'
as_g6_node(x, ...)

## S3 method for class 'list'
as_g6_node(x, ...)

as_g6_edge(x, ...)

## S3 method for class 'g6_edge'
as_g6_edge(x, ...)

## S3 method for class 'list'
as_g6_edge(x, ...)

as_g6_combo(x, ...)

## S3 method for class 'g6_combo'
as_g6_combo(x, ...)

## S3 method for class 'list'
as_g6_combo(x, ...)

Arguments

Value

An element of class g6_node, g6_edge, or g6_combo.

Description

Coerce to a list of g6_elements objects

Usage

as_g6_nodes(x, ...)

as_g6_edges(x, ...)

## S3 method for class 'g6_edges'
as_g6_edges(x, ...)

## S3 method for class 'data.frame'
as_g6_edges(x, ...)

## S3 method for class 'list'
as_g6_edges(x, ...)

as_g6_combos(x, ...)

## S3 method for class 'g6_combos'
as_g6_combos(x, ...)

## S3 method for class 'data.frame'
as_g6_combos(x, ...)

## S3 method for class 'list'
as_g6_combos(x, ...)

Arguments

Value

An object of class g6_nodes, g6_edges, or g6_combos.

Description

Coerce to a g6_port object

Usage

as_g6_port(x, ...)

## S3 method for class 'g6_port'
as_g6_port(x, ...)

## S3 method for class 'list'
as_g6_port(x, ...)

Arguments

Value

An object of class g6_port.

Examples

as_g6_port(list(key = "input-1", type = "input", placement = "left"))
as_g6_port(g6_port("input-1", type = "input"))

Description

Coerce to a list of g6_port objects (g6_ports)

Usage

as_g6_ports(x, ...)

## S3 method for class 'g6_ports'
as_g6_ports(x, ...)

## S3 method for class 'list'
as_g6_ports(x, ...)

Arguments

Value

An object of class g6_ports.

Examples

as_g6_ports(list(
  list(key = "input-1", type = "input", placement = "left"),
  list(key = "output-1", type = "output", placement = "right")
))
as_g6_ports(g6_ports(
  g6_port("input-1", type = "input"),
  g6_port("output-1", type = "output")
))

Description

Creates a configuration object for the auto-adapt-label behavior in G6. This behavior automatically adjusts label positions to reduce overlapping and improve readability in the graph visualization.

Usage

auto_adapt_label(
  key = "auto-adapt-label",
  enable = TRUE,
  throttle = 100,
  padding = 0,
  sort = NULL,
  sortNode = list(type = "degree"),
  sortEdge = NULL,
  sortCombo = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the auto-adapt-label behavior.

Examples

# Basic configuration with defaults
config <- auto_adapt_label()

# Custom configuration with more padding and custom throttle
config <- auto_adapt_label(
  key = "my-label-adapter",
  throttle = 200,
  padding = 5
)


# Using a custom enable function
config <- auto_adapt_label(
  enable = JS("(e) => e.targetType === 'node'")
)

Description

Configures the auto-fit behavior for a G6 graph. Auto-fit automatically adjusts the view to fit all elements or centers them within the canvas.

Usage

auto_fit_config(
  type = c("view", "center"),
  when = c("overflow", "always"),
  direction = c("x", "y", "both"),
  duration = 1000,
  easing = c("ease-in-out", "ease", "ease-in", "ease-out", "linear", "cubic-bezier",
    "step-start", "step-end")
)

Arguments

Details

The auto-fit feature helps ensure that graph elements remain visible within the canvas. It can be configured to either fit all elements to view or center them, and can be triggered under different conditions.

Value

A list containing the auto-fit configuration that can be passed to g6_options().

Examples

# Basic auto-fit configuration with default settings
config <- auto_fit_config()

# Auto-fit with only centering (no scaling)
config <- auto_fit_config(type = "center")

# Auto-fit that always triggers when graph data changes
config <- auto_fit_config(when = "always")

# Auto-fit only in the x direction
config <- auto_fit_config(direction = "x")

# Auto-fit with a fast animation
config <- auto_fit_config(duration = 300, easing = "ease-out")

Description

Creates a configuration object for the background plugin in G6. This plugin adds a customizable background to the graph canvas.

Usage

background(
  key = NULL,
  width = "100%",
  height = "100%",
  backgroundColor = NULL,
  backgroundImage = NULL,
  backgroundSize = "cover",
  backgroundPosition = NULL,
  backgroundRepeat = NULL,
  opacity = NULL,
  transition = "background 0.5s",
  zIndex = "-1",
  ...
)

Arguments

Value

A list with the configuration settings for the background plugin.

Examples

# Basic background color
bg <- background(backgroundColor = "#f0f0f0")

# Background with image
bg <- background(
  backgroundImage = "https://example.com/background.jpg",
  backgroundSize = "contain",
  backgroundRepeat = "no-repeat",
  backgroundPosition = "center"
)

# Semi-transparent background with transition
bg <- background(
  backgroundColor = "#000000",
  opacity = "0.3",
  transition = "all 1s ease-in-out"
)

Description

Creates a configuration object for brush selection interaction in graph visualizations. This function configures how elements are selected when using a brush selection tool.

Usage

brush_select(
  key = "brush-select",
  animation = FALSE,
  enable = JS("(e) => {\n      return true;\n    }"),
  enableElements = "node",
  immediately = FALSE,
  mode = c("default", "union", "intersect", "diff"),
  onSelect = NULL,
  state = c("selected", "active", "inactive", "disabled", "highlight"),
  style = NULL,
  trigger = "shift",
  outputId = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the brush select behavior.

Examples

# Basic configuration
config <- brush_select()

# Custom configuration
config <- brush_select(
  animation = TRUE,
  enableElements = c("node", "edge"),
  mode = "union",
  state = "highlight",
  style = list(
    fill = "rgba(0, 0, 255, 0.1)",
    stroke = "blue",
    lineWidth = 2
  ),
  trigger = c("Shift")
)

Description

Creates a configuration object for the bubble-sets plugin in G6. This plugin creates bubble-like contours around groups of specified elements.

Usage

bubble_sets(
  members,
  key = "bubble-sets",
  avoidMembers = NULL,
  label = TRUE,
  labelPlacement = c("bottom", "left", "right", "top", "center"),
  labelBackground = FALSE,
  labelPadding = 0,
  labelCloseToPath = TRUE,
  labelAutoRotate = TRUE,
  labelOffsetX = 0,
  labelOffsetY = 0,
  labelMaxWidth = NULL,
  maxRoutingIterations = 100,
  maxMarchingIterations = 20,
  pixelGroup = 4,
  edgeR0 = NULL,
  edgeR1 = NULL,
  nodeR0 = NULL,
  nodeR1 = NULL,
  morphBuffer = NULL,
  threshold = NULL,
  memberInfluenceFactor = NULL,
  edgeInfluenceFactor = NULL,
  nonMemberInfluenceFactor = NULL,
  virtualEdges = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the bubble-sets plugin.

Examples

# Basic bubble set around specific nodes
bubble <- bubble_sets(
  members = c("node1", "node2", "node3"),
  label = TRUE
)

# More customized bubble set
bubble <- bubble_sets(
  key = "team-a",
  members = c("node1", "node2", "node3", "edge1", "edge2"),
  avoidMembers = c("node4", "node5"),
  labelPlacement = "top",
  labelBackground = TRUE,
  labelPadding = c(4, 2),
  maxRoutingIterations = 150
)

# Bubble set with advanced parameters
bubble <- bubble_sets(
  members = c("node1", "node2", "node3"),
  pixelGroup = 6,
  edgeR0 = 10,
  nodeR0 = 5,
  memberInfluenceFactor = 0.8,
  edgeInfluenceFactor = 0.5,
  nonMemberInfluenceFactor = 0.3,
  virtualEdges = TRUE
)

Description

Configures the canvas settings for a G6 graph. The canvas is the rendering surface where the graph is drawn.

Usage

canvas_config(
  container = NULL,
  devicePixelRatio = NULL,
  width = NULL,
  height = NULL,
  cursor = NULL,
  background = NULL,
  renderer = NULL,
  enableMultiLayer = NULL
)

Arguments

Details

Canvas configuration controls how the graph is rendered, including its size, scaling, background, and rendering layer settings. This function provides a structured way to configure all canvas-related options.

Note that many of these settings (container, width, height, devicePixelRatio, background, cursor) can also be set directly in the main graph configuration, which will be automatically converted to canvas configuration items.

Value

A list containing the canvas configuration that can be passed to g6_options().

Examples

# Basic canvas configuration
config <- canvas_config(
  container = "#graph-container",
  width = 800,
  height = 600
)

# Canvas with multi-layer rendering enabled
config <- canvas_config(
  container = "#graph-container",
  width = 1000,
  height = 700,
  enableMultiLayer = TRUE,
  cursor = "grab"
)

Description

This function creates a configuration list for G6 AntV circular layout with all available options as parameters.

Usage

circular_layout(
  angleRatio = 1,
  center = NULL,
  clockwise = TRUE,
  divisions = 1,
  nodeSize = 10,
  nodeSpacing = 10,
  ordering = NULL,
  radius = NULL,
  startAngle = 0,
  endAngle = 2 * pi,
  startRadius = NULL,
  endRadius = NULL,
  width = NULL,
  height = NULL,
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV circular layout.

Examples

circular_config <- circular_layout(
  radius = 200,
  startAngle = 0,
  endAngle = pi,
  clockwise = FALSE
)

Description

Creates a configuration object for the click-select behavior in G6. This allows users to select graph elements by clicking.

Usage

click_select(
  key = "click-select",
  animation = TRUE,
  degree = 0,
  enable = TRUE,
  multiple = FALSE,
  state = c("selected", "active", "inactive", "disabled", "highlight"),
  neighborState = c("selected", "active", "inactive", "disabled", "highlight"),
  unselectedState = NULL,
  onClick = NULL,
  trigger = "shift",
  ...
)

Arguments

Value

A list with the configuration settings for the click select behavior.

Examples

# Basic configuration
config <- click_select()

# Custom configuration
config <- click_select(
  animation = FALSE,
  degree = 1,
  multiple = TRUE,
  state = "active",
  neighborState = "highlight",
  unselectedState = "inactive",
  trigger = c("Control")
)

# Example leveraging the input[["<GRAPH_ID>-selected_<ELEMENT_TYPE>"]]
if (interactive()) {
  library(shiny)
  library(g6R)
  library(bslib)

  nodes <- data.frame(id = c("node1", "node2"))
  edges <- data.frame(source = "node1", target = "node2")
  combos <- data.frame(id = "combo1", type = "rect")

  ui <- page_fluid(
    g6_output("graph"),
    verbatimTextOutput("selected_elements")
  )

  server <- function(input, output, session) {
    output$graph <- render_g6({
      g6(
        nodes = nodes,
        edges = edges,
        combos = combos
      ) |>
        g6_layout() |>
        g6_behaviors(
          click_select(multiple = TRUE),
          brush_select(
            enableElements = c("node", "edge", "combo"),
            immediately = TRUE
          )
        )
    })

    output$selected_elements <- renderPrint({
      list(
        selected_nodes = input[["graph-selected_node"]],
        selected_edges = input[["graph-selected_edge"]],
        selected_combos = input[["graph-selected_combo"]]
      )
    })
  }

  shinyApp(ui, server)
}

Description

Creates a configuration object for the collapse-expand behavior in G6. This allows users to collapse or expand nodes/combos with child elements.

Usage

collapse_expand(
  key = "collapse-expand",
  animation = TRUE,
  enable = TRUE,
  trigger = "dblclick",
  onCollapse = NULL,
  onExpand = NULL,
  align = TRUE,
  ...
)

Arguments

Value

A list with the configuration settings for the collapse-expand behavior.

Examples

# Basic configuration
config <- collapse_expand()

Description

Creates a combo combined layout configuration for G6 graphs. This layout algorithm combines different layout strategies for elements inside combos and the outermost layer, providing hierarchical organization of graph elements.

Usage

combo_combined_layout(
  center = NULL,
  comboPadding = 10,
  innerLayout = NULL,
  nodeSize = 10,
  outerLayout = NULL,
  spacing = NULL,
  treeKey = NULL,
  ...
)

Arguments

Details

The combo combined layout is particularly useful for graphs with hierarchical structures where you want different layout algorithms for different levels of the hierarchy. The inner layout handles elements within combos, while the outer layout manages the overall arrangement.

Value

A layout configuration object for use with G6 graphs.

See Also

antv_dagre_layout for dagre layout configuration

Examples

# Basic combo combined layout
layout <- combo_combined_layout()

# Custom configuration with specific center and padding
layout <- combo_combined_layout(
  comboPadding = 20,
  nodeSize = 15,
  spacing = 10
)

Description

Configures the general options for combos in a G6 graph. These settings control the type, style, state, palette, and animation of combos.

Usage

combo_options(
  type = "circle",
  style = NULL,
  state = NULL,
  palette = NULL,
  animation = NULL
)

Arguments

Details

Combo options allow defining how combos (node groupings) appear and behave in a G6 graph. This includes selecting combo types, setting styles, configuring state-based appearances, defining color palettes, and specifying animation effects.

Value

A list containing combo options configuration that can be passed to g6_options().

Examples

# Basic combo options with default circle type
options <- combo_options()

# Rectangle combo with custom style
options <- combo_options(
  type = "rect",
  style = list(
    fill = "#F6F6F6",
    stroke = "#CCCCCC",
    lineWidth = 1
  )
)

Description

This function creates a configuration list for G6 AntV Compact Box layout with all available options as parameters. The Compact Box layout is designed for efficiently laying out trees and hierarchical structures.

Usage

compact_box_layout(
  direction = c("LR", "RL", "TB", "BT", "H", "V"),
  getSide = NULL,
  getId = NULL,
  getWidth = NULL,
  getHeight = NULL,
  getHGap = NULL,
  getVGap = NULL,
  radial = FALSE,
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV Compact Box layout.

Examples

# Basic compact box layout
box_config <- compact_box_layout()

# Vertical compact box layout
box_config <- compact_box_layout(
  direction = "TB"
)

# Radial layout
box_config <- compact_box_layout(
  radial = TRUE
)

Description

This function creates a configuration list for G6 AntV Concentric layout with all available options as parameters. The Concentric layout places nodes in concentric circles based on a centrality measure.

Usage

concentric_layout(
  center = NULL,
  clockwise = FALSE,
  equidistant = FALSE,
  width = NULL,
  height = NULL,
  sortBy = "degree",
  maxLevelDiff = NULL,
  nodeSize = 30,
  nodeSpacing = 10,
  preventOverlap = FALSE,
  startAngle = 3/2 * pi,
  sweep = NULL,
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV Concentric layout

Examples

# Basic concentric layout
concentric_config <- concentric_layout()

# Custom concentric layout with degree-based sorting and overlap prevention
concentric_config <- concentric_layout(
  clockwise = TRUE,
  sortBy = "degree",
  preventOverlap = TRUE,
  nodeSize = 30,
  nodeSpacing = 20
)

# Custom concentric layout with specific center and dimensions
concentric_config <- concentric_layout(
  center = c(300, 300),
  width = 600,
  height = 600,
  equidistant = TRUE,
  startAngle = pi
)

Description

Creates a configuration object for the context-menu behavior in G6. This allows users to display a context menu when right-clicking or clicking on graph elements.

Usage

context_menu(
  key = "contextmenu",
  className = "g6-contextmenu",
  trigger = "contextmenu",
  offset = c(4, 4),
  onClick = NULL,
  getItems = NULL,
  getContent = NULL,
  loadingContent = NULL,
  enable = JS("(e) => e.targetType === 'node'"),
  ...
)

Arguments

Value

A list with the configuration settings for the context menu plugin.

Examples

# Basic configuration
config <- context_menu()

# Custom configuration with JavaScript functions
config <- context_menu(
  key = "my-context-menu",
  className = "my-context-menu",
  trigger = "click",
  offset = c(10, 10),
  getItems = JS("(event) => {
    const type = event.itemType;
    const isNode = type === 'node';
    return [
      { key: 'delete', text: 'Delete' },
      { key: 'edit', text: 'Edit' },
      { key: 'details', text: 'View Details', disabled: !isNode }
    ];
  }"),
  onClick = JS("(value, target, current) => {
    if (value === 'delete') {
      // do stuff
  }")
)
if (interactive()) {
  library(shiny)
  library(g6R)
  library(bslib)

  nodes <- data.frame(id = c("node1", "node2"))
  edges <- data.frame(source = "node1", target = "node2")

  ui <- page_fluid(
    g6_output("graph"),
    verbatimTextOutput("contextmenu_info")
  )

  server <- function(input, output, session) {
    output$graph <- render_g6({
      g6(
        nodes = nodes,
        edges = edges
      ) |>
        g6_layout() |>
        g6_plugins(
          context_menu()
        )
    })

    output$contextmenu_info <- renderPrint({
      input[["graph-contextmenu"]]
    })
  }

  shinyApp(ui, server)
}

Description

Creates a configuration object for the create-edge behavior in G6. This allows users to create edges between nodes by clicking or dragging.

Usage

create_edge(
  key = "create-edge",
  trigger = "drag",
  enable = FALSE,
  onCreate = NULL,
  onFinish = NULL,
  style = NULL,
  notify = FALSE,
  outputId = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the create-edge behavior.

Examples

# Basic configuration
config <- create_edge()
if (interactive()) {
  library(shiny)
  library(bslib)
  library(g6R)

  nodes <- list(
    list(
      id = "node1"
    ),
    list(
      id = "node2"
    )
  )

  modUI <- function(id) {
    ns <- NS(id)
    tagList(
      g6Output(ns("graph"))
    )
  }

  modServer <- function(id) {
    moduleServer(id, function(input, output, session) {
      output$graph <- renderG6({
        g6(nodes) |>
          g6_options(
            animation = FALSE,
            edge = edge_options(
              style = list(
                endArrow = TRUE
              )
            )
          ) |>
          g6_layout(d3_force_layout()) |>
          g6_behaviors(
            # avoid conflict with internal function
            g6R::create_edge(
              target = c("node", "combo", "canvas"),
              enable = JS(
                "(e) => {
                  return e.shiftKey;
                }"
              ),
              onFinish = JS(
                sprintf(
                  "(edge) => {
                    const graph = HTMLWidgets.find('#%s').getWidget();
                    // Avoid to create edges in combos. If so, we remove it
                    if (edge.targetType === 'combo') {
                      graph.removeEdgeData([edge.id]);
                      return;
                    }
                    Shiny.setInputValue('%s', edge);
                  }",
                  session$ns("graph"),
                  session$ns("added_edge")
                )
              )
            )
          )
      })

      observeEvent(input[["added_edge"]], {
        showNotification(
          sprintf("Edge dropped on: %s", input[["added_edge"]]$targetType),
          type = "message"
        )
      })
    })
  }

  ui <- page_fluid(
    modUI("test")
  )

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

  shinyApp(ui, server)
}

Description

This function creates a configuration list for G6 D3 Force layout with all available options as parameters.

Usage

d3_force_layout(
  link = list(distance = 100, strength = 2),
  collide = list(radius = 40),
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV D3 Force layout.

Examples

# Basic D3 force layout
d3_force_config <- d3_force_layout()

# Custom link distance and collision radius
d3_force_config <- d3_force_layout(
  link = list(
    distance = 150,
    strength = 0.5,
    iterations = 3
  ),
  collide = list(
    radius = 30,
    strength = 0.8
  )
)

Description

The graph is a directed acyclic graph

Usage

data(dag)

Format

A list with 2 data frames:

nodes

data frame with 12 rows for the nodes.

edges

data frame with 12 rows for the edges.

combo

data frame with 3 rows for the combos.

Source

https://gw.alipayobjects.com/os/antvdemo/assets/data/algorithm-category.json

Description

This function creates a configuration list for G6 AntV Dagre layout with all available options as parameters. The Dagre layout is designed for directed graphs, creating hierarchical layouts with nodes arranged in layers.

Usage

dagre_layout(
  rankdir = c("TB", "BT", "LR", "RL"),
  align = c("UL", "UR", "DL", "DR"),
  nodesep = 50,
  ranksep = 100,
  ranker = c("network-simplex", "tight-tree", "longest-path"),
  nodeSize = NULL,
  controlPoints = FALSE,
  ...
)

Arguments

Value

A list containing the configuration for G6 AntV Dagre layout.

Examples

# Basic dagre layout
dagre_config <- dagre_layout()

# Custom dagre layout with horizontal flow
dagre_config <- dagre_layout(
  rankdir = "LR",
  nodesep = 80,
  ranksep = 150,
  ranker = "tight-tree"
)

# Custom dagre layout with specific node size
dagre_config <- dagre_layout(
  nodeSize = 40,
  controlPoints = TRUE
)

Description

This function creates a configuration list for G6 Dendrogram layout with all available options as parameters.

Usage

dendrogram_layout(
  direction = c("LR", "RL", "TB", "BT", "H", "V"),
  nodeSep = 20,
  rankSep = 200,
  radial = FALSE,
  ...
)

Arguments

Value

A list containing the configuration for G6 dendrogram layout.

Description

Creates a configuration object for the drag-canvas behavior in G6. This allows users to drag the canvas to pan the view.

Usage

drag_canvas(
  key = "drag-canvas",
  enable = NULL,
  animation = NULL,
  direction = c("both", "x", "y"),
  range = NULL,
  sensitivity = 10,
  trigger = NULL,
  onFinish = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the drag-canvas behavior.

Examples

# Basic configuration
config <- drag_canvas()

# Custom configuration
config <- drag_canvas(
  enable = TRUE,
  direction = "x",
  range = c(-100, 100),
  sensitivity = 5,
  trigger = list(
   up = "ArrowUp",
   down = "ArrowDown",
   left = "ArrowLeft",
   right = "ArrowRight"
  )
)

Description

Creates a configuration object for the drag-element behavior in G6. This allows users to drag nodes and combos in the graph.

Usage

drag_element(
  key = "drag-element",
  enable = NULL,
  animation = TRUE,
  state = "selected",
  dropEffect = c("move", "link", "none"),
  hideEdge = c("none", "out", "in", "both", "all"),
  shadow = FALSE,
  cursor = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the drag-element behavior.

Examples

# Basic configuration
config <- drag_element()

# Custom configuration
config <- drag_element(
  key = "my-drag-behavior",
  animation = FALSE,
  dropEffect = "link",
  hideEdge = "both",
  shadow = TRUE,
  cursor = list(
    default = "default",
    grab = "grab",
    grabbing = "grabbing"
  ),
  enable = JS(
   "(e) => {
     return e.targetType === 'node' || e.targetType === 'combo';
   }"
  )
)

Description

Creates a configuration object for the drag-element-force behavior in G6. This allows users to drag nodes and combos with force-directed layout interactions.

Usage

drag_element_force(
  key = "drag-element-force",
  fixed = FALSE,
  enable = NULL,
  state = "selected",
  hideEdge = c("none", "out", "in", "both", "all"),
  cursor = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the drag-element-force behavior.

Examples

# Basic configuration
config <- drag_element_force()

# Custom configuration with JavaScript arrow function and custom key
config <- drag_element_force(
  key = "my-custom-drag-force",
  fixed = TRUE,
  enable = JS("(event) => { return event.targetType === 'node'; }"),
  hideEdge = "both",
  cursor = list(
    default = "default",
    grab = "grab",
    grabbing = "grabbing"
  )
)

Description

Creates a configuration object for the edge-bundling plugin in G6. This plugin automatically bundles similar edges together to reduce visual clutter.

Usage

edge_bundling(
  key = "edge-bundling",
  bundleThreshold = 0.6,
  cycles = 6,
  divisions = 1,
  divRate = 2,
  iterations = 90,
  iterRate = 2/3,
  K = 0.1,
  lambda = 0.1,
  ...
)

Arguments

Value

A list with the configuration settings for the edge-bundling plugin.

Examples

# Basic configuration
config <- edge_bundling()

# Custom configuration
config <- edge_bundling(
  key = "my-edge-bundling",
  bundleThreshold = 0.8,
  cycles = 8,
  K = 0.2
)

Description

Creates a configuration object for the edge-filter-lens plugin in G6. This plugin creates a lens that filters and displays edges within a specific area.

Usage

edge_filter_lens(
  key = "edge-filter-lens",
  trigger = c("pointermove", "click", "drag"),
  r = 60,
  maxR = NULL,
  minR = 0,
  scaleRBy = "wheel",
  nodeType = c("both", "source", "target", "either"),
  filter = NULL,
  style = NULL,
  nodeStyle = list(label = FALSE),
  edgeStyle = list(label = TRUE),
  preventDefault = TRUE,
  ...
)

Arguments

Value

A list with the configuration settings for the edge-filter-lens plugin.

Examples

# Basic configuration
config <- edge_filter_lens()

# Custom configuration
config <- edge_filter_lens(
  key = "my-edge-lens",
  trigger = "drag",
  r = 100,
  nodeType = "either",
  style = list(
    fill = "rgba(200, 200, 200, 0.3)",
    stroke = "#999",
    lineWidth = 2
  ),
  filter = JS("(id, type) => {
    // Only display edges connected to specific nodes
    if (type === 'edge') {
      const edge = graph.getEdgeData(id);
      return edge.source === 'node1' || edge.target === 'node1';
    }
    return true;
  }")
)

Description

Configures the general options for edges in a G6 graph. These settings control the type, style, state, palette, and animation of edges.

Usage

edge_options(
  type = c("line", "polyline", "arc", "quadratic", "cubic", "cubic-vertical",
    "cubic-horizontal", "loop"),
  style = edge_style_options(),
  state = NULL,
  palette = NULL,
  animation = NULL
)

Arguments

Details

Edge options allow defining how edges appear and behave in a G6 graph. This includes selecting edge types, setting styles, configuring state-based appearances, defining color palettes, and specifying animation effects.

Value

A list containing edge options configuration that can be passed to g6_options().

Examples

# Basic edge options with default line type
options <- edge_options()

# Curved edge with custom style
options <- edge_options(
  type = "cubic",
  style = edge_style_options(
    stroke = "#1783FF",
    lineWidth = 2,
    endArrow = TRUE
  )
)

Description

Configures the styling options for edges in a G6 graph. These settings control the appearance and interaction behavior of edges.

Usage

edge_style_options(
  class = NULL,
  cursor = valid_cursors,
  fill = NULL,
  fillRule = c("nonzero", "evenodd"),
  filter = NULL,
  increasedLineWidthForHitTesting = NULL,
  isBillboard = TRUE,
  lineDash = 0,
  lineDashOffset = 0,
  lineWidth = 1,
  opacity = 1,
  pointerEvents = NULL,
  shadowBlur = NULL,
  shadowColor = NULL,
  shadowOffsetX = NULL,
  shadowOffsetY = NULL,
  shadowType = NULL,
  sourcePort = NULL,
  stroke = "#000",
  strokeOpacity = 1,
  targetPort = NULL,
  transform = NULL,
  transformOrigin = NULL,
  visibility = c("visible", "hidden"),
  zIndex = -10000,
  ...
)

Arguments

Details

Edge style options allow fine-grained control over how edges are rendered and behave in a G6 graph. This includes colors, widths, line styles, shadows, visibility, and interaction properties.

Value

A list containing edge style options that can be passed to edge_options().

Description

Creates a configuration object for the fisheye plugin in G6. This plugin creates a fisheye lens effect that magnifies elements within a specific area.

Usage

fish_eye(
  key = "fish-eye",
  trigger = c("pointermove", "click", "drag"),
  r = 120,
  maxR = NULL,
  minR = 0,
  d = 1.5,
  maxD = 5,
  minD = 0,
  scaleRBy = NULL,
  scaleDBy = NULL,
  showDPercent = TRUE,
  style = NULL,
  nodeStyle = list(label = TRUE),
  preventDefault = TRUE,
  ...
)

Arguments

Value

A list with the configuration settings for the fisheye plugin.

Examples

# Basic configuration
config <- fish_eye()

# Custom configuration
config <- fish_eye(
  key = "my-fisheye",
  trigger = "drag",
  r = 200,
  d = 2.5,
  scaleRBy = "wheel",
  scaleDBy = "drag",
  style = list(
    stroke = "#1890ff",
    fill = "rgba(24, 144, 255, 0.1)",
    lineWidth = 2
  ),
  nodeStyle = JS("(datum) => {
    return {
      label: true,
      labelCfg: {
        style: {
          fill: '#003a8c',
          fontSize: 14
        }
      }
    };
  }")
)

Description

Creates a configuration object for the fix-element-size behavior in G6. This allows maintaining fixed visual sizes for elements during zoom operations.

Usage

fix_element_size(
  key = "fix-element-size",
  enable = TRUE,
  reset = FALSE,
  state = "",
  node = NULL,
  nodeFilter = JS("() => true"),
  edge = list(list(shape = "key", fields = c("lineWidth")), list(shape = "halo", fields =
    c("lineWidth")), list(shape = "label", fields = c("fontSize"))),
  edgeFilter = JS("() => true"),
  combo = NULL,
  comboFilter = JS("() => true"),
  ...
)

Arguments

Value

A list with the configuration settings for the fix-element-size behavior.

Examples

# Basic configuration
config <- fix_element_size()

# Custom configuration with filters and specific shape configurations
config <- fix_element_size(
  key = "my-fix-size-behavior",
  reset = TRUE,
  state = "active",
  node = list(
    list(shape = "circle", fields = c("r", "lineWidth")),
    list(shape = "label", fields = c("fontSize"))
  ),
  nodeFilter = JS("(node) => node.type === 'important'"),
  edge = list(shape = "line", fields = c("lineWidth", "lineDash")),
  edgeFilter = JS("(edge) => edge.weight > 5")
)

Description

Creates a configuration object for the focus-element behavior in G6. This behavior allows focusing on specific elements by automatically adjusting the viewport.

Usage

focus_element(
  key = "focus-element",
  animation = list(duration = 500, easing = "ease-in"),
  enable = TRUE,
  ...
)

Arguments

Value

A list with the configuration settings for the focus-element behavior.

Examples

# Basic configuration
config <- focus_element()

# Custom configuration
config <- focus_element(
  key = "my-focus-behavior",
  animation = list(duration = 1000, easing = "ease-out"),
  enable = JS("(event) => event.targetType === 'node'")
)

Description

This function creates a configuration list for G6 Force Atlas2 layout with all available options as parameters.

Usage

force_atlas2_layout(
  barnesHut = NULL,
  dissuadeHubs = FALSE,
  height = NULL,
  kg = 1,
  kr = 5,
  ks = 0.1,
  ksmax = 10,
  mode = "normal",
  nodeSize = NULL,
  preventOverlap = FALSE,
  prune = NULL,
  tao = 0.1,
  width = NULL,
  center = NULL,
  ...
)

Arguments

Value

A list containing the configuration for G6 force atlas2 layout.

Examples

if (interactive()) {
  g6(lesmis$nodes, lesmis$edges) |>
    g6_layout(force_atlas2_layout(
      kr = 20,
      preventOverlap = TRUE,
      center = c(250, 250))) |>
    g6_options(autoResize = TRUE) |>
    g6_behaviors(
      "zoom-canvas",
      drag_element()
    )
}

Description

This function creates a configuration list for G6 Fruchterman layout with all available options as parameters.

Usage

fruchterman_layout(height = NULL, width = NULL, gravity = 10, speed = 5, ...)

Arguments

Value

A list containing the configuration for G6 fruchterman layout.

Examples

if (interactive()) {
  g6(lesmis$nodes, lesmis$edges) |>
   g6_layout(fruchterman_layout(
     gravity = 5,
     speed = 5
   )) |>
   g6_behaviors(
     "zoom-canvas",
     drag_element()
   )
}

Description

Creates a configuration object for the fullscreen plugin in G6. This plugin enables fullscreen mode for the graph.

Usage

fullscreen(
  key = "fullscreen",
  autoFit = TRUE,
  trigger = NULL,
  onEnter = NULL,
  onExit = NULL,
  ...
)

Arguments

Value

A list with the configuration settings for the fullscreen plugin.

Examples

# Basic configuration
config <- fullscreen()

# Custom configuration
config <- fullscreen(
  key = "my-fullscreen",
  autoFit = TRUE,
  trigger = list(
    request = "F",
    exit = "Esc"
  ),
  onEnter = JS("() => {
    console.log('Entered fullscreen mode');
  }"),
  onExit = JS("() => {
    console.log('Exited fullscreen mode');
  }")
)

Description

Creates an interactive graph visualization using the G6 graph visualization library. This function is the main entry point for creating G6 graph visualizations in R.

Usage

g6(
  nodes = NULL,
  edges = NULL,
  combos = NULL,
  jsonUrl = NULL,
  iconsUrl = "//at.alicdn.com/t/font_2678727_za4qjydwkkh.js",
  width = "100%",
  height = NULL,
  elementId = NULL
)

Arguments

Details

The g6 function creates a G6 graph as an htmlwidget that can be used in R Markdown, Shiny applications, or rendered to HTML. It takes graph data in the form of nodes, edges, and optional combo groupings, along with various configuration options for customizing the appearance and behavior of the graph.

Nodes

The nodes parameter should be a data frame or list of nodes with at least an id field for each node. Additional fields can include:

• id (required): Unique identifier for the node. Must be a character.

• type: Node type (e.g., "circle", "rect", "diamond").

• data: Custom data associated with the node.

• style: List of style attributes (color, size, etc.).

• states: String. Initial states for the node, such as selected, active, hover, etc.

• combo: ID of the combo this node belongs to.

• ports: Node ports. Can also be passed inside the style field.

Edges

The edges parameter should be a data frame or list of edges with at least source and target fields identifying the connected nodes. Additional fields can include:

• source (required): ID of the source node. Must be a character.

• target (required): ID of the target node. Must be a character.

• id: Unique identifier for the edge.

• type: Edge type (e.g., "line", "cubic", "arc").

• data: Custom data associated with the edge.

• style: List of style attributes (color, width, etc.).

• states: String. Initial states for the edge.

Combos

The combos parameter is used for grouping nodes and can be a data frame or list with combo definitions. Fields include:

• id (required): Unique identifier for the combo. Must be a character.

• type: String: Combo type. It can be the type of built-in Combo, or the custom Combo.

• data: Custom data associated with the combo.

• style: List of style attributes.

• states: String. Initial states for the combo.

• combo: String. Parent combo ID. If there is no parent combo, it is null.

Nodes are assigned to combos by setting their combo field to the ID of the combo.

Value

An htmlwidget object that can be printed, included in R Markdown documents, or used in Shiny applications. This widget contains the graph data and configuration necessary to render the G6 graph visualization.

Examples

# Create a simple graph with two nodes and one edge
nodes <- data.frame(
  id = c("node1", "node2")
)

edges <- data.frame(
  source = "node1",
  target = "node2"
)

g6(nodes = nodes, edges = edges)

Description

This function adds one or more nodes/edges/combos to an existing g6 graph instance using a proxy object. This allows updating the graph without completely re-rendering it.

Usage

g6_add_nodes(graph, ...)

g6_add_edges(graph, ...)

g6_add_combos(graph, ...)

g6_add_data(graph, data)

Arguments

Details

This function can only be used with a g6_proxy object within a Shiny application. It will not work with regular g6 objects outside of Shiny.

If a node with the same ID already exists, it will not be added again. See https://g6.antv.antgroup.com/en/api/data#graphaddnodedata, https://g6.antv.antgroup.com/en/api/data#graphaddedgedata and https://g6.antv.antgroup.com/en/api/data#graphaddcombodata for more details.

Value

The g6_proxy object (invisibly), allowing for method chaining.

See Also

g6_proxy, g6_remove_nodes

Examples

if (interactive()) {
  library(shiny)
  library(g6R)
  library(bslib)

  # Static data defined globally
  nodes <- data.frame(id = 1:3)
  edges <- data.frame(source = c(1, 2), target = c(2, 3))

  ui <- page_fluid(
    title = "Add Nodes Dynamically",
    g6_output("graph"),
    actionButton("add_node", "Add Node")
  )

  server <- function(input, output, session) {
    output$graph <- render_g6({
      g6(nodes = nodes, edges = edges) |> g6_layout()
    })

    next_id <- reactiveVal(max(nodes$id) + 1)

    observeEvent(input$add_node, {
      g6_add_nodes(g6_proxy("graph"), data.frame(id = next_id()))
      next_id(next_id() + 1)
    })
  }

  shinyApp(ui, server)
}

Description

This function adds one or more plugins to an existing g6 graph instance using a proxy object within a Shiny application.

Usage

g6_add_plugin(graph, ...)

Arguments

Details

This function can only be used with a g6_proxy object within a Shiny application. It will not work with regular g6 objects outside of Shiny.

G6 plugins extend the functionality of the graph visualization with features like minimaps, toolbar controls, contextual menus, and more. This function allows adding these plugins dynamically after the graph has been initialized.

Value

The g6_proxy object (invisibly), allowing for method chaining.

See Also

g6_proxy, g6_update_plugin

Description

Configures interaction behaviors for a G6 graph visualization. This function collects and combines multiple behavior configurations into a list that can be passed to graph initialization functions.

Usage

g6_behaviors(graph, ...)

Arguments

Value

A list of behavior configuration objects that can be passed to G6 graph initialization

Note

You can create custom behaviors from JavaScript and use them on the R side. See more at https://g6.antv.antgroup.com/en/manual/behavior/custom-behavior.

Examples

# Create a basic set of behaviors
behaviors <- g6_behaviors(
  g6(),
  drag_canvas(),
  zoom_canvas(),
  click_select()
)

# Create a more customized set of behaviors
behaviors <- g6_behaviors(
  g6(),
  drag_canvas(),
  zoom_canvas(sensitivity = 1.5),
  hover_activate(state = "highlight"),
  fix_element_size(
    node = list(
      list(shape = "circle", fields = c("r", "lineWidth"))
    )
  )
)

Description

This function changes the size of the canvas of an existing g6 graph instance using a proxy object. This allows updating the graph dimensions without completely re-rendering it.

Usage

g6_canvas_resize(graph, width, height)

Arguments

Details

This function can only be used with a g6_proxy object within a Shiny application. It will not work with regular g6 objects outside of Shiny.

See https://g6.antv.antgroup.com/en/api/canvas#graphsetsizewidth-height for more details.

Value

The g6_proxy object (invisibly), allowing for method chaining.

See Also

g6_proxy

Description

This function collapses/expands a specified combo (a group of nodes) in a g6 graph, hiding its member nodes and edges while maintaining the combo itself visible. This is useful for simplifying complex graphs with multiple hierarchical groups.

Usage

g6_collapse_combo(graph, id, options = NULL)

g6_expand_combo(graph, id, options = NULL)

Arguments

Details

When a combo is collapsed, its member nodes and edges are hidden from view while the combo itself remains visible, typically shown as a single node. This helps to reduce visual complexity in large graphs with hierarchical groupings.

Value

The modified g6 graph or g6_proxy object, allowing for method chaining.

References

https://g6.antv.antgroup.com/en/api/element#graphcollapseelementid-options, https://g6.antv.antgroup.com/en/api/element#graphexpandelementid-options

Description

Configure collapse button for nodes

Check if object is a g6_collapse_options configuration

Usage

g6_collapse_options(
  collapsed = FALSE,
  visibility = c("visible", "hover"),
  placement = "right-top",
  r = 6,
  fill = "#fff",
  stroke = "#9cabd4",
  lineWidth = 1,
  iconStroke = "#9cabd4",
  iconLineWidth = 1.4,
  cursor = "pointer",
  zIndex = 999
)

is_g6_collapse_options(x)

Arguments

Value

A list of collapse button configuration options.

Logical indicating if x is of class g6_collapse_options.

Examples

# Default collapse button
g6_collapse_options()

# Custom styled collapse button
g6_collapse_options(
  placement = "right-top",
  fill = "#f0f0f0",
  stroke = "#333",
  r = 10
)

# Collapse button with custom coordinates
g6_collapse_options(placement = c(1, 0.2))

Description

Create compatible data structure for g6_add_data(), g6_set_data() or simply g6().

Usage

g6_data(nodes = NULL, edges = NULL, combos = NULL)

as_g6_data(x, ...)

## S3 method for class 'g6_data'
as_g6_data(x, ...)

## S3 method for class 'list'
as_g6_data(x, ...)

Arguments

Value

An object of class g6_data.

Description

This function pans the graph to the center of the viewport

Usage

g6_fit_center(graph, animation = NULL)

Arguments

Details

This function can only be used with a g6_proxy object within a Shiny application. It will not work with regular g6 objects outside of Shiny.

See https://g6.antv.antgroup.com/en/api/viewport#graphfitcenteranimation for more details.

Value

The g6_proxy object (invisibly), allowing for method chaining.

See Also

g6_proxy

Description

This function gets the state of one or more nodes/edges/combos to an existing g6 graph instance using a proxy object.

Usage

g6_get_nodes(graph, nodes)

g6_get_edges(graph, edges)

g6_get_combos(graph, combos)

Arguments

Details

This function can only be used with a g6_proxy object within a Shiny application. It will not work with regular g6 objects outside of Shiny.

If a node with the same ID already exists, it will not be added again. See https://g6.antv.antgroup.com/en/api/data#graphgetnodedata for more details.

Value

The g6_proxy object (invisibly), allowing for method chaining.

See Also

g6_proxy

Examples

if (interactive()) {
   library(shiny)
   library(bslib)

    ui <- page_fluid(
      verbatimTextOutput("res"),
      g6Output("graph")
    )

    server <- function(input, output, session) {
      output$graph <- renderG6({
        g6(
          nodes = data.frame(id = c("node1", "node2"))
        ) |>
          g6_options(animation = FALSE) |>
          g6_layout() |>
          g6_behaviors(click_select())
      })

      # Send query to JS
      observeEvent(req(input[["graph-initialized"]]), {
        g6_proxy("graph") |> g6_get_nodes(c("node1", "node2"))
      })

      # Recover query result inside input[["<GRAPH_ID>-<ELEMENT_ID>-state"]]
      output$res <- renderPrint({
        list(
          node1_state = input[["graph-node1-state"]],
          node2_state = input[["graph-node2-state"]]
        )
      })
    }
    shinyApp(ui, server)
 }

Description

These helpers extract ports from the graph state stored in Shiny input, accessed via a g6_proxy object. Ports are grouped by node and can be filtered by type.

Usage

g6_get_ports(graph)

g6_get_input_ports(graph)

g6_get_output_ports(graph)

Arguments

Value

A named list of ports for each node, optionally filtered by type.

Description

This function hides/shows specified elements (nodes, edges, or combos) in a g6 graph. Hidden elements are removed from view but remain in the graph data structure.

Usage

g6_hide_elements(graph, ids, animation = NULL)

g6_hide_nodes(graph, ids, animation = NULL)

g6_hide_edges(graph, ids, animation = NULL)

g6_hide_combos(graph, ids, animation = NULL)

g6_show_elements(graph, ids, animation = NULL)

g6_show_nodes(graph, ids, animation = NULL)

g6_show_edges(graph, ids, animation = NULL)

g6_show_combos(graph, ids, animation = NULL)

Arguments

Details

When elements are hidden, they are removed from the visual display but still exist in the underlying data structure. This means they can be shown again later using g6_show_elements without having to recreate them.

Hidden elements will not participate in layout calculations, which may cause other elements to reposition. When elements are shown again, the graph may recalculate layout positions, which can cause other elements to reposition.

Value

The modified g6 graph or g6_proxy object, allowing for method chaining.

See Also

g6_show_elements

Description

Converts an igraph graph object into the format required by the g6() function and creates an interactive G6 graph visualization. This is a convenience wrapper around g6() that allows you to work directly with igraph objects.

Usage

g6_igraph(
  graph,
  combos = NULL,
  width = "100%",
  height = NULL,
  elementId = NULL
)

Arguments

Details

This function extracts the node and edge data from an igraph object, converts them into the appropriate format for G6, and passes them to g6(). Node styling is derived from vertex attributes, and edge styling from edge attributes.

If the graph is directed, edges will automatically be rendered with arrows.

Value

An htmlwidget object that can be rendered in R Markdown, Shiny apps, or the R console.

See Also

g6() for more information about node, edge, and combo structure.

Examples

if (require(igraph)) {
  g <- igraph::make_ring(5)
  g6_igraph(g)
}

Description

This function configures the layout algorithm used to position nodes in a g6 graph.

Usage

g6_layout(graph, layout = d3_force_layout())

Arguments

Details

G6 provides several layout algorithms, each suitable for different graph structures:

• force: Force-directed layout using physical simulation of forces.

• random: Random layout placing nodes randomly.

• circular: Arranges nodes on a circle.

• radial: Radial layout with nodes arranged outward from a central node.

• grid: Arranges nodes in a grid pattern.

• concentric: Concentric circles with important nodes in the center.

• dagre: Hierarchical layout for directed acyclic graphs.

• fruchterman: Force-directed layout based on the Fruchterman-Reingold algorithm.

• mds: Multidimensional scaling layout.

• comboForce: Force-directed layout specially designed for combo graphs.

Each layout algorithm has specific configuration options. See the G6 documentation for detailed information on each layout and its parameters: https://g6.antv.antgroup.com/en/manual/layout/overview.

Value

The modified g6 graph object with the specified layout, allowing for method chaining.

See Also

g6()

Description

Constructors and validators for G6 node, edge, and combo elements.

Usage

g6_node(
  id,
  type = NULL,
  data = NULL,
  style = NULL,
  states = NULL,
  combo = NULL,
  children = NULL,
  ports = NULL,
  collapse = NULL
)

g6_edge(
  source,
  target,
  id = paste(source, target, sep = "-"),
  type = NULL,
  data = NULL,
  style = NULL,
  states = NULL
)

g6_combo(
  id,
  type = NULL,
  data = NULL,
  style = NULL,
  states = NULL,
  combo = NULL,
  collapse = NULL
)

validate_element(x, ...)

## S3 method for class 'g6_element'
validate_element(x, ...)

## S3 method for class 'g6_node'
validate_element(x, ...)

## S3 method for class 'g6_edge'
validate_element(x, ...)

## S3 method for class 'g6_combo'
validate_element(x, ...)

Arguments

Value

An S3 object of class g6_node, g6_edge, or g6_combo (and g6_element).

Examples

# Create a node
node <- g6_node(
  id = "n1",
  type = "rect",
  data = list(label = "Node 1"),
  style = list(color = "red"),
  states = list("selected"),
  combo = NULL,
  children = c("n2", "n3")
)

# Create an edge
edge <- g6_edge(
  source = "n1",
  target = "n2",
  type = "line",
  style = list(width = 2)
)

# Create a combo
combo <- g6_combo(
  id = "combo1",
  type = "rect",
  data = list(label = "Combo 1"),
  style = list(border = "dashed"),
  states = list("active"),
  combo = NULL
)

# Validate a node explicitly
validate_element(node)

Description

Constructors for lists of G6 node, edge, and combo elements. Each function accepts multiple validated elements and returns a list with the appropriate class. All elements are validated on construction.

S3 generic for validating lists of G6 elements.

Usage

g6_nodes(...)

g6_edges(...)

g6_combos(...)

validate_elements(x, ...)

## S3 method for class 'g6_nodes'
validate_elements(x, ...)

## S3 method for class 'g6_edges'
validate_elements(x, ...)

## S3 method for class 'g6_combos'
validate_elements(x, ...)

## S3 method for class 'g6_nodes'
as_g6_nodes(x, ...)

## S3 method for class 'data.frame'
as_g6_nodes(x, ...)

## S3 method for class 'list'
as_g6_nodes(x, ...)

Arguments

Value

An object of class g6_nodes, g6_edges, or g6_combos.

Invisibly returns the validated object.

Examples

nodes <- g6_nodes(
  g6_node(id = "n1"),
  g6_node(id = "n2")
)
edges <- g6_edges(
  g6_edge(source = "n1", target = "n2")
)
combos <- g6_combos(
  g6_combo(id = "c1")
)

Description

Sets up the global configuration options for a G6 graph including node, edge and combo styles, layout, canvas, animation, and interactive behavior settings.

Usage

g6_options(
  graph,
  node = NULL,
  edge = NULL,
  combo = NULL,
  autoFit = NULL,
  canvas = NULL,
  animation = TRUE,
  autoResize = FALSE,
  background = NULL,
  cursor = valid_cursors,
  devicePixelRatio = NULL,
  renderer = NULL,
  padding = NULL,
  rotation = 0,
  x = NULL,
  y = NULL,
  zoom = 1,
  zoomRange = c(0.01, 10),
  theme = "light",
  ...
)

Arguments

Details

The g6_options function provides a comprehensive configuration interface for G6 graphs. It allows you to control all aspects of graph rendering and behavior, from styling of individual elements to global visualization settings.

Value

A list containing all specified G6 graph configuration options.

Examples

# Basic usage with defaults
opts <- g6_options(g6())

# Customize node and edge styles
opts <- g6_options(
  g6(),
  node = node_options(
    type = "circle",
    style = node_style_options(
      fill = "#1783FF",
      stroke = "#0066CC"
    )
  ),
  edge = edge_options(
    type = "cubic",
    style = edge_style_options(
      stroke = "#999999",
      lineWidth = 1.5
    )
  )
)

# Configure graph with dark theme, auto-resize, and custom background
opts <- g6_options(
  g6(),
  theme = "dark",
  autoResize = TRUE,
  background = "#222222",
  padding = 20,
  zoom = 0.8,
  zoomRange = c(0.5, 2)
)

# Configure with custom animations
opts <- g6_options(
  g6(),
  animation = animation_config(
    duration = 500,
    easing = "easeCubic"
  ),
  autoFit = auto_fit_config(duration = 300, easing = "ease-out")
)